1 /* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988, 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "insn-flags.h"
27 #include "insn-codes.h"
29 #include "insn-config.h"
33 #include "typeclass.h"
35 #define CEIL(x,y) (((x) + (y) - 1) / (y))
37 /* Decide whether a function's arguments should be processed
38 from first to last or from last to first. */
40 #ifdef STACK_GROWS_DOWNWARD
42 #define PUSH_ARGS_REVERSED /* If it's last to first */
46 #ifndef STACK_PUSH_CODE
47 #ifdef STACK_GROWS_DOWNWARD
48 #define STACK_PUSH_CODE PRE_DEC
50 #define STACK_PUSH_CODE PRE_INC
54 /* Like STACK_BOUNDARY but in units of bytes, not bits. */
55 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
57 /* If this is nonzero, we do not bother generating VOLATILE
58 around volatile memory references, and we are willing to
59 output indirect addresses. If cse is to follow, we reject
60 indirect addresses so a useful potential cse is generated;
61 if it is used only once, instruction combination will produce
62 the same indirect address eventually. */
65 /* Nonzero to generate code for all the subroutines within an
66 expression before generating the upper levels of the expression.
67 Nowadays this is never zero. */
68 int do_preexpand_calls
= 1;
70 /* Number of units that we should eventually pop off the stack.
71 These are the arguments to function calls that have already returned. */
72 int pending_stack_adjust
;
74 /* Nonzero means stack pops must not be deferred, and deferred stack
75 pops must not be output. It is nonzero inside a function call,
76 inside a conditional expression, inside a statement expression,
77 and in other cases as well. */
78 int inhibit_defer_pop
;
80 /* A list of all cleanups which belong to the arguments of
81 function calls being expanded by expand_call. */
82 tree cleanups_this_call
;
84 /* Nonzero means __builtin_saveregs has already been done in this function.
85 The value is the pseudoreg containing the value __builtin_saveregs
87 static rtx saveregs_value
;
90 static void store_constructor ();
91 static rtx
store_field ();
92 static rtx
expand_builtin ();
93 static rtx
compare ();
94 static rtx
do_store_flag ();
95 static void preexpand_calls ();
96 static rtx
expand_increment ();
97 static void init_queue ();
99 void do_pending_stack_adjust ();
100 static void do_jump_for_compare ();
101 static void do_jump_by_parts_equality ();
102 static void do_jump_by_parts_equality_rtx ();
103 static void do_jump_by_parts_greater ();
105 /* MOVE_RATIO is the number of move instructions that is better than
109 #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi)
112 /* A value of around 6 would minimize code size; infinity would minimize
114 #define MOVE_RATIO 15
118 /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
120 #ifndef SLOW_UNALIGNED_ACCESS
121 #define SLOW_UNALIGNED_ACCESS 0
124 /* This is run at the start of compiling a function. */
131 pending_stack_adjust
= 0;
132 inhibit_defer_pop
= 0;
133 cleanups_this_call
= 0;
138 /* Save all variables describing the current status into the structure *P.
139 This is used before starting a nested function. */
145 /* Instead of saving the postincrement queue, empty it. */
148 p
->pending_stack_adjust
= pending_stack_adjust
;
149 p
->inhibit_defer_pop
= inhibit_defer_pop
;
150 p
->cleanups_this_call
= cleanups_this_call
;
151 p
->saveregs_value
= saveregs_value
;
152 p
->forced_labels
= forced_labels
;
154 pending_stack_adjust
= 0;
155 inhibit_defer_pop
= 0;
156 cleanups_this_call
= 0;
161 /* Restore all variables describing the current status from the structure *P.
162 This is used after a nested function. */
165 restore_expr_status (p
)
168 pending_stack_adjust
= p
->pending_stack_adjust
;
169 inhibit_defer_pop
= p
->inhibit_defer_pop
;
170 cleanups_this_call
= p
->cleanups_this_call
;
171 saveregs_value
= p
->saveregs_value
;
172 forced_labels
= p
->forced_labels
;
175 /* Manage the queue of increment instructions to be output
176 for POSTINCREMENT_EXPR expressions, etc. */
178 static rtx pending_chain
;
180 /* Queue up to increment (or change) VAR later. BODY says how:
181 BODY should be the same thing you would pass to emit_insn
182 to increment right away. It will go to emit_insn later on.
184 The value is a QUEUED expression to be used in place of VAR
185 where you want to guarantee the pre-incrementation value of VAR. */
188 enqueue_insn (var
, body
)
191 pending_chain
= gen_rtx (QUEUED
, GET_MODE (var
),
192 var
, 0, 0, body
, pending_chain
);
193 return pending_chain
;
196 /* Use protect_from_queue to convert a QUEUED expression
197 into something that you can put immediately into an instruction.
198 If the queued incrementation has not happened yet,
199 protect_from_queue returns the variable itself.
200 If the incrementation has happened, protect_from_queue returns a temp
201 that contains a copy of the old value of the variable.
203 Any time an rtx which might possibly be a QUEUED is to be put
204 into an instruction, it must be passed through protect_from_queue first.
205 QUEUED expressions are not meaningful in instructions.
207 Do not pass a value through protect_from_queue and then hold
208 on to it for a while before putting it in an instruction!
209 If the queue is flushed in between, incorrect code will result. */
212 protect_from_queue (x
, modify
)
216 register RTX_CODE code
= GET_CODE (x
);
218 #if 0 /* A QUEUED can hang around after the queue is forced out. */
219 /* Shortcut for most common case. */
220 if (pending_chain
== 0)
226 /* A special hack for read access to (MEM (QUEUED ...))
227 to facilitate use of autoincrement.
228 Make a copy of the contents of the memory location
229 rather than a copy of the address, but not
230 if the value is of mode BLKmode. */
231 if (code
== MEM
&& GET_MODE (x
) != BLKmode
232 && GET_CODE (XEXP (x
, 0)) == QUEUED
&& !modify
)
234 register rtx y
= XEXP (x
, 0);
235 XEXP (x
, 0) = QUEUED_VAR (y
);
238 register rtx temp
= gen_reg_rtx (GET_MODE (x
));
239 emit_insn_before (gen_move_insn (temp
, x
),
245 /* Otherwise, recursively protect the subexpressions of all
246 the kinds of rtx's that can contain a QUEUED. */
248 XEXP (x
, 0) = protect_from_queue (XEXP (x
, 0), 0);
249 else if (code
== PLUS
|| code
== MULT
)
251 XEXP (x
, 0) = protect_from_queue (XEXP (x
, 0), 0);
252 XEXP (x
, 1) = protect_from_queue (XEXP (x
, 1), 0);
256 /* If the increment has not happened, use the variable itself. */
257 if (QUEUED_INSN (x
) == 0)
258 return QUEUED_VAR (x
);
259 /* If the increment has happened and a pre-increment copy exists,
261 if (QUEUED_COPY (x
) != 0)
262 return QUEUED_COPY (x
);
263 /* The increment has happened but we haven't set up a pre-increment copy.
264 Set one up now, and use it. */
265 QUEUED_COPY (x
) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x
)));
266 emit_insn_before (gen_move_insn (QUEUED_COPY (x
), QUEUED_VAR (x
)),
268 return QUEUED_COPY (x
);
271 /* Return nonzero if X contains a QUEUED expression:
272 if it contains anything that will be altered by a queued increment.
273 We handle only combinations of MEM, PLUS, MINUS and MULT operators
274 since memory addresses generally contain only those. */
280 register enum rtx_code code
= GET_CODE (x
);
286 return queued_subexp_p (XEXP (x
, 0));
290 return queued_subexp_p (XEXP (x
, 0))
291 || queued_subexp_p (XEXP (x
, 1));
296 /* Perform all the pending incrementations. */
302 while (p
= pending_chain
)
304 QUEUED_INSN (p
) = emit_insn (QUEUED_BODY (p
));
305 pending_chain
= QUEUED_NEXT (p
);
316 /* Copy data from FROM to TO, where the machine modes are not the same.
317 Both modes may be integer, or both may be floating.
318 UNSIGNEDP should be nonzero if FROM is an unsigned type.
319 This causes zero-extension instead of sign-extension. */
322 convert_move (to
, from
, unsignedp
)
323 register rtx to
, from
;
326 enum machine_mode to_mode
= GET_MODE (to
);
327 enum machine_mode from_mode
= GET_MODE (from
);
328 int to_real
= GET_MODE_CLASS (to_mode
) == MODE_FLOAT
;
329 int from_real
= GET_MODE_CLASS (from_mode
) == MODE_FLOAT
;
333 /* rtx code for making an equivalent value. */
334 enum rtx_code equiv_code
= (unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
);
336 to
= protect_from_queue (to
, 1);
337 from
= protect_from_queue (from
, 0);
339 if (to_real
!= from_real
)
342 if (to_mode
== from_mode
343 || (from_mode
== VOIDmode
&& CONSTANT_P (from
)))
345 emit_move_insn (to
, from
);
351 #ifdef HAVE_extendsfdf2
352 if (HAVE_extendsfdf2
&& from_mode
== SFmode
&& to_mode
== DFmode
)
354 emit_unop_insn (CODE_FOR_extendsfdf2
, to
, from
, UNKNOWN
);
358 #ifdef HAVE_extendsftf2
359 if (HAVE_extendsftf2
&& from_mode
== SFmode
&& to_mode
== TFmode
)
361 emit_unop_insn (CODE_FOR_extendsftf2
, to
, from
, UNKNOWN
);
365 #ifdef HAVE_extenddftf2
366 if (HAVE_extenddftf2
&& from_mode
== DFmode
&& to_mode
== TFmode
)
368 emit_unop_insn (CODE_FOR_extenddftf2
, to
, from
, UNKNOWN
);
372 #ifdef HAVE_truncdfsf2
373 if (HAVE_truncdfsf2
&& from_mode
== DFmode
&& to_mode
== SFmode
)
375 emit_unop_insn (CODE_FOR_truncdfsf2
, to
, from
, UNKNOWN
);
379 #ifdef HAVE_trunctfsf2
380 if (HAVE_trunctfsf2
&& from_mode
== TFmode
&& to_mode
== SFmode
)
382 emit_unop_insn (CODE_FOR_trunctfsf2
, to
, from
, UNKNOWN
);
386 #ifdef HAVE_trunctfdf2
387 if (HAVE_trunctfdf2
&& from_mode
== TFmode
&& to_mode
== DFmode
)
389 emit_unop_insn (CODE_FOR_trunctfdf2
, to
, from
, UNKNOWN
);
394 if (from_mode
== SFmode
&& to_mode
== DFmode
)
395 libcall
= extendsfdf2_libfunc
;
396 else if (from_mode
== DFmode
&& to_mode
== SFmode
)
397 libcall
= truncdfsf2_libfunc
;
399 /* This conversion is not implemented yet. There aren't any TFmode
403 emit_library_call (libcall
, 1, to_mode
, 1, from
, from_mode
);
404 emit_move_insn (to
, hard_libcall_value (to_mode
));
408 /* Now both modes are integers. */
410 /* Handle expanding beyond a word. */
411 if (GET_MODE_BITSIZE (from_mode
) < GET_MODE_BITSIZE (to_mode
)
412 && GET_MODE_BITSIZE (to_mode
) > BITS_PER_WORD
)
419 enum machine_mode lowpart_mode
;
420 int nwords
= CEIL (GET_MODE_SIZE (to_mode
), UNITS_PER_WORD
);
422 /* Try converting directly if the insn is supported. */
423 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
426 emit_unop_insn (code
, to
, from
, equiv_code
);
429 /* Next, try converting via full word. */
430 else if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
431 && ((code
= can_extend_p (to_mode
, word_mode
, unsignedp
))
432 != CODE_FOR_nothing
))
434 convert_move (gen_lowpart (word_mode
, to
), from
, unsignedp
);
435 emit_unop_insn (code
, to
,
436 gen_lowpart (word_mode
, to
), equiv_code
);
440 /* No special multiword conversion insn; do it by hand. */
443 /* Get a copy of FROM widened to a word, if necessary. */
444 if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
)
445 lowpart_mode
= word_mode
;
447 lowpart_mode
= from_mode
;
449 lowfrom
= convert_to_mode (lowpart_mode
, from
, unsignedp
);
451 lowpart
= gen_lowpart (lowpart_mode
, to
);
452 emit_move_insn (lowpart
, lowfrom
);
454 /* Compute the value to put in each remaining word. */
456 fill_value
= const0_rtx
;
461 && insn_operand_mode
[(int) CODE_FOR_slt
][0] == word_mode
462 && STORE_FLAG_VALUE
== -1)
464 emit_cmp_insn (lowfrom
, const0_rtx
, NE
, 0, lowpart_mode
, 0, 0);
465 fill_value
= gen_reg_rtx (word_mode
);
466 emit_insn (gen_slt (fill_value
));
472 = expand_shift (RSHIFT_EXPR
, lowpart_mode
, lowfrom
,
473 size_int (GET_MODE_BITSIZE (lowpart_mode
) - 1),
475 fill_value
= convert_to_mode (word_mode
, fill_value
, 1);
479 /* Fill the remaining words. */
480 for (i
= GET_MODE_SIZE (lowpart_mode
) / UNITS_PER_WORD
; i
< nwords
; i
++)
482 int index
= (WORDS_BIG_ENDIAN
? nwords
- i
- 1 : i
);
483 rtx subword
= operand_subword (to
, index
, 1, to_mode
);
488 if (fill_value
!= subword
)
489 emit_move_insn (subword
, fill_value
);
492 insns
= get_insns ();
495 emit_no_conflict_block (insns
, to
, from
, 0,
496 gen_rtx (equiv_code
, to_mode
, from
));
500 if (GET_MODE_BITSIZE (from_mode
) > BITS_PER_WORD
)
502 convert_move (to
, gen_lowpart (word_mode
, from
), 0);
506 /* Handle pointer conversion */ /* SPEE 900220 */
507 if (to_mode
== PSImode
)
509 if (from_mode
!= SImode
)
510 from
= convert_to_mode (SImode
, from
, unsignedp
);
512 #ifdef HAVE_truncsipsi
515 emit_unop_insn (CODE_FOR_truncsipsi
, to
, from
, UNKNOWN
);
518 #endif /* HAVE_truncsipsi */
522 if (from_mode
== PSImode
)
524 if (to_mode
!= SImode
)
526 from
= convert_to_mode (SImode
, from
, unsignedp
);
531 #ifdef HAVE_extendpsisi
532 if (HAVE_extendpsisi
)
534 emit_unop_insn (CODE_FOR_extendpsisi
, to
, from
, UNKNOWN
);
537 #endif /* HAVE_extendpsisi */
542 /* Now follow all the conversions between integers
543 no more than a word long. */
545 /* For truncation, usually we can just refer to FROM in a narrower mode. */
546 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
)
547 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode
),
548 GET_MODE_BITSIZE (from_mode
))
549 && ((GET_CODE (from
) == MEM
550 && ! MEM_VOLATILE_P (from
)
551 && ! mode_dependent_address_p (XEXP (from
, 0)))
552 || GET_CODE (from
) == REG
553 || GET_CODE (from
) == SUBREG
))
555 emit_move_insn (to
, gen_lowpart (to_mode
, from
));
559 /* For truncation, usually we can just refer to FROM in a narrower mode. */
560 if (GET_MODE_BITSIZE (to_mode
) > GET_MODE_BITSIZE (from_mode
))
562 /* Convert directly if that works. */
563 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
566 emit_unop_insn (code
, to
, from
, equiv_code
);
571 enum machine_mode intermediate
;
573 /* Search for a mode to convert via. */
574 for (intermediate
= from_mode
; intermediate
!= VOIDmode
;
575 intermediate
= GET_MODE_WIDER_MODE (intermediate
))
576 if ((can_extend_p (to_mode
, intermediate
, unsignedp
)
578 && (can_extend_p (intermediate
, from_mode
, unsignedp
)
579 != CODE_FOR_nothing
))
581 convert_move (to
, convert_to_mode (intermediate
, from
,
582 unsignedp
), unsignedp
);
586 /* No suitable intermediate mode. */
591 /* Support special truncate insns for certain modes. */
593 if (from_mode
== DImode
&& to_mode
== SImode
)
595 #ifdef HAVE_truncdisi2
598 emit_unop_insn (CODE_FOR_truncdisi2
, to
, from
, UNKNOWN
);
602 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
606 if (from_mode
== DImode
&& to_mode
== HImode
)
608 #ifdef HAVE_truncdihi2
611 emit_unop_insn (CODE_FOR_truncdihi2
, to
, from
, UNKNOWN
);
615 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
619 if (from_mode
== DImode
&& to_mode
== QImode
)
621 #ifdef HAVE_truncdiqi2
624 emit_unop_insn (CODE_FOR_truncdiqi2
, to
, from
, UNKNOWN
);
628 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
632 if (from_mode
== SImode
&& to_mode
== HImode
)
634 #ifdef HAVE_truncsihi2
637 emit_unop_insn (CODE_FOR_truncsihi2
, to
, from
, UNKNOWN
);
641 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
645 if (from_mode
== SImode
&& to_mode
== QImode
)
647 #ifdef HAVE_truncsiqi2
650 emit_unop_insn (CODE_FOR_truncsiqi2
, to
, from
, UNKNOWN
);
654 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
658 if (from_mode
== HImode
&& to_mode
== QImode
)
660 #ifdef HAVE_trunchiqi2
663 emit_unop_insn (CODE_FOR_trunchiqi2
, to
, from
, UNKNOWN
);
667 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
671 /* Handle truncation of volatile memrefs, and so on;
672 the things that couldn't be truncated directly,
673 and for which there was no special instruction. */
674 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
))
676 rtx temp
= force_reg (to_mode
, gen_lowpart (to_mode
, from
));
677 emit_move_insn (to
, temp
);
681 /* Mode combination is not recognized. */
685 /* Return an rtx for a value that would result
686 from converting X to mode MODE.
687 Both X and MODE may be floating, or both integer.
688 UNSIGNEDP is nonzero if X is an unsigned value.
689 This can be done by referring to a part of X in place
690 or by copying to a new temporary with conversion. */
693 convert_to_mode (mode
, x
, unsignedp
)
694 enum machine_mode mode
;
700 x
= protect_from_queue (x
, 0);
702 if (mode
== GET_MODE (x
))
705 /* There is one case that we must handle specially: If we are converting
706 a CONST_INT into a mode whose size is twice HOST_BITS_PER_INT and
707 we are to interpret the constant as unsigned, gen_lowpart will do
708 the wrong if the constant appears negative. What we want to do is
709 make the high-order word of the constant zero, not all ones. */
711 if (unsignedp
&& GET_MODE_CLASS (mode
) == MODE_INT
712 && GET_MODE_BITSIZE (mode
) == 2 * HOST_BITS_PER_INT
713 && GET_CODE (x
) == CONST_INT
&& INTVAL (x
) < 0)
714 return immed_double_const (INTVAL (x
), 0, mode
);
716 /* We can do this with a gen_lowpart if both desired and current modes
717 are integer, and this is either a constant integer, a register, or a
718 non-volatile MEM. Except for the constant case, we must be narrowing
721 if (GET_CODE (x
) == CONST_INT
722 || (GET_MODE_CLASS (mode
) == MODE_INT
723 && GET_MODE_CLASS (GET_MODE (x
)) == MODE_INT
724 && (GET_CODE (x
) == CONST_DOUBLE
725 || (GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (GET_MODE (x
))
726 && ((GET_CODE (x
) == MEM
&& ! MEM_VOLATILE_P (x
))
727 || GET_CODE (x
) == REG
)))))
728 return gen_lowpart (mode
, x
);
730 temp
= gen_reg_rtx (mode
);
731 convert_move (temp
, x
, unsignedp
);
735 /* Generate several move instructions to copy LEN bytes
736 from block FROM to block TO. (These are MEM rtx's with BLKmode).
737 The caller must pass FROM and TO
738 through protect_from_queue before calling.
739 ALIGN (in bytes) is maximum alignment we can assume. */
741 struct move_by_pieces
750 int explicit_inc_from
;
756 static void move_by_pieces_1 ();
757 static int move_by_pieces_ninsns ();
760 move_by_pieces (to
, from
, len
, align
)
764 struct move_by_pieces data
;
765 rtx to_addr
= XEXP (to
, 0), from_addr
= XEXP (from
, 0);
766 int max_size
= MOVE_MAX
+ 1;
769 data
.to_addr
= to_addr
;
770 data
.from_addr
= from_addr
;
774 = (GET_CODE (to_addr
) == PRE_INC
|| GET_CODE (to_addr
) == PRE_DEC
775 || GET_CODE (to_addr
) == POST_INC
|| GET_CODE (to_addr
) == POST_DEC
);
777 = (GET_CODE (from_addr
) == PRE_INC
|| GET_CODE (from_addr
) == PRE_DEC
778 || GET_CODE (from_addr
) == POST_INC
779 || GET_CODE (from_addr
) == POST_DEC
);
781 data
.explicit_inc_from
= 0;
782 data
.explicit_inc_to
= 0;
784 = (GET_CODE (to_addr
) == PRE_DEC
|| GET_CODE (to_addr
) == POST_DEC
);
785 if (data
.reverse
) data
.offset
= len
;
788 /* If copying requires more than two move insns,
789 copy addresses to registers (to make displacements shorter)
790 and use post-increment if available. */
791 if (!(data
.autinc_from
&& data
.autinc_to
)
792 && move_by_pieces_ninsns (len
, align
) > 2)
794 #ifdef HAVE_PRE_DECREMENT
795 if (data
.reverse
&& ! data
.autinc_from
)
797 data
.from_addr
= copy_addr_to_reg (plus_constant (from_addr
, len
));
798 data
.autinc_from
= 1;
799 data
.explicit_inc_from
= -1;
802 #ifdef HAVE_POST_INCREMENT
803 if (! data
.autinc_from
)
805 data
.from_addr
= copy_addr_to_reg (from_addr
);
806 data
.autinc_from
= 1;
807 data
.explicit_inc_from
= 1;
810 if (!data
.autinc_from
&& CONSTANT_P (from_addr
))
811 data
.from_addr
= copy_addr_to_reg (from_addr
);
812 #ifdef HAVE_PRE_DECREMENT
813 if (data
.reverse
&& ! data
.autinc_to
)
815 data
.to_addr
= copy_addr_to_reg (plus_constant (to_addr
, len
));
817 data
.explicit_inc_to
= -1;
820 #ifdef HAVE_POST_INCREMENT
821 if (! data
.reverse
&& ! data
.autinc_to
)
823 data
.to_addr
= copy_addr_to_reg (to_addr
);
825 data
.explicit_inc_to
= 1;
828 if (!data
.autinc_to
&& CONSTANT_P (to_addr
))
829 data
.to_addr
= copy_addr_to_reg (to_addr
);
832 if (! (STRICT_ALIGNMENT
|| SLOW_UNALIGNED_ACCESS
)
833 || align
> MOVE_MAX
|| align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
836 /* First move what we can in the largest integer mode, then go to
837 successively smaller modes. */
841 enum machine_mode mode
= VOIDmode
, tmode
;
842 enum insn_code icode
;
844 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
845 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
846 if (GET_MODE_SIZE (tmode
) < max_size
)
849 if (mode
== VOIDmode
)
852 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
853 if (icode
!= CODE_FOR_nothing
854 && align
>= MIN (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
,
855 GET_MODE_SIZE (mode
)))
856 move_by_pieces_1 (GEN_FCN (icode
), mode
, &data
);
858 max_size
= GET_MODE_SIZE (mode
);
861 /* The code above should have handled everything. */
866 /* Return number of insns required to move L bytes by pieces.
867 ALIGN (in bytes) is maximum alignment we can assume. */
870 move_by_pieces_ninsns (l
, align
)
874 register int n_insns
= 0;
875 int max_size
= MOVE_MAX
+ 1;
877 if (! (STRICT_ALIGNMENT
|| SLOW_UNALIGNED_ACCESS
)
878 || align
> MOVE_MAX
|| align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
883 enum machine_mode mode
= VOIDmode
, tmode
;
884 enum insn_code icode
;
886 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
887 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
888 if (GET_MODE_SIZE (tmode
) < max_size
)
891 if (mode
== VOIDmode
)
894 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
895 if (icode
!= CODE_FOR_nothing
896 && align
>= MIN (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
,
897 GET_MODE_SIZE (mode
)))
898 n_insns
+= l
/ GET_MODE_SIZE (mode
), l
%= GET_MODE_SIZE (mode
);
900 max_size
= GET_MODE_SIZE (mode
);
906 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
907 with move instructions for mode MODE. GENFUN is the gen_... function
908 to make a move insn for that mode. DATA has all the other info. */
911 move_by_pieces_1 (genfun
, mode
, data
)
913 enum machine_mode mode
;
914 struct move_by_pieces
*data
;
916 register int size
= GET_MODE_SIZE (mode
);
917 register rtx to1
, from1
;
919 while (data
->len
>= size
)
921 if (data
->reverse
) data
->offset
-= size
;
923 to1
= (data
->autinc_to
924 ? gen_rtx (MEM
, mode
, data
->to_addr
)
925 : change_address (data
->to
, mode
,
926 plus_constant (data
->to_addr
, data
->offset
)));
929 ? gen_rtx (MEM
, mode
, data
->from_addr
)
930 : change_address (data
->from
, mode
,
931 plus_constant (data
->from_addr
, data
->offset
)));
933 #ifdef HAVE_PRE_DECREMENT
934 if (data
->explicit_inc_to
< 0)
935 emit_insn (gen_add2_insn (data
->to_addr
,
936 gen_rtx (CONST_INT
, VOIDmode
, -size
)));
937 if (data
->explicit_inc_from
< 0)
938 emit_insn (gen_add2_insn (data
->from_addr
,
939 gen_rtx (CONST_INT
, VOIDmode
, -size
)));
942 emit_insn ((*genfun
) (to1
, from1
));
943 #ifdef HAVE_POST_INCREMENT
944 if (data
->explicit_inc_to
> 0)
945 emit_insn (gen_add2_insn (data
->to_addr
,
946 gen_rtx (CONST_INT
, VOIDmode
, size
)));
947 if (data
->explicit_inc_from
> 0)
948 emit_insn (gen_add2_insn (data
->from_addr
,
949 gen_rtx (CONST_INT
, VOIDmode
, size
)));
952 if (! data
->reverse
) data
->offset
+= size
;
958 /* Emit code to move a block Y to a block X.
959 This may be done with string-move instructions,
960 with multiple scalar move instructions, or with a library call.
962 Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
964 SIZE is an rtx that says how long they are.
965 ALIGN is the maximum alignment we can assume they have,
966 measured in bytes. */
969 emit_block_move (x
, y
, size
, align
)
974 if (GET_MODE (x
) != BLKmode
)
977 if (GET_MODE (y
) != BLKmode
)
980 x
= protect_from_queue (x
, 1);
981 y
= protect_from_queue (y
, 0);
983 if (GET_CODE (x
) != MEM
)
985 if (GET_CODE (y
) != MEM
)
990 if (GET_CODE (size
) == CONST_INT
991 && (move_by_pieces_ninsns ((unsigned) INTVAL (size
), align
)
993 move_by_pieces (x
, y
, INTVAL (size
), align
);
996 /* Try the most limited insn first, because there's no point
997 including more than one in the machine description unless
998 the more limited one has some advantage. */
1001 && GET_CODE (size
) == CONST_INT
1002 && ((unsigned) INTVAL (size
)
1003 < (1 << (GET_MODE_BITSIZE (QImode
) - 1))))
1005 rtx insn
= gen_movstrqi (x
, y
, size
,
1006 gen_rtx (CONST_INT
, VOIDmode
, align
));
1014 #ifdef HAVE_movstrhi
1016 && GET_CODE (size
) == CONST_INT
1017 && ((unsigned) INTVAL (size
)
1018 < (1 << (GET_MODE_BITSIZE (HImode
) - 1))))
1020 rtx insn
= gen_movstrhi (x
, y
, size
,
1021 gen_rtx (CONST_INT
, VOIDmode
, align
));
1029 #ifdef HAVE_movstrsi
1032 rtx insn
= gen_movstrsi (x
, y
, size
,
1033 gen_rtx (CONST_INT
, VOIDmode
, align
));
1041 #ifdef HAVE_movstrdi
1044 rtx insn
= gen_movstrdi (x
, y
, size
,
1045 gen_rtx (CONST_INT
, VOIDmode
, align
));
1054 #ifdef TARGET_MEM_FUNCTIONS
1055 emit_library_call (memcpy_libfunc
, 1,
1056 VOIDmode
, 3, XEXP (x
, 0), Pmode
,
1060 emit_library_call (bcopy_libfunc
, 1,
1061 VOIDmode
, 3, XEXP (y
, 0), Pmode
,
1068 /* Copy all or part of a value X into registers starting at REGNO.
1069 The number of registers to be filled is NREGS. */
1072 move_block_to_reg (regno
, x
, nregs
, mode
)
1076 enum machine_mode mode
;
1081 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
1082 x
= validize_mem (force_const_mem (mode
, x
));
1084 /* See if the machine can do this with a load multiple insn. */
1085 #ifdef HAVE_load_multiple
1086 last
= get_last_insn ();
1087 pat
= gen_load_multiple (gen_rtx (REG
, word_mode
, regno
), x
,
1088 gen_rtx (CONST_INT
, VOIDmode
, nregs
));
1095 delete_insns_since (last
);
1098 for (i
= 0; i
< nregs
; i
++)
1099 emit_move_insn (gen_rtx (REG
, word_mode
, regno
+ i
),
1100 operand_subword_force (x
, i
, mode
));
1103 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1104 The number of registers to be filled is NREGS. */
1107 move_block_from_reg (regno
, x
, nregs
)
1115 /* See if the machine can do this with a store multiple insn. */
1116 #ifdef HAVE_store_multiple
1117 last
= get_last_insn ();
1118 pat
= gen_store_multiple (x
, gen_rtx (REG
, word_mode
, regno
),
1119 gen_rtx (CONST_INT
, VOIDmode
, nregs
));
1126 delete_insns_since (last
);
1129 for (i
= 0; i
< nregs
; i
++)
1131 rtx tem
= operand_subword (x
, i
, 1, BLKmode
);
1136 emit_move_insn (tem
, gen_rtx (REG
, word_mode
, regno
+ i
));
1140 /* Mark NREGS consecutive regs, starting at REGNO, as being live now. */
1143 use_regs (regno
, nregs
)
1149 for (i
= 0; i
< nregs
; i
++)
1150 emit_insn (gen_rtx (USE
, VOIDmode
, gen_rtx (REG
, word_mode
, regno
+ i
)));
1153 /* Write zeros through the storage of OBJECT.
1154 If OBJECT has BLKmode, SIZE is its length in bytes. */
1157 clear_storage (object
, size
)
1161 if (GET_MODE (object
) == BLKmode
)
1163 #ifdef TARGET_MEM_FUNCTIONS
1164 emit_library_call (memset_libfunc
, 1,
1166 XEXP (object
, 0), Pmode
, const0_rtx
, Pmode
,
1167 gen_rtx (CONST_INT
, VOIDmode
, size
), Pmode
);
1169 emit_library_call (bzero_libfunc
, 1,
1171 XEXP (object
, 0), Pmode
,
1172 gen_rtx (CONST_INT
, VOIDmode
, size
), Pmode
);
1176 emit_move_insn (object
, const0_rtx
);
1179 /* Generate code to copy Y into X.
1180 Both Y and X must have the same mode, except that
1181 Y can be a constant with VOIDmode.
1182 This mode cannot be BLKmode; use emit_block_move for that.
1184 Return the last instruction emitted. */
1187 emit_move_insn (x
, y
)
1190 enum machine_mode mode
= GET_MODE (x
);
1193 x
= protect_from_queue (x
, 1);
1194 y
= protect_from_queue (y
, 0);
1196 if (mode
== BLKmode
|| (GET_MODE (y
) != mode
&& GET_MODE (y
) != VOIDmode
))
1199 if (CONSTANT_P (y
) && ! LEGITIMATE_CONSTANT_P (y
))
1200 y
= force_const_mem (mode
, y
);
1202 /* If X or Y are memory references, verify that their addresses are valid
1204 if (GET_CODE (x
) == MEM
1205 && ((! memory_address_p (GET_MODE (x
), XEXP (x
, 0))
1206 && ! push_operand (x
, GET_MODE (x
)))
1208 && CONSTANT_ADDRESS_P (XEXP (x
, 0)))))
1209 x
= change_address (x
, VOIDmode
, XEXP (x
, 0));
1211 if (GET_CODE (y
) == MEM
1212 && (! memory_address_p (GET_MODE (y
), XEXP (y
, 0))
1214 && CONSTANT_ADDRESS_P (XEXP (y
, 0)))))
1215 y
= change_address (y
, VOIDmode
, XEXP (y
, 0));
1217 if (mode
== BLKmode
)
1220 if (mov_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
1222 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) mode
].insn_code
) (x
, y
));
1224 /* This will handle any multi-word mode that lacks a move_insn pattern.
1225 However, you will get better code if you define such patterns,
1226 even if they must turn into multiple assembler instructions. */
1227 else if (GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
)
1232 i
< (GET_MODE_SIZE (mode
) + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
1235 rtx xpart
= operand_subword (x
, i
, 1, mode
);
1236 rtx ypart
= operand_subword (y
, i
, 1, mode
);
1238 /* If we can't get a part of Y, put Y into memory if it is a
1239 constant. Otherwise, force it into a register. If we still
1240 can't get a part of Y, abort. */
1241 if (ypart
== 0 && CONSTANT_P (y
))
1243 y
= force_const_mem (mode
, y
);
1244 ypart
= operand_subword (y
, i
, 1, mode
);
1246 else if (ypart
== 0)
1247 ypart
= operand_subword_force (y
, i
, mode
);
1249 if (xpart
== 0 || ypart
== 0)
1252 last_insn
= emit_move_insn (xpart
, ypart
);
1260 /* Pushing data onto the stack. */
1262 /* Push a block of length SIZE (perhaps variable)
1263 and return an rtx to address the beginning of the block.
1264 Note that it is not possible for the value returned to be a QUEUED.
1265 The value may be virtual_outgoing_args_rtx.
1267 EXTRA is the number of bytes of padding to push in addition to SIZE.
1268 BELOW nonzero means this padding comes at low addresses;
1269 otherwise, the padding comes at high addresses. */
1272 push_block (size
, extra
, below
)
1277 if (CONSTANT_P (size
))
1278 anti_adjust_stack (plus_constant (size
, extra
));
1279 else if (GET_CODE (size
) == REG
&& extra
== 0)
1280 anti_adjust_stack (size
);
1283 rtx temp
= copy_to_mode_reg (Pmode
, size
);
1285 temp
= expand_binop (Pmode
, add_optab
,
1287 gen_rtx (CONST_INT
, VOIDmode
, extra
),
1288 temp
, 0, OPTAB_LIB_WIDEN
);
1289 anti_adjust_stack (temp
);
1292 #ifdef STACK_GROWS_DOWNWARD
1293 temp
= virtual_outgoing_args_rtx
;
1294 if (extra
!= 0 && below
)
1295 temp
= plus_constant (temp
, extra
);
1297 if (GET_CODE (size
) == CONST_INT
)
1298 temp
= plus_constant (virtual_outgoing_args_rtx
,
1299 - INTVAL (size
) - (below
? 0 : extra
));
1300 else if (extra
!= 0 && !below
)
1301 temp
= gen_rtx (PLUS
, Pmode
, virtual_outgoing_args_rtx
,
1302 negate_rtx (Pmode
, plus_constant (size
, extra
)));
1304 temp
= gen_rtx (PLUS
, Pmode
, virtual_outgoing_args_rtx
,
1305 negate_rtx (Pmode
, size
));
1308 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT
), temp
);
1314 return gen_rtx (STACK_PUSH_CODE
, Pmode
, stack_pointer_rtx
);
1317 /* Generate code to push X onto the stack, assuming it has mode MODE and
1319 MODE is redundant except when X is a CONST_INT (since they don't
1321 SIZE is an rtx for the size of data to be copied (in bytes),
1322 needed only if X is BLKmode.
1324 ALIGN (in bytes) is maximum alignment we can assume.
1326 If PARTIAL is nonzero, then copy that many of the first words
1327 of X into registers starting with REG, and push the rest of X.
1328 The amount of space pushed is decreased by PARTIAL words,
1329 rounded *down* to a multiple of PARM_BOUNDARY.
1330 REG must be a hard register in this case.
1332 EXTRA is the amount in bytes of extra space to leave next to this arg.
1333 This is ignored if an argument block has already been allocted.
1335 On a machine that lacks real push insns, ARGS_ADDR is the address of
1336 the bottom of the argument block for this call. We use indexing off there
1337 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
1338 argument block has not been preallocated.
1340 ARGS_SO_FAR is the size of args previously pushed for this call. */
1343 emit_push_insn (x
, mode
, type
, size
, align
, partial
, reg
, extra
,
1344 args_addr
, args_so_far
)
1346 enum machine_mode mode
;
1357 enum direction stack_direction
1358 #ifdef STACK_GROWS_DOWNWARD
1364 /* Decide where to pad the argument: `downward' for below,
1365 `upward' for above, or `none' for don't pad it.
1366 Default is below for small data on big-endian machines; else above. */
1367 enum direction where_pad
= FUNCTION_ARG_PADDING (mode
, type
);
1369 /* Invert direction if stack is post-update. */
1370 if (STACK_PUSH_CODE
== POST_INC
|| STACK_PUSH_CODE
== POST_DEC
)
1371 if (where_pad
!= none
)
1372 where_pad
= (where_pad
== downward
? upward
: downward
);
1374 xinner
= x
= protect_from_queue (x
, 0);
1376 if (mode
== BLKmode
)
1378 /* Copy a block into the stack, entirely or partially. */
1381 int used
= partial
* UNITS_PER_WORD
;
1382 int offset
= used
% (PARM_BOUNDARY
/ BITS_PER_UNIT
);
1390 /* USED is now the # of bytes we need not copy to the stack
1391 because registers will take care of them. */
1394 xinner
= change_address (xinner
, BLKmode
,
1395 plus_constant (XEXP (xinner
, 0), used
));
1397 /* If the partial register-part of the arg counts in its stack size,
1398 skip the part of stack space corresponding to the registers.
1399 Otherwise, start copying to the beginning of the stack space,
1400 by setting SKIP to 0. */
1401 #ifndef REG_PARM_STACK_SPACE
1407 #ifdef PUSH_ROUNDING
1408 /* Do it with several push insns if that doesn't take lots of insns
1409 and if there is no difficulty with push insns that skip bytes
1410 on the stack for alignment purposes. */
1412 && GET_CODE (size
) == CONST_INT
1414 && (move_by_pieces_ninsns ((unsigned) INTVAL (size
) - used
, align
)
1416 /* Here we avoid the case of a structure whose weak alignment
1417 forces many pushes of a small amount of data,
1418 and such small pushes do rounding that causes trouble. */
1419 && ((! STRICT_ALIGNMENT
&& ! SLOW_UNALIGNED_ACCESS
)
1420 || align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
1421 || PUSH_ROUNDING (align
) == align
)
1422 && PUSH_ROUNDING (INTVAL (size
)) == INTVAL (size
))
1424 /* Push padding now if padding above and stack grows down,
1425 or if padding below and stack grows up.
1426 But if space already allocated, this has already been done. */
1427 if (extra
&& args_addr
== 0
1428 && where_pad
!= none
&& where_pad
!= stack_direction
)
1429 anti_adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, extra
));
1431 move_by_pieces (gen_rtx (MEM
, BLKmode
, gen_push_operand ()), xinner
,
1432 INTVAL (size
) - used
, align
);
1435 #endif /* PUSH_ROUNDING */
1437 /* Otherwise make space on the stack and copy the data
1438 to the address of that space. */
1440 /* Deduct words put into registers from the size we must copy. */
1443 if (GET_CODE (size
) == CONST_INT
)
1444 size
= gen_rtx (CONST_INT
, VOIDmode
, INTVAL (size
) - used
);
1446 size
= expand_binop (GET_MODE (size
), sub_optab
, size
,
1447 gen_rtx (CONST_INT
, VOIDmode
, used
),
1448 0, 0, OPTAB_LIB_WIDEN
);
1451 /* Get the address of the stack space.
1452 In this case, we do not deal with EXTRA separately.
1453 A single stack adjust will do. */
1456 temp
= push_block (size
, extra
, where_pad
== downward
);
1459 else if (GET_CODE (args_so_far
) == CONST_INT
)
1460 temp
= memory_address (BLKmode
,
1461 plus_constant (args_addr
,
1462 skip
+ INTVAL (args_so_far
)));
1464 temp
= memory_address (BLKmode
,
1465 plus_constant (gen_rtx (PLUS
, Pmode
,
1466 args_addr
, args_so_far
),
1469 /* TEMP is the address of the block. Copy the data there. */
1470 if (GET_CODE (size
) == CONST_INT
1471 && (move_by_pieces_ninsns ((unsigned) INTVAL (size
), align
)
1474 move_by_pieces (gen_rtx (MEM
, BLKmode
, temp
), xinner
,
1475 INTVAL (size
), align
);
1478 /* Try the most limited insn first, because there's no point
1479 including more than one in the machine description unless
1480 the more limited one has some advantage. */
1481 #ifdef HAVE_movstrqi
1483 && GET_CODE (size
) == CONST_INT
1484 && ((unsigned) INTVAL (size
)
1485 < (1 << (GET_MODE_BITSIZE (QImode
) - 1))))
1487 emit_insn (gen_movstrqi (gen_rtx (MEM
, BLKmode
, temp
),
1489 gen_rtx (CONST_INT
, VOIDmode
, align
)));
1493 #ifdef HAVE_movstrhi
1495 && GET_CODE (size
) == CONST_INT
1496 && ((unsigned) INTVAL (size
)
1497 < (1 << (GET_MODE_BITSIZE (HImode
) - 1))))
1499 emit_insn (gen_movstrhi (gen_rtx (MEM
, BLKmode
, temp
),
1501 gen_rtx (CONST_INT
, VOIDmode
, align
)));
1505 #ifdef HAVE_movstrsi
1508 emit_insn (gen_movstrsi (gen_rtx (MEM
, BLKmode
, temp
),
1510 gen_rtx (CONST_INT
, VOIDmode
, align
)));
1514 #ifdef HAVE_movstrdi
1517 emit_insn (gen_movstrdi (gen_rtx (MEM
, BLKmode
, temp
),
1519 gen_rtx (CONST_INT
, VOIDmode
, align
)));
1524 #ifndef ACCUMULATE_OUTGOING_ARGS
1525 /* If the source is referenced relative to the stack pointer,
1526 copy it to another register to stabilize it. We do not need
1527 to do this if we know that we won't be changing sp. */
1529 if (reg_mentioned_p (virtual_stack_dynamic_rtx
, temp
)
1530 || reg_mentioned_p (virtual_outgoing_args_rtx
, temp
))
1531 temp
= copy_to_reg (temp
);
1534 /* Make inhibit_defer_pop nonzero around the library call
1535 to force it to pop the bcopy-arguments right away. */
1537 #ifdef TARGET_MEM_FUNCTIONS
1538 emit_library_call (memcpy_libfunc
, 1,
1539 VOIDmode
, 3, temp
, Pmode
, XEXP (xinner
, 0), Pmode
,
1542 emit_library_call (bcopy_libfunc
, 1,
1543 VOIDmode
, 3, XEXP (xinner
, 0), Pmode
, temp
, Pmode
,
1549 else if (partial
> 0)
1551 /* Scalar partly in registers. */
1553 int size
= GET_MODE_SIZE (mode
) / UNITS_PER_WORD
;
1556 /* # words of start of argument
1557 that we must make space for but need not store. */
1558 int offset
= partial
% (PARM_BOUNDARY
/ BITS_PER_WORD
);
1559 int args_offset
= INTVAL (args_so_far
);
1562 /* Push padding now if padding above and stack grows down,
1563 or if padding below and stack grows up.
1564 But if space already allocated, this has already been done. */
1565 if (extra
&& args_addr
== 0
1566 && where_pad
!= none
&& where_pad
!= stack_direction
)
1567 anti_adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, extra
));
1569 /* If we make space by pushing it, we might as well push
1570 the real data. Otherwise, we can leave OFFSET nonzero
1571 and leave the space uninitialized. */
1575 /* Now NOT_STACK gets the number of words that we don't need to
1576 allocate on the stack. */
1577 not_stack
= partial
- offset
;
1579 /* If the partial register-part of the arg counts in its stack size,
1580 skip the part of stack space corresponding to the registers.
1581 Otherwise, start copying to the beginning of the stack space,
1582 by setting SKIP to 0. */
1583 #ifndef REG_PARM_STACK_SPACE
1589 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
1590 x
= validize_mem (force_const_mem (mode
, x
));
1592 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
1593 SUBREGs of such registers are not allowed. */
1594 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
1595 && GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
))
1596 x
= copy_to_reg (x
);
1598 /* Loop over all the words allocated on the stack for this arg. */
1599 /* We can do it by words, because any scalar bigger than a word
1600 has a size a multiple of a word. */
1601 #ifndef PUSH_ARGS_REVERSED
1602 for (i
= not_stack
; i
< size
; i
++)
1604 for (i
= size
- 1; i
>= not_stack
; i
--)
1606 if (i
>= not_stack
+ offset
)
1607 emit_push_insn (operand_subword_force (x
, i
, mode
),
1608 word_mode
, 0, 0, align
, 0, 0, 0, args_addr
,
1609 gen_rtx (CONST_INT
, VOIDmode
,
1610 args_offset
+ ((i
- not_stack
+ skip
)
1611 * UNITS_PER_WORD
)));
1617 /* Push padding now if padding above and stack grows down,
1618 or if padding below and stack grows up.
1619 But if space already allocated, this has already been done. */
1620 if (extra
&& args_addr
== 0
1621 && where_pad
!= none
&& where_pad
!= stack_direction
)
1622 anti_adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, extra
));
1624 #ifdef PUSH_ROUNDING
1626 addr
= gen_push_operand ();
1629 if (GET_CODE (args_so_far
) == CONST_INT
)
1631 = memory_address (mode
,
1632 plus_constant (args_addr
, INTVAL (args_so_far
)));
1634 addr
= memory_address (mode
, gen_rtx (PLUS
, Pmode
, args_addr
,
1637 emit_move_insn (gen_rtx (MEM
, mode
, addr
), x
);
1641 /* If part should go in registers, copy that part
1642 into the appropriate registers. Do this now, at the end,
1643 since mem-to-mem copies above may do function calls. */
1645 move_block_to_reg (REGNO (reg
), x
, partial
, mode
);
1647 if (extra
&& args_addr
== 0 && where_pad
== stack_direction
)
1648 anti_adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, extra
));
1651 /* Output a library call to function FUN (a SYMBOL_REF rtx)
1652 (emitting the queue unless NO_QUEUE is nonzero),
1653 for a value of mode OUTMODE,
1654 with NARGS different arguments, passed as alternating rtx values
1655 and machine_modes to convert them to.
1656 The rtx values should have been passed through protect_from_queue already.
1658 NO_QUEUE will be true if and only if the library call is a `const' call
1659 which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent
1660 to the variable is_const in expand_call. */
1663 emit_library_call (va_alist
)
1667 struct args_size args_size
;
1668 register int argnum
;
1669 enum machine_mode outmode
;
1676 CUMULATIVE_ARGS args_so_far
;
1677 struct arg
{ rtx value
; enum machine_mode mode
; rtx reg
; int partial
;
1678 struct args_size offset
; struct args_size size
; };
1680 int old_inhibit_defer_pop
= inhibit_defer_pop
;
1685 orgfun
= fun
= va_arg (p
, rtx
);
1686 no_queue
= va_arg (p
, int);
1687 outmode
= va_arg (p
, enum machine_mode
);
1688 nargs
= va_arg (p
, int);
1690 /* Copy all the libcall-arguments out of the varargs data
1691 and into a vector ARGVEC.
1693 Compute how to pass each argument. We only support a very small subset
1694 of the full argument passing conventions to limit complexity here since
1695 library functions shouldn't have many args. */
1697 argvec
= (struct arg
*) alloca (nargs
* sizeof (struct arg
));
1699 INIT_CUMULATIVE_ARGS (args_so_far
, (tree
)0, fun
);
1701 args_size
.constant
= 0;
1704 for (count
= 0; count
< nargs
; count
++)
1706 rtx val
= va_arg (p
, rtx
);
1707 enum machine_mode mode
= va_arg (p
, enum machine_mode
);
1709 /* We cannot convert the arg value to the mode the library wants here;
1710 must do it earlier where we know the signedness of the arg. */
1712 || (GET_MODE (val
) != mode
&& GET_MODE (val
) != VOIDmode
))
1715 /* On some machines, there's no way to pass a float to a library fcn.
1716 Pass it as a double instead. */
1717 #ifdef LIBGCC_NEEDS_DOUBLE
1718 if (LIBGCC_NEEDS_DOUBLE
&& mode
== SFmode
)
1719 val
= convert_to_mode (DFmode
, val
), mode
= DFmode
;
1722 /* Make sure it is a reasonable operand for a move or push insn. */
1723 if (GET_CODE (val
) != REG
&& GET_CODE (val
) != MEM
1724 && ! (CONSTANT_P (val
) && LEGITIMATE_CONSTANT_P (val
)))
1725 val
= force_operand (val
, 0);
1727 argvec
[count
].value
= val
;
1728 argvec
[count
].mode
= mode
;
1730 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1731 if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far
, mode
, (tree
)0, 1))
1735 argvec
[count
].reg
= FUNCTION_ARG (args_so_far
, mode
, (tree
)0, 1);
1736 if (argvec
[count
].reg
&& GET_CODE (argvec
[count
].reg
) == EXPR_LIST
)
1738 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1739 argvec
[count
].partial
1740 = FUNCTION_ARG_PARTIAL_NREGS (args_so_far
, mode
, (tree
)0, 1);
1742 argvec
[count
].partial
= 0;
1745 locate_and_pad_parm (mode
, 0,
1746 argvec
[count
].reg
&& argvec
[count
].partial
== 0,
1747 0, &args_size
, &argvec
[count
].offset
,
1748 &argvec
[count
].size
);
1750 if (argvec
[count
].size
.var
)
1753 #ifndef REG_PARM_STACK_SPACE
1754 if (argvec
[count
].partial
)
1755 argvec
[count
].size
.constant
-= argvec
[count
].partial
* UNITS_PER_WORD
;
1758 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
1759 #ifdef REG_PARM_STACK_SPACE
1763 args_size
.constant
+= argvec
[count
].size
.constant
;
1765 #ifdef ACCUMULATE_OUTGOING_ARGS
1766 /* If this arg is actually passed on the stack, it might be
1767 clobbering something we already put there (this library call might
1768 be inside the evaluation of an argument to a function whose call
1769 requires the stack). This will only occur when the library call
1770 has sufficient args to run out of argument registers. Abort in
1771 this case; if this ever occurs, code must be added to save and
1772 restore the arg slot. */
1774 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0)
1778 FUNCTION_ARG_ADVANCE (args_so_far
, mode
, (tree
)0, 1);
1782 /* If this machine requires an external definition for library
1783 functions, write one out. */
1784 assemble_external_libcall (fun
);
1786 #ifdef STACK_BOUNDARY
1787 args_size
.constant
= (((args_size
.constant
+ (STACK_BYTES
- 1))
1788 / STACK_BYTES
) * STACK_BYTES
);
1791 #ifdef REG_PARM_STACK_SPACE
1792 args_size
.constant
= MAX (args_size
.constant
,
1793 REG_PARM_STACK_SPACE ((tree
) 0));
1796 #ifdef ACCUMULATE_OUTGOING_ARGS
1797 if (args_size
.constant
> current_function_outgoing_args_size
)
1798 current_function_outgoing_args_size
= args_size
.constant
;
1799 args_size
.constant
= 0;
1802 #ifndef PUSH_ROUNDING
1803 argblock
= push_block (gen_rtx (CONST_INT
, VOIDmode
, args_size
.constant
),
1807 #ifdef PUSH_ARGS_REVERSED
1815 /* Push the args that need to be pushed. */
1817 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
1819 register enum machine_mode mode
= argvec
[argnum
].mode
;
1820 register rtx val
= argvec
[argnum
].value
;
1821 rtx reg
= argvec
[argnum
].reg
;
1822 int partial
= argvec
[argnum
].partial
;
1824 if (! (reg
!= 0 && partial
== 0))
1825 emit_push_insn (val
, mode
, 0, 0, 0, partial
, reg
, 0, argblock
,
1826 gen_rtx (CONST_INT
, VOIDmode
,
1827 argvec
[count
].offset
.constant
));
1831 #ifdef PUSH_ARGS_REVERSED
1837 /* Now load any reg parms into their regs. */
1839 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
1841 register enum machine_mode mode
= argvec
[argnum
].mode
;
1842 register rtx val
= argvec
[argnum
].value
;
1843 rtx reg
= argvec
[argnum
].reg
;
1844 int partial
= argvec
[argnum
].partial
;
1846 if (reg
!= 0 && partial
== 0)
1847 emit_move_insn (reg
, val
);
1851 /* For version 1.37, try deleting this entirely. */
1855 /* Any regs containing parms remain in use through the call. */
1857 for (count
= 0; count
< nargs
; count
++)
1858 if (argvec
[count
].reg
!= 0)
1859 emit_insn (gen_rtx (USE
, VOIDmode
, argvec
[count
].reg
));
1861 use_insns
= get_insns ();
1864 fun
= prepare_call_address (fun
, 0, &use_insns
);
1866 /* Don't allow popping to be deferred, since then
1867 cse'ing of library calls could delete a call and leave the pop. */
1870 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
1871 will set inhibit_defer_pop to that value. */
1873 emit_call_1 (fun
, get_identifier (XSTR (orgfun
, 0)), args_size
.constant
, 0,
1874 FUNCTION_ARG (args_so_far
, VOIDmode
, void_type_node
, 1),
1875 outmode
!= VOIDmode
? hard_libcall_value (outmode
) : 0,
1876 old_inhibit_defer_pop
+ 1, use_insns
, no_queue
);
1878 /* Now restore inhibit_defer_pop to its actual original value. */
1882 /* Expand an assignment that stores the value of FROM into TO.
1883 If WANT_VALUE is nonzero, return an rtx for the value of TO.
1884 (This may contain a QUEUED rtx.)
1885 Otherwise, the returned value is not meaningful.
1887 SUGGEST_REG is no longer actually used.
1888 It used to mean, copy the value through a register
1889 and return that register, if that is possible.
1890 But now we do this if WANT_VALUE.
1892 If the value stored is a constant, we return the constant. */
1895 expand_assignment (to
, from
, want_value
, suggest_reg
)
1900 register rtx to_rtx
= 0;
1903 /* Don't crash if the lhs of the assignment was erroneous. */
1905 if (TREE_CODE (to
) == ERROR_MARK
)
1906 return expand_expr (from
, 0, VOIDmode
, 0);
1908 /* Assignment of a structure component needs special treatment
1909 if the structure component's rtx is not simply a MEM.
1910 Assignment of an array element at a constant index
1911 has the same problem. */
1913 if (TREE_CODE (to
) == COMPONENT_REF
1914 || TREE_CODE (to
) == BIT_FIELD_REF
1915 || (TREE_CODE (to
) == ARRAY_REF
1916 && TREE_CODE (TREE_OPERAND (to
, 1)) == INTEGER_CST
1917 && TREE_CODE (TYPE_SIZE (TREE_TYPE (to
))) == INTEGER_CST
))
1919 enum machine_mode mode1
;
1924 tree tem
= get_inner_reference (to
, &bitsize
, &bitpos
,
1925 &mode1
, &unsignedp
, &volatilep
);
1927 /* If we are going to use store_bit_field and extract_bit_field,
1928 make sure to_rtx will be safe for multiple use. */
1930 if (mode1
== VOIDmode
&& want_value
)
1931 tem
= stabilize_reference (tem
);
1933 to_rtx
= expand_expr (tem
, 0, VOIDmode
, 0);
1936 if (GET_CODE (to_rtx
) == MEM
)
1937 MEM_VOLATILE_P (to_rtx
) = 1;
1938 #if 0 /* This was turned off because, when a field is volatile
1939 in an object which is not volatile, the object may be in a register,
1940 and then we would abort over here. */
1946 result
= store_field (to_rtx
, bitsize
, bitpos
, mode1
, from
,
1948 /* Spurious cast makes HPUX compiler happy. */
1949 ? (enum machine_mode
) TYPE_MODE (TREE_TYPE (to
))
1952 /* Required alignment of containing datum. */
1953 TYPE_ALIGN (TREE_TYPE (tem
)) / BITS_PER_UNIT
,
1954 int_size_in_bytes (TREE_TYPE (tem
)));
1955 preserve_temp_slots (result
);
1961 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
1962 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
1965 to_rtx
= expand_expr (to
, 0, VOIDmode
, 0);
1967 /* In case we are returning the contents of an object which overlaps
1968 the place the value is being stored, use a safe function when copying
1969 a value through a pointer into a structure value return block. */
1970 if (TREE_CODE (to
) == RESULT_DECL
&& TREE_CODE (from
) == INDIRECT_REF
1971 && current_function_returns_struct
1972 && !current_function_returns_pcc_struct
)
1974 rtx from_rtx
= expand_expr (from
, 0, VOIDmode
, 0);
1975 rtx size
= expr_size (from
);
1977 #ifdef TARGET_MEM_FUNCTIONS
1978 emit_library_call (memcpy_libfunc
, 1,
1979 VOIDmode
, 3, XEXP (to_rtx
, 0), Pmode
,
1980 XEXP (from_rtx
, 0), Pmode
,
1983 emit_library_call (bcopy_libfunc
, 1,
1984 VOIDmode
, 3, XEXP (from_rtx
, 0), Pmode
,
1985 XEXP (to_rtx
, 0), Pmode
,
1989 preserve_temp_slots (to_rtx
);
1994 /* Compute FROM and store the value in the rtx we got. */
1996 result
= store_expr (from
, to_rtx
, want_value
);
1997 preserve_temp_slots (result
);
2002 /* Generate code for computing expression EXP,
2003 and storing the value into TARGET.
2004 Returns TARGET or an equivalent value.
2005 TARGET may contain a QUEUED rtx.
2007 If SUGGEST_REG is nonzero, copy the value through a register
2008 and return that register, if that is possible.
2010 If the value stored is a constant, we return the constant. */
2013 store_expr (exp
, target
, suggest_reg
)
2015 register rtx target
;
2019 int dont_return_target
= 0;
2021 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
2023 /* Perform first part of compound expression, then assign from second
2025 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
2027 return store_expr (TREE_OPERAND (exp
, 1), target
, suggest_reg
);
2029 else if (TREE_CODE (exp
) == COND_EXPR
&& GET_MODE (target
) == BLKmode
)
2031 /* For conditional expression, get safe form of the target. Then
2032 test the condition, doing the appropriate assignment on either
2033 side. This avoids the creation of unnecessary temporaries.
2034 For non-BLKmode, it is more efficient not to do this. */
2036 rtx lab1
= gen_label_rtx (), lab2
= gen_label_rtx ();
2039 target
= protect_from_queue (target
, 1);
2042 jumpifnot (TREE_OPERAND (exp
, 0), lab1
);
2043 store_expr (TREE_OPERAND (exp
, 1), target
, suggest_reg
);
2045 emit_jump_insn (gen_jump (lab2
));
2048 store_expr (TREE_OPERAND (exp
, 2), target
, suggest_reg
);
2054 else if (suggest_reg
&& GET_CODE (target
) == MEM
2055 && GET_MODE (target
) != BLKmode
)
2056 /* If target is in memory and caller wants value in a register instead,
2057 arrange that. Pass TARGET as target for expand_expr so that,
2058 if EXP is another assignment, SUGGEST_REG will be nonzero for it.
2059 We know expand_expr will not use the target in that case. */
2061 temp
= expand_expr (exp
, cse_not_expected
? 0 : target
,
2062 GET_MODE (target
), 0);
2063 if (GET_MODE (temp
) != BLKmode
&& GET_MODE (temp
) != VOIDmode
)
2064 temp
= copy_to_reg (temp
);
2065 dont_return_target
= 1;
2067 else if (queued_subexp_p (target
))
2068 /* If target contains a postincrement, it is not safe
2069 to use as the returned value. It would access the wrong
2070 place by the time the queued increment gets output.
2071 So copy the value through a temporary and use that temp
2074 if (GET_MODE (target
) != BLKmode
&& GET_MODE (target
) != VOIDmode
)
2076 /* Expand EXP into a new pseudo. */
2077 temp
= gen_reg_rtx (GET_MODE (target
));
2078 temp
= expand_expr (exp
, temp
, GET_MODE (target
), 0);
2081 temp
= expand_expr (exp
, 0, GET_MODE (target
), 0);
2082 dont_return_target
= 1;
2086 temp
= expand_expr (exp
, target
, GET_MODE (target
), 0);
2087 /* DO return TARGET if it's a specified hardware register.
2088 expand_return relies on this. */
2089 if (!(target
&& GET_CODE (target
) == REG
2090 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)
2091 && CONSTANT_P (temp
))
2092 dont_return_target
= 1;
2095 /* If value was not generated in the target, store it there.
2096 Convert the value to TARGET's type first if nec. */
2098 if (temp
!= target
&& TREE_CODE (exp
) != ERROR_MARK
)
2100 target
= protect_from_queue (target
, 1);
2101 if (GET_MODE (temp
) != GET_MODE (target
)
2102 && GET_MODE (temp
) != VOIDmode
)
2104 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (exp
));
2105 if (dont_return_target
)
2107 /* In this case, we will return TEMP,
2108 so make sure it has the proper mode.
2109 But don't forget to store the value into TARGET. */
2110 temp
= convert_to_mode (GET_MODE (target
), temp
, unsignedp
);
2111 emit_move_insn (target
, temp
);
2114 convert_move (target
, temp
, unsignedp
);
2117 else if (GET_MODE (temp
) == BLKmode
&& TREE_CODE (exp
) == STRING_CST
)
2119 /* Handle copying a string constant into an array.
2120 The string constant may be shorter than the array.
2121 So copy just the string's actual length, and clear the rest. */
2124 /* Get the size of the data type of the string,
2125 which is actually the size of the target. */
2126 size
= expr_size (exp
);
2127 if (GET_CODE (size
) == CONST_INT
2128 && INTVAL (size
) < TREE_STRING_LENGTH (exp
))
2129 emit_block_move (target
, temp
, size
,
2130 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
2133 /* Compute the size of the data to copy from the string. */
2135 = fold (build (MIN_EXPR
, sizetype
,
2136 size_binop (CEIL_DIV_EXPR
,
2137 TYPE_SIZE (TREE_TYPE (exp
)),
2138 size_int (BITS_PER_UNIT
)),
2140 build_int_2 (TREE_STRING_LENGTH (exp
), 0))));
2141 rtx copy_size_rtx
= expand_expr (copy_size
, 0, VOIDmode
, 0);
2144 /* Copy that much. */
2145 emit_block_move (target
, temp
, copy_size_rtx
,
2146 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
2148 /* Figure out how much is left in TARGET
2149 that we have to clear. */
2150 if (GET_CODE (copy_size_rtx
) == CONST_INT
)
2152 temp
= plus_constant (XEXP (target
, 0),
2153 TREE_STRING_LENGTH (exp
));
2154 size
= plus_constant (size
,
2155 - TREE_STRING_LENGTH (exp
));
2159 enum machine_mode size_mode
= Pmode
;
2161 temp
= force_reg (Pmode
, XEXP (target
, 0));
2162 temp
= expand_binop (size_mode
, add_optab
, temp
,
2163 copy_size_rtx
, 0, 0, OPTAB_LIB_WIDEN
);
2165 size
= expand_binop (size_mode
, sub_optab
, size
,
2166 copy_size_rtx
, 0, 0, OPTAB_LIB_WIDEN
);
2168 emit_cmp_insn (size
, const0_rtx
, LT
, 0,
2169 GET_MODE (size
), 0, 0);
2170 label
= gen_label_rtx ();
2171 emit_jump_insn (gen_blt (label
));
2174 if (size
!= const0_rtx
)
2176 #ifdef TARGET_MEM_FUNCTIONS
2177 emit_library_call (memset_libfunc
, 1, VOIDmode
, 3,
2178 temp
, Pmode
, const0_rtx
, Pmode
, size
, Pmode
);
2180 emit_library_call (bzero_libfunc
, 1, VOIDmode
, 2,
2181 temp
, Pmode
, size
, Pmode
);
2188 else if (GET_MODE (temp
) == BLKmode
)
2189 emit_block_move (target
, temp
, expr_size (exp
),
2190 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
2192 emit_move_insn (target
, temp
);
2194 if (dont_return_target
)
2199 /* Store the value of constructor EXP into the rtx TARGET.
2200 TARGET is either a REG or a MEM. */
2203 store_constructor (exp
, target
)
2207 tree type
= TREE_TYPE (exp
);
2209 /* We know our target cannot conflict, since safe_from_p has been called. */
2211 /* Don't try copying piece by piece into a hard register
2212 since that is vulnerable to being clobbered by EXP.
2213 Instead, construct in a pseudo register and then copy it all. */
2214 if (GET_CODE (target
) == REG
&& REGNO (target
) < FIRST_PSEUDO_REGISTER
)
2216 rtx temp
= gen_reg_rtx (GET_MODE (target
));
2217 store_constructor (exp
, temp
);
2218 emit_move_insn (target
, temp
);
2223 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
)
2227 /* Inform later passes that the whole union value is dead. */
2228 if (TREE_CODE (type
) == UNION_TYPE
)
2229 emit_insn (gen_rtx (CLOBBER
, VOIDmode
, target
));
2231 /* If we are building a static constructor into a register,
2232 set the initial value as zero so we can fold the value into
2234 else if (GET_CODE (target
) == REG
&& TREE_STATIC (exp
))
2235 emit_move_insn (target
, const0_rtx
);
2237 /* If the constructor has fewer fields than the structure,
2238 clear the whole structure first. */
2239 else if (list_length (CONSTRUCTOR_ELTS (exp
))
2240 != list_length (TYPE_FIELDS (type
)))
2241 clear_storage (target
, int_size_in_bytes (type
));
2243 /* Inform later passes that the old value is dead. */
2244 emit_insn (gen_rtx (CLOBBER
, VOIDmode
, target
));
2246 /* Store each element of the constructor into
2247 the corresponding field of TARGET. */
2249 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
2251 register tree field
= TREE_PURPOSE (elt
);
2252 register enum machine_mode mode
;
2257 bitsize
= TREE_INT_CST_LOW (DECL_SIZE (field
));
2258 unsignedp
= TREE_UNSIGNED (field
);
2259 mode
= DECL_MODE (field
);
2260 if (DECL_BIT_FIELD (field
))
2263 if (TREE_CODE (DECL_FIELD_BITPOS (field
)) != INTEGER_CST
)
2264 /* ??? This case remains to be written. */
2267 bitpos
= TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
));
2269 store_field (target
, bitsize
, bitpos
, mode
, TREE_VALUE (elt
),
2270 /* The alignment of TARGET is
2271 at least what its type requires. */
2273 TYPE_ALIGN (type
) / BITS_PER_UNIT
,
2274 int_size_in_bytes (type
));
2277 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2281 tree domain
= TYPE_DOMAIN (type
);
2282 int minelt
= TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
));
2283 int maxelt
= TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
));
2284 tree elttype
= TREE_TYPE (type
);
2286 /* If the constructor has fewer fields than the structure,
2287 clear the whole structure first. Similarly if this this is
2288 static constructor of a non-BLKmode object. */
2290 if (list_length (CONSTRUCTOR_ELTS (exp
)) < maxelt
- minelt
+ 1
2291 || (GET_CODE (target
) == REG
&& TREE_STATIC (exp
)))
2292 clear_storage (target
, maxelt
- minelt
+ 1);
2294 /* Inform later passes that the old value is dead. */
2295 emit_insn (gen_rtx (CLOBBER
, VOIDmode
, target
));
2297 /* Store each element of the constructor into
2298 the corresponding element of TARGET, determined
2299 by counting the elements. */
2300 for (elt
= CONSTRUCTOR_ELTS (exp
), i
= 0;
2302 elt
= TREE_CHAIN (elt
), i
++)
2304 register enum machine_mode mode
;
2309 mode
= TYPE_MODE (elttype
);
2310 bitsize
= GET_MODE_BITSIZE (mode
);
2311 unsignedp
= TREE_UNSIGNED (elttype
);
2313 bitpos
= (i
* TREE_INT_CST_LOW (TYPE_SIZE (elttype
)));
2315 store_field (target
, bitsize
, bitpos
, mode
, TREE_VALUE (elt
),
2316 /* The alignment of TARGET is
2317 at least what its type requires. */
2319 TYPE_ALIGN (type
) / BITS_PER_UNIT
,
2320 int_size_in_bytes (type
));
2328 /* Store the value of EXP (an expression tree)
2329 into a subfield of TARGET which has mode MODE and occupies
2330 BITSIZE bits, starting BITPOS bits from the start of TARGET.
2331 If MODE is VOIDmode, it means that we are storing into a bit-field.
2333 If VALUE_MODE is VOIDmode, return nothing in particular.
2334 UNSIGNEDP is not used in this case.
2336 Otherwise, return an rtx for the value stored. This rtx
2337 has mode VALUE_MODE if that is convenient to do.
2338 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
2340 ALIGN is the alignment that TARGET is known to have, measured in bytes.
2341 TOTAL_SIZE is the size in bytes of the structure, or -1 if varying. */
2344 store_field (target
, bitsize
, bitpos
, mode
, exp
, value_mode
,
2345 unsignedp
, align
, total_size
)
2347 int bitsize
, bitpos
;
2348 enum machine_mode mode
;
2350 enum machine_mode value_mode
;
2357 if (bitsize
< HOST_BITS_PER_INT
)
2358 width_mask
= (1 << bitsize
) - 1;
2360 /* If we are storing into an unaligned field of an aligned union that is
2361 in a register, we may have the mode of TARGET being an integer mode but
2362 MODE == BLKmode. In that case, get an aligned object whose size and
2363 alignment are the same as TARGET and store TARGET into it (we can avoid
2364 the store if the field being stored is the entire width of TARGET). Then
2365 call ourselves recursively to store the field into a BLKmode version of
2366 that object. Finally, load from the object into TARGET. This is not
2367 very efficient in general, but should only be slightly more expensive
2368 than the otherwise-required unaligned accesses. Perhaps this can be
2369 cleaned up later. */
2372 && (GET_CODE (target
) == REG
|| GET_CODE (target
) == SUBREG
))
2374 rtx object
= assign_stack_temp (GET_MODE (target
),
2375 GET_MODE_SIZE (GET_MODE (target
)), 0);
2376 rtx blk_object
= copy_rtx (object
);
2378 PUT_MODE (blk_object
, BLKmode
);
2380 if (bitsize
!= GET_MODE_BITSIZE (GET_MODE (target
)))
2381 emit_move_insn (object
, target
);
2383 store_field (blk_object
, bitsize
, bitpos
, mode
, exp
, VOIDmode
, 0,
2386 emit_move_insn (target
, object
);
2391 /* If the structure is in a register or if the component
2392 is a bit field, we cannot use addressing to access it.
2393 Use bit-field techniques or SUBREG to store in it. */
2395 if (mode
== VOIDmode
|| GET_CODE (target
) == REG
2396 || GET_CODE (target
) == SUBREG
)
2398 rtx temp
= expand_expr (exp
, 0, VOIDmode
, 0);
2399 /* Store the value in the bitfield. */
2400 store_bit_field (target
, bitsize
, bitpos
, mode
, temp
, align
, total_size
);
2401 if (value_mode
!= VOIDmode
)
2403 /* The caller wants an rtx for the value. */
2404 /* If possible, avoid refetching from the bitfield itself. */
2406 && ! (GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
)))
2407 return expand_and (temp
,
2408 gen_rtx (CONST_INT
, VOIDmode
, width_mask
), 0);
2409 return extract_bit_field (target
, bitsize
, bitpos
, unsignedp
,
2410 0, value_mode
, 0, align
, total_size
);
2416 rtx addr
= XEXP (target
, 0);
2419 /* If a value is wanted, it must be the lhs;
2420 so make the address stable for multiple use. */
2422 if (value_mode
!= VOIDmode
&& GET_CODE (addr
) != REG
2423 && ! CONSTANT_ADDRESS_P (addr
)
2424 /* A frame-pointer reference is already stable. */
2425 && ! (GET_CODE (addr
) == PLUS
2426 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
2427 && (XEXP (addr
, 0) == virtual_incoming_args_rtx
2428 || XEXP (addr
, 0) == virtual_stack_vars_rtx
)))
2429 addr
= copy_to_reg (addr
);
2431 /* Now build a reference to just the desired component. */
2433 to_rtx
= change_address (target
, mode
,
2434 plus_constant (addr
, (bitpos
/ BITS_PER_UNIT
)));
2435 MEM_IN_STRUCT_P (to_rtx
) = 1;
2437 return store_expr (exp
, to_rtx
, value_mode
!= VOIDmode
);
2441 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
2442 or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
2443 ARRAY_REFs at constant positions and find the ultimate containing object,
2446 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
2447 bit position, and *PUNSIGNEDP to the signedness of the field.
2449 If any of the extraction expressions is volatile,
2450 we store 1 in *PVOLATILEP. Otherwise we don't change that.
2452 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
2453 is a mode that can be used to access the field. In that case, *PBITSIZE
2456 If the field describes a variable-sized object, *PMODE is set to
2457 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
2458 this case, but the address of the object can be found. */
2461 get_inner_reference (exp
, pbitsize
, pbitpos
, pmode
, punsignedp
, pvolatilep
)
2465 enum machine_mode
*pmode
;
2470 enum machine_mode mode
= VOIDmode
;
2472 if (TREE_CODE (exp
) == COMPONENT_REF
)
2474 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
2475 if (! DECL_BIT_FIELD (TREE_OPERAND (exp
, 1)))
2476 mode
= DECL_MODE (TREE_OPERAND (exp
, 1));
2477 *punsignedp
= TREE_UNSIGNED (TREE_OPERAND (exp
, 1));
2479 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
2481 size_tree
= TREE_OPERAND (exp
, 1);
2482 *punsignedp
= TREE_UNSIGNED (exp
);
2486 mode
= TYPE_MODE (TREE_TYPE (exp
));
2487 *pbitsize
= GET_MODE_BITSIZE (mode
);
2488 *punsignedp
= TREE_UNSIGNED (TREE_TYPE (exp
));
2493 if (TREE_CODE (size_tree
) != INTEGER_CST
)
2494 mode
= BLKmode
, *pbitsize
= -1;
2496 *pbitsize
= TREE_INT_CST_LOW (size_tree
);
2499 /* Compute cumulative bit-offset for nested component-refs and array-refs,
2500 and find the ultimate containing object. */
2506 if (TREE_CODE (exp
) == COMPONENT_REF
)
2508 tree field
= TREE_OPERAND (exp
, 1);
2510 if (TREE_CODE (DECL_FIELD_BITPOS (field
)) != INTEGER_CST
)
2511 /* ??? This case remains to be written. */
2514 *pbitpos
+= TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
));
2515 if (TREE_THIS_VOLATILE (exp
))
2518 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
2520 if (TREE_CODE (TREE_OPERAND (exp
, 2)) != INTEGER_CST
)
2521 /* ??? This case remains to be written. */
2524 *pbitpos
+= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 2));
2525 if (TREE_THIS_VOLATILE (exp
))
2528 else if (TREE_CODE (exp
) == ARRAY_REF
2529 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
2530 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) == INTEGER_CST
)
2532 *pbitpos
+= (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))
2533 * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp
))));
2534 if (TREE_THIS_VOLATILE (exp
))
2537 else if (TREE_CODE (exp
) != NON_LVALUE_EXPR
2538 && ! ((TREE_CODE (exp
) == NOP_EXPR
2539 || TREE_CODE (exp
) == CONVERT_EXPR
)
2540 && (TYPE_MODE (TREE_TYPE (exp
))
2541 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))))
2543 exp
= TREE_OPERAND (exp
, 0);
2546 /* If this was a bit-field, see if there is a mode that allows direct
2547 access in case EXP is in memory. */
2548 if (mode
== VOIDmode
&& *pbitpos
% *pbitsize
== 0)
2550 mode
= mode_for_size (*pbitsize
, MODE_INT
, 0);
2551 if (mode
== BLKmode
)
2560 /* Given an rtx VALUE that may contain additions and multiplications,
2561 return an equivalent value that just refers to a register or memory.
2562 This is done by generating instructions to perform the arithmetic
2563 and returning a pseudo-register containing the value. */
2566 force_operand (value
, target
)
2569 register optab binoptab
= 0;
2570 /* Use a temporary to force order of execution of calls to
2574 /* Use subtarget as the target for operand 0 of a binary operation. */
2575 register rtx subtarget
= (target
!= 0 && GET_CODE (target
) == REG
? target
: 0);
2577 if (GET_CODE (value
) == PLUS
)
2578 binoptab
= add_optab
;
2579 else if (GET_CODE (value
) == MINUS
)
2580 binoptab
= sub_optab
;
2581 else if (GET_CODE (value
) == MULT
)
2583 op2
= XEXP (value
, 1);
2584 if (!CONSTANT_P (op2
)
2585 && !(GET_CODE (op2
) == REG
&& op2
!= subtarget
))
2587 tmp
= force_operand (XEXP (value
, 0), subtarget
);
2588 return expand_mult (GET_MODE (value
), tmp
,
2589 force_operand (op2
, 0),
2595 op2
= XEXP (value
, 1);
2596 if (!CONSTANT_P (op2
)
2597 && !(GET_CODE (op2
) == REG
&& op2
!= subtarget
))
2599 if (binoptab
== sub_optab
&& GET_CODE (op2
) == CONST_INT
)
2601 binoptab
= add_optab
;
2602 op2
= negate_rtx (GET_MODE (value
), op2
);
2605 /* Check for an addition with OP2 a constant integer and our first
2606 operand a PLUS of a virtual register and something else. In that
2607 case, we want to emit the sum of the virtual register and the
2608 constant first and then add the other value. This allows virtual
2609 register instantiation to simply modify the constant rather than
2610 creating another one around this addition. */
2611 if (binoptab
== add_optab
&& GET_CODE (op2
) == CONST_INT
2612 && GET_CODE (XEXP (value
, 0)) == PLUS
2613 && GET_CODE (XEXP (XEXP (value
, 0), 0)) == REG
2614 && REGNO (XEXP (XEXP (value
, 0), 0)) >= FIRST_VIRTUAL_REGISTER
2615 && REGNO (XEXP (XEXP (value
, 0), 0)) <= LAST_VIRTUAL_REGISTER
)
2617 rtx temp
= expand_binop (GET_MODE (value
), binoptab
,
2618 XEXP (XEXP (value
, 0), 0), op2
,
2619 subtarget
, 0, OPTAB_LIB_WIDEN
);
2620 return expand_binop (GET_MODE (value
), binoptab
, temp
,
2621 force_operand (XEXP (XEXP (value
, 0), 1), 0),
2622 target
, 0, OPTAB_LIB_WIDEN
);
2625 tmp
= force_operand (XEXP (value
, 0), subtarget
);
2626 return expand_binop (GET_MODE (value
), binoptab
, tmp
,
2627 force_operand (op2
, 0),
2628 target
, 0, OPTAB_LIB_WIDEN
);
2629 /* We give UNSIGNEP = 0 to expand_binop
2630 because the only operations we are expanding here are signed ones. */
2635 /* Subroutine of expand_expr:
2636 save the non-copied parts (LIST) of an expr (LHS), and return a list
2637 which can restore these values to their previous values,
2638 should something modify their storage. */
2641 save_noncopied_parts (lhs
, list
)
2648 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2649 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
2650 parts
= chainon (parts
, save_noncopied_parts (lhs
, TREE_VALUE (tail
)));
2653 tree part
= TREE_VALUE (tail
);
2654 tree part_type
= TREE_TYPE (part
);
2655 tree to_be_saved
= build (COMPONENT_REF
, part_type
, lhs
, part
, 0);
2656 rtx target
= assign_stack_temp (TYPE_MODE (part_type
),
2657 int_size_in_bytes (part_type
), 0);
2658 if (! memory_address_p (TYPE_MODE (part_type
), XEXP (target
, 0)))
2659 target
= change_address (target
, TYPE_MODE (part_type
), 0);
2660 parts
= tree_cons (to_be_saved
,
2661 build (RTL_EXPR
, part_type
, 0, (tree
) target
),
2663 store_expr (TREE_PURPOSE (parts
), RTL_EXPR_RTL (TREE_VALUE (parts
)), 0);
2668 /* Subroutine of expand_expr:
2669 record the non-copied parts (LIST) of an expr (LHS), and return a list
2670 which specifies the initial values of these parts. */
2673 init_noncopied_parts (lhs
, list
)
2680 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2681 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
2682 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
2685 tree part
= TREE_VALUE (tail
);
2686 tree part_type
= TREE_TYPE (part
);
2687 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
, 0);
2688 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
2693 /* Subroutine of expand_expr: return nonzero iff there is no way that
2694 EXP can reference X, which is being modified. */
2697 safe_from_p (x
, exp
)
2707 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
2708 find the underlying pseudo. */
2709 if (GET_CODE (x
) == SUBREG
)
2712 if (GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
2716 /* If X is a location in the outgoing argument area, it is always safe. */
2717 if (GET_CODE (x
) == MEM
2718 && (XEXP (x
, 0) == virtual_outgoing_args_rtx
2719 || (GET_CODE (XEXP (x
, 0)) == PLUS
2720 && XEXP (XEXP (x
, 0), 0) == virtual_outgoing_args_rtx
)))
2723 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
2726 exp_rtl
= DECL_RTL (exp
);
2733 if (TREE_CODE (exp
) == TREE_LIST
)
2734 return (safe_from_p (x
, TREE_VALUE (exp
))
2735 && (TREE_CHAIN (exp
) == 0
2736 || safe_from_p (x
, TREE_CHAIN (exp
))));
2741 return safe_from_p (x
, TREE_OPERAND (exp
, 0));
2745 return (safe_from_p (x
, TREE_OPERAND (exp
, 0))
2746 && safe_from_p (x
, TREE_OPERAND (exp
, 1)));
2750 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
2751 the expression. If it is set, we conflict iff we are that rtx or
2752 both are in memory. Otherwise, we check all operands of the
2753 expression recursively. */
2755 switch (TREE_CODE (exp
))
2758 return staticp (TREE_OPERAND (exp
, 0));
2761 if (GET_CODE (x
) == MEM
)
2766 exp_rtl
= CALL_EXPR_RTL (exp
);
2769 /* Assume that the call will clobber all hard registers and
2771 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
2772 || GET_CODE (x
) == MEM
)
2779 exp_rtl
= RTL_EXPR_RTL (exp
);
2781 /* We don't know what this can modify. */
2786 case WITH_CLEANUP_EXPR
:
2787 exp_rtl
= RTL_EXPR_RTL (exp
);
2791 exp_rtl
= SAVE_EXPR_RTL (exp
);
2795 /* The only operand we look at is operand 1. The rest aren't
2796 part of the expression. */
2797 return safe_from_p (x
, TREE_OPERAND (exp
, 1));
2799 case METHOD_CALL_EXPR
:
2800 /* This takes a rtx argument, but shouldn't appear here. */
2804 /* If we have an rtx, we do not need to scan our operands. */
2808 nops
= tree_code_length
[(int) TREE_CODE (exp
)];
2809 for (i
= 0; i
< nops
; i
++)
2810 if (TREE_OPERAND (exp
, i
) != 0
2811 && ! safe_from_p (x
, TREE_OPERAND (exp
, i
)))
2815 /* If we have an rtl, find any enclosed object. Then see if we conflict
2819 if (GET_CODE (exp_rtl
) == SUBREG
)
2821 exp_rtl
= SUBREG_REG (exp_rtl
);
2822 if (GET_CODE (exp_rtl
) == REG
2823 && REGNO (exp_rtl
) < FIRST_PSEUDO_REGISTER
)
2827 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
2828 are memory and EXP is not readonly. */
2829 return ! (rtx_equal_p (x
, exp_rtl
)
2830 || (GET_CODE (x
) == MEM
&& GET_CODE (exp_rtl
) == MEM
2831 && ! TREE_READONLY (exp
)));
2834 /* If we reach here, it is safe. */
2838 /* Subroutine of expand_expr: return nonzero iff EXP is an
2839 expression whose type is statically determinable. */
2845 if (TREE_CODE (exp
) == PARM_DECL
2846 || TREE_CODE (exp
) == VAR_DECL
2847 || TREE_CODE (exp
) == CALL_EXPR
|| TREE_CODE (exp
) == TARGET_EXPR
2848 || TREE_CODE (exp
) == COMPONENT_REF
2849 || TREE_CODE (exp
) == ARRAY_REF
)
2854 /* expand_expr: generate code for computing expression EXP.
2855 An rtx for the computed value is returned. The value is never null.
2856 In the case of a void EXP, const0_rtx is returned.
2858 The value may be stored in TARGET if TARGET is nonzero.
2859 TARGET is just a suggestion; callers must assume that
2860 the rtx returned may not be the same as TARGET.
2862 If TARGET is CONST0_RTX, it means that the value will be ignored.
2864 If TMODE is not VOIDmode, it suggests generating the
2865 result in mode TMODE. But this is done only when convenient.
2866 Otherwise, TMODE is ignored and the value generated in its natural mode.
2867 TMODE is just a suggestion; callers must assume that
2868 the rtx returned may not have mode TMODE.
2870 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
2871 with a constant address even if that address is not normally legitimate.
2872 EXPAND_INITIALIZER and EXPAND_SUM also have this effect.
2874 If MODIFIER is EXPAND_SUM then when EXP is an addition
2875 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
2876 or a nest of (PLUS ...) and (MINUS ...) where the terms are
2877 products as above, or REG or MEM, or constant.
2878 Ordinarily in such cases we would output mul or add instructions
2879 and then return a pseudo reg containing the sum.
2881 EXPAND_INITIALIZER is much like EXPAND_SUM except that
2882 it also marks a label as absolutely required (it can't be dead).
2883 This is used for outputting expressions used in intializers. */
2886 expand_expr (exp
, target
, tmode
, modifier
)
2889 enum machine_mode tmode
;
2890 enum expand_modifier modifier
;
2892 register rtx op0
, op1
, temp
;
2893 tree type
= TREE_TYPE (exp
);
2894 int unsignedp
= TREE_UNSIGNED (type
);
2895 register enum machine_mode mode
= TYPE_MODE (type
);
2896 register enum tree_code code
= TREE_CODE (exp
);
2898 /* Use subtarget as the target for operand 0 of a binary operation. */
2899 rtx subtarget
= (target
!= 0 && GET_CODE (target
) == REG
? target
: 0);
2900 rtx original_target
= target
;
2901 int ignore
= target
== const0_rtx
;
2904 /* Don't use hard regs as subtargets, because the combiner
2905 can only handle pseudo regs. */
2906 if (subtarget
&& REGNO (subtarget
) < FIRST_PSEUDO_REGISTER
)
2908 /* Avoid subtargets inside loops,
2909 since they hide some invariant expressions. */
2910 if (preserve_subexpressions_p ())
2913 if (ignore
) target
= 0, original_target
= 0;
2915 /* If will do cse, generate all results into pseudo registers
2916 since 1) that allows cse to find more things
2917 and 2) otherwise cse could produce an insn the machine
2920 if (! cse_not_expected
&& mode
!= BLKmode
&& target
2921 && (GET_CODE (target
) != REG
|| REGNO (target
) < FIRST_PSEUDO_REGISTER
))
2924 /* Ensure we reference a volatile object even if value is ignored. */
2925 if (ignore
&& TREE_THIS_VOLATILE (exp
)
2926 && mode
!= VOIDmode
&& mode
!= BLKmode
)
2928 target
= gen_reg_rtx (mode
);
2929 temp
= expand_expr (exp
, target
, VOIDmode
, modifier
);
2931 emit_move_insn (target
, temp
);
2938 if (modifier
== EXPAND_INITIALIZER
)
2939 forced_labels
= gen_rtx (EXPR_LIST
, VOIDmode
,
2940 label_rtx (exp
), forced_labels
);
2941 return gen_rtx (MEM
, FUNCTION_MODE
,
2942 gen_rtx (LABEL_REF
, Pmode
, label_rtx (exp
)));
2945 if (DECL_RTL (exp
) == 0)
2947 error_with_decl (exp
, "prior parameter's size depends on `%s'");
2948 return CONST0_RTX (mode
);
2954 if (DECL_RTL (exp
) == 0)
2956 /* Ensure variable marked as used
2957 even if it doesn't go through a parser. */
2958 TREE_USED (exp
) = 1;
2959 /* Handle variables inherited from containing functions. */
2960 context
= decl_function_context (exp
);
2962 /* We treat inline_function_decl as an alias for the current function
2963 because that is the inline function whose vars, types, etc.
2964 are being merged into the current function.
2965 See expand_inline_function. */
2966 if (context
!= 0 && context
!= current_function_decl
2967 && context
!= inline_function_decl
2968 /* If var is static, we don't need a static chain to access it. */
2969 && ! (GET_CODE (DECL_RTL (exp
)) == MEM
2970 && CONSTANT_P (XEXP (DECL_RTL (exp
), 0))))
2974 /* Mark as non-local and addressable. */
2975 TREE_NONLOCAL (exp
) = 1;
2976 mark_addressable (exp
);
2977 if (GET_CODE (DECL_RTL (exp
)) != MEM
)
2979 addr
= XEXP (DECL_RTL (exp
), 0);
2980 if (GET_CODE (addr
) == MEM
)
2981 addr
= gen_rtx (MEM
, Pmode
, fix_lexical_addr (XEXP (addr
, 0), exp
));
2983 addr
= fix_lexical_addr (addr
, exp
);
2984 return change_address (DECL_RTL (exp
), mode
, addr
);
2987 /* This is the case of an array whose size is to be determined
2988 from its initializer, while the initializer is still being parsed.
2990 if (GET_CODE (DECL_RTL (exp
)) == MEM
2991 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) == REG
)
2992 return change_address (DECL_RTL (exp
), GET_MODE (DECL_RTL (exp
)),
2993 XEXP (DECL_RTL (exp
), 0));
2994 if (GET_CODE (DECL_RTL (exp
)) == MEM
2995 && modifier
!= EXPAND_CONST_ADDRESS
2996 && modifier
!= EXPAND_SUM
2997 && modifier
!= EXPAND_INITIALIZER
)
2999 /* DECL_RTL probably contains a constant address.
3000 On RISC machines where a constant address isn't valid,
3001 make some insns to get that address into a register. */
3002 if (!memory_address_p (DECL_MODE (exp
), XEXP (DECL_RTL (exp
), 0))
3004 && CONSTANT_ADDRESS_P (XEXP (DECL_RTL (exp
), 0))))
3005 return change_address (DECL_RTL (exp
), VOIDmode
,
3006 copy_rtx (XEXP (DECL_RTL (exp
), 0)));
3008 return DECL_RTL (exp
);
3011 return immed_double_const (TREE_INT_CST_LOW (exp
),
3012 TREE_INT_CST_HIGH (exp
),
3016 return expand_expr (DECL_INITIAL (exp
), target
, VOIDmode
, 0);
3019 /* If optimized, generate immediate CONST_DOUBLE
3020 which will be turned into memory by reload if necessary.
3022 We used to force a register so that loop.c could see it. But
3023 this does not allow gen_* patterns to perform optimizations with
3024 the constants. It also produces two insns in cases like "x = 1.0;".
3025 On most machines, floating-point constants are not permitted in
3026 many insns, so we'd end up copying it to a register in any case.
3028 Now, we do the copying in expand_binop, if appropriate. */
3029 return immed_real_const (exp
);
3033 if (! TREE_CST_RTL (exp
))
3034 output_constant_def (exp
);
3036 /* TREE_CST_RTL probably contains a constant address.
3037 On RISC machines where a constant address isn't valid,
3038 make some insns to get that address into a register. */
3039 if (GET_CODE (TREE_CST_RTL (exp
)) == MEM
3040 && modifier
!= EXPAND_CONST_ADDRESS
3041 && modifier
!= EXPAND_INITIALIZER
3042 && modifier
!= EXPAND_SUM
3043 && !memory_address_p (mode
, XEXP (TREE_CST_RTL (exp
), 0)))
3044 return change_address (TREE_CST_RTL (exp
), VOIDmode
,
3045 copy_rtx (XEXP (TREE_CST_RTL (exp
), 0)));
3046 return TREE_CST_RTL (exp
);
3049 context
= decl_function_context (exp
);
3050 /* We treat inline_function_decl as an alias for the current function
3051 because that is the inline function whose vars, types, etc.
3052 are being merged into the current function.
3053 See expand_inline_function. */
3054 if (context
== current_function_decl
|| context
== inline_function_decl
)
3057 /* If this is non-local, handle it. */
3060 temp
= SAVE_EXPR_RTL (exp
);
3061 if (temp
&& GET_CODE (temp
) == REG
)
3063 put_var_into_stack (exp
);
3064 temp
= SAVE_EXPR_RTL (exp
);
3066 if (temp
== 0 || GET_CODE (temp
) != MEM
)
3068 return change_address (temp
, mode
,
3069 fix_lexical_addr (XEXP (temp
, 0), exp
));
3071 if (SAVE_EXPR_RTL (exp
) == 0)
3073 if (mode
== BLKmode
)
3075 = assign_stack_temp (mode
,
3076 int_size_in_bytes (TREE_TYPE (exp
)), 0);
3078 temp
= gen_reg_rtx (mode
);
3079 SAVE_EXPR_RTL (exp
) = temp
;
3080 store_expr (TREE_OPERAND (exp
, 0), temp
, 0);
3081 if (!optimize
&& GET_CODE (temp
) == REG
)
3082 save_expr_regs
= gen_rtx (EXPR_LIST
, VOIDmode
, temp
,
3085 return SAVE_EXPR_RTL (exp
);
3088 /* Exit the current loop if the body-expression is true. */
3090 rtx label
= gen_label_rtx ();
3091 do_jump (TREE_OPERAND (exp
, 0), label
, 0);
3092 expand_exit_loop (0);
3098 expand_start_loop (1);
3099 expand_expr_stmt (TREE_OPERAND (exp
, 0));
3106 tree vars
= TREE_OPERAND (exp
, 0);
3107 int vars_need_expansion
= 0;
3109 /* Need to open a binding contour here because
3110 if there are any cleanups they most be contained here. */
3111 expand_start_bindings (0);
3113 /* Mark the corresponding BLOCK for output. */
3114 if (TREE_OPERAND (exp
, 2) != 0)
3115 TREE_USED (TREE_OPERAND (exp
, 2)) = 1;
3117 /* If VARS have not yet been expanded, expand them now. */
3120 if (DECL_RTL (vars
) == 0)
3122 vars_need_expansion
= 1;
3125 expand_decl_init (vars
);
3126 vars
= TREE_CHAIN (vars
);
3129 temp
= expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, modifier
);
3131 expand_end_bindings (TREE_OPERAND (exp
, 0), 0, 0);
3137 if (RTL_EXPR_SEQUENCE (exp
) == const0_rtx
)
3139 emit_insns (RTL_EXPR_SEQUENCE (exp
));
3140 RTL_EXPR_SEQUENCE (exp
) = const0_rtx
;
3141 return RTL_EXPR_RTL (exp
);
3144 /* All elts simple constants => refer to a constant in memory. But
3145 if this is a non-BLKmode mode, let it store a field at a time
3146 since that should make a CONST_INT or CONST_DOUBLE when we
3148 if (TREE_STATIC (exp
) && (mode
== BLKmode
|| TREE_ADDRESSABLE (exp
)))
3150 rtx constructor
= output_constant_def (exp
);
3151 if (! memory_address_p (GET_MODE (constructor
),
3152 XEXP (constructor
, 0)))
3153 constructor
= change_address (constructor
, VOIDmode
,
3154 XEXP (constructor
, 0));
3161 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
3162 expand_expr (TREE_VALUE (elt
), const0_rtx
, VOIDmode
, 0);
3167 if (target
== 0 || ! safe_from_p (target
, exp
))
3169 if (mode
!= BLKmode
&& ! TREE_ADDRESSABLE (exp
))
3170 target
= gen_reg_rtx (mode
);
3173 rtx safe_target
= assign_stack_temp (mode
, int_size_in_bytes (type
), 0);
3175 MEM_IN_STRUCT_P (safe_target
) = MEM_IN_STRUCT_P (target
);
3176 target
= safe_target
;
3179 store_constructor (exp
, target
);
3185 tree exp1
= TREE_OPERAND (exp
, 0);
3188 /* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated
3189 for *PTR += ANYTHING where PTR is put inside the SAVE_EXPR.
3190 This code has the same general effect as simply doing
3191 expand_expr on the save expr, except that the expression PTR
3192 is computed for use as a memory address. This means different
3193 code, suitable for indexing, may be generated. */
3194 if (TREE_CODE (exp1
) == SAVE_EXPR
3195 && SAVE_EXPR_RTL (exp1
) == 0
3196 && TREE_CODE (exp2
= TREE_OPERAND (exp1
, 0)) != ERROR_MARK
3197 && TYPE_MODE (TREE_TYPE (exp1
)) == Pmode
3198 && TYPE_MODE (TREE_TYPE (exp2
)) == Pmode
)
3200 temp
= expand_expr (TREE_OPERAND (exp1
, 0), 0, VOIDmode
, EXPAND_SUM
);
3201 op0
= memory_address (mode
, temp
);
3202 op0
= copy_all_regs (op0
);
3203 SAVE_EXPR_RTL (exp1
) = op0
;
3207 op0
= expand_expr (exp1
, 0, VOIDmode
, EXPAND_SUM
);
3208 op0
= memory_address (mode
, op0
);
3211 temp
= gen_rtx (MEM
, mode
, op0
);
3212 /* If address was computed by addition,
3213 mark this as an element of an aggregate. */
3214 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
3215 || (TREE_CODE (TREE_OPERAND (exp
, 0)) == SAVE_EXPR
3216 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) == PLUS_EXPR
)
3217 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
3218 || TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
3219 || TREE_CODE (TREE_TYPE (exp
)) == UNION_TYPE
3220 || (TREE_CODE (exp1
) == ADDR_EXPR
3221 && (exp2
= TREE_OPERAND (exp1
, 0))
3222 && (TREE_CODE (TREE_TYPE (exp2
)) == ARRAY_TYPE
3223 || TREE_CODE (TREE_TYPE (exp2
)) == RECORD_TYPE
3224 || TREE_CODE (TREE_TYPE (exp2
)) == UNION_TYPE
)))
3225 MEM_IN_STRUCT_P (temp
) = 1;
3226 MEM_VOLATILE_P (temp
) = TREE_THIS_VOLATILE (exp
) || flag_volatile
;
3227 #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that
3228 a location is accessed through a pointer to const does not mean
3229 that the value there can never change. */
3230 RTX_UNCHANGING_P (temp
) = TREE_READONLY (exp
);
3236 if (TREE_CODE (TREE_OPERAND (exp
, 1)) != INTEGER_CST
3237 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
3239 /* Nonconstant array index or nonconstant element size.
3240 Generate the tree for *(&array+index) and expand that,
3241 except do it in a language-independent way
3242 and don't complain about non-lvalue arrays.
3243 `mark_addressable' should already have been called
3244 for any array for which this case will be reached. */
3246 /* Don't forget the const or volatile flag from the array element. */
3247 tree variant_type
= build_type_variant (type
,
3248 TREE_READONLY (exp
),
3249 TREE_THIS_VOLATILE (exp
));
3250 tree array_adr
= build1 (ADDR_EXPR
, build_pointer_type (variant_type
),
3251 TREE_OPERAND (exp
, 0));
3252 tree index
= TREE_OPERAND (exp
, 1);
3255 /* Convert the integer argument to a type the same size as a pointer
3256 so the multiply won't overflow spuriously. */
3257 if (TYPE_PRECISION (TREE_TYPE (index
)) != POINTER_SIZE
)
3258 index
= convert (type_for_size (POINTER_SIZE
, 0), index
);
3260 /* Don't think the address has side effects
3261 just because the array does.
3262 (In some cases the address might have side effects,
3263 and we fail to record that fact here. However, it should not
3264 matter, since expand_expr should not care.) */
3265 TREE_SIDE_EFFECTS (array_adr
) = 0;
3267 elt
= build1 (INDIRECT_REF
, type
,
3268 fold (build (PLUS_EXPR
, TYPE_POINTER_TO (variant_type
),
3270 fold (build (MULT_EXPR
,
3271 TYPE_POINTER_TO (variant_type
),
3272 index
, size_in_bytes (type
))))));
3274 /* Volatility, etc., of new expression is same as old expression. */
3275 TREE_SIDE_EFFECTS (elt
) = TREE_SIDE_EFFECTS (exp
);
3276 TREE_THIS_VOLATILE (elt
) = TREE_THIS_VOLATILE (exp
);
3277 TREE_READONLY (elt
) = TREE_READONLY (exp
);
3279 return expand_expr (elt
, target
, tmode
, modifier
);
3282 /* Fold an expression like: "foo"[2].
3283 This is not done in fold so it won't happen inside &. */
3286 tree arg0
= TREE_OPERAND (exp
, 0);
3287 tree arg1
= TREE_OPERAND (exp
, 1);
3289 if (TREE_CODE (arg0
) == STRING_CST
3290 && TREE_CODE (arg1
) == INTEGER_CST
3291 && !TREE_INT_CST_HIGH (arg1
)
3292 && (i
= TREE_INT_CST_LOW (arg1
)) < TREE_STRING_LENGTH (arg0
))
3294 if (TREE_TYPE (TREE_TYPE (arg0
)) == integer_type_node
)
3296 exp
= build_int_2 (((int *)TREE_STRING_POINTER (arg0
))[i
], 0);
3297 TREE_TYPE (exp
) = integer_type_node
;
3298 return expand_expr (exp
, target
, tmode
, modifier
);
3300 if (TREE_TYPE (TREE_TYPE (arg0
)) == char_type_node
)
3302 exp
= build_int_2 (TREE_STRING_POINTER (arg0
)[i
], 0);
3303 TREE_TYPE (exp
) = integer_type_node
;
3304 return expand_expr (convert (TREE_TYPE (TREE_TYPE (arg0
)), exp
), target
, tmode
, modifier
);
3309 /* If this is a constant index into a constant array,
3310 just get the value from the array. Handle both the cases when
3311 we have an explicit constructor and when our operand is a variable
3312 that was declared const. */
3314 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
3315 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
3317 tree index
= fold (TREE_OPERAND (exp
, 1));
3318 if (TREE_CODE (index
) == INTEGER_CST
3319 && TREE_INT_CST_HIGH (index
) == 0)
3321 int i
= TREE_INT_CST_LOW (index
);
3322 tree elem
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0));
3325 elem
= TREE_CHAIN (elem
);
3327 return expand_expr (fold (TREE_VALUE (elem
)), target
,
3332 else if (TREE_READONLY (TREE_OPERAND (exp
, 0))
3333 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
3334 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == ARRAY_TYPE
3335 && TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
3336 && DECL_INITIAL (TREE_OPERAND (exp
, 0))
3338 && (TREE_CODE (DECL_INITIAL (TREE_OPERAND (exp
, 0)))
3341 tree index
= fold (TREE_OPERAND (exp
, 1));
3342 if (TREE_CODE (index
) == INTEGER_CST
3343 && TREE_INT_CST_HIGH (index
) == 0)
3345 int i
= TREE_INT_CST_LOW (index
);
3346 tree init
= DECL_INITIAL (TREE_OPERAND (exp
, 0));
3348 if (TREE_CODE (init
) == CONSTRUCTOR
)
3350 tree elem
= CONSTRUCTOR_ELTS (init
);
3353 elem
= TREE_CHAIN (elem
);
3355 return expand_expr (fold (TREE_VALUE (elem
)), target
,
3358 else if (TREE_CODE (init
) == STRING_CST
3359 && i
< TREE_STRING_LENGTH (init
))
3361 temp
= gen_rtx (CONST_INT
, VOIDmode
,
3362 TREE_STRING_POINTER (init
)[i
]);
3363 return convert_to_mode (mode
, temp
, 0);
3367 /* Treat array-ref with constant index as a component-ref. */
3371 /* If the operand is a CONSTRUCTOR, we can just extract the
3372 appropriate field if it is present. */
3373 if (code
!= ARRAY_REF
3374 && TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
)
3378 for (elt
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)); elt
;
3379 elt
= TREE_CHAIN (elt
))
3380 if (TREE_PURPOSE (elt
) == TREE_OPERAND (exp
, 1))
3381 return expand_expr (TREE_VALUE (elt
), target
, tmode
, modifier
);
3385 enum machine_mode mode1
;
3389 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
,
3390 &mode1
, &unsignedp
, &volatilep
);
3392 /* In some cases, we will be offsetting OP0's address by a constant.
3393 So get it as a sum, if possible. If we will be using it
3394 directly in an insn, we validate it. */
3395 op0
= expand_expr (tem
, 0, VOIDmode
, EXPAND_SUM
);
3397 /* If this is a constant, put it into a register if it is a
3398 legimate constant and memory if it isn't. */
3399 if (CONSTANT_P (op0
))
3401 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (tem
));
3402 if (LEGITIMATE_CONSTANT_P (op0
))
3403 op0
= force_reg (mode
, op0
);
3405 op0
= validize_mem (force_const_mem (mode
, op0
));
3408 /* Don't forget about volatility even if this is a bitfield. */
3409 if (GET_CODE (op0
) == MEM
&& volatilep
&& ! MEM_VOLATILE_P (op0
))
3411 op0
= copy_rtx (op0
);
3412 MEM_VOLATILE_P (op0
) = 1;
3415 if (mode1
== VOIDmode
3416 || GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
)
3418 /* In cases where an aligned union has an unaligned object
3419 as a field, we might be extracting a BLKmode value from
3420 an integer-mode (e.g., SImode) object. Handle this case
3421 by doing the extract into an object as wide as the field
3422 (which we know to be the width of a basic mode), then
3423 storing into memory, and changing the mode to BLKmode. */
3424 enum machine_mode ext_mode
= mode
;
3426 if (ext_mode
== BLKmode
)
3427 ext_mode
= mode_for_size (bitsize
, MODE_INT
, 1);
3429 if (ext_mode
== BLKmode
)
3432 op0
= extract_bit_field (validize_mem (op0
), bitsize
, bitpos
,
3433 unsignedp
, target
, ext_mode
, ext_mode
,
3434 TYPE_ALIGN (TREE_TYPE (tem
)) / BITS_PER_UNIT
,
3435 int_size_in_bytes (TREE_TYPE (tem
)));
3436 if (mode
== BLKmode
)
3438 rtx
new = assign_stack_temp (ext_mode
,
3439 bitsize
/ BITS_PER_UNIT
, 0);
3441 emit_move_insn (new, op0
);
3442 op0
= copy_rtx (new);
3443 PUT_MODE (op0
, BLKmode
);
3449 /* Get a reference to just this component. */
3450 if (modifier
== EXPAND_CONST_ADDRESS
3451 || modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
3452 op0
= gen_rtx (MEM
, mode1
, plus_constant (XEXP (op0
, 0),
3453 (bitpos
/ BITS_PER_UNIT
)));
3455 op0
= change_address (op0
, mode1
,
3456 plus_constant (XEXP (op0
, 0),
3457 (bitpos
/ BITS_PER_UNIT
)));
3458 MEM_IN_STRUCT_P (op0
) = 1;
3459 MEM_VOLATILE_P (op0
) |= volatilep
;
3460 if (mode
== mode1
|| mode1
== BLKmode
|| mode1
== tmode
)
3463 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
3464 convert_move (target
, op0
, unsignedp
);
3470 tree base
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 0), 0);
3471 tree addr
= build (PLUS_EXPR
, type
, base
, TREE_OPERAND (exp
, 1));
3472 op0
= expand_expr (addr
, 0, VOIDmode
, EXPAND_SUM
);
3473 temp
= gen_rtx (MEM
, mode
, memory_address (mode
, op0
));
3474 MEM_IN_STRUCT_P (temp
) = 1;
3475 MEM_VOLATILE_P (temp
) = TREE_THIS_VOLATILE (exp
) || flag_volatile
;
3476 #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that
3477 a location is accessed through a pointer to const does not mean
3478 that the value there can never change. */
3479 RTX_UNCHANGING_P (temp
) = TREE_READONLY (exp
);
3484 /* Intended for a reference to a buffer of a file-object in Pascal.
3485 But it's not certain that a special tree code will really be
3486 necessary for these. INDIRECT_REF might work for them. */
3490 case WITH_CLEANUP_EXPR
:
3491 if (RTL_EXPR_RTL (exp
) == 0)
3494 = expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
3495 cleanups_this_call
= tree_cons (0, TREE_OPERAND (exp
, 2), cleanups_this_call
);
3496 /* That's it for this cleanup. */
3497 TREE_OPERAND (exp
, 2) = 0;
3499 return RTL_EXPR_RTL (exp
);
3502 /* Check for a built-in function. */
3503 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3504 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) == FUNCTION_DECL
3505 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3506 return expand_builtin (exp
, target
, subtarget
, tmode
, ignore
);
3507 /* If this call was expanded already by preexpand_calls,
3508 just return the result we got. */
3509 if (CALL_EXPR_RTL (exp
) != 0)
3510 return CALL_EXPR_RTL (exp
);
3511 return expand_call (exp
, target
, ignore
);
3513 case NON_LVALUE_EXPR
:
3516 case REFERENCE_EXPR
:
3517 if (TREE_CODE (type
) == VOID_TYPE
|| ignore
)
3519 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, modifier
);
3522 if (mode
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3523 return expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, modifier
);
3524 if (TREE_CODE (type
) == UNION_TYPE
)
3526 tree valtype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
3529 if (mode
== BLKmode
)
3531 if (TYPE_SIZE (type
) == 0
3532 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
3534 target
= assign_stack_temp (BLKmode
,
3535 (TREE_INT_CST_LOW (TYPE_SIZE (type
))
3536 + BITS_PER_UNIT
- 1)
3537 / BITS_PER_UNIT
, 0);
3540 target
= gen_reg_rtx (mode
);
3542 if (GET_CODE (target
) == MEM
)
3543 /* Store data into beginning of memory target. */
3544 store_expr (TREE_OPERAND (exp
, 0),
3545 change_address (target
, TYPE_MODE (valtype
), 0), 0);
3546 else if (GET_CODE (target
) == REG
)
3547 /* Store this field into a union of the proper type. */
3548 store_field (target
, GET_MODE_BITSIZE (TYPE_MODE (valtype
)), 0,
3549 TYPE_MODE (valtype
), TREE_OPERAND (exp
, 0),
3551 int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3555 /* Return the entire union. */
3558 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, mode
, 0);
3559 if (GET_MODE (op0
) == mode
|| GET_MODE (op0
) == VOIDmode
)
3561 if (flag_force_mem
&& GET_CODE (op0
) == MEM
)
3562 op0
= copy_to_reg (op0
);
3565 return convert_to_mode (mode
, op0
, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3567 convert_move (target
, op0
, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3571 /* We come here from MINUS_EXPR when the second operand is a constant. */
3573 this_optab
= add_optab
;
3575 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
3576 something else, make sure we add the register to the constant and
3577 then to the other thing. This case can occur during strength
3578 reduction and doing it this way will produce better code if the
3579 frame pointer or argument pointer is eliminated.
3581 fold-const.c will ensure that the constant is always in the inner
3582 PLUS_EXPR, so the only case we need to do anything about is if
3583 sp, ap, or fp is our second argument, in which case we must swap
3584 the innermost first argument and our second argument. */
3586 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
3587 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1)) == INTEGER_CST
3588 && TREE_CODE (TREE_OPERAND (exp
, 1)) == RTL_EXPR
3589 && (RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == frame_pointer_rtx
3590 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == stack_pointer_rtx
3591 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == arg_pointer_rtx
))
3593 tree t
= TREE_OPERAND (exp
, 1);
3595 TREE_OPERAND (exp
, 1) = TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3596 TREE_OPERAND (TREE_OPERAND (exp
, 0), 0) = t
;
3599 /* If the result is to be Pmode and we are adding an integer to
3600 something, we might be forming a constant. So try to use
3601 plus_constant. If it produces a sum and we can't accept it,
3602 use force_operand. This allows P = &ARR[const] to generate
3603 efficient code on machines where a SYMBOL_REF is not a valid
3606 If this is an EXPAND_SUM call, always return the sum. */
3607 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
3608 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
3609 && (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
3612 op1
= expand_expr (TREE_OPERAND (exp
, 1), subtarget
, VOIDmode
,
3614 op1
= plus_constant (op1
, TREE_INT_CST_LOW (TREE_OPERAND (exp
, 0)));
3615 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3616 op1
= force_operand (op1
, target
);
3620 else if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3621 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
3622 && (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
3625 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
3627 op0
= plus_constant (op0
, TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)));
3628 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3629 op0
= force_operand (op0
, target
);
3633 /* No sense saving up arithmetic to be done
3634 if it's all in the wrong mode to form part of an address.
3635 And force_operand won't know whether to sign-extend or
3637 if ((modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3638 || mode
!= Pmode
) goto binop
;
3640 preexpand_calls (exp
);
3641 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3644 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, modifier
);
3645 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, modifier
);
3647 /* Make sure any term that's a sum with a constant comes last. */
3648 if (GET_CODE (op0
) == PLUS
3649 && CONSTANT_P (XEXP (op0
, 1)))
3655 /* If adding to a sum including a constant,
3656 associate it to put the constant outside. */
3657 if (GET_CODE (op1
) == PLUS
3658 && CONSTANT_P (XEXP (op1
, 1)))
3660 rtx constant_term
= const0_rtx
;
3662 temp
= simplify_binary_operation (PLUS
, mode
, XEXP (op1
, 0), op0
);
3666 op0
= gen_rtx (PLUS
, mode
, XEXP (op1
, 0), op0
);
3668 /* Let's also eliminate constants from op0 if possible. */
3669 op0
= eliminate_constant_term (op0
, &constant_term
);
3671 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
3672 their sum should be a constant. Form it into OP1, since the
3673 result we want will then be OP0 + OP1. */
3675 temp
= simplify_binary_operation (PLUS
, mode
, constant_term
,
3680 op1
= gen_rtx (PLUS
, mode
, constant_term
, XEXP (op1
, 1));
3683 /* Put a constant term last and put a multiplication first. */
3684 if (CONSTANT_P (op0
) || GET_CODE (op1
) == MULT
)
3685 temp
= op1
, op1
= op0
, op0
= temp
;
3687 temp
= simplify_binary_operation (PLUS
, mode
, op0
, op1
);
3688 return temp
? temp
: gen_rtx (PLUS
, mode
, op0
, op1
);
3691 /* Handle difference of two symbolic constants,
3692 for the sake of an initializer. */
3693 if ((modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
3694 && really_constant_p (TREE_OPERAND (exp
, 0))
3695 && really_constant_p (TREE_OPERAND (exp
, 1)))
3697 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, modifier
);
3698 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, modifier
);
3699 return gen_rtx (MINUS
, mode
, op0
, op1
);
3701 /* Convert A - const to A + (-const). */
3702 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
3704 exp
= build (PLUS_EXPR
, type
, TREE_OPERAND (exp
, 0),
3705 fold (build1 (NEGATE_EXPR
, type
,
3706 TREE_OPERAND (exp
, 1))));
3709 this_optab
= sub_optab
;
3713 preexpand_calls (exp
);
3714 /* If first operand is constant, swap them.
3715 Thus the following special case checks need only
3716 check the second operand. */
3717 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
)
3719 register tree t1
= TREE_OPERAND (exp
, 0);
3720 TREE_OPERAND (exp
, 0) = TREE_OPERAND (exp
, 1);
3721 TREE_OPERAND (exp
, 1) = t1
;
3724 /* Attempt to return something suitable for generating an
3725 indexed address, for machines that support that. */
3727 if (modifier
== EXPAND_SUM
&& mode
== Pmode
3728 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3729 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
)
3731 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, EXPAND_SUM
);
3733 /* Apply distributive law if OP0 is x+c. */
3734 if (GET_CODE (op0
) == PLUS
3735 && GET_CODE (XEXP (op0
, 1)) == CONST_INT
)
3736 return gen_rtx (PLUS
, mode
,
3737 gen_rtx (MULT
, mode
, XEXP (op0
, 0),
3738 gen_rtx (CONST_INT
, VOIDmode
,
3739 TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)))),
3740 gen_rtx (CONST_INT
, VOIDmode
,
3741 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))
3742 * INTVAL (XEXP (op0
, 1)))));
3744 if (GET_CODE (op0
) != REG
)
3745 op0
= force_operand (op0
, 0);
3746 if (GET_CODE (op0
) != REG
)
3747 op0
= copy_to_mode_reg (mode
, op0
);
3749 return gen_rtx (MULT
, mode
, op0
,
3750 gen_rtx (CONST_INT
, VOIDmode
,
3751 TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))));
3754 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3757 /* Check for multiplying things that have been extended
3758 from a narrower type. If this machine supports multiplying
3759 in that narrower type with a result in the desired type,
3760 do it that way, and avoid the explicit type-conversion. */
3761 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == NOP_EXPR
3762 && TREE_CODE (type
) == INTEGER_TYPE
3763 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3764 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3765 && ((TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3766 && int_fits_type_p (TREE_OPERAND (exp
, 1),
3767 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3768 /* Don't use a widening multiply if a shift will do. */
3769 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
3770 > HOST_BITS_PER_INT
)
3771 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))) < 0))
3773 (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
3774 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
3776 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))))
3777 /* If both operands are extended, they must either both
3778 be zero-extended or both be sign-extended. */
3779 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
3781 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))))))
3783 enum machine_mode innermode
3784 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)));
3785 this_optab
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3786 ? umul_widen_optab
: smul_widen_optab
);
3787 if (mode
== GET_MODE_WIDER_MODE (innermode
)
3788 && this_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
3790 op0
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
3792 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
3793 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3795 op1
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
3800 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3801 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3802 return expand_mult (mode
, op0
, op1
, target
, unsignedp
);
3804 case TRUNC_DIV_EXPR
:
3805 case FLOOR_DIV_EXPR
:
3807 case ROUND_DIV_EXPR
:
3808 case EXACT_DIV_EXPR
:
3809 preexpand_calls (exp
);
3810 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3812 /* Possible optimization: compute the dividend with EXPAND_SUM
3813 then if the divisor is constant can optimize the case
3814 where some terms of the dividend have coeffs divisible by it. */
3815 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3816 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3817 return expand_divmod (0, code
, mode
, op0
, op1
, target
, unsignedp
);
3820 this_optab
= flodiv_optab
;
3823 case TRUNC_MOD_EXPR
:
3824 case FLOOR_MOD_EXPR
:
3826 case ROUND_MOD_EXPR
:
3827 preexpand_calls (exp
);
3828 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3830 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3831 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3832 return expand_divmod (1, code
, mode
, op0
, op1
, target
, unsignedp
);
3834 case FIX_ROUND_EXPR
:
3835 case FIX_FLOOR_EXPR
:
3837 abort (); /* Not used for C. */
3839 case FIX_TRUNC_EXPR
:
3840 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
3842 target
= gen_reg_rtx (mode
);
3843 expand_fix (target
, op0
, unsignedp
);
3847 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
3849 target
= gen_reg_rtx (mode
);
3850 /* expand_float can't figure out what to do if FROM has VOIDmode.
3851 So give it the correct mode. With -O, cse will optimize this. */
3852 if (GET_MODE (op0
) == VOIDmode
)
3853 op0
= copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
3855 expand_float (target
, op0
,
3856 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3860 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
3861 temp
= expand_unop (mode
, neg_optab
, op0
, target
, 0);
3867 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3869 /* Unsigned abs is simply the operand. Testing here means we don't
3870 risk generating incorrect code below. */
3871 if (TREE_UNSIGNED (type
))
3874 /* First try to do it with a special abs instruction. */
3875 temp
= expand_unop (mode
, abs_optab
, op0
, target
, 0);
3879 /* If this machine has expensive jumps, we can do integer absolute
3880 value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
3881 where W is the width of MODE. */
3883 if (GET_MODE_CLASS (mode
) == MODE_INT
&& BRANCH_COST
>= 2)
3885 rtx extended
= expand_shift (RSHIFT_EXPR
, mode
, op0
,
3886 size_int (GET_MODE_BITSIZE (mode
) - 1),
3889 temp
= expand_binop (mode
, xor_optab
, extended
, op0
, target
, 0,
3892 temp
= expand_binop (mode
, sub_optab
, temp
, extended
, target
, 0,
3899 /* If that does not win, use conditional jump and negate. */
3900 target
= original_target
;
3901 temp
= gen_label_rtx ();
3902 if (target
== 0 || ! safe_from_p (target
, TREE_OPERAND (exp
, 0))
3903 || (GET_CODE (target
) == REG
3904 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3905 target
= gen_reg_rtx (mode
);
3906 emit_move_insn (target
, op0
);
3907 emit_cmp_insn (target
,
3908 expand_expr (convert (type
, integer_zero_node
),
3912 emit_jump_insn (gen_bge (temp
));
3913 op0
= expand_unop (mode
, neg_optab
, target
, target
, 0);
3915 emit_move_insn (target
, op0
);
3922 target
= original_target
;
3923 if (target
== 0 || ! safe_from_p (target
, TREE_OPERAND (exp
, 1))
3924 || (GET_CODE (target
) == REG
3925 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3926 target
= gen_reg_rtx (mode
);
3927 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3928 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
3930 /* First try to do it with a special MIN or MAX instruction.
3931 If that does not win, use a conditional jump to select the proper
3933 this_optab
= (TREE_UNSIGNED (type
)
3934 ? (code
== MIN_EXPR
? umin_optab
: umax_optab
)
3935 : (code
== MIN_EXPR
? smin_optab
: smax_optab
));
3937 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
, unsignedp
,
3943 emit_move_insn (target
, op0
);
3944 op0
= gen_label_rtx ();
3945 if (code
== MAX_EXPR
)
3946 temp
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1)))
3947 ? compare_from_rtx (target
, op1
, GEU
, 1, mode
, 0, 0)
3948 : compare_from_rtx (target
, op1
, GE
, 0, mode
, 0, 0));
3950 temp
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1)))
3951 ? compare_from_rtx (target
, op1
, LEU
, 1, mode
, 0, 0)
3952 : compare_from_rtx (target
, op1
, LE
, 0, mode
, 0, 0));
3953 if (temp
== const0_rtx
)
3954 emit_move_insn (target
, op1
);
3955 else if (temp
!= const_true_rtx
)
3957 if (bcc_gen_fctn
[(int) GET_CODE (temp
)] != 0)
3958 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (temp
)]) (op0
));
3961 emit_move_insn (target
, op1
);
3966 /* ??? Can optimize when the operand of this is a bitwise operation,
3967 by using a different bitwise operation. */
3969 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3970 temp
= expand_unop (mode
, one_cmpl_optab
, op0
, target
, 1);
3976 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3977 temp
= expand_unop (mode
, ffs_optab
, op0
, target
, 1);
3982 /* ??? Can optimize bitwise operations with one arg constant.
3983 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
3984 and (a bitwise1 b) bitwise2 b (etc)
3985 but that is probably not worth while. */
3987 /* BIT_AND_EXPR is for bitwise anding.
3988 TRUTH_AND_EXPR is for anding two boolean values
3989 when we want in all cases to compute both of them.
3990 In general it is fastest to do TRUTH_AND_EXPR by
3991 computing both operands as actual zero-or-1 values
3992 and then bitwise anding. In cases where there cannot
3993 be any side effects, better code would be made by
3994 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR;
3995 but the question is how to recognize those cases. */
3997 case TRUTH_AND_EXPR
:
3999 this_optab
= and_optab
;
4002 /* See comment above about TRUTH_AND_EXPR; it applies here too. */
4005 this_optab
= ior_optab
;
4009 this_optab
= xor_optab
;
4016 preexpand_calls (exp
);
4017 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
4019 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
4020 return expand_shift (code
, mode
, op0
, TREE_OPERAND (exp
, 1), target
,
4023 /* Could determine the answer when only additive constants differ.
4024 Also, the addition of one can be handled by changing the condition. */
4031 preexpand_calls (exp
);
4032 temp
= do_store_flag (exp
, target
, tmode
!= VOIDmode
? tmode
: mode
, 0);
4035 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
4036 if (code
== NE_EXPR
&& integer_zerop (TREE_OPERAND (exp
, 1))
4038 && GET_CODE (original_target
) == REG
4039 && (GET_MODE (original_target
)
4040 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
4042 temp
= expand_expr (TREE_OPERAND (exp
, 0), original_target
, VOIDmode
, 0);
4043 if (temp
!= original_target
)
4044 temp
= copy_to_reg (temp
);
4045 op1
= gen_label_rtx ();
4046 emit_cmp_insn (temp
, const0_rtx
, EQ
, 0,
4047 GET_MODE (temp
), unsignedp
, 0);
4048 emit_jump_insn (gen_beq (op1
));
4049 emit_move_insn (temp
, const1_rtx
);
4053 /* If no set-flag instruction, must generate a conditional
4054 store into a temporary variable. Drop through
4055 and handle this like && and ||. */
4057 case TRUTH_ANDIF_EXPR
:
4058 case TRUTH_ORIF_EXPR
:
4059 if (target
== 0 || ! safe_from_p (target
, exp
)
4060 /* Make sure we don't have a hard reg (such as function's return
4061 value) live across basic blocks, if not optimizing. */
4062 || (!optimize
&& GET_CODE (target
) == REG
4063 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
4064 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
4065 emit_clr_insn (target
);
4066 op1
= gen_label_rtx ();
4067 jumpifnot (exp
, op1
);
4068 emit_0_to_1_insn (target
);
4072 case TRUTH_NOT_EXPR
:
4073 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
4074 /* The parser is careful to generate TRUTH_NOT_EXPR
4075 only with operands that are always zero or one. */
4076 temp
= expand_binop (mode
, xor_optab
, op0
,
4077 gen_rtx (CONST_INT
, mode
, 1),
4078 target
, 1, OPTAB_LIB_WIDEN
);
4084 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
4086 return expand_expr (TREE_OPERAND (exp
, 1),
4087 (ignore
? const0_rtx
: target
),
4092 /* Note that COND_EXPRs whose type is a structure or union
4093 are required to be constructed to contain assignments of
4094 a temporary variable, so that we can evaluate them here
4095 for side effect only. If type is void, we must do likewise. */
4097 /* If an arm of the branch requires a cleanup,
4098 only that cleanup is performed. */
4101 tree binary_op
= 0, unary_op
= 0;
4102 tree old_cleanups
= cleanups_this_call
;
4103 cleanups_this_call
= 0;
4105 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
4106 convert it to our mode, if necessary. */
4107 if (integer_onep (TREE_OPERAND (exp
, 1))
4108 && integer_zerop (TREE_OPERAND (exp
, 2))
4109 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
4111 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, mode
, modifier
);
4112 if (GET_MODE (op0
) == mode
)
4115 target
= gen_reg_rtx (mode
);
4116 convert_move (target
, op0
, unsignedp
);
4120 /* If we are not to produce a result, we have no target. Otherwise,
4121 if a target was specified use it; it will not be used as an
4122 intermediate target unless it is safe. If no target, use a
4125 if (mode
== VOIDmode
|| ignore
)
4127 else if (original_target
4128 && safe_from_p (original_target
, TREE_OPERAND (exp
, 0)))
4129 temp
= original_target
;
4130 else if (mode
== BLKmode
)
4132 if (TYPE_SIZE (type
) == 0
4133 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4135 temp
= assign_stack_temp (BLKmode
,
4136 (TREE_INT_CST_LOW (TYPE_SIZE (type
))
4137 + BITS_PER_UNIT
- 1)
4138 / BITS_PER_UNIT
, 0);
4141 temp
= gen_reg_rtx (mode
);
4143 /* Check for X ? A + B : A. If we have this, we can copy
4144 A to the output and conditionally add B. Similarly for unary
4145 operations. Don't do this if X has side-effects because
4146 those side effects might affect A or B and the "?" operation is
4147 a sequence point in ANSI. (We test for side effects later.) */
4149 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '2'
4150 && operand_equal_p (TREE_OPERAND (exp
, 2),
4151 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
4152 singleton
= TREE_OPERAND (exp
, 2), binary_op
= TREE_OPERAND (exp
, 1);
4153 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '2'
4154 && operand_equal_p (TREE_OPERAND (exp
, 1),
4155 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
4156 singleton
= TREE_OPERAND (exp
, 1), binary_op
= TREE_OPERAND (exp
, 2);
4157 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '1'
4158 && operand_equal_p (TREE_OPERAND (exp
, 2),
4159 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
4160 singleton
= TREE_OPERAND (exp
, 2), unary_op
= TREE_OPERAND (exp
, 1);
4161 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '1'
4162 && operand_equal_p (TREE_OPERAND (exp
, 1),
4163 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
4164 singleton
= TREE_OPERAND (exp
, 1), unary_op
= TREE_OPERAND (exp
, 2);
4166 /* If we had X ? A + 1 : A and we can do the test of X as a store-flag
4167 operation, do this as A + (X != 0). Similarly for other simple
4168 binary operators. */
4169 if (singleton
&& binary_op
4170 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4171 && (TREE_CODE (binary_op
) == PLUS_EXPR
4172 || TREE_CODE (binary_op
) == MINUS_EXPR
4173 || TREE_CODE (binary_op
) == BIT_IOR_EXPR
4174 || TREE_CODE (binary_op
) == BIT_XOR_EXPR
4175 || TREE_CODE (binary_op
) == BIT_AND_EXPR
)
4176 && integer_onep (TREE_OPERAND (binary_op
, 1))
4177 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
4180 optab boptab
= (TREE_CODE (binary_op
) == PLUS_EXPR
? add_optab
4181 : TREE_CODE (binary_op
) == MINUS_EXPR
? sub_optab
4182 : TREE_CODE (binary_op
) == BIT_IOR_EXPR
? ior_optab
4183 : TREE_CODE (binary_op
) == BIT_XOR_EXPR
? xor_optab
4186 /* If we had X ? A : A + 1, do this as A + (X == 0).
4188 We have to invert the truth value here and then put it
4189 back later if do_store_flag fails. We cannot simply copy
4190 TREE_OPERAND (exp, 0) to another variable and modify that
4191 because invert_truthvalue can modify the tree pointed to
4193 if (singleton
== TREE_OPERAND (exp
, 1))
4194 TREE_OPERAND (exp
, 0)
4195 = invert_truthvalue (TREE_OPERAND (exp
, 0));
4197 result
= do_store_flag (TREE_OPERAND (exp
, 0),
4198 safe_from_p (temp
, singleton
) ? temp
: 0,
4199 mode
, BRANCH_COST
<= 1);
4203 op1
= expand_expr (singleton
, 0, VOIDmode
, 0);
4204 return expand_binop (mode
, boptab
, op1
, result
, temp
,
4205 unsignedp
, OPTAB_LIB_WIDEN
);
4207 else if (singleton
== TREE_OPERAND (exp
, 1))
4208 TREE_OPERAND (exp
, 0)
4209 = invert_truthvalue (TREE_OPERAND (exp
, 0));
4213 op0
= gen_label_rtx ();
4215 if (singleton
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
4219 /* If the target conflicts with the other operand of the
4220 binary op, we can't use it. Also, we can't use the target
4221 if it is a hard register, because evaluating the condition
4222 might clobber it. */
4224 && ! safe_from_p (temp
, TREE_OPERAND (binary_op
, 1)))
4225 || (GET_CODE (temp
) == REG
4226 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
))
4227 temp
= gen_reg_rtx (mode
);
4228 store_expr (singleton
, temp
, 0);
4231 expand_expr (singleton
, ignore
? const1_rtx
: 0, VOIDmode
, 0);
4232 if (cleanups_this_call
)
4234 sorry ("aggregate value in COND_EXPR");
4235 cleanups_this_call
= 0;
4237 if (singleton
== TREE_OPERAND (exp
, 1))
4238 jumpif (TREE_OPERAND (exp
, 0), op0
);
4240 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4242 if (binary_op
&& temp
== 0)
4243 /* Just touch the other operand. */
4244 expand_expr (TREE_OPERAND (binary_op
, 1),
4245 ignore
? const0_rtx
: 0, VOIDmode
, 0);
4247 store_expr (build (TREE_CODE (binary_op
), type
,
4248 make_tree (type
, temp
),
4249 TREE_OPERAND (binary_op
, 1)),
4252 store_expr (build1 (TREE_CODE (unary_op
), type
,
4253 make_tree (type
, temp
)),
4258 /* This is now done in jump.c and is better done there because it
4259 produces shorter register lifetimes. */
4261 /* Check for both possibilities either constants or variables
4262 in registers (but not the same as the target!). If so, can
4263 save branches by assigning one, branching, and assigning the
4265 else if (temp
&& GET_MODE (temp
) != BLKmode
4266 && (TREE_CONSTANT (TREE_OPERAND (exp
, 1))
4267 || ((TREE_CODE (TREE_OPERAND (exp
, 1)) == PARM_DECL
4268 || TREE_CODE (TREE_OPERAND (exp
, 1)) == VAR_DECL
)
4269 && DECL_RTL (TREE_OPERAND (exp
, 1))
4270 && GET_CODE (DECL_RTL (TREE_OPERAND (exp
, 1))) == REG
4271 && DECL_RTL (TREE_OPERAND (exp
, 1)) != temp
))
4272 && (TREE_CONSTANT (TREE_OPERAND (exp
, 2))
4273 || ((TREE_CODE (TREE_OPERAND (exp
, 2)) == PARM_DECL
4274 || TREE_CODE (TREE_OPERAND (exp
, 2)) == VAR_DECL
)
4275 && DECL_RTL (TREE_OPERAND (exp
, 2))
4276 && GET_CODE (DECL_RTL (TREE_OPERAND (exp
, 2))) == REG
4277 && DECL_RTL (TREE_OPERAND (exp
, 2)) != temp
)))
4279 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4280 temp
= gen_reg_rtx (mode
);
4281 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4282 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4283 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4287 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
4288 comparison operator. If we have one of these cases, set the
4289 output to A, branch on A (cse will merge these two references),
4290 then set the output to FOO. */
4292 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
4293 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
4294 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
4295 TREE_OPERAND (exp
, 1), 0)
4296 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4297 && safe_from_p (temp
, TREE_OPERAND (exp
, 2)))
4299 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4300 temp
= gen_reg_rtx (mode
);
4301 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4302 jumpif (TREE_OPERAND (exp
, 0), op0
);
4303 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4307 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
4308 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
4309 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
4310 TREE_OPERAND (exp
, 2), 0)
4311 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4312 && safe_from_p (temp
, TREE_OPERAND (exp
, 1)))
4314 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4315 temp
= gen_reg_rtx (mode
);
4316 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4317 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4318 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4323 op1
= gen_label_rtx ();
4324 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4326 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4328 expand_expr (TREE_OPERAND (exp
, 1), ignore
? const0_rtx
: 0,
4330 if (cleanups_this_call
)
4332 sorry ("aggregate value in COND_EXPR");
4333 cleanups_this_call
= 0;
4337 emit_jump_insn (gen_jump (op1
));
4341 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4343 expand_expr (TREE_OPERAND (exp
, 2), ignore
? const0_rtx
: 0,
4347 if (cleanups_this_call
)
4349 sorry ("aggregate value in COND_EXPR");
4350 cleanups_this_call
= 0;
4356 cleanups_this_call
= old_cleanups
;
4362 /* Something needs to be initialized, but we didn't know
4363 where that thing was when building the tree. For example,
4364 it could be the return value of a function, or a parameter
4365 to a function which lays down in the stack, or a temporary
4366 variable which must be passed by reference.
4368 We guarantee that the expression will either be constructed
4369 or copied into our original target. */
4371 tree slot
= TREE_OPERAND (exp
, 0);
4373 if (TREE_CODE (slot
) != VAR_DECL
)
4378 if (DECL_RTL (slot
) != 0)
4379 target
= DECL_RTL (slot
);
4382 target
= assign_stack_temp (mode
, int_size_in_bytes (type
), 0);
4383 /* All temp slots at this level must not conflict. */
4384 preserve_temp_slots (target
);
4385 DECL_RTL (slot
) = target
;
4389 /* Since SLOT is not known to the called function
4390 to belong to its stack frame, we must build an explicit
4391 cleanup. This case occurs when we must build up a reference
4392 to pass the reference as an argument. In this case,
4393 it is very likely that such a reference need not be
4396 if (TREE_OPERAND (exp
, 2) == 0)
4397 TREE_OPERAND (exp
, 2) = maybe_build_cleanup (slot
);
4398 if (TREE_OPERAND (exp
, 2))
4399 cleanups_this_call
= tree_cons (0, TREE_OPERAND (exp
, 2),
4400 cleanups_this_call
);
4405 /* This case does occur, when expanding a parameter which
4406 needs to be constructed on the stack. The target
4407 is the actual stack address that we want to initialize.
4408 The function we call will perform the cleanup in this case. */
4410 DECL_RTL (slot
) = target
;
4413 return expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, modifier
);
4418 tree lhs
= TREE_OPERAND (exp
, 0);
4419 tree rhs
= TREE_OPERAND (exp
, 1);
4420 tree noncopied_parts
= 0;
4421 tree lhs_type
= TREE_TYPE (lhs
);
4423 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
4424 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0 && !fixed_type_p (rhs
))
4425 noncopied_parts
= init_noncopied_parts (stabilize_reference (lhs
),
4426 TYPE_NONCOPIED_PARTS (lhs_type
));
4427 while (noncopied_parts
!= 0)
4429 expand_assignment (TREE_VALUE (noncopied_parts
),
4430 TREE_PURPOSE (noncopied_parts
), 0, 0);
4431 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
4438 /* If lhs is complex, expand calls in rhs before computing it.
4439 That's so we don't compute a pointer and save it over a call.
4440 If lhs is simple, compute it first so we can give it as a
4441 target if the rhs is just a call. This avoids an extra temp and copy
4442 and that prevents a partial-subsumption which makes bad code.
4443 Actually we could treat component_ref's of vars like vars. */
4445 tree lhs
= TREE_OPERAND (exp
, 0);
4446 tree rhs
= TREE_OPERAND (exp
, 1);
4447 tree noncopied_parts
= 0;
4448 tree lhs_type
= TREE_TYPE (lhs
);
4452 if (TREE_CODE (lhs
) != VAR_DECL
4453 && TREE_CODE (lhs
) != RESULT_DECL
4454 && TREE_CODE (lhs
) != PARM_DECL
)
4455 preexpand_calls (exp
);
4457 /* Check for |= or &= of a bitfield of size one into another bitfield
4458 of size 1. In this case, (unless we need the result of the
4459 assignment) we can do this more efficiently with a
4460 test followed by an assignment, if necessary.
4462 ??? At this point, we can't get a BIT_FIELD_REF here. But if
4463 things change so we do, this code should be enhanced to
4466 && TREE_CODE (lhs
) == COMPONENT_REF
4467 && (TREE_CODE (rhs
) == BIT_IOR_EXPR
4468 || TREE_CODE (rhs
) == BIT_AND_EXPR
)
4469 && TREE_OPERAND (rhs
, 0) == lhs
4470 && TREE_CODE (TREE_OPERAND (rhs
, 1)) == COMPONENT_REF
4471 && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs
, 1))) == 1
4472 && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs
, 1), 1))) == 1)
4474 rtx label
= gen_label_rtx ();
4476 do_jump (TREE_OPERAND (rhs
, 1),
4477 TREE_CODE (rhs
) == BIT_IOR_EXPR
? label
: 0,
4478 TREE_CODE (rhs
) == BIT_AND_EXPR
? label
: 0);
4479 expand_assignment (lhs
, convert (TREE_TYPE (rhs
),
4480 (TREE_CODE (rhs
) == BIT_IOR_EXPR
4482 : integer_zero_node
)),
4484 do_pending_stack_adjust ();
4489 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0
4490 && ! (fixed_type_p (lhs
) && fixed_type_p (rhs
)))
4491 noncopied_parts
= save_noncopied_parts (stabilize_reference (lhs
),
4492 TYPE_NONCOPIED_PARTS (lhs_type
));
4494 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
4495 while (noncopied_parts
!= 0)
4497 expand_assignment (TREE_PURPOSE (noncopied_parts
),
4498 TREE_VALUE (noncopied_parts
), 0, 0);
4499 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
4504 case PREINCREMENT_EXPR
:
4505 case PREDECREMENT_EXPR
:
4506 return expand_increment (exp
, 0);
4508 case POSTINCREMENT_EXPR
:
4509 case POSTDECREMENT_EXPR
:
4510 /* Faster to treat as pre-increment if result is not used. */
4511 return expand_increment (exp
, ! ignore
);
4514 /* Are we taking the address of a nested function? */
4515 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == FUNCTION_DECL
4516 && decl_function_context (TREE_OPERAND (exp
, 0)) != 0)
4518 op0
= trampoline_address (TREE_OPERAND (exp
, 0));
4519 op0
= force_operand (op0
, target
);
4523 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
,
4524 (modifier
== EXPAND_INITIALIZER
4525 ? modifier
: EXPAND_CONST_ADDRESS
));
4526 if (GET_CODE (op0
) != MEM
)
4529 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
4530 return XEXP (op0
, 0);
4531 op0
= force_operand (XEXP (op0
, 0), target
);
4533 if (flag_force_addr
&& GET_CODE (op0
) != REG
)
4534 return force_reg (Pmode
, op0
);
4537 case ENTRY_VALUE_EXPR
:
4544 return (*lang_expand_expr
) (exp
, target
, tmode
, modifier
);
4547 /* Here to do an ordinary binary operator, generating an instruction
4548 from the optab already placed in `this_optab'. */
4550 preexpand_calls (exp
);
4551 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
4553 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
4554 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
4556 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
,
4557 unsignedp
, OPTAB_LIB_WIDEN
);
4563 /* Return the alignment in bits of EXP, a pointer valued expression.
4564 But don't return more than MAX_ALIGN no matter what.
4565 The alignment returned is, by default, the alignment of the thing that
4566 EXP points to (if it is not a POINTER_TYPE, 0 is returned).
4568 Otherwise, look at the expression to see if we can do better, i.e., if the
4569 expression is actually pointing at an object whose alignment is tighter. */
4572 get_pointer_alignment (exp
, max_align
)
4576 unsigned align
, inner
;
4578 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
4581 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
4582 align
= MIN (align
, max_align
);
4586 switch (TREE_CODE (exp
))
4590 case NON_LVALUE_EXPR
:
4591 exp
= TREE_OPERAND (exp
, 0);
4592 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
4594 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
4595 inner
= MIN (inner
, max_align
);
4596 align
= MAX (align
, inner
);
4600 /* If sum of pointer + int, restrict our maximum alignment to that
4601 imposed by the integer. If not, we can't do any better than
4603 if (TREE_CODE (TREE_OPERAND (exp
, 1)) != INTEGER_CST
)
4606 while (((TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)) * BITS_PER_UNIT
)
4611 exp
= TREE_OPERAND (exp
, 0);
4615 /* See what we are pointing at and look at its alignment. */
4616 exp
= TREE_OPERAND (exp
, 0);
4617 if (TREE_CODE (exp
) == FUNCTION_DECL
)
4618 align
= MAX (align
, FUNCTION_BOUNDARY
);
4619 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
4620 align
= MAX (align
, DECL_ALIGN (exp
));
4621 #ifdef CONSTANT_ALIGNMENT
4622 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
4623 align
= CONSTANT_ALIGNMENT (exp
, align
);
4625 return MIN (align
, max_align
);
4633 /* Return the tree node and offset if a given argument corresponds to
4634 a string constant. */
4637 string_constant (arg
, ptr_offset
)
4643 if (TREE_CODE (arg
) == ADDR_EXPR
4644 && TREE_CODE (TREE_OPERAND (arg
, 0)) == STRING_CST
)
4646 *ptr_offset
= integer_zero_node
;
4647 return TREE_OPERAND (arg
, 0);
4649 else if (TREE_CODE (arg
) == PLUS_EXPR
)
4651 tree arg0
= TREE_OPERAND (arg
, 0);
4652 tree arg1
= TREE_OPERAND (arg
, 1);
4657 if (TREE_CODE (arg0
) == ADDR_EXPR
4658 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == STRING_CST
)
4661 return TREE_OPERAND (arg0
, 0);
4663 else if (TREE_CODE (arg1
) == ADDR_EXPR
4664 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == STRING_CST
)
4667 return TREE_OPERAND (arg1
, 0);
4674 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
4675 way, because it could contain a zero byte in the middle.
4676 TREE_STRING_LENGTH is the size of the character array, not the string.
4678 Unfortunately, string_constant can't access the values of const char
4679 arrays with initializers, so neither can we do so here. */
4689 src
= string_constant (src
, &offset_node
);
4692 max
= TREE_STRING_LENGTH (src
);
4693 ptr
= TREE_STRING_POINTER (src
);
4694 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
4696 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
4697 compute the offset to the following null if we don't know where to
4698 start searching for it. */
4700 for (i
= 0; i
< max
; i
++)
4703 /* We don't know the starting offset, but we do know that the string
4704 has no internal zero bytes. We can assume that the offset falls
4705 within the bounds of the string; otherwise, the programmer deserves
4706 what he gets. Subtract the offset from the length of the string,
4708 /* This would perhaps not be valid if we were dealing with named
4709 arrays in addition to literal string constants. */
4710 return size_binop (MINUS_EXPR
, size_int (max
), offset_node
);
4713 /* We have a known offset into the string. Start searching there for
4714 a null character. */
4715 if (offset_node
== 0)
4719 /* Did we get a long long offset? If so, punt. */
4720 if (TREE_INT_CST_HIGH (offset_node
) != 0)
4722 offset
= TREE_INT_CST_LOW (offset_node
);
4724 /* If the offset is known to be out of bounds, warn, and call strlen at
4726 if (offset
< 0 || offset
> max
)
4728 warning ("offset outside bounds of constant string");
4731 /* Use strlen to search for the first zero byte. Since any strings
4732 constructed with build_string will have nulls appended, we win even
4733 if we get handed something like (char[4])"abcd".
4735 Since OFFSET is our starting index into the string, no further
4736 calculation is needed. */
4737 return size_int (strlen (ptr
+ offset
));
4740 /* Expand an expression EXP that calls a built-in function,
4741 with result going to TARGET if that's convenient
4742 (and in mode MODE if that's convenient).
4743 SUBTARGET may be used as the target for computing one of EXP's operands.
4744 IGNORE is nonzero if the value is to be ignored. */
4747 expand_builtin (exp
, target
, subtarget
, mode
, ignore
)
4751 enum machine_mode mode
;
4754 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4755 tree arglist
= TREE_OPERAND (exp
, 1);
4757 rtx lab1
, lab2
, insns
;
4758 enum machine_mode value_mode
= TYPE_MODE (TREE_TYPE (exp
));
4760 switch (DECL_FUNCTION_CODE (fndecl
))
4765 /* build_function_call changes these into ABS_EXPR. */
4768 case BUILT_IN_FSQRT
:
4769 /* If not optimizing, call the library function. */
4774 /* Arg could be non-integer if user redeclared this fcn wrong. */
4775 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != REAL_TYPE
)
4778 /* Compute the argument. */
4779 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4781 /* Make a suitable register to place result in. */
4782 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
4784 /* Test the argument to make sure it is in the proper domain for
4785 the sqrt function. If it is not in the domain, branch to a
4788 lab1
= gen_label_rtx ();
4789 lab2
= gen_label_rtx ();
4791 /* By default check the arguments. If flag_fast_math is turned on,
4792 then assume sqrt will always be called with valid arguments.
4793 Note changing the test below from "> 0" to ">= 0" would cause
4794 incorrect results when computing sqrt(-0.0). */
4796 if (! flag_fast_math
)
4798 /* By checking op > 0 we are able to catch all of the
4799 IEEE special cases with a single if conditional. */
4800 emit_cmp_insn (op0
, CONST0_RTX (GET_MODE (op0
)), GT
, 0,
4801 GET_MODE (op0
), 0, 0);
4802 emit_jump_insn (gen_bgt (lab1
));
4804 /* The argument was not in the domain; do this via library call.
4805 Pop the arguments right away in case the call gets deleted. */
4807 expand_call (exp
, target
, 0);
4810 /* Branch around open coded version */
4811 emit_jump_insn (gen_jump (lab2
));
4815 /* Arg is in the domain, compute sqrt, into TARGET.
4816 Set TARGET to wherever the result comes back. */
4817 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4818 sqrt_optab
, op0
, target
, 0);
4820 /* If we were unable to expand via the builtin, stop the
4821 sequence (without outputting the insns) and break, causing
4822 a call the the library function. */
4831 /* Output the entire sequence. */
4832 insns
= get_insns ();
4838 case BUILT_IN_SAVEREGS
:
4839 /* Don't do __builtin_saveregs more than once in a function.
4840 Save the result of the first call and reuse it. */
4841 if (saveregs_value
!= 0)
4842 return saveregs_value
;
4844 /* When this function is called, it means that registers must be
4845 saved on entry to this function. So we migrate the
4846 call to the first insn of this function. */
4849 rtx valreg
, saved_valreg
;
4851 /* Now really call the function. `expand_call' does not call
4852 expand_builtin, so there is no danger of infinite recursion here. */
4855 #ifdef EXPAND_BUILTIN_SAVEREGS
4856 /* Do whatever the machine needs done in this case. */
4857 temp
= EXPAND_BUILTIN_SAVEREGS (arglist
);
4859 /* The register where the function returns its value
4860 is likely to have something else in it, such as an argument.
4861 So preserve that register around the call. */
4862 if (value_mode
!= VOIDmode
)
4864 valreg
= hard_libcall_value (value_mode
);
4865 saved_valreg
= gen_reg_rtx (value_mode
);
4866 emit_move_insn (saved_valreg
, valreg
);
4869 /* Generate the call, putting the value in a pseudo. */
4870 temp
= expand_call (exp
, target
, ignore
);
4872 if (value_mode
!= VOIDmode
)
4873 emit_move_insn (valreg
, saved_valreg
);
4879 saveregs_value
= temp
;
4881 /* This won't work inside a SEQUENCE--it really has to be
4882 at the start of the function. */
4883 if (in_sequence_p ())
4885 /* Better to do this than to crash. */
4886 error ("`va_start' used within `({...})'");
4890 /* Put the sequence after the NOTE that starts the function. */
4891 emit_insns_before (seq
, NEXT_INSN (get_insns ()));
4895 /* __builtin_args_info (N) returns word N of the arg space info
4896 for the current function. The number and meanings of words
4897 is controlled by the definition of CUMULATIVE_ARGS. */
4898 case BUILT_IN_ARGS_INFO
:
4900 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4902 int *word_ptr
= (int *) ¤t_function_args_info
;
4903 tree type
, elts
, result
;
4905 if (sizeof (CUMULATIVE_ARGS
) % sizeof (int) != 0)
4906 fatal ("CUMULATIVE_ARGS type defined badly; see %s, line %d",
4907 __FILE__
, __LINE__
);
4911 tree arg
= TREE_VALUE (arglist
);
4912 if (TREE_CODE (arg
) != INTEGER_CST
)
4913 error ("argument of __builtin_args_info must be constant");
4916 int wordnum
= TREE_INT_CST_LOW (arg
);
4918 if (wordnum
< 0 || wordnum
>= nwords
)
4919 error ("argument of __builtin_args_info out of range");
4921 return gen_rtx (CONST_INT
, VOIDmode
, word_ptr
[wordnum
]);
4925 error ("missing argument in __builtin_args_info");
4930 for (i
= 0; i
< nwords
; i
++)
4931 elts
= tree_cons (NULL_TREE
, build_int_2 (word_ptr
[i
], 0));
4933 type
= build_array_type (integer_type_node
,
4934 build_index_type (build_int_2 (nwords
, 0)));
4935 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (elts
));
4936 TREE_CONSTANT (result
) = 1;
4937 TREE_STATIC (result
) = 1;
4938 result
= build (INDIRECT_REF
, build_pointer_type (type
), result
);
4939 TREE_CONSTANT (result
) = 1;
4940 return expand_expr (result
, 0, VOIDmode
, 0);
4944 /* Return the address of the first anonymous stack arg. */
4945 case BUILT_IN_NEXT_ARG
:
4947 tree fntype
= TREE_TYPE (current_function_decl
);
4948 if (!(TYPE_ARG_TYPES (fntype
) != 0
4949 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
4950 != void_type_node
)))
4952 error ("`va_start' used in function with fixed args");
4957 return expand_binop (Pmode
, add_optab
,
4958 current_function_internal_arg_pointer
,
4959 current_function_arg_offset_rtx
,
4960 0, 0, OPTAB_LIB_WIDEN
);
4962 case BUILT_IN_CLASSIFY_TYPE
:
4965 tree type
= TREE_TYPE (TREE_VALUE (arglist
));
4966 enum tree_code code
= TREE_CODE (type
);
4967 if (code
== VOID_TYPE
)
4968 return gen_rtx (CONST_INT
, VOIDmode
, void_type_class
);
4969 if (code
== INTEGER_TYPE
)
4970 return gen_rtx (CONST_INT
, VOIDmode
, integer_type_class
);
4971 if (code
== CHAR_TYPE
)
4972 return gen_rtx (CONST_INT
, VOIDmode
, char_type_class
);
4973 if (code
== ENUMERAL_TYPE
)
4974 return gen_rtx (CONST_INT
, VOIDmode
, enumeral_type_class
);
4975 if (code
== BOOLEAN_TYPE
)
4976 return gen_rtx (CONST_INT
, VOIDmode
, boolean_type_class
);
4977 if (code
== POINTER_TYPE
)
4978 return gen_rtx (CONST_INT
, VOIDmode
, pointer_type_class
);
4979 if (code
== REFERENCE_TYPE
)
4980 return gen_rtx (CONST_INT
, VOIDmode
, reference_type_class
);
4981 if (code
== OFFSET_TYPE
)
4982 return gen_rtx (CONST_INT
, VOIDmode
, offset_type_class
);
4983 if (code
== REAL_TYPE
)
4984 return gen_rtx (CONST_INT
, VOIDmode
, real_type_class
);
4985 if (code
== COMPLEX_TYPE
)
4986 return gen_rtx (CONST_INT
, VOIDmode
, complex_type_class
);
4987 if (code
== FUNCTION_TYPE
)
4988 return gen_rtx (CONST_INT
, VOIDmode
, function_type_class
);
4989 if (code
== METHOD_TYPE
)
4990 return gen_rtx (CONST_INT
, VOIDmode
, method_type_class
);
4991 if (code
== RECORD_TYPE
)
4992 return gen_rtx (CONST_INT
, VOIDmode
, record_type_class
);
4993 if (code
== UNION_TYPE
)
4994 return gen_rtx (CONST_INT
, VOIDmode
, union_type_class
);
4995 if (code
== ARRAY_TYPE
)
4996 return gen_rtx (CONST_INT
, VOIDmode
, array_type_class
);
4997 if (code
== STRING_TYPE
)
4998 return gen_rtx (CONST_INT
, VOIDmode
, string_type_class
);
4999 if (code
== SET_TYPE
)
5000 return gen_rtx (CONST_INT
, VOIDmode
, set_type_class
);
5001 if (code
== FILE_TYPE
)
5002 return gen_rtx (CONST_INT
, VOIDmode
, file_type_class
);
5003 if (code
== LANG_TYPE
)
5004 return gen_rtx (CONST_INT
, VOIDmode
, lang_type_class
);
5006 return gen_rtx (CONST_INT
, VOIDmode
, no_type_class
);
5008 case BUILT_IN_CONSTANT_P
:
5012 return (TREE_CODE_CLASS (TREE_VALUE (arglist
)) == 'c'
5013 ? const1_rtx
: const0_rtx
);
5015 case BUILT_IN_FRAME_ADDRESS
:
5016 /* The argument must be a nonnegative integer constant.
5017 It counts the number of frames to scan up the stack.
5018 The value is the address of that frame. */
5019 case BUILT_IN_RETURN_ADDRESS
:
5020 /* The argument must be a nonnegative integer constant.
5021 It counts the number of frames to scan up the stack.
5022 The value is the return address saved in that frame. */
5024 /* Warning about missing arg was already issued. */
5026 else if (TREE_CODE (TREE_VALUE (arglist
)) != INTEGER_CST
)
5028 error ("invalid arg to __builtin_return_address");
5031 else if (tree_int_cst_lt (TREE_VALUE (arglist
), integer_zero_node
))
5033 error ("invalid arg to __builtin_return_address");
5038 int count
= TREE_INT_CST_LOW (TREE_VALUE (arglist
));
5039 rtx tem
= frame_pointer_rtx
;
5042 /* Scan back COUNT frames to the specified frame. */
5043 for (i
= 0; i
< count
; i
++)
5045 /* Assume the dynamic chain pointer is in the word that
5046 the frame address points to, unless otherwise specified. */
5047 #ifdef DYNAMIC_CHAIN_ADDRESS
5048 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
5050 tem
= memory_address (Pmode
, tem
);
5051 tem
= copy_to_reg (gen_rtx (MEM
, Pmode
, tem
));
5054 /* For __builtin_frame_address, return what we've got. */
5055 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
5058 /* For __builtin_return_address,
5059 Get the return address from that frame. */
5060 #ifdef RETURN_ADDR_RTX
5061 return RETURN_ADDR_RTX (count
, tem
);
5063 tem
= memory_address (Pmode
,
5064 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
5065 return copy_to_reg (gen_rtx (MEM
, Pmode
, tem
));
5069 case BUILT_IN_ALLOCA
:
5071 /* Arg could be non-integer if user redeclared this fcn wrong. */
5072 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
)
5074 current_function_calls_alloca
= 1;
5075 /* Compute the argument. */
5076 op0
= expand_expr (TREE_VALUE (arglist
), 0, VOIDmode
, 0);
5078 /* Allocate the desired space. */
5079 target
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
5081 /* Record the new stack level for nonlocal gotos. */
5082 if (nonlocal_goto_stack_level
!= 0)
5083 emit_move_insn (nonlocal_goto_stack_level
, stack_pointer_rtx
);
5087 /* If not optimizing, call the library function. */
5092 /* Arg could be non-integer if user redeclared this fcn wrong. */
5093 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
)
5096 /* Compute the argument. */
5097 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
5098 /* Compute ffs, into TARGET if possible.
5099 Set TARGET to wherever the result comes back. */
5100 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
5101 ffs_optab
, op0
, target
, 1);
5106 case BUILT_IN_STRLEN
:
5107 /* If not optimizing, call the library function. */
5112 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5113 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
5117 tree src
= TREE_VALUE (arglist
);
5118 tree len
= c_strlen (src
);
5121 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5123 rtx result
, src_rtx
, char_rtx
;
5124 enum machine_mode insn_mode
= value_mode
, char_mode
;
5125 enum insn_code icode
;
5127 /* If the length is known, just return it. */
5129 return expand_expr (len
, target
, mode
, 0);
5131 /* If SRC is not a pointer type, don't do this operation inline. */
5135 /* Call a function if we can't compute strlen in the right mode. */
5137 while (insn_mode
!= VOIDmode
)
5139 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
5140 if (icode
!= CODE_FOR_nothing
)
5143 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
5145 if (insn_mode
== VOIDmode
)
5148 /* Make a place to write the result of the instruction. */
5151 && GET_CODE (result
) == REG
5152 && GET_MODE (result
) == insn_mode
5153 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
5154 result
= gen_reg_rtx (insn_mode
);
5156 /* Make the operands are acceptable to the predicates. */
5158 if (! (*insn_operand_predicate
[icode
][0]) (result
, insn_mode
))
5159 result
= gen_reg_rtx (insn_mode
);
5161 src_rtx
= memory_address (BLKmode
,
5162 expand_expr (src
, 0, Pmode
,
5164 if (! (*insn_operand_predicate
[icode
][1]) (src_rtx
, Pmode
))
5165 src_rtx
= copy_to_mode_reg (Pmode
, src_rtx
);
5167 char_rtx
= const0_rtx
;
5168 char_mode
= insn_operand_mode
[icode
][2];
5169 if (! (*insn_operand_predicate
[icode
][2]) (char_rtx
, char_mode
))
5170 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
5172 emit_insn (GEN_FCN (icode
) (result
,
5173 gen_rtx (MEM
, BLKmode
, src_rtx
),
5175 gen_rtx (CONST_INT
, VOIDmode
, align
)));
5177 /* Return the value in the proper mode for this function. */
5178 if (GET_MODE (result
) == value_mode
)
5180 else if (target
!= 0)
5182 convert_move (target
, result
, 0);
5186 return convert_to_mode (value_mode
, result
, 0);
5189 case BUILT_IN_STRCPY
:
5190 /* If not optimizing, call the library function. */
5195 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5196 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5197 || TREE_CHAIN (arglist
) == 0
5198 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
)
5202 tree len
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)));
5207 len
= size_binop (PLUS_EXPR
, len
, integer_one_node
);
5209 chainon (arglist
, build_tree_list (0, len
));
5213 case BUILT_IN_MEMCPY
:
5214 /* If not optimizing, call the library function. */
5219 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5220 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5221 || TREE_CHAIN (arglist
) == 0
5222 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
5223 || TREE_CHAIN (TREE_CHAIN (arglist
)) == 0
5224 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))))) != INTEGER_TYPE
)
5228 tree dest
= TREE_VALUE (arglist
);
5229 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
5230 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
5233 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5235 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5238 /* If either SRC or DEST is not a pointer type, don't do
5239 this operation in-line. */
5240 if (src_align
== 0 || dest_align
== 0)
5242 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRCPY
)
5243 TREE_CHAIN (TREE_CHAIN (arglist
)) = 0;
5247 dest_rtx
= expand_expr (dest
, 0, Pmode
, EXPAND_NORMAL
);
5249 /* Copy word part most expediently. */
5250 emit_block_move (gen_rtx (MEM
, BLKmode
,
5251 memory_address (BLKmode
, dest_rtx
)),
5252 gen_rtx (MEM
, BLKmode
,
5253 memory_address (BLKmode
,
5254 expand_expr (src
, 0, Pmode
,
5256 expand_expr (len
, 0, VOIDmode
, 0),
5257 MIN (src_align
, dest_align
));
5261 /* These comparison functions need an instruction that returns an actual
5262 index. An ordinary compare that just sets the condition codes
5264 #ifdef HAVE_cmpstrsi
5265 case BUILT_IN_STRCMP
:
5266 /* If not optimizing, call the library function. */
5271 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5272 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5273 || TREE_CHAIN (arglist
) == 0
5274 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
)
5276 else if (!HAVE_cmpstrsi
)
5279 tree arg1
= TREE_VALUE (arglist
);
5280 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
5284 len
= c_strlen (arg1
);
5286 len
= size_binop (PLUS_EXPR
, integer_one_node
, len
);
5287 len2
= c_strlen (arg2
);
5289 len2
= size_binop (PLUS_EXPR
, integer_one_node
, len2
);
5291 /* If we don't have a constant length for the first, use the length
5292 of the second, if we know it. We don't require a constant for
5293 this case; some cost analysis could be done if both are available
5294 but neither is constant. For now, assume they're equally cheap.
5296 If both strings have constant lengths, use the smaller. This
5297 could arise if optimization results in strcpy being called with
5298 two fixed strings, or if the code was machine-generated. We should
5299 add some code to the `memcmp' handler below to deal with such
5300 situations, someday. */
5301 if (!len
|| TREE_CODE (len
) != INTEGER_CST
)
5308 else if (len2
&& TREE_CODE (len2
) == INTEGER_CST
)
5310 if (tree_int_cst_lt (len2
, len
))
5314 chainon (arglist
, build_tree_list (0, len
));
5318 case BUILT_IN_MEMCMP
:
5319 /* If not optimizing, call the library function. */
5324 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5325 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5326 || TREE_CHAIN (arglist
) == 0
5327 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
5328 || TREE_CHAIN (TREE_CHAIN (arglist
)) == 0
5329 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))))) != INTEGER_TYPE
)
5331 else if (!HAVE_cmpstrsi
)
5334 tree arg1
= TREE_VALUE (arglist
);
5335 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
5336 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
5340 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5342 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5343 enum machine_mode insn_mode
5344 = insn_operand_mode
[(int) CODE_FOR_cmpstrsi
][0];
5346 /* If we don't have POINTER_TYPE, call the function. */
5347 if (arg1_align
== 0 || arg2_align
== 0)
5349 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRCMP
)
5350 TREE_CHAIN (TREE_CHAIN (arglist
)) = 0;
5354 /* Make a place to write the result of the instruction. */
5357 && GET_CODE (result
) == REG
&& GET_MODE (result
) == insn_mode
5358 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
5359 result
= gen_reg_rtx (insn_mode
);
5361 emit_insn (gen_cmpstrsi (result
,
5362 gen_rtx (MEM
, BLKmode
,
5363 expand_expr (arg1
, 0, Pmode
, EXPAND_NORMAL
)),
5364 gen_rtx (MEM
, BLKmode
,
5365 expand_expr (arg2
, 0, Pmode
, EXPAND_NORMAL
)),
5366 expand_expr (len
, 0, VOIDmode
, 0),
5367 gen_rtx (CONST_INT
, VOIDmode
,
5368 MIN (arg1_align
, arg2_align
))));
5370 /* Return the value in the proper mode for this function. */
5371 mode
= TYPE_MODE (TREE_TYPE (exp
));
5372 if (GET_MODE (result
) == mode
)
5374 else if (target
!= 0)
5376 convert_move (target
, result
, 0);
5380 return convert_to_mode (mode
, result
, 0);
5383 case BUILT_IN_STRCMP
:
5384 case BUILT_IN_MEMCMP
:
5388 default: /* just do library call, if unknown builtin */
5389 error ("built-in function %s not currently supported",
5390 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
5393 /* The switch statement above can drop through to cause the function
5394 to be called normally. */
5396 return expand_call (exp
, target
, ignore
);
5399 /* Expand code for a post- or pre- increment or decrement
5400 and return the RTX for the result.
5401 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
5404 expand_increment (exp
, post
)
5408 register rtx op0
, op1
;
5409 register rtx temp
, value
;
5410 register tree incremented
= TREE_OPERAND (exp
, 0);
5411 optab this_optab
= add_optab
;
5413 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
5414 int op0_is_copy
= 0;
5416 /* Stabilize any component ref that might need to be
5417 evaluated more than once below. */
5418 if (TREE_CODE (incremented
) == BIT_FIELD_REF
5419 || (TREE_CODE (incremented
) == COMPONENT_REF
5420 && (TREE_CODE (TREE_OPERAND (incremented
, 0)) != INDIRECT_REF
5421 || DECL_BIT_FIELD (TREE_OPERAND (incremented
, 1)))))
5422 incremented
= stabilize_reference (incremented
);
5424 /* Compute the operands as RTX.
5425 Note whether OP0 is the actual lvalue or a copy of it:
5426 I believe it is a copy iff it is a register and insns were
5427 generated in computing it or if it is a SUBREG (generated when
5428 the low-order field in a register was referenced). */
5429 temp
= get_last_insn ();
5430 op0
= expand_expr (incremented
, 0, VOIDmode
, 0);
5431 op0_is_copy
= (GET_CODE (op0
) == SUBREG
5432 || (GET_CODE (op0
) == REG
&& temp
!= get_last_insn ()));
5433 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
5435 /* Decide whether incrementing or decrementing. */
5436 if (TREE_CODE (exp
) == POSTDECREMENT_EXPR
5437 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
5438 this_optab
= sub_optab
;
5440 /* If OP0 is not the actual lvalue, but rather a copy in a register,
5441 then we cannot just increment OP0. We must
5442 therefore contrive to increment the original value.
5443 Then we can return OP0 since it is a copy of the old value. */
5446 /* This is the easiest way to increment the value wherever it is.
5447 Problems with multiple evaluation of INCREMENTED
5448 are prevented because either (1) it is a component_ref,
5449 in which case it was stabilized above, or (2) it is an array_ref
5450 with constant index in an array in a register, which is
5451 safe to reevaluate. */
5452 tree newexp
= build ((this_optab
== add_optab
5453 ? PLUS_EXPR
: MINUS_EXPR
),
5456 TREE_OPERAND (exp
, 1));
5457 temp
= expand_assignment (incremented
, newexp
, ! post
, 0);
5458 return post
? op0
: temp
;
5461 /* Convert decrement by a constant into a negative increment. */
5462 if (this_optab
== sub_optab
5463 && GET_CODE (op1
) == CONST_INT
)
5465 op1
= gen_rtx (CONST_INT
, VOIDmode
, - INTVAL (op1
));
5466 this_optab
= add_optab
;
5471 /* We have a true reference to the value in OP0.
5472 If there is an insn to add or subtract in this mode, queue it. */
5474 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
5475 op0
= stabilize (op0
);
5478 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
5479 if (icode
!= (int) CODE_FOR_nothing
5480 /* Make sure that OP0 is valid for operands 0 and 1
5481 of the insn we want to queue. */
5482 && (*insn_operand_predicate
[icode
][0]) (op0
, mode
)
5483 && (*insn_operand_predicate
[icode
][1]) (op0
, mode
))
5485 if (! (*insn_operand_predicate
[icode
][2]) (op1
, mode
))
5486 op1
= force_reg (mode
, op1
);
5488 return enqueue_insn (op0
, GEN_FCN (icode
) (op0
, op0
, op1
));
5492 /* Preincrement, or we can't increment with one simple insn. */
5494 /* Save a copy of the value before inc or dec, to return it later. */
5495 temp
= value
= copy_to_reg (op0
);
5497 /* Arrange to return the incremented value. */
5498 /* Copy the rtx because expand_binop will protect from the queue,
5499 and the results of that would be invalid for us to return
5500 if our caller does emit_queue before using our result. */
5501 temp
= copy_rtx (value
= op0
);
5503 /* Increment however we can. */
5504 op1
= expand_binop (mode
, this_optab
, value
, op1
, op0
,
5505 TREE_UNSIGNED (TREE_TYPE (exp
)), OPTAB_LIB_WIDEN
);
5506 /* Make sure the value is stored into OP0. */
5508 emit_move_insn (op0
, op1
);
5513 /* Expand all function calls contained within EXP, innermost ones first.
5514 But don't look within expressions that have sequence points.
5515 For each CALL_EXPR, record the rtx for its value
5516 in the CALL_EXPR_RTL field. */
5519 preexpand_calls (exp
)
5522 register int nops
, i
;
5523 int type
= TREE_CODE_CLASS (TREE_CODE (exp
));
5525 if (! do_preexpand_calls
)
5528 /* Only expressions and references can contain calls. */
5530 if (type
!= 'e' && type
!= '<' && type
!= '1' && type
!= '2' && type
!= 'r')
5533 switch (TREE_CODE (exp
))
5536 /* Do nothing if already expanded. */
5537 if (CALL_EXPR_RTL (exp
) != 0)
5540 /* Do nothing to built-in functions. */
5541 if (TREE_CODE (TREE_OPERAND (exp
, 0)) != ADDR_EXPR
5542 || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) != FUNCTION_DECL
5543 || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
5544 CALL_EXPR_RTL (exp
) = expand_call (exp
, 0, 0);
5549 case TRUTH_ANDIF_EXPR
:
5550 case TRUTH_ORIF_EXPR
:
5551 /* If we find one of these, then we can be sure
5552 the adjust will be done for it (since it makes jumps).
5553 Do it now, so that if this is inside an argument
5554 of a function, we don't get the stack adjustment
5555 after some other args have already been pushed. */
5556 do_pending_stack_adjust ();
5561 case WITH_CLEANUP_EXPR
:
5565 if (SAVE_EXPR_RTL (exp
) != 0)
5569 nops
= tree_code_length
[(int) TREE_CODE (exp
)];
5570 for (i
= 0; i
< nops
; i
++)
5571 if (TREE_OPERAND (exp
, i
) != 0)
5573 type
= TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, i
)));
5574 if (type
== 'e' || type
== '<' || type
== '1' || type
== '2'
5576 preexpand_calls (TREE_OPERAND (exp
, i
));
5580 /* At the start of a function, record that we have no previously-pushed
5581 arguments waiting to be popped. */
5584 init_pending_stack_adjust ()
5586 pending_stack_adjust
= 0;
5589 /* When exiting from function, if safe, clear out any pending stack adjust
5590 so the adjustment won't get done. */
5593 clear_pending_stack_adjust ()
5595 #ifdef EXIT_IGNORE_STACK
5596 if (! flag_omit_frame_pointer
&& EXIT_IGNORE_STACK
5597 && ! (TREE_INLINE (current_function_decl
) && ! flag_no_inline
)
5598 && ! flag_inline_functions
)
5599 pending_stack_adjust
= 0;
5603 /* Pop any previously-pushed arguments that have not been popped yet. */
5606 do_pending_stack_adjust ()
5608 if (inhibit_defer_pop
== 0)
5610 if (pending_stack_adjust
!= 0)
5611 adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, pending_stack_adjust
));
5612 pending_stack_adjust
= 0;
5616 /* Expand all cleanups up to OLD_CLEANUPS.
5617 Needed here, and also for language-dependent calls. */
5620 expand_cleanups_to (old_cleanups
)
5623 while (cleanups_this_call
!= old_cleanups
)
5625 expand_expr (TREE_VALUE (cleanups_this_call
), 0, VOIDmode
, 0);
5626 cleanups_this_call
= TREE_CHAIN (cleanups_this_call
);
5630 /* Expand conditional expressions. */
5632 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
5633 LABEL is an rtx of code CODE_LABEL, in this function and all the
5637 jumpifnot (exp
, label
)
5641 do_jump (exp
, label
, 0);
5644 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
5651 do_jump (exp
, 0, label
);
5654 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
5655 the result is zero, or IF_TRUE_LABEL if the result is one.
5656 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
5657 meaning fall through in that case.
5659 do_jump always does any pending stack adjust except when it does not
5660 actually perform a jump. An example where there is no jump
5661 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
5663 This function is responsible for optimizing cases such as
5664 &&, || and comparison operators in EXP. */
5667 do_jump (exp
, if_false_label
, if_true_label
)
5669 rtx if_false_label
, if_true_label
;
5671 register enum tree_code code
= TREE_CODE (exp
);
5672 /* Some cases need to create a label to jump to
5673 in order to properly fall through.
5674 These cases set DROP_THROUGH_LABEL nonzero. */
5675 rtx drop_through_label
= 0;
5689 temp
= integer_zerop (exp
) ? if_false_label
: if_true_label
;
5695 /* This is not true with #pragma weak */
5697 /* The address of something can never be zero. */
5699 emit_jump (if_true_label
);
5704 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == COMPONENT_REF
5705 || TREE_CODE (TREE_OPERAND (exp
, 0)) == BIT_FIELD_REF
5706 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_REF
)
5709 /* If we are narrowing the operand, we have to do the compare in the
5711 if ((TYPE_PRECISION (TREE_TYPE (exp
))
5712 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5714 case NON_LVALUE_EXPR
:
5715 case REFERENCE_EXPR
:
5720 /* These cannot change zero->non-zero or vice versa. */
5721 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5725 /* This is never less insns than evaluating the PLUS_EXPR followed by
5726 a test and can be longer if the test is eliminated. */
5728 /* Reduce to minus. */
5729 exp
= build (MINUS_EXPR
, TREE_TYPE (exp
),
5730 TREE_OPERAND (exp
, 0),
5731 fold (build1 (NEGATE_EXPR
, TREE_TYPE (TREE_OPERAND (exp
, 1)),
5732 TREE_OPERAND (exp
, 1))));
5733 /* Process as MINUS. */
5737 /* Non-zero iff operands of minus differ. */
5738 comparison
= compare (build (NE_EXPR
, TREE_TYPE (exp
),
5739 TREE_OPERAND (exp
, 0),
5740 TREE_OPERAND (exp
, 1)),
5745 /* If we are AND'ing with a small constant, do this comparison in the
5746 smallest type that fits. If the machine doesn't have comparisons
5747 that small, it will be converted back to the wider comparison.
5748 This helps if we are testing the sign bit of a narrower object.
5749 combine can't do this for us because it can't know whether a
5750 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
5752 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
5753 && TYPE_PRECISION (TREE_TYPE (exp
)) <= HOST_BITS_PER_INT
5754 && (i
= floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)))) >= 0
5755 && (type
= type_for_size (i
+ 1, 1)) != 0
5756 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
)))
5758 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
5763 case TRUTH_NOT_EXPR
:
5764 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5767 case TRUTH_ANDIF_EXPR
:
5768 if (if_false_label
== 0)
5769 if_false_label
= drop_through_label
= gen_label_rtx ();
5770 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, 0);
5771 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5774 case TRUTH_ORIF_EXPR
:
5775 if (if_true_label
== 0)
5776 if_true_label
= drop_through_label
= gen_label_rtx ();
5777 do_jump (TREE_OPERAND (exp
, 0), 0, if_true_label
);
5778 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5782 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
5785 do_pending_stack_adjust ();
5786 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5793 int bitsize
, bitpos
, unsignedp
;
5794 enum machine_mode mode
;
5798 /* Get description of this reference. We don't actually care
5799 about the underlying object here. */
5800 get_inner_reference (exp
, &bitsize
, &bitpos
, &mode
, &unsignedp
,
5803 type
= type_for_size (bitsize
, unsignedp
);
5804 if (type
!= 0 && bitsize
>= 0
5805 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
)))
5807 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
5814 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
5815 if (integer_onep (TREE_OPERAND (exp
, 1))
5816 && integer_zerop (TREE_OPERAND (exp
, 2)))
5817 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5819 else if (integer_zerop (TREE_OPERAND (exp
, 1))
5820 && integer_onep (TREE_OPERAND (exp
, 2)))
5821 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5825 register rtx label1
= gen_label_rtx ();
5826 drop_through_label
= gen_label_rtx ();
5827 do_jump (TREE_OPERAND (exp
, 0), label1
, 0);
5828 /* Now the THEN-expression. */
5829 do_jump (TREE_OPERAND (exp
, 1),
5830 if_false_label
? if_false_label
: drop_through_label
,
5831 if_true_label
? if_true_label
: drop_through_label
);
5832 /* In case the do_jump just above never jumps. */
5833 do_pending_stack_adjust ();
5834 emit_label (label1
);
5835 /* Now the ELSE-expression. */
5836 do_jump (TREE_OPERAND (exp
, 2),
5837 if_false_label
? if_false_label
: drop_through_label
,
5838 if_true_label
? if_true_label
: drop_through_label
);
5843 if (integer_zerop (TREE_OPERAND (exp
, 1)))
5844 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5845 else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5848 !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5849 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
);
5851 comparison
= compare (exp
, EQ
, EQ
);
5855 if (integer_zerop (TREE_OPERAND (exp
, 1)))
5856 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5857 else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5860 !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5861 do_jump_by_parts_equality (exp
, if_true_label
, if_false_label
);
5863 comparison
= compare (exp
, NE
, NE
);
5867 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5869 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5870 do_jump_by_parts_greater (exp
, 1, if_false_label
, if_true_label
);
5872 comparison
= compare (exp
, LT
, LTU
);
5876 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5878 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5879 do_jump_by_parts_greater (exp
, 0, if_true_label
, if_false_label
);
5881 comparison
= compare (exp
, LE
, LEU
);
5885 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5887 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5888 do_jump_by_parts_greater (exp
, 0, if_false_label
, if_true_label
);
5890 comparison
= compare (exp
, GT
, GTU
);
5894 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5896 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5897 do_jump_by_parts_greater (exp
, 1, if_true_label
, if_false_label
);
5899 comparison
= compare (exp
, GE
, GEU
);
5904 temp
= expand_expr (exp
, 0, VOIDmode
, 0);
5906 /* This is not needed any more and causes poor code since it causes
5907 comparisons and tests from non-SI objects to have different code
5909 /* Copy to register to avoid generating bad insns by cse
5910 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
5911 if (!cse_not_expected
&& GET_CODE (temp
) == MEM
)
5912 temp
= copy_to_reg (temp
);
5914 do_pending_stack_adjust ();
5915 if (GET_CODE (temp
) == CONST_INT
)
5916 comparison
= (temp
== const0_rtx
? const0_rtx
: const_true_rtx
);
5917 else if (GET_CODE (temp
) == LABEL_REF
)
5918 comparison
= const_true_rtx
;
5919 else if (GET_MODE_CLASS (GET_MODE (temp
)) == MODE_INT
5920 && !can_compare_p (GET_MODE (temp
)))
5921 /* Note swapping the labels gives us not-equal. */
5922 do_jump_by_parts_equality_rtx (temp
, if_true_label
, if_false_label
);
5923 else if (GET_MODE (temp
) != VOIDmode
)
5924 comparison
= compare_from_rtx (temp
, CONST0_RTX (GET_MODE (temp
)),
5925 NE
, 1, GET_MODE (temp
), 0, 0);
5930 /* Do any postincrements in the expression that was tested. */
5933 /* If COMPARISON is nonzero here, it is an rtx that can be substituted
5934 straight into a conditional jump instruction as the jump condition.
5935 Otherwise, all the work has been done already. */
5937 if (comparison
== const_true_rtx
)
5940 emit_jump (if_true_label
);
5942 else if (comparison
== const0_rtx
)
5945 emit_jump (if_false_label
);
5947 else if (comparison
)
5948 do_jump_for_compare (comparison
, if_false_label
, if_true_label
);
5952 if (drop_through_label
)
5954 /* If do_jump produces code that might be jumped around,
5955 do any stack adjusts from that code, before the place
5956 where control merges in. */
5957 do_pending_stack_adjust ();
5958 emit_label (drop_through_label
);
5962 /* Given a comparison expression EXP for values too wide to be compared
5963 with one insn, test the comparison and jump to the appropriate label.
5964 The code of EXP is ignored; we always test GT if SWAP is 0,
5965 and LT if SWAP is 1. */
5968 do_jump_by_parts_greater (exp
, swap
, if_false_label
, if_true_label
)
5971 rtx if_false_label
, if_true_label
;
5973 rtx op0
= expand_expr (TREE_OPERAND (exp
, swap
), 0, VOIDmode
, 0);
5974 rtx op1
= expand_expr (TREE_OPERAND (exp
, !swap
), 0, VOIDmode
, 0);
5975 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5976 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
5977 rtx drop_through_label
= 0;
5978 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5981 if (! if_true_label
|| ! if_false_label
)
5982 drop_through_label
= gen_label_rtx ();
5983 if (! if_true_label
)
5984 if_true_label
= drop_through_label
;
5985 if (! if_false_label
)
5986 if_false_label
= drop_through_label
;
5988 /* Compare a word at a time, high order first. */
5989 for (i
= 0; i
< nwords
; i
++)
5992 rtx op0_word
, op1_word
;
5994 if (WORDS_BIG_ENDIAN
)
5996 op0_word
= operand_subword_force (op0
, i
, mode
);
5997 op1_word
= operand_subword_force (op1
, i
, mode
);
6001 op0_word
= operand_subword_force (op0
, nwords
- 1 - i
, mode
);
6002 op1_word
= operand_subword_force (op1
, nwords
- 1 - i
, mode
);
6005 /* All but high-order word must be compared as unsigned. */
6006 comp
= compare_from_rtx (op0_word
, op1_word
,
6007 (unsignedp
|| i
> 0) ? GTU
: GT
,
6008 unsignedp
, word_mode
, 0, 0);
6009 if (comp
== const_true_rtx
)
6010 emit_jump (if_true_label
);
6011 else if (comp
!= const0_rtx
)
6012 do_jump_for_compare (comp
, 0, if_true_label
);
6014 /* Consider lower words only if these are equal. */
6015 comp
= compare_from_rtx (op0_word
, op1_word
, NE
, unsignedp
, word_mode
,
6017 if (comp
== const_true_rtx
)
6018 emit_jump (if_false_label
);
6019 else if (comp
!= const0_rtx
)
6020 do_jump_for_compare (comp
, 0, if_false_label
);
6024 emit_jump (if_false_label
);
6025 if (drop_through_label
)
6026 emit_label (drop_through_label
);
6029 /* Given an EQ_EXPR expression EXP for values too wide to be compared
6030 with one insn, test the comparison and jump to the appropriate label. */
6033 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
)
6035 rtx if_false_label
, if_true_label
;
6037 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
6038 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
6039 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
6040 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
6042 rtx drop_through_label
= 0;
6044 if (! if_false_label
)
6045 drop_through_label
= if_false_label
= gen_label_rtx ();
6047 for (i
= 0; i
< nwords
; i
++)
6049 rtx comp
= compare_from_rtx (operand_subword_force (op0
, i
, mode
),
6050 operand_subword_force (op1
, i
, mode
),
6051 EQ
, 0, word_mode
, 0, 0);
6052 if (comp
== const_true_rtx
)
6053 emit_jump (if_false_label
);
6054 else if (comp
!= const0_rtx
)
6055 do_jump_for_compare (comp
, if_false_label
, 0);
6059 emit_jump (if_true_label
);
6060 if (drop_through_label
)
6061 emit_label (drop_through_label
);
6064 /* Jump according to whether OP0 is 0.
6065 We assume that OP0 has an integer mode that is too wide
6066 for the available compare insns. */
6069 do_jump_by_parts_equality_rtx (op0
, if_false_label
, if_true_label
)
6071 rtx if_false_label
, if_true_label
;
6073 int nwords
= GET_MODE_SIZE (GET_MODE (op0
)) / UNITS_PER_WORD
;
6075 rtx drop_through_label
= 0;
6077 if (! if_false_label
)
6078 drop_through_label
= if_false_label
= gen_label_rtx ();
6080 for (i
= 0; i
< nwords
; i
++)
6082 rtx comp
= compare_from_rtx (operand_subword_force (op0
, i
,
6084 const0_rtx
, EQ
, 0, word_mode
, 0, 0);
6085 if (comp
== const_true_rtx
)
6086 emit_jump (if_false_label
);
6087 else if (comp
!= const0_rtx
)
6088 do_jump_for_compare (comp
, if_false_label
, 0);
6092 emit_jump (if_true_label
);
6093 if (drop_through_label
)
6094 emit_label (drop_through_label
);
6097 /* Given a comparison expression in rtl form, output conditional branches to
6098 IF_TRUE_LABEL, IF_FALSE_LABEL, or both. */
6101 do_jump_for_compare (comparison
, if_false_label
, if_true_label
)
6102 rtx comparison
, if_false_label
, if_true_label
;
6106 if (bcc_gen_fctn
[(int) GET_CODE (comparison
)] != 0)
6107 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (comparison
)]) (if_true_label
));
6112 emit_jump (if_false_label
);
6114 else if (if_false_label
)
6117 rtx prev
= PREV_INSN (get_last_insn ());
6120 /* Output the branch with the opposite condition. Then try to invert
6121 what is generated. If more than one insn is a branch, or if the
6122 branch is not the last insn written, abort. If we can't invert
6123 the branch, emit make a true label, redirect this jump to that,
6124 emit a jump to the false label and define the true label. */
6126 if (bcc_gen_fctn
[(int) GET_CODE (comparison
)] != 0)
6127 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (comparison
)]) (if_false_label
));
6131 /* Here we get the insn before what was just emitted.
6132 On some machines, emitting the branch can discard
6133 the previous compare insn and emit a replacement. */
6135 /* If there's only one preceding insn... */
6136 insn
= get_insns ();
6138 insn
= NEXT_INSN (prev
);
6140 for (insn
= NEXT_INSN (insn
); insn
; insn
= NEXT_INSN (insn
))
6141 if (GET_CODE (insn
) == JUMP_INSN
)
6148 if (branch
!= get_last_insn ())
6151 if (! invert_jump (branch
, if_false_label
))
6153 if_true_label
= gen_label_rtx ();
6154 redirect_jump (branch
, if_true_label
);
6155 emit_jump (if_false_label
);
6156 emit_label (if_true_label
);
6161 /* Generate code for a comparison expression EXP
6162 (including code to compute the values to be compared)
6163 and set (CC0) according to the result.
6164 SIGNED_CODE should be the rtx operation for this comparison for
6165 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
6167 We force a stack adjustment unless there are currently
6168 things pushed on the stack that aren't yet used. */
6171 compare (exp
, signed_code
, unsigned_code
)
6173 enum rtx_code signed_code
, unsigned_code
;
6175 register rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
6176 register rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
6177 register tree type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
6178 register enum machine_mode mode
= TYPE_MODE (type
);
6179 int unsignedp
= TREE_UNSIGNED (type
);
6180 enum rtx_code code
= unsignedp
? unsigned_code
: signed_code
;
6182 return compare_from_rtx (op0
, op1
, code
, unsignedp
, mode
,
6184 ? expr_size (TREE_OPERAND (exp
, 0)) : 0),
6185 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
6188 /* Like compare but expects the values to compare as two rtx's.
6189 The decision as to signed or unsigned comparison must be made by the caller.
6191 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
6194 If ALIGN is non-zero, it is the alignment of this type; if zero, the
6195 size of MODE should be used. */
6198 compare_from_rtx (op0
, op1
, code
, unsignedp
, mode
, size
, align
)
6199 register rtx op0
, op1
;
6202 enum machine_mode mode
;
6206 /* If one operand is constant, make it the second one. */
6208 if (GET_CODE (op0
) == CONST_INT
|| GET_CODE (op0
) == CONST_DOUBLE
)
6213 code
= swap_condition (code
);
6218 op0
= force_not_mem (op0
);
6219 op1
= force_not_mem (op1
);
6222 do_pending_stack_adjust ();
6224 if (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) == CONST_INT
)
6225 return simplify_relational_operation (code
, mode
, op0
, op1
);
6227 /* If this is a signed equality comparison, we can do it as an
6228 unsigned comparison since zero-extension is cheaper than sign
6229 extension and comparisons with zero are done as unsigned. If we
6230 are comparing against a constant, we must convert it to what it
6231 would look like unsigned. */
6232 if ((code
== EQ
|| code
== NE
) && ! unsignedp
6233 && GET_MODE_BITSIZE (GET_MODE (op0
)) <= HOST_BITS_PER_INT
)
6235 if (GET_CODE (op1
) == CONST_INT
6236 && (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
))) != INTVAL (op1
))
6237 op1
= gen_rtx (CONST_INT
, VOIDmode
,
6238 INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
)));
6242 emit_cmp_insn (op0
, op1
, code
, size
, mode
, unsignedp
, align
);
6244 return gen_rtx (code
, VOIDmode
, cc0_rtx
, const0_rtx
);
6247 /* Generate code to calculate EXP using a store-flag instruction
6248 and return an rtx for the result. EXP is either a comparison
6249 or a TRUTH_NOT_EXPR whose operand is a comparison.
6251 If TARGET is nonzero, store the result there if convenient.
6253 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
6256 Return zero if there is no suitable set-flag instruction
6257 available on this machine.
6259 Once expand_expr has been called on the arguments of the comparison,
6260 we are committed to doing the store flag, since it is not safe to
6261 re-evaluate the expression. We emit the store-flag insn by calling
6262 emit_store_flag, but only expand the arguments if we have a reason
6263 to believe that emit_store_flag will be successful. If we think that
6264 it will, but it isn't, we have to simulate the store-flag with a
6265 set/jump/set sequence. */
6268 do_store_flag (exp
, target
, mode
, only_cheap
)
6271 enum machine_mode mode
;
6275 tree arg0
, arg1
, type
;
6277 enum machine_mode operand_mode
;
6281 enum insn_code icode
;
6282 rtx subtarget
= target
;
6283 rtx result
, label
, pattern
, jump_pat
;
6285 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
6286 result at the end. We can't simply invert the test since it would
6287 have already been inverted if it were valid. This case occurs for
6288 some floating-point comparisons. */
6290 if (TREE_CODE (exp
) == TRUTH_NOT_EXPR
)
6291 invert
= 1, exp
= TREE_OPERAND (exp
, 0);
6293 arg0
= TREE_OPERAND (exp
, 0);
6294 arg1
= TREE_OPERAND (exp
, 1);
6295 type
= TREE_TYPE (arg0
);
6296 operand_mode
= TYPE_MODE (type
);
6297 unsignedp
= TREE_UNSIGNED (type
);
6299 /* We won't bother with BLKmode store-flag operations because it would mean
6300 passing a lot of information to emit_store_flag. */
6301 if (operand_mode
== BLKmode
)
6304 while (TREE_CODE (arg0
) == NON_LVALUE_EXPR
)
6305 arg0
= TREE_OPERAND (arg0
, 0);
6307 while (TREE_CODE (arg1
) == NON_LVALUE_EXPR
)
6308 arg1
= TREE_OPERAND (arg1
, 0);
6310 /* Get the rtx comparison code to use. We know that EXP is a comparison
6311 operation of some type. Some comparisons against 1 and -1 can be
6312 converted to comparisons with zero. Do so here so that the tests
6313 below will be aware that we have a comparison with zero. These
6314 tests will not catch constants in the first operand, but constants
6315 are rarely passed as the first operand. */
6317 switch (TREE_CODE (exp
))
6326 if (integer_onep (arg1
))
6327 arg1
= integer_zero_node
, code
= unsignedp
? LEU
: LE
;
6329 code
= unsignedp
? LTU
: LT
;
6332 if (integer_all_onesp (arg1
))
6333 arg1
= integer_zero_node
, code
= unsignedp
? LTU
: LT
;
6335 code
= unsignedp
? LEU
: LE
;
6338 if (integer_all_onesp (arg1
))
6339 arg1
= integer_zero_node
, code
= unsignedp
? GEU
: GE
;
6341 code
= unsignedp
? GTU
: GT
;
6344 if (integer_onep (arg1
))
6345 arg1
= integer_zero_node
, code
= unsignedp
? GTU
: GT
;
6347 code
= unsignedp
? GEU
: GE
;
6353 /* Put a constant second. */
6354 if (TREE_CODE (arg0
) == REAL_CST
|| TREE_CODE (arg0
) == INTEGER_CST
)
6356 tem
= arg0
; arg0
= arg1
; arg1
= tem
;
6357 code
= swap_condition (code
);
6360 /* If this is an equality or inequality test of a single bit, we can
6361 do this by shifting the bit being tested to the low-order bit and
6362 masking the result with the constant 1. If the condition was EQ,
6363 we xor it with 1. This does not require an scc insn and is faster
6364 than an scc insn even if we have it. */
6366 if ((code
== NE
|| code
== EQ
)
6367 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6368 && integer_pow2p (TREE_OPERAND (arg0
, 1))
6369 && TYPE_PRECISION (type
) <= HOST_BITS_PER_INT
)
6371 int bitnum
= exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0
, 1),
6374 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
6375 || GET_MODE (subtarget
) != operand_mode
6376 || ! safe_from_p (subtarget
, TREE_OPERAND (arg0
, 0)))
6379 op0
= expand_expr (TREE_OPERAND (arg0
, 0), subtarget
, VOIDmode
, 0);
6382 op0
= expand_shift (RSHIFT_EXPR
, GET_MODE (op0
), op0
,
6383 size_int (bitnum
), target
, 1);
6385 if (GET_MODE (op0
) != mode
)
6386 op0
= convert_to_mode (mode
, op0
, 1);
6388 if (bitnum
!= TYPE_PRECISION (type
) - 1)
6389 op0
= expand_and (op0
, const1_rtx
, target
);
6391 if ((code
== EQ
&& ! invert
) || (code
== NE
&& invert
))
6392 op0
= expand_binop (mode
, xor_optab
, op0
, const1_rtx
, target
, 0,
6398 /* Now see if we are likely to be able to do this. Return if not. */
6399 if (! can_compare_p (operand_mode
))
6401 icode
= setcc_gen_code
[(int) code
];
6402 if (icode
== CODE_FOR_nothing
6403 || (only_cheap
&& insn_operand_mode
[(int) icode
][0] != mode
))
6405 /* We can only do this if it is one of the special cases that
6406 can be handled without an scc insn. */
6407 if ((code
== LT
&& integer_zerop (arg1
))
6408 || (! only_cheap
&& code
== GE
&& integer_zerop (arg1
)))
6410 else if (BRANCH_COST
>= 0
6411 && ! only_cheap
&& (code
== NE
|| code
== EQ
)
6412 && TREE_CODE (type
) != REAL_TYPE
6413 && ((abs_optab
->handlers
[(int) operand_mode
].insn_code
6414 != CODE_FOR_nothing
)
6415 || (ffs_optab
->handlers
[(int) operand_mode
].insn_code
6416 != CODE_FOR_nothing
)))
6422 preexpand_calls (exp
);
6423 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
6424 || GET_MODE (subtarget
) != operand_mode
6425 || ! safe_from_p (subtarget
, arg1
))
6428 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
6429 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
6432 target
= gen_reg_rtx (mode
);
6434 result
= emit_store_flag (target
, code
, op0
, op1
, operand_mode
,
6440 result
= expand_binop (mode
, xor_optab
, result
, const1_rtx
,
6441 result
, 0, OPTAB_LIB_WIDEN
);
6445 /* If this failed, we have to do this with set/compare/jump/set code. */
6446 if (target
== 0 || GET_CODE (target
) != REG
6447 || reg_mentioned_p (target
, op0
) || reg_mentioned_p (target
, op1
))
6448 target
= gen_reg_rtx (GET_MODE (target
));
6450 emit_move_insn (target
, invert
? const0_rtx
: const1_rtx
);
6451 result
= compare_from_rtx (op0
, op1
, code
, unsignedp
, operand_mode
, 0, 0);
6452 if (GET_CODE (result
) == CONST_INT
)
6453 return (((result
== const0_rtx
&& ! invert
)
6454 || (result
!= const0_rtx
&& invert
))
6455 ? const0_rtx
: const1_rtx
);
6457 label
= gen_label_rtx ();
6458 if (bcc_gen_fctn
[(int) code
] == 0)
6461 emit_jump_insn ((*bcc_gen_fctn
[(int) code
]) (label
));
6462 emit_move_insn (target
, invert
? const1_rtx
: const0_rtx
);
6468 /* Generate a tablejump instruction (used for switch statements). */
6470 #ifdef HAVE_tablejump
6472 /* INDEX is the value being switched on, with the lowest value
6473 in the table already subtracted.
6474 MODE is its expected mode (needed if INDEX is ever constant).
6475 RANGE is the length of the jump table.
6476 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
6478 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
6479 index value is out of range. */
6482 do_tablejump (index
, mode
, range
, table_label
, default_label
)
6483 rtx index
, range
, table_label
, default_label
;
6484 enum machine_mode mode
;
6486 register rtx temp
, vector
;
6488 /* Code below assumes that MODE is Pmode,
6489 but I think that is a mistake. Let's see if that is true. */
6493 emit_cmp_insn (range
, index
, LTU
, 0, mode
, 0, 0);
6494 emit_jump_insn (gen_bltu (default_label
));
6495 /* If flag_force_addr were to affect this address
6496 it could interfere with the tricky assumptions made
6497 about addresses that contain label-refs,
6498 which may be valid only very near the tablejump itself. */
6499 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
6500 GET_MODE_SIZE, because this indicates how large insns are. The other
6501 uses should all be Pmode, because they are addresses. This code
6502 could fail if addresses and insns are not the same size. */
6503 index
= memory_address_noforce
6505 gen_rtx (PLUS
, Pmode
,
6506 gen_rtx (MULT
, Pmode
, index
,
6507 gen_rtx (CONST_INT
, VOIDmode
,
6508 GET_MODE_SIZE (CASE_VECTOR_MODE
))),
6509 gen_rtx (LABEL_REF
, Pmode
, table_label
)));
6510 temp
= gen_reg_rtx (CASE_VECTOR_MODE
);
6511 vector
= gen_rtx (MEM
, CASE_VECTOR_MODE
, index
);
6512 RTX_UNCHANGING_P (vector
) = 1;
6513 convert_move (temp
, vector
, 0);
6515 emit_jump_insn (gen_tablejump (temp
, table_label
));
6517 #ifndef CASE_VECTOR_PC_RELATIVE
6518 /* If we are generating PIC code or if the table is PC-relative, the
6519 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
6525 #endif /* HAVE_tablejump */