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 allocated.
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 initializers. */
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
);
2939 tree function
= decl_function_context (exp
);
2940 /* Handle using a label in a containing function. */
2941 if (function
!= current_function_decl
&& function
!= 0)
2943 struct function
*p
= find_function_data (function
);
2944 /* Allocate in the memory associated with the function
2945 that the label is in. */
2946 push_obstacks (p
->function_obstack
,
2947 p
->function_maybepermanent_obstack
);
2949 p
->forced_labels
= gen_rtx (EXPR_LIST
, VOIDmode
,
2950 label_rtx (exp
), p
->forced_labels
);
2953 else if (modifier
== EXPAND_INITIALIZER
)
2954 forced_labels
= gen_rtx (EXPR_LIST
, VOIDmode
,
2955 label_rtx (exp
), forced_labels
);
2956 return gen_rtx (MEM
, FUNCTION_MODE
,
2957 gen_rtx (LABEL_REF
, Pmode
, label_rtx (exp
)));
2961 if (DECL_RTL (exp
) == 0)
2963 error_with_decl (exp
, "prior parameter's size depends on `%s'");
2964 return CONST0_RTX (mode
);
2970 if (DECL_RTL (exp
) == 0)
2972 /* Ensure variable marked as used
2973 even if it doesn't go through a parser. */
2974 TREE_USED (exp
) = 1;
2975 /* Handle variables inherited from containing functions. */
2976 context
= decl_function_context (exp
);
2978 /* We treat inline_function_decl as an alias for the current function
2979 because that is the inline function whose vars, types, etc.
2980 are being merged into the current function.
2981 See expand_inline_function. */
2982 if (context
!= 0 && context
!= current_function_decl
2983 && context
!= inline_function_decl
2984 /* If var is static, we don't need a static chain to access it. */
2985 && ! (GET_CODE (DECL_RTL (exp
)) == MEM
2986 && CONSTANT_P (XEXP (DECL_RTL (exp
), 0))))
2990 /* Mark as non-local and addressable. */
2991 TREE_NONLOCAL (exp
) = 1;
2992 mark_addressable (exp
);
2993 if (GET_CODE (DECL_RTL (exp
)) != MEM
)
2995 addr
= XEXP (DECL_RTL (exp
), 0);
2996 if (GET_CODE (addr
) == MEM
)
2997 addr
= gen_rtx (MEM
, Pmode
, fix_lexical_addr (XEXP (addr
, 0), exp
));
2999 addr
= fix_lexical_addr (addr
, exp
);
3000 return change_address (DECL_RTL (exp
), mode
, addr
);
3003 /* This is the case of an array whose size is to be determined
3004 from its initializer, while the initializer is still being parsed.
3006 if (GET_CODE (DECL_RTL (exp
)) == MEM
3007 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) == REG
)
3008 return change_address (DECL_RTL (exp
), GET_MODE (DECL_RTL (exp
)),
3009 XEXP (DECL_RTL (exp
), 0));
3010 if (GET_CODE (DECL_RTL (exp
)) == MEM
3011 && modifier
!= EXPAND_CONST_ADDRESS
3012 && modifier
!= EXPAND_SUM
3013 && modifier
!= EXPAND_INITIALIZER
)
3015 /* DECL_RTL probably contains a constant address.
3016 On RISC machines where a constant address isn't valid,
3017 make some insns to get that address into a register. */
3018 if (!memory_address_p (DECL_MODE (exp
), XEXP (DECL_RTL (exp
), 0))
3020 && CONSTANT_ADDRESS_P (XEXP (DECL_RTL (exp
), 0))))
3021 return change_address (DECL_RTL (exp
), VOIDmode
,
3022 copy_rtx (XEXP (DECL_RTL (exp
), 0)));
3024 return DECL_RTL (exp
);
3027 return immed_double_const (TREE_INT_CST_LOW (exp
),
3028 TREE_INT_CST_HIGH (exp
),
3032 return expand_expr (DECL_INITIAL (exp
), target
, VOIDmode
, 0);
3035 /* If optimized, generate immediate CONST_DOUBLE
3036 which will be turned into memory by reload if necessary.
3038 We used to force a register so that loop.c could see it. But
3039 this does not allow gen_* patterns to perform optimizations with
3040 the constants. It also produces two insns in cases like "x = 1.0;".
3041 On most machines, floating-point constants are not permitted in
3042 many insns, so we'd end up copying it to a register in any case.
3044 Now, we do the copying in expand_binop, if appropriate. */
3045 return immed_real_const (exp
);
3049 if (! TREE_CST_RTL (exp
))
3050 output_constant_def (exp
);
3052 /* TREE_CST_RTL probably contains a constant address.
3053 On RISC machines where a constant address isn't valid,
3054 make some insns to get that address into a register. */
3055 if (GET_CODE (TREE_CST_RTL (exp
)) == MEM
3056 && modifier
!= EXPAND_CONST_ADDRESS
3057 && modifier
!= EXPAND_INITIALIZER
3058 && modifier
!= EXPAND_SUM
3059 && !memory_address_p (mode
, XEXP (TREE_CST_RTL (exp
), 0)))
3060 return change_address (TREE_CST_RTL (exp
), VOIDmode
,
3061 copy_rtx (XEXP (TREE_CST_RTL (exp
), 0)));
3062 return TREE_CST_RTL (exp
);
3065 context
= decl_function_context (exp
);
3066 /* We treat inline_function_decl as an alias for the current function
3067 because that is the inline function whose vars, types, etc.
3068 are being merged into the current function.
3069 See expand_inline_function. */
3070 if (context
== current_function_decl
|| context
== inline_function_decl
)
3073 /* If this is non-local, handle it. */
3076 temp
= SAVE_EXPR_RTL (exp
);
3077 if (temp
&& GET_CODE (temp
) == REG
)
3079 put_var_into_stack (exp
);
3080 temp
= SAVE_EXPR_RTL (exp
);
3082 if (temp
== 0 || GET_CODE (temp
) != MEM
)
3084 return change_address (temp
, mode
,
3085 fix_lexical_addr (XEXP (temp
, 0), exp
));
3087 if (SAVE_EXPR_RTL (exp
) == 0)
3089 if (mode
== BLKmode
)
3091 = assign_stack_temp (mode
,
3092 int_size_in_bytes (TREE_TYPE (exp
)), 0);
3094 temp
= gen_reg_rtx (mode
);
3095 SAVE_EXPR_RTL (exp
) = temp
;
3096 store_expr (TREE_OPERAND (exp
, 0), temp
, 0);
3097 if (!optimize
&& GET_CODE (temp
) == REG
)
3098 save_expr_regs
= gen_rtx (EXPR_LIST
, VOIDmode
, temp
,
3101 return SAVE_EXPR_RTL (exp
);
3104 /* Exit the current loop if the body-expression is true. */
3106 rtx label
= gen_label_rtx ();
3107 do_jump (TREE_OPERAND (exp
, 0), label
, 0);
3108 expand_exit_loop (0);
3114 expand_start_loop (1);
3115 expand_expr_stmt (TREE_OPERAND (exp
, 0));
3122 tree vars
= TREE_OPERAND (exp
, 0);
3123 int vars_need_expansion
= 0;
3125 /* Need to open a binding contour here because
3126 if there are any cleanups they most be contained here. */
3127 expand_start_bindings (0);
3129 /* Mark the corresponding BLOCK for output. */
3130 if (TREE_OPERAND (exp
, 2) != 0)
3131 TREE_USED (TREE_OPERAND (exp
, 2)) = 1;
3133 /* If VARS have not yet been expanded, expand them now. */
3136 if (DECL_RTL (vars
) == 0)
3138 vars_need_expansion
= 1;
3141 expand_decl_init (vars
);
3142 vars
= TREE_CHAIN (vars
);
3145 temp
= expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, modifier
);
3147 expand_end_bindings (TREE_OPERAND (exp
, 0), 0, 0);
3153 if (RTL_EXPR_SEQUENCE (exp
) == const0_rtx
)
3155 emit_insns (RTL_EXPR_SEQUENCE (exp
));
3156 RTL_EXPR_SEQUENCE (exp
) = const0_rtx
;
3157 return RTL_EXPR_RTL (exp
);
3160 /* All elts simple constants => refer to a constant in memory. But
3161 if this is a non-BLKmode mode, let it store a field at a time
3162 since that should make a CONST_INT or CONST_DOUBLE when we
3164 if (TREE_STATIC (exp
) && (mode
== BLKmode
|| TREE_ADDRESSABLE (exp
)))
3166 rtx constructor
= output_constant_def (exp
);
3167 if (modifier
!= EXPAND_CONST_ADDRESS
3168 && modifier
!= EXPAND_INITIALIZER
3169 && modifier
!= EXPAND_SUM
3170 && !memory_address_p (GET_MODE (constructor
),
3171 XEXP (constructor
, 0)))
3172 constructor
= change_address (constructor
, VOIDmode
,
3173 XEXP (constructor
, 0));
3180 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
3181 expand_expr (TREE_VALUE (elt
), const0_rtx
, VOIDmode
, 0);
3186 if (target
== 0 || ! safe_from_p (target
, exp
))
3188 if (mode
!= BLKmode
&& ! TREE_ADDRESSABLE (exp
))
3189 target
= gen_reg_rtx (mode
);
3192 rtx safe_target
= assign_stack_temp (mode
, int_size_in_bytes (type
), 0);
3194 MEM_IN_STRUCT_P (safe_target
) = MEM_IN_STRUCT_P (target
);
3195 target
= safe_target
;
3198 store_constructor (exp
, target
);
3204 tree exp1
= TREE_OPERAND (exp
, 0);
3207 /* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated
3208 for *PTR += ANYTHING where PTR is put inside the SAVE_EXPR.
3209 This code has the same general effect as simply doing
3210 expand_expr on the save expr, except that the expression PTR
3211 is computed for use as a memory address. This means different
3212 code, suitable for indexing, may be generated. */
3213 if (TREE_CODE (exp1
) == SAVE_EXPR
3214 && SAVE_EXPR_RTL (exp1
) == 0
3215 && TREE_CODE (exp2
= TREE_OPERAND (exp1
, 0)) != ERROR_MARK
3216 && TYPE_MODE (TREE_TYPE (exp1
)) == Pmode
3217 && TYPE_MODE (TREE_TYPE (exp2
)) == Pmode
)
3219 temp
= expand_expr (TREE_OPERAND (exp1
, 0), 0, VOIDmode
, EXPAND_SUM
);
3220 op0
= memory_address (mode
, temp
);
3221 op0
= copy_all_regs (op0
);
3222 SAVE_EXPR_RTL (exp1
) = op0
;
3226 op0
= expand_expr (exp1
, 0, VOIDmode
, EXPAND_SUM
);
3227 op0
= memory_address (mode
, op0
);
3230 temp
= gen_rtx (MEM
, mode
, op0
);
3231 /* If address was computed by addition,
3232 mark this as an element of an aggregate. */
3233 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
3234 || (TREE_CODE (TREE_OPERAND (exp
, 0)) == SAVE_EXPR
3235 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) == PLUS_EXPR
)
3236 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
3237 || TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
3238 || TREE_CODE (TREE_TYPE (exp
)) == UNION_TYPE
3239 || (TREE_CODE (exp1
) == ADDR_EXPR
3240 && (exp2
= TREE_OPERAND (exp1
, 0))
3241 && (TREE_CODE (TREE_TYPE (exp2
)) == ARRAY_TYPE
3242 || TREE_CODE (TREE_TYPE (exp2
)) == RECORD_TYPE
3243 || TREE_CODE (TREE_TYPE (exp2
)) == UNION_TYPE
)))
3244 MEM_IN_STRUCT_P (temp
) = 1;
3245 MEM_VOLATILE_P (temp
) = TREE_THIS_VOLATILE (exp
) || flag_volatile
;
3246 #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that
3247 a location is accessed through a pointer to const does not mean
3248 that the value there can never change. */
3249 RTX_UNCHANGING_P (temp
) = TREE_READONLY (exp
);
3255 if (TREE_CODE (TREE_OPERAND (exp
, 1)) != INTEGER_CST
3256 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
3258 /* Nonconstant array index or nonconstant element size.
3259 Generate the tree for *(&array+index) and expand that,
3260 except do it in a language-independent way
3261 and don't complain about non-lvalue arrays.
3262 `mark_addressable' should already have been called
3263 for any array for which this case will be reached. */
3265 /* Don't forget the const or volatile flag from the array element. */
3266 tree variant_type
= build_type_variant (type
,
3267 TREE_READONLY (exp
),
3268 TREE_THIS_VOLATILE (exp
));
3269 tree array_adr
= build1 (ADDR_EXPR
, build_pointer_type (variant_type
),
3270 TREE_OPERAND (exp
, 0));
3271 tree index
= TREE_OPERAND (exp
, 1);
3274 /* Convert the integer argument to a type the same size as a pointer
3275 so the multiply won't overflow spuriously. */
3276 if (TYPE_PRECISION (TREE_TYPE (index
)) != POINTER_SIZE
)
3277 index
= convert (type_for_size (POINTER_SIZE
, 0), index
);
3279 /* Don't think the address has side effects
3280 just because the array does.
3281 (In some cases the address might have side effects,
3282 and we fail to record that fact here. However, it should not
3283 matter, since expand_expr should not care.) */
3284 TREE_SIDE_EFFECTS (array_adr
) = 0;
3286 elt
= build1 (INDIRECT_REF
, type
,
3287 fold (build (PLUS_EXPR
, TYPE_POINTER_TO (variant_type
),
3289 fold (build (MULT_EXPR
,
3290 TYPE_POINTER_TO (variant_type
),
3291 index
, size_in_bytes (type
))))));
3293 /* Volatility, etc., of new expression is same as old expression. */
3294 TREE_SIDE_EFFECTS (elt
) = TREE_SIDE_EFFECTS (exp
);
3295 TREE_THIS_VOLATILE (elt
) = TREE_THIS_VOLATILE (exp
);
3296 TREE_READONLY (elt
) = TREE_READONLY (exp
);
3298 return expand_expr (elt
, target
, tmode
, modifier
);
3301 /* Fold an expression like: "foo"[2].
3302 This is not done in fold so it won't happen inside &. */
3305 tree arg0
= TREE_OPERAND (exp
, 0);
3306 tree arg1
= TREE_OPERAND (exp
, 1);
3308 if (TREE_CODE (arg0
) == STRING_CST
3309 && TREE_CODE (arg1
) == INTEGER_CST
3310 && !TREE_INT_CST_HIGH (arg1
)
3311 && (i
= TREE_INT_CST_LOW (arg1
)) < TREE_STRING_LENGTH (arg0
))
3313 if (TREE_TYPE (TREE_TYPE (arg0
)) == integer_type_node
)
3315 exp
= build_int_2 (((int *)TREE_STRING_POINTER (arg0
))[i
], 0);
3316 TREE_TYPE (exp
) = integer_type_node
;
3317 return expand_expr (exp
, target
, tmode
, modifier
);
3319 if (TREE_TYPE (TREE_TYPE (arg0
)) == char_type_node
)
3321 exp
= build_int_2 (TREE_STRING_POINTER (arg0
)[i
], 0);
3322 TREE_TYPE (exp
) = integer_type_node
;
3323 return expand_expr (convert (TREE_TYPE (TREE_TYPE (arg0
)), exp
), target
, tmode
, modifier
);
3328 /* If this is a constant index into a constant array,
3329 just get the value from the array. Handle both the cases when
3330 we have an explicit constructor and when our operand is a variable
3331 that was declared const. */
3333 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
3334 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
3336 tree index
= fold (TREE_OPERAND (exp
, 1));
3337 if (TREE_CODE (index
) == INTEGER_CST
3338 && TREE_INT_CST_HIGH (index
) == 0)
3340 int i
= TREE_INT_CST_LOW (index
);
3341 tree elem
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0));
3344 elem
= TREE_CHAIN (elem
);
3346 return expand_expr (fold (TREE_VALUE (elem
)), target
,
3351 else if (TREE_READONLY (TREE_OPERAND (exp
, 0))
3352 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
3353 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == ARRAY_TYPE
3354 && TREE_CODE (TREE_OPERAND (exp
, 0)) == VAR_DECL
3355 && DECL_INITIAL (TREE_OPERAND (exp
, 0))
3357 && (TREE_CODE (DECL_INITIAL (TREE_OPERAND (exp
, 0)))
3360 tree index
= fold (TREE_OPERAND (exp
, 1));
3361 if (TREE_CODE (index
) == INTEGER_CST
3362 && TREE_INT_CST_HIGH (index
) == 0)
3364 int i
= TREE_INT_CST_LOW (index
);
3365 tree init
= DECL_INITIAL (TREE_OPERAND (exp
, 0));
3367 if (TREE_CODE (init
) == CONSTRUCTOR
)
3369 tree elem
= CONSTRUCTOR_ELTS (init
);
3372 elem
= TREE_CHAIN (elem
);
3374 return expand_expr (fold (TREE_VALUE (elem
)), target
,
3377 else if (TREE_CODE (init
) == STRING_CST
3378 && i
< TREE_STRING_LENGTH (init
))
3380 temp
= gen_rtx (CONST_INT
, VOIDmode
,
3381 TREE_STRING_POINTER (init
)[i
]);
3382 return convert_to_mode (mode
, temp
, 0);
3386 /* Treat array-ref with constant index as a component-ref. */
3390 /* If the operand is a CONSTRUCTOR, we can just extract the
3391 appropriate field if it is present. */
3392 if (code
!= ARRAY_REF
3393 && TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
)
3397 for (elt
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)); elt
;
3398 elt
= TREE_CHAIN (elt
))
3399 if (TREE_PURPOSE (elt
) == TREE_OPERAND (exp
, 1))
3400 return expand_expr (TREE_VALUE (elt
), target
, tmode
, modifier
);
3404 enum machine_mode mode1
;
3408 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
,
3409 &mode1
, &unsignedp
, &volatilep
);
3411 /* In some cases, we will be offsetting OP0's address by a constant.
3412 So get it as a sum, if possible. If we will be using it
3413 directly in an insn, we validate it. */
3414 op0
= expand_expr (tem
, 0, VOIDmode
, EXPAND_SUM
);
3416 /* If this is a constant, put it into a register if it is a
3417 legimate constant and memory if it isn't. */
3418 if (CONSTANT_P (op0
))
3420 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (tem
));
3421 if (LEGITIMATE_CONSTANT_P (op0
))
3422 op0
= force_reg (mode
, op0
);
3424 op0
= validize_mem (force_const_mem (mode
, op0
));
3427 /* Don't forget about volatility even if this is a bitfield. */
3428 if (GET_CODE (op0
) == MEM
&& volatilep
&& ! MEM_VOLATILE_P (op0
))
3430 op0
= copy_rtx (op0
);
3431 MEM_VOLATILE_P (op0
) = 1;
3434 if (mode1
== VOIDmode
3435 || GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
)
3437 /* In cases where an aligned union has an unaligned object
3438 as a field, we might be extracting a BLKmode value from
3439 an integer-mode (e.g., SImode) object. Handle this case
3440 by doing the extract into an object as wide as the field
3441 (which we know to be the width of a basic mode), then
3442 storing into memory, and changing the mode to BLKmode. */
3443 enum machine_mode ext_mode
= mode
;
3445 if (ext_mode
== BLKmode
)
3446 ext_mode
= mode_for_size (bitsize
, MODE_INT
, 1);
3448 if (ext_mode
== BLKmode
)
3451 op0
= extract_bit_field (validize_mem (op0
), bitsize
, bitpos
,
3452 unsignedp
, target
, ext_mode
, ext_mode
,
3453 TYPE_ALIGN (TREE_TYPE (tem
)) / BITS_PER_UNIT
,
3454 int_size_in_bytes (TREE_TYPE (tem
)));
3455 if (mode
== BLKmode
)
3457 rtx
new = assign_stack_temp (ext_mode
,
3458 bitsize
/ BITS_PER_UNIT
, 0);
3460 emit_move_insn (new, op0
);
3461 op0
= copy_rtx (new);
3462 PUT_MODE (op0
, BLKmode
);
3468 /* Get a reference to just this component. */
3469 if (modifier
== EXPAND_CONST_ADDRESS
3470 || modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
3471 op0
= gen_rtx (MEM
, mode1
, plus_constant (XEXP (op0
, 0),
3472 (bitpos
/ BITS_PER_UNIT
)));
3474 op0
= change_address (op0
, mode1
,
3475 plus_constant (XEXP (op0
, 0),
3476 (bitpos
/ BITS_PER_UNIT
)));
3477 MEM_IN_STRUCT_P (op0
) = 1;
3478 MEM_VOLATILE_P (op0
) |= volatilep
;
3479 if (mode
== mode1
|| mode1
== BLKmode
|| mode1
== tmode
)
3482 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
3483 convert_move (target
, op0
, unsignedp
);
3489 tree base
= build_unary_op (ADDR_EXPR
, TREE_OPERAND (exp
, 0), 0);
3490 tree addr
= build (PLUS_EXPR
, type
, base
, TREE_OPERAND (exp
, 1));
3491 op0
= expand_expr (addr
, 0, VOIDmode
, EXPAND_SUM
);
3492 temp
= gen_rtx (MEM
, mode
, memory_address (mode
, op0
));
3493 MEM_IN_STRUCT_P (temp
) = 1;
3494 MEM_VOLATILE_P (temp
) = TREE_THIS_VOLATILE (exp
) || flag_volatile
;
3495 #if 0 /* It is incorrectto set RTX_UNCHANGING_P here, because the fact that
3496 a location is accessed through a pointer to const does not mean
3497 that the value there can never change. */
3498 RTX_UNCHANGING_P (temp
) = TREE_READONLY (exp
);
3503 /* Intended for a reference to a buffer of a file-object in Pascal.
3504 But it's not certain that a special tree code will really be
3505 necessary for these. INDIRECT_REF might work for them. */
3509 case WITH_CLEANUP_EXPR
:
3510 if (RTL_EXPR_RTL (exp
) == 0)
3513 = expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
3514 cleanups_this_call
= tree_cons (0, TREE_OPERAND (exp
, 2), cleanups_this_call
);
3515 /* That's it for this cleanup. */
3516 TREE_OPERAND (exp
, 2) = 0;
3518 return RTL_EXPR_RTL (exp
);
3521 /* Check for a built-in function. */
3522 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3523 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) == FUNCTION_DECL
3524 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3525 return expand_builtin (exp
, target
, subtarget
, tmode
, ignore
);
3526 /* If this call was expanded already by preexpand_calls,
3527 just return the result we got. */
3528 if (CALL_EXPR_RTL (exp
) != 0)
3529 return CALL_EXPR_RTL (exp
);
3530 return expand_call (exp
, target
, ignore
);
3532 case NON_LVALUE_EXPR
:
3535 case REFERENCE_EXPR
:
3536 if (TREE_CODE (type
) == VOID_TYPE
|| ignore
)
3538 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, modifier
);
3541 if (mode
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3542 return expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, modifier
);
3543 if (TREE_CODE (type
) == UNION_TYPE
)
3545 tree valtype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
3548 if (mode
== BLKmode
)
3550 if (TYPE_SIZE (type
) == 0
3551 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
3553 target
= assign_stack_temp (BLKmode
,
3554 (TREE_INT_CST_LOW (TYPE_SIZE (type
))
3555 + BITS_PER_UNIT
- 1)
3556 / BITS_PER_UNIT
, 0);
3559 target
= gen_reg_rtx (mode
);
3561 if (GET_CODE (target
) == MEM
)
3562 /* Store data into beginning of memory target. */
3563 store_expr (TREE_OPERAND (exp
, 0),
3564 change_address (target
, TYPE_MODE (valtype
), 0), 0);
3565 else if (GET_CODE (target
) == REG
)
3566 /* Store this field into a union of the proper type. */
3567 store_field (target
, GET_MODE_BITSIZE (TYPE_MODE (valtype
)), 0,
3568 TYPE_MODE (valtype
), TREE_OPERAND (exp
, 0),
3570 int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3574 /* Return the entire union. */
3577 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, mode
, 0);
3578 if (GET_MODE (op0
) == mode
|| GET_MODE (op0
) == VOIDmode
)
3580 if (flag_force_mem
&& GET_CODE (op0
) == MEM
)
3581 op0
= copy_to_reg (op0
);
3584 return convert_to_mode (mode
, op0
, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3586 convert_move (target
, op0
, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3590 /* We come here from MINUS_EXPR when the second operand is a constant. */
3592 this_optab
= add_optab
;
3594 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
3595 something else, make sure we add the register to the constant and
3596 then to the other thing. This case can occur during strength
3597 reduction and doing it this way will produce better code if the
3598 frame pointer or argument pointer is eliminated.
3600 fold-const.c will ensure that the constant is always in the inner
3601 PLUS_EXPR, so the only case we need to do anything about is if
3602 sp, ap, or fp is our second argument, in which case we must swap
3603 the innermost first argument and our second argument. */
3605 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
3606 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1)) == INTEGER_CST
3607 && TREE_CODE (TREE_OPERAND (exp
, 1)) == RTL_EXPR
3608 && (RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == frame_pointer_rtx
3609 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == stack_pointer_rtx
3610 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == arg_pointer_rtx
))
3612 tree t
= TREE_OPERAND (exp
, 1);
3614 TREE_OPERAND (exp
, 1) = TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3615 TREE_OPERAND (TREE_OPERAND (exp
, 0), 0) = t
;
3618 /* If the result is to be Pmode and we are adding an integer to
3619 something, we might be forming a constant. So try to use
3620 plus_constant. If it produces a sum and we can't accept it,
3621 use force_operand. This allows P = &ARR[const] to generate
3622 efficient code on machines where a SYMBOL_REF is not a valid
3625 If this is an EXPAND_SUM call, always return the sum. */
3626 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
3627 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
3628 && (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
3631 op1
= expand_expr (TREE_OPERAND (exp
, 1), subtarget
, VOIDmode
,
3633 op1
= plus_constant (op1
, TREE_INT_CST_LOW (TREE_OPERAND (exp
, 0)));
3634 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3635 op1
= force_operand (op1
, target
);
3639 else if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3640 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
3641 && (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
3644 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
3646 op0
= plus_constant (op0
, TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)));
3647 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3648 op0
= force_operand (op0
, target
);
3652 /* No sense saving up arithmetic to be done
3653 if it's all in the wrong mode to form part of an address.
3654 And force_operand won't know whether to sign-extend or
3656 if ((modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
3657 || mode
!= Pmode
) goto binop
;
3659 preexpand_calls (exp
);
3660 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3663 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, modifier
);
3664 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, modifier
);
3666 /* Make sure any term that's a sum with a constant comes last. */
3667 if (GET_CODE (op0
) == PLUS
3668 && CONSTANT_P (XEXP (op0
, 1)))
3674 /* If adding to a sum including a constant,
3675 associate it to put the constant outside. */
3676 if (GET_CODE (op1
) == PLUS
3677 && CONSTANT_P (XEXP (op1
, 1)))
3679 rtx constant_term
= const0_rtx
;
3681 temp
= simplify_binary_operation (PLUS
, mode
, XEXP (op1
, 0), op0
);
3684 /* Ensure that MULT comes first if there is one. */
3685 else if (GET_CODE (op0
) == MULT
)
3686 op0
= gen_rtx (PLUS
, mode
, op0
, XEXP (op1
, 0));
3688 op0
= gen_rtx (PLUS
, mode
, XEXP (op1
, 0), op0
);
3690 /* Let's also eliminate constants from op0 if possible. */
3691 op0
= eliminate_constant_term (op0
, &constant_term
);
3693 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
3694 their sum should be a constant. Form it into OP1, since the
3695 result we want will then be OP0 + OP1. */
3697 temp
= simplify_binary_operation (PLUS
, mode
, constant_term
,
3702 op1
= gen_rtx (PLUS
, mode
, constant_term
, XEXP (op1
, 1));
3705 /* Put a constant term last and put a multiplication first. */
3706 if (CONSTANT_P (op0
) || GET_CODE (op1
) == MULT
)
3707 temp
= op1
, op1
= op0
, op0
= temp
;
3709 temp
= simplify_binary_operation (PLUS
, mode
, op0
, op1
);
3710 return temp
? temp
: gen_rtx (PLUS
, mode
, op0
, op1
);
3713 /* Handle difference of two symbolic constants,
3714 for the sake of an initializer. */
3715 if ((modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
3716 && really_constant_p (TREE_OPERAND (exp
, 0))
3717 && really_constant_p (TREE_OPERAND (exp
, 1)))
3719 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, modifier
);
3720 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, modifier
);
3721 return gen_rtx (MINUS
, mode
, op0
, op1
);
3723 /* Convert A - const to A + (-const). */
3724 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
3726 exp
= build (PLUS_EXPR
, type
, TREE_OPERAND (exp
, 0),
3727 fold (build1 (NEGATE_EXPR
, type
,
3728 TREE_OPERAND (exp
, 1))));
3731 this_optab
= sub_optab
;
3735 preexpand_calls (exp
);
3736 /* If first operand is constant, swap them.
3737 Thus the following special case checks need only
3738 check the second operand. */
3739 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
)
3741 register tree t1
= TREE_OPERAND (exp
, 0);
3742 TREE_OPERAND (exp
, 0) = TREE_OPERAND (exp
, 1);
3743 TREE_OPERAND (exp
, 1) = t1
;
3746 /* Attempt to return something suitable for generating an
3747 indexed address, for machines that support that. */
3749 if (modifier
== EXPAND_SUM
&& mode
== Pmode
3750 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3751 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
)
3753 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, EXPAND_SUM
);
3755 /* Apply distributive law if OP0 is x+c. */
3756 if (GET_CODE (op0
) == PLUS
3757 && GET_CODE (XEXP (op0
, 1)) == CONST_INT
)
3758 return gen_rtx (PLUS
, mode
,
3759 gen_rtx (MULT
, mode
, XEXP (op0
, 0),
3760 gen_rtx (CONST_INT
, VOIDmode
,
3761 TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)))),
3762 gen_rtx (CONST_INT
, VOIDmode
,
3763 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))
3764 * INTVAL (XEXP (op0
, 1)))));
3766 if (GET_CODE (op0
) != REG
)
3767 op0
= force_operand (op0
, 0);
3768 if (GET_CODE (op0
) != REG
)
3769 op0
= copy_to_mode_reg (mode
, op0
);
3771 return gen_rtx (MULT
, mode
, op0
,
3772 gen_rtx (CONST_INT
, VOIDmode
,
3773 TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))));
3776 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3779 /* Check for multiplying things that have been extended
3780 from a narrower type. If this machine supports multiplying
3781 in that narrower type with a result in the desired type,
3782 do it that way, and avoid the explicit type-conversion. */
3783 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == NOP_EXPR
3784 && TREE_CODE (type
) == INTEGER_TYPE
3785 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3786 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))))
3787 && ((TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
3788 && int_fits_type_p (TREE_OPERAND (exp
, 1),
3789 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3790 /* Don't use a widening multiply if a shift will do. */
3791 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
3792 > HOST_BITS_PER_INT
)
3793 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))) < 0))
3795 (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
3796 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
3798 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))))
3799 /* If both operands are extended, they must either both
3800 be zero-extended or both be sign-extended. */
3801 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
3803 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))))))
3805 enum machine_mode innermode
3806 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)));
3807 this_optab
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
3808 ? umul_widen_optab
: smul_widen_optab
);
3809 if (mode
== GET_MODE_WIDER_MODE (innermode
)
3810 && this_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
3812 op0
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
3814 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
3815 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3817 op1
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
3822 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3823 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3824 return expand_mult (mode
, op0
, op1
, target
, unsignedp
);
3826 case TRUNC_DIV_EXPR
:
3827 case FLOOR_DIV_EXPR
:
3829 case ROUND_DIV_EXPR
:
3830 case EXACT_DIV_EXPR
:
3831 preexpand_calls (exp
);
3832 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3834 /* Possible optimization: compute the dividend with EXPAND_SUM
3835 then if the divisor is constant can optimize the case
3836 where some terms of the dividend have coeffs divisible by it. */
3837 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3838 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3839 return expand_divmod (0, code
, mode
, op0
, op1
, target
, unsignedp
);
3842 this_optab
= flodiv_optab
;
3845 case TRUNC_MOD_EXPR
:
3846 case FLOOR_MOD_EXPR
:
3848 case ROUND_MOD_EXPR
:
3849 preexpand_calls (exp
);
3850 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
3852 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3853 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3854 return expand_divmod (1, code
, mode
, op0
, op1
, target
, unsignedp
);
3856 case FIX_ROUND_EXPR
:
3857 case FIX_FLOOR_EXPR
:
3859 abort (); /* Not used for C. */
3861 case FIX_TRUNC_EXPR
:
3862 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
3864 target
= gen_reg_rtx (mode
);
3865 expand_fix (target
, op0
, unsignedp
);
3869 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
3871 target
= gen_reg_rtx (mode
);
3872 /* expand_float can't figure out what to do if FROM has VOIDmode.
3873 So give it the correct mode. With -O, cse will optimize this. */
3874 if (GET_MODE (op0
) == VOIDmode
)
3875 op0
= copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
3877 expand_float (target
, op0
,
3878 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
3882 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
3883 temp
= expand_unop (mode
, neg_optab
, op0
, target
, 0);
3889 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3891 /* Unsigned abs is simply the operand. Testing here means we don't
3892 risk generating incorrect code below. */
3893 if (TREE_UNSIGNED (type
))
3896 /* First try to do it with a special abs instruction. */
3897 temp
= expand_unop (mode
, abs_optab
, op0
, target
, 0);
3901 /* If this machine has expensive jumps, we can do integer absolute
3902 value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
3903 where W is the width of MODE. */
3905 if (GET_MODE_CLASS (mode
) == MODE_INT
&& BRANCH_COST
>= 2)
3907 rtx extended
= expand_shift (RSHIFT_EXPR
, mode
, op0
,
3908 size_int (GET_MODE_BITSIZE (mode
) - 1),
3911 temp
= expand_binop (mode
, xor_optab
, extended
, op0
, target
, 0,
3914 temp
= expand_binop (mode
, sub_optab
, temp
, extended
, target
, 0,
3921 /* If that does not win, use conditional jump and negate. */
3922 target
= original_target
;
3923 temp
= gen_label_rtx ();
3924 if (target
== 0 || ! safe_from_p (target
, TREE_OPERAND (exp
, 0))
3925 || (GET_CODE (target
) == REG
3926 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3927 target
= gen_reg_rtx (mode
);
3928 emit_move_insn (target
, op0
);
3929 emit_cmp_insn (target
,
3930 expand_expr (convert (type
, integer_zero_node
),
3934 emit_jump_insn (gen_bge (temp
));
3935 op0
= expand_unop (mode
, neg_optab
, target
, target
, 0);
3937 emit_move_insn (target
, op0
);
3944 target
= original_target
;
3945 if (target
== 0 || ! safe_from_p (target
, TREE_OPERAND (exp
, 1))
3946 || (GET_CODE (target
) == REG
3947 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3948 target
= gen_reg_rtx (mode
);
3949 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
3950 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
3952 /* First try to do it with a special MIN or MAX instruction.
3953 If that does not win, use a conditional jump to select the proper
3955 this_optab
= (TREE_UNSIGNED (type
)
3956 ? (code
== MIN_EXPR
? umin_optab
: umax_optab
)
3957 : (code
== MIN_EXPR
? smin_optab
: smax_optab
));
3959 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
, unsignedp
,
3965 emit_move_insn (target
, op0
);
3966 op0
= gen_label_rtx ();
3967 if (code
== MAX_EXPR
)
3968 temp
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1)))
3969 ? compare_from_rtx (target
, op1
, GEU
, 1, mode
, 0, 0)
3970 : compare_from_rtx (target
, op1
, GE
, 0, mode
, 0, 0));
3972 temp
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1)))
3973 ? compare_from_rtx (target
, op1
, LEU
, 1, mode
, 0, 0)
3974 : compare_from_rtx (target
, op1
, LE
, 0, mode
, 0, 0));
3975 if (temp
== const0_rtx
)
3976 emit_move_insn (target
, op1
);
3977 else if (temp
!= const_true_rtx
)
3979 if (bcc_gen_fctn
[(int) GET_CODE (temp
)] != 0)
3980 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (temp
)]) (op0
));
3983 emit_move_insn (target
, op1
);
3988 /* ??? Can optimize when the operand of this is a bitwise operation,
3989 by using a different bitwise operation. */
3991 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3992 temp
= expand_unop (mode
, one_cmpl_optab
, op0
, target
, 1);
3998 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
3999 temp
= expand_unop (mode
, ffs_optab
, op0
, target
, 1);
4004 /* ??? Can optimize bitwise operations with one arg constant.
4005 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
4006 and (a bitwise1 b) bitwise2 b (etc)
4007 but that is probably not worth while. */
4009 /* BIT_AND_EXPR is for bitwise anding.
4010 TRUTH_AND_EXPR is for anding two boolean values
4011 when we want in all cases to compute both of them.
4012 In general it is fastest to do TRUTH_AND_EXPR by
4013 computing both operands as actual zero-or-1 values
4014 and then bitwise anding. In cases where there cannot
4015 be any side effects, better code would be made by
4016 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR;
4017 but the question is how to recognize those cases. */
4019 case TRUTH_AND_EXPR
:
4021 this_optab
= and_optab
;
4024 /* See comment above about TRUTH_AND_EXPR; it applies here too. */
4027 this_optab
= ior_optab
;
4031 this_optab
= xor_optab
;
4038 preexpand_calls (exp
);
4039 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
4041 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
4042 return expand_shift (code
, mode
, op0
, TREE_OPERAND (exp
, 1), target
,
4045 /* Could determine the answer when only additive constants differ.
4046 Also, the addition of one can be handled by changing the condition. */
4053 preexpand_calls (exp
);
4054 temp
= do_store_flag (exp
, target
, tmode
!= VOIDmode
? tmode
: mode
, 0);
4057 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
4058 if (code
== NE_EXPR
&& integer_zerop (TREE_OPERAND (exp
, 1))
4060 && GET_CODE (original_target
) == REG
4061 && (GET_MODE (original_target
)
4062 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
4064 temp
= expand_expr (TREE_OPERAND (exp
, 0), original_target
, VOIDmode
, 0);
4065 if (temp
!= original_target
)
4066 temp
= copy_to_reg (temp
);
4067 op1
= gen_label_rtx ();
4068 emit_cmp_insn (temp
, const0_rtx
, EQ
, 0,
4069 GET_MODE (temp
), unsignedp
, 0);
4070 emit_jump_insn (gen_beq (op1
));
4071 emit_move_insn (temp
, const1_rtx
);
4075 /* If no set-flag instruction, must generate a conditional
4076 store into a temporary variable. Drop through
4077 and handle this like && and ||. */
4079 case TRUTH_ANDIF_EXPR
:
4080 case TRUTH_ORIF_EXPR
:
4081 if (target
== 0 || ! safe_from_p (target
, exp
)
4082 /* Make sure we don't have a hard reg (such as function's return
4083 value) live across basic blocks, if not optimizing. */
4084 || (!optimize
&& GET_CODE (target
) == REG
4085 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
4086 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
4087 emit_clr_insn (target
);
4088 op1
= gen_label_rtx ();
4089 jumpifnot (exp
, op1
);
4090 emit_0_to_1_insn (target
);
4094 case TRUTH_NOT_EXPR
:
4095 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
4096 /* The parser is careful to generate TRUTH_NOT_EXPR
4097 only with operands that are always zero or one. */
4098 temp
= expand_binop (mode
, xor_optab
, op0
,
4099 gen_rtx (CONST_INT
, mode
, 1),
4100 target
, 1, OPTAB_LIB_WIDEN
);
4106 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
4108 return expand_expr (TREE_OPERAND (exp
, 1),
4109 (ignore
? const0_rtx
: target
),
4114 /* Note that COND_EXPRs whose type is a structure or union
4115 are required to be constructed to contain assignments of
4116 a temporary variable, so that we can evaluate them here
4117 for side effect only. If type is void, we must do likewise. */
4119 /* If an arm of the branch requires a cleanup,
4120 only that cleanup is performed. */
4123 tree binary_op
= 0, unary_op
= 0;
4124 tree old_cleanups
= cleanups_this_call
;
4125 cleanups_this_call
= 0;
4127 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
4128 convert it to our mode, if necessary. */
4129 if (integer_onep (TREE_OPERAND (exp
, 1))
4130 && integer_zerop (TREE_OPERAND (exp
, 2))
4131 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
4133 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, mode
, modifier
);
4134 if (GET_MODE (op0
) == mode
)
4137 target
= gen_reg_rtx (mode
);
4138 convert_move (target
, op0
, unsignedp
);
4142 /* If we are not to produce a result, we have no target. Otherwise,
4143 if a target was specified use it; it will not be used as an
4144 intermediate target unless it is safe. If no target, use a
4147 if (mode
== VOIDmode
|| ignore
)
4149 else if (original_target
4150 && safe_from_p (original_target
, TREE_OPERAND (exp
, 0)))
4151 temp
= original_target
;
4152 else if (mode
== BLKmode
)
4154 if (TYPE_SIZE (type
) == 0
4155 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4157 temp
= assign_stack_temp (BLKmode
,
4158 (TREE_INT_CST_LOW (TYPE_SIZE (type
))
4159 + BITS_PER_UNIT
- 1)
4160 / BITS_PER_UNIT
, 0);
4163 temp
= gen_reg_rtx (mode
);
4165 /* Check for X ? A + B : A. If we have this, we can copy
4166 A to the output and conditionally add B. Similarly for unary
4167 operations. Don't do this if X has side-effects because
4168 those side effects might affect A or B and the "?" operation is
4169 a sequence point in ANSI. (We test for side effects later.) */
4171 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '2'
4172 && operand_equal_p (TREE_OPERAND (exp
, 2),
4173 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
4174 singleton
= TREE_OPERAND (exp
, 2), binary_op
= TREE_OPERAND (exp
, 1);
4175 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '2'
4176 && operand_equal_p (TREE_OPERAND (exp
, 1),
4177 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
4178 singleton
= TREE_OPERAND (exp
, 1), binary_op
= TREE_OPERAND (exp
, 2);
4179 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '1'
4180 && operand_equal_p (TREE_OPERAND (exp
, 2),
4181 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
4182 singleton
= TREE_OPERAND (exp
, 2), unary_op
= TREE_OPERAND (exp
, 1);
4183 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '1'
4184 && operand_equal_p (TREE_OPERAND (exp
, 1),
4185 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
4186 singleton
= TREE_OPERAND (exp
, 1), unary_op
= TREE_OPERAND (exp
, 2);
4188 /* If we had X ? A + 1 : A and we can do the test of X as a store-flag
4189 operation, do this as A + (X != 0). Similarly for other simple
4190 binary operators. */
4191 if (singleton
&& binary_op
4192 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4193 && (TREE_CODE (binary_op
) == PLUS_EXPR
4194 || TREE_CODE (binary_op
) == MINUS_EXPR
4195 || TREE_CODE (binary_op
) == BIT_IOR_EXPR
4196 || TREE_CODE (binary_op
) == BIT_XOR_EXPR
4197 || TREE_CODE (binary_op
) == BIT_AND_EXPR
)
4198 && integer_onep (TREE_OPERAND (binary_op
, 1))
4199 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
4202 optab boptab
= (TREE_CODE (binary_op
) == PLUS_EXPR
? add_optab
4203 : TREE_CODE (binary_op
) == MINUS_EXPR
? sub_optab
4204 : TREE_CODE (binary_op
) == BIT_IOR_EXPR
? ior_optab
4205 : TREE_CODE (binary_op
) == BIT_XOR_EXPR
? xor_optab
4208 /* If we had X ? A : A + 1, do this as A + (X == 0).
4210 We have to invert the truth value here and then put it
4211 back later if do_store_flag fails. We cannot simply copy
4212 TREE_OPERAND (exp, 0) to another variable and modify that
4213 because invert_truthvalue can modify the tree pointed to
4215 if (singleton
== TREE_OPERAND (exp
, 1))
4216 TREE_OPERAND (exp
, 0)
4217 = invert_truthvalue (TREE_OPERAND (exp
, 0));
4219 result
= do_store_flag (TREE_OPERAND (exp
, 0),
4220 safe_from_p (temp
, singleton
) ? temp
: 0,
4221 mode
, BRANCH_COST
<= 1);
4225 op1
= expand_expr (singleton
, 0, VOIDmode
, 0);
4226 return expand_binop (mode
, boptab
, op1
, result
, temp
,
4227 unsignedp
, OPTAB_LIB_WIDEN
);
4229 else if (singleton
== TREE_OPERAND (exp
, 1))
4230 TREE_OPERAND (exp
, 0)
4231 = invert_truthvalue (TREE_OPERAND (exp
, 0));
4235 op0
= gen_label_rtx ();
4237 if (singleton
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
4241 /* If the target conflicts with the other operand of the
4242 binary op, we can't use it. Also, we can't use the target
4243 if it is a hard register, because evaluating the condition
4244 might clobber it. */
4246 && ! safe_from_p (temp
, TREE_OPERAND (binary_op
, 1)))
4247 || (GET_CODE (temp
) == REG
4248 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
))
4249 temp
= gen_reg_rtx (mode
);
4250 store_expr (singleton
, temp
, 0);
4253 expand_expr (singleton
, ignore
? const1_rtx
: 0, VOIDmode
, 0);
4254 if (cleanups_this_call
)
4256 sorry ("aggregate value in COND_EXPR");
4257 cleanups_this_call
= 0;
4259 if (singleton
== TREE_OPERAND (exp
, 1))
4260 jumpif (TREE_OPERAND (exp
, 0), op0
);
4262 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4264 if (binary_op
&& temp
== 0)
4265 /* Just touch the other operand. */
4266 expand_expr (TREE_OPERAND (binary_op
, 1),
4267 ignore
? const0_rtx
: 0, VOIDmode
, 0);
4269 store_expr (build (TREE_CODE (binary_op
), type
,
4270 make_tree (type
, temp
),
4271 TREE_OPERAND (binary_op
, 1)),
4274 store_expr (build1 (TREE_CODE (unary_op
), type
,
4275 make_tree (type
, temp
)),
4280 /* This is now done in jump.c and is better done there because it
4281 produces shorter register lifetimes. */
4283 /* Check for both possibilities either constants or variables
4284 in registers (but not the same as the target!). If so, can
4285 save branches by assigning one, branching, and assigning the
4287 else if (temp
&& GET_MODE (temp
) != BLKmode
4288 && (TREE_CONSTANT (TREE_OPERAND (exp
, 1))
4289 || ((TREE_CODE (TREE_OPERAND (exp
, 1)) == PARM_DECL
4290 || TREE_CODE (TREE_OPERAND (exp
, 1)) == VAR_DECL
)
4291 && DECL_RTL (TREE_OPERAND (exp
, 1))
4292 && GET_CODE (DECL_RTL (TREE_OPERAND (exp
, 1))) == REG
4293 && DECL_RTL (TREE_OPERAND (exp
, 1)) != temp
))
4294 && (TREE_CONSTANT (TREE_OPERAND (exp
, 2))
4295 || ((TREE_CODE (TREE_OPERAND (exp
, 2)) == PARM_DECL
4296 || TREE_CODE (TREE_OPERAND (exp
, 2)) == VAR_DECL
)
4297 && DECL_RTL (TREE_OPERAND (exp
, 2))
4298 && GET_CODE (DECL_RTL (TREE_OPERAND (exp
, 2))) == REG
4299 && DECL_RTL (TREE_OPERAND (exp
, 2)) != temp
)))
4301 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4302 temp
= gen_reg_rtx (mode
);
4303 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4304 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4305 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4309 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
4310 comparison operator. If we have one of these cases, set the
4311 output to A, branch on A (cse will merge these two references),
4312 then set the output to FOO. */
4314 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
4315 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
4316 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
4317 TREE_OPERAND (exp
, 1), 0)
4318 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4319 && safe_from_p (temp
, TREE_OPERAND (exp
, 2)))
4321 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4322 temp
= gen_reg_rtx (mode
);
4323 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4324 jumpif (TREE_OPERAND (exp
, 0), op0
);
4325 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4329 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
4330 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
4331 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
4332 TREE_OPERAND (exp
, 2), 0)
4333 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
4334 && safe_from_p (temp
, TREE_OPERAND (exp
, 1)))
4336 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
4337 temp
= gen_reg_rtx (mode
);
4338 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4339 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4340 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4345 op1
= gen_label_rtx ();
4346 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
4348 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
4350 expand_expr (TREE_OPERAND (exp
, 1), ignore
? const0_rtx
: 0,
4352 if (cleanups_this_call
)
4354 sorry ("aggregate value in COND_EXPR");
4355 cleanups_this_call
= 0;
4359 emit_jump_insn (gen_jump (op1
));
4363 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
4365 expand_expr (TREE_OPERAND (exp
, 2), ignore
? const0_rtx
: 0,
4369 if (cleanups_this_call
)
4371 sorry ("aggregate value in COND_EXPR");
4372 cleanups_this_call
= 0;
4378 cleanups_this_call
= old_cleanups
;
4384 /* Something needs to be initialized, but we didn't know
4385 where that thing was when building the tree. For example,
4386 it could be the return value of a function, or a parameter
4387 to a function which lays down in the stack, or a temporary
4388 variable which must be passed by reference.
4390 We guarantee that the expression will either be constructed
4391 or copied into our original target. */
4393 tree slot
= TREE_OPERAND (exp
, 0);
4395 if (TREE_CODE (slot
) != VAR_DECL
)
4400 if (DECL_RTL (slot
) != 0)
4401 target
= DECL_RTL (slot
);
4404 target
= assign_stack_temp (mode
, int_size_in_bytes (type
), 0);
4405 /* All temp slots at this level must not conflict. */
4406 preserve_temp_slots (target
);
4407 DECL_RTL (slot
) = target
;
4411 /* Since SLOT is not known to the called function
4412 to belong to its stack frame, we must build an explicit
4413 cleanup. This case occurs when we must build up a reference
4414 to pass the reference as an argument. In this case,
4415 it is very likely that such a reference need not be
4418 if (TREE_OPERAND (exp
, 2) == 0)
4419 TREE_OPERAND (exp
, 2) = maybe_build_cleanup (slot
);
4420 if (TREE_OPERAND (exp
, 2))
4421 cleanups_this_call
= tree_cons (0, TREE_OPERAND (exp
, 2),
4422 cleanups_this_call
);
4427 /* This case does occur, when expanding a parameter which
4428 needs to be constructed on the stack. The target
4429 is the actual stack address that we want to initialize.
4430 The function we call will perform the cleanup in this case. */
4432 DECL_RTL (slot
) = target
;
4435 return expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, modifier
);
4440 tree lhs
= TREE_OPERAND (exp
, 0);
4441 tree rhs
= TREE_OPERAND (exp
, 1);
4442 tree noncopied_parts
= 0;
4443 tree lhs_type
= TREE_TYPE (lhs
);
4445 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
4446 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0 && !fixed_type_p (rhs
))
4447 noncopied_parts
= init_noncopied_parts (stabilize_reference (lhs
),
4448 TYPE_NONCOPIED_PARTS (lhs_type
));
4449 while (noncopied_parts
!= 0)
4451 expand_assignment (TREE_VALUE (noncopied_parts
),
4452 TREE_PURPOSE (noncopied_parts
), 0, 0);
4453 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
4460 /* If lhs is complex, expand calls in rhs before computing it.
4461 That's so we don't compute a pointer and save it over a call.
4462 If lhs is simple, compute it first so we can give it as a
4463 target if the rhs is just a call. This avoids an extra temp and copy
4464 and that prevents a partial-subsumption which makes bad code.
4465 Actually we could treat component_ref's of vars like vars. */
4467 tree lhs
= TREE_OPERAND (exp
, 0);
4468 tree rhs
= TREE_OPERAND (exp
, 1);
4469 tree noncopied_parts
= 0;
4470 tree lhs_type
= TREE_TYPE (lhs
);
4474 if (TREE_CODE (lhs
) != VAR_DECL
4475 && TREE_CODE (lhs
) != RESULT_DECL
4476 && TREE_CODE (lhs
) != PARM_DECL
)
4477 preexpand_calls (exp
);
4479 /* Check for |= or &= of a bitfield of size one into another bitfield
4480 of size 1. In this case, (unless we need the result of the
4481 assignment) we can do this more efficiently with a
4482 test followed by an assignment, if necessary.
4484 ??? At this point, we can't get a BIT_FIELD_REF here. But if
4485 things change so we do, this code should be enhanced to
4488 && TREE_CODE (lhs
) == COMPONENT_REF
4489 && (TREE_CODE (rhs
) == BIT_IOR_EXPR
4490 || TREE_CODE (rhs
) == BIT_AND_EXPR
)
4491 && TREE_OPERAND (rhs
, 0) == lhs
4492 && TREE_CODE (TREE_OPERAND (rhs
, 1)) == COMPONENT_REF
4493 && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs
, 1))) == 1
4494 && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs
, 1), 1))) == 1)
4496 rtx label
= gen_label_rtx ();
4498 do_jump (TREE_OPERAND (rhs
, 1),
4499 TREE_CODE (rhs
) == BIT_IOR_EXPR
? label
: 0,
4500 TREE_CODE (rhs
) == BIT_AND_EXPR
? label
: 0);
4501 expand_assignment (lhs
, convert (TREE_TYPE (rhs
),
4502 (TREE_CODE (rhs
) == BIT_IOR_EXPR
4504 : integer_zero_node
)),
4506 do_pending_stack_adjust ();
4511 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0
4512 && ! (fixed_type_p (lhs
) && fixed_type_p (rhs
)))
4513 noncopied_parts
= save_noncopied_parts (stabilize_reference (lhs
),
4514 TYPE_NONCOPIED_PARTS (lhs_type
));
4516 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
4517 while (noncopied_parts
!= 0)
4519 expand_assignment (TREE_PURPOSE (noncopied_parts
),
4520 TREE_VALUE (noncopied_parts
), 0, 0);
4521 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
4526 case PREINCREMENT_EXPR
:
4527 case PREDECREMENT_EXPR
:
4528 return expand_increment (exp
, 0);
4530 case POSTINCREMENT_EXPR
:
4531 case POSTDECREMENT_EXPR
:
4532 /* Faster to treat as pre-increment if result is not used. */
4533 return expand_increment (exp
, ! ignore
);
4536 /* Are we taking the address of a nested function? */
4537 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == FUNCTION_DECL
4538 && decl_function_context (TREE_OPERAND (exp
, 0)) != 0)
4540 op0
= trampoline_address (TREE_OPERAND (exp
, 0));
4541 op0
= force_operand (op0
, target
);
4545 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
,
4546 (modifier
== EXPAND_INITIALIZER
4547 ? modifier
: EXPAND_CONST_ADDRESS
));
4548 if (GET_CODE (op0
) != MEM
)
4551 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
4552 return XEXP (op0
, 0);
4553 op0
= force_operand (XEXP (op0
, 0), target
);
4555 if (flag_force_addr
&& GET_CODE (op0
) != REG
)
4556 return force_reg (Pmode
, op0
);
4559 case ENTRY_VALUE_EXPR
:
4566 return (*lang_expand_expr
) (exp
, target
, tmode
, modifier
);
4569 /* Here to do an ordinary binary operator, generating an instruction
4570 from the optab already placed in `this_optab'. */
4572 preexpand_calls (exp
);
4573 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1)))
4575 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
4576 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
4578 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
,
4579 unsignedp
, OPTAB_LIB_WIDEN
);
4585 /* Return the alignment in bits of EXP, a pointer valued expression.
4586 But don't return more than MAX_ALIGN no matter what.
4587 The alignment returned is, by default, the alignment of the thing that
4588 EXP points to (if it is not a POINTER_TYPE, 0 is returned).
4590 Otherwise, look at the expression to see if we can do better, i.e., if the
4591 expression is actually pointing at an object whose alignment is tighter. */
4594 get_pointer_alignment (exp
, max_align
)
4598 unsigned align
, inner
;
4600 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
4603 align
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
4604 align
= MIN (align
, max_align
);
4608 switch (TREE_CODE (exp
))
4612 case NON_LVALUE_EXPR
:
4613 exp
= TREE_OPERAND (exp
, 0);
4614 if (TREE_CODE (TREE_TYPE (exp
)) != POINTER_TYPE
)
4616 inner
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
)));
4617 inner
= MIN (inner
, max_align
);
4618 align
= MAX (align
, inner
);
4622 /* If sum of pointer + int, restrict our maximum alignment to that
4623 imposed by the integer. If not, we can't do any better than
4625 if (TREE_CODE (TREE_OPERAND (exp
, 1)) != INTEGER_CST
)
4628 while (((TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)) * BITS_PER_UNIT
)
4633 exp
= TREE_OPERAND (exp
, 0);
4637 /* See what we are pointing at and look at its alignment. */
4638 exp
= TREE_OPERAND (exp
, 0);
4639 if (TREE_CODE (exp
) == FUNCTION_DECL
)
4640 align
= MAX (align
, FUNCTION_BOUNDARY
);
4641 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd')
4642 align
= MAX (align
, DECL_ALIGN (exp
));
4643 #ifdef CONSTANT_ALIGNMENT
4644 else if (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c')
4645 align
= CONSTANT_ALIGNMENT (exp
, align
);
4647 return MIN (align
, max_align
);
4655 /* Return the tree node and offset if a given argument corresponds to
4656 a string constant. */
4659 string_constant (arg
, ptr_offset
)
4665 if (TREE_CODE (arg
) == ADDR_EXPR
4666 && TREE_CODE (TREE_OPERAND (arg
, 0)) == STRING_CST
)
4668 *ptr_offset
= integer_zero_node
;
4669 return TREE_OPERAND (arg
, 0);
4671 else if (TREE_CODE (arg
) == PLUS_EXPR
)
4673 tree arg0
= TREE_OPERAND (arg
, 0);
4674 tree arg1
= TREE_OPERAND (arg
, 1);
4679 if (TREE_CODE (arg0
) == ADDR_EXPR
4680 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == STRING_CST
)
4683 return TREE_OPERAND (arg0
, 0);
4685 else if (TREE_CODE (arg1
) == ADDR_EXPR
4686 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == STRING_CST
)
4689 return TREE_OPERAND (arg1
, 0);
4696 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
4697 way, because it could contain a zero byte in the middle.
4698 TREE_STRING_LENGTH is the size of the character array, not the string.
4700 Unfortunately, string_constant can't access the values of const char
4701 arrays with initializers, so neither can we do so here. */
4711 src
= string_constant (src
, &offset_node
);
4714 max
= TREE_STRING_LENGTH (src
);
4715 ptr
= TREE_STRING_POINTER (src
);
4716 if (offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
)
4718 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
4719 compute the offset to the following null if we don't know where to
4720 start searching for it. */
4722 for (i
= 0; i
< max
; i
++)
4725 /* We don't know the starting offset, but we do know that the string
4726 has no internal zero bytes. We can assume that the offset falls
4727 within the bounds of the string; otherwise, the programmer deserves
4728 what he gets. Subtract the offset from the length of the string,
4730 /* This would perhaps not be valid if we were dealing with named
4731 arrays in addition to literal string constants. */
4732 return size_binop (MINUS_EXPR
, size_int (max
), offset_node
);
4735 /* We have a known offset into the string. Start searching there for
4736 a null character. */
4737 if (offset_node
== 0)
4741 /* Did we get a long long offset? If so, punt. */
4742 if (TREE_INT_CST_HIGH (offset_node
) != 0)
4744 offset
= TREE_INT_CST_LOW (offset_node
);
4746 /* If the offset is known to be out of bounds, warn, and call strlen at
4748 if (offset
< 0 || offset
> max
)
4750 warning ("offset outside bounds of constant string");
4753 /* Use strlen to search for the first zero byte. Since any strings
4754 constructed with build_string will have nulls appended, we win even
4755 if we get handed something like (char[4])"abcd".
4757 Since OFFSET is our starting index into the string, no further
4758 calculation is needed. */
4759 return size_int (strlen (ptr
+ offset
));
4762 /* Expand an expression EXP that calls a built-in function,
4763 with result going to TARGET if that's convenient
4764 (and in mode MODE if that's convenient).
4765 SUBTARGET may be used as the target for computing one of EXP's operands.
4766 IGNORE is nonzero if the value is to be ignored. */
4769 expand_builtin (exp
, target
, subtarget
, mode
, ignore
)
4773 enum machine_mode mode
;
4776 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4777 tree arglist
= TREE_OPERAND (exp
, 1);
4779 rtx lab1
, lab2
, insns
;
4780 enum machine_mode value_mode
= TYPE_MODE (TREE_TYPE (exp
));
4782 switch (DECL_FUNCTION_CODE (fndecl
))
4787 /* build_function_call changes these into ABS_EXPR. */
4790 case BUILT_IN_FSQRT
:
4791 /* If not optimizing, call the library function. */
4796 /* Arg could be non-integer if user redeclared this fcn wrong. */
4797 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != REAL_TYPE
)
4800 /* Compute the argument. */
4801 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
4803 /* Make a suitable register to place result in. */
4804 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
4806 /* Test the argument to make sure it is in the proper domain for
4807 the sqrt function. If it is not in the domain, branch to a
4810 lab1
= gen_label_rtx ();
4811 lab2
= gen_label_rtx ();
4813 /* By default check the arguments. If flag_fast_math is turned on,
4814 then assume sqrt will always be called with valid arguments.
4815 Note changing the test below from "> 0" to ">= 0" would cause
4816 incorrect results when computing sqrt(-0.0). */
4818 if (! flag_fast_math
)
4820 /* By checking op > 0 we are able to catch all of the
4821 IEEE special cases with a single if conditional. */
4822 emit_cmp_insn (op0
, CONST0_RTX (GET_MODE (op0
)), GT
, 0,
4823 GET_MODE (op0
), 0, 0);
4824 emit_jump_insn (gen_bgt (lab1
));
4826 /* The argument was not in the domain; do this via library call.
4827 Pop the arguments right away in case the call gets deleted. */
4829 expand_call (exp
, target
, 0);
4832 /* Branch around open coded version */
4833 emit_jump_insn (gen_jump (lab2
));
4837 /* Arg is in the domain, compute sqrt, into TARGET.
4838 Set TARGET to wherever the result comes back. */
4839 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
4840 sqrt_optab
, op0
, target
, 0);
4842 /* If we were unable to expand via the builtin, stop the
4843 sequence (without outputting the insns) and break, causing
4844 a call the the library function. */
4853 /* Output the entire sequence. */
4854 insns
= get_insns ();
4860 case BUILT_IN_SAVEREGS
:
4861 /* Don't do __builtin_saveregs more than once in a function.
4862 Save the result of the first call and reuse it. */
4863 if (saveregs_value
!= 0)
4864 return saveregs_value
;
4866 /* When this function is called, it means that registers must be
4867 saved on entry to this function. So we migrate the
4868 call to the first insn of this function. */
4871 rtx valreg
, saved_valreg
;
4873 /* Now really call the function. `expand_call' does not call
4874 expand_builtin, so there is no danger of infinite recursion here. */
4877 #ifdef EXPAND_BUILTIN_SAVEREGS
4878 /* Do whatever the machine needs done in this case. */
4879 temp
= EXPAND_BUILTIN_SAVEREGS (arglist
);
4881 /* The register where the function returns its value
4882 is likely to have something else in it, such as an argument.
4883 So preserve that register around the call. */
4884 if (value_mode
!= VOIDmode
)
4886 valreg
= hard_libcall_value (value_mode
);
4887 saved_valreg
= gen_reg_rtx (value_mode
);
4888 emit_move_insn (saved_valreg
, valreg
);
4891 /* Generate the call, putting the value in a pseudo. */
4892 temp
= expand_call (exp
, target
, ignore
);
4894 if (value_mode
!= VOIDmode
)
4895 emit_move_insn (valreg
, saved_valreg
);
4901 saveregs_value
= temp
;
4903 /* This won't work inside a SEQUENCE--it really has to be
4904 at the start of the function. */
4905 if (in_sequence_p ())
4907 /* Better to do this than to crash. */
4908 error ("`va_start' used within `({...})'");
4912 /* Put the sequence after the NOTE that starts the function. */
4913 emit_insns_before (seq
, NEXT_INSN (get_insns ()));
4917 /* __builtin_args_info (N) returns word N of the arg space info
4918 for the current function. The number and meanings of words
4919 is controlled by the definition of CUMULATIVE_ARGS. */
4920 case BUILT_IN_ARGS_INFO
:
4922 int nwords
= sizeof (CUMULATIVE_ARGS
) / sizeof (int);
4924 int *word_ptr
= (int *) ¤t_function_args_info
;
4925 tree type
, elts
, result
;
4927 if (sizeof (CUMULATIVE_ARGS
) % sizeof (int) != 0)
4928 fatal ("CUMULATIVE_ARGS type defined badly; see %s, line %d",
4929 __FILE__
, __LINE__
);
4933 tree arg
= TREE_VALUE (arglist
);
4934 if (TREE_CODE (arg
) != INTEGER_CST
)
4935 error ("argument of __builtin_args_info must be constant");
4938 int wordnum
= TREE_INT_CST_LOW (arg
);
4940 if (wordnum
< 0 || wordnum
>= nwords
)
4941 error ("argument of __builtin_args_info out of range");
4943 return gen_rtx (CONST_INT
, VOIDmode
, word_ptr
[wordnum
]);
4947 error ("missing argument in __builtin_args_info");
4952 for (i
= 0; i
< nwords
; i
++)
4953 elts
= tree_cons (NULL_TREE
, build_int_2 (word_ptr
[i
], 0));
4955 type
= build_array_type (integer_type_node
,
4956 build_index_type (build_int_2 (nwords
, 0)));
4957 result
= build (CONSTRUCTOR
, type
, NULL_TREE
, nreverse (elts
));
4958 TREE_CONSTANT (result
) = 1;
4959 TREE_STATIC (result
) = 1;
4960 result
= build (INDIRECT_REF
, build_pointer_type (type
), result
);
4961 TREE_CONSTANT (result
) = 1;
4962 return expand_expr (result
, 0, VOIDmode
, 0);
4966 /* Return the address of the first anonymous stack arg. */
4967 case BUILT_IN_NEXT_ARG
:
4969 tree fntype
= TREE_TYPE (current_function_decl
);
4970 if (!(TYPE_ARG_TYPES (fntype
) != 0
4971 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype
)))
4972 != void_type_node
)))
4974 error ("`va_start' used in function with fixed args");
4979 return expand_binop (Pmode
, add_optab
,
4980 current_function_internal_arg_pointer
,
4981 current_function_arg_offset_rtx
,
4982 0, 0, OPTAB_LIB_WIDEN
);
4984 case BUILT_IN_CLASSIFY_TYPE
:
4987 tree type
= TREE_TYPE (TREE_VALUE (arglist
));
4988 enum tree_code code
= TREE_CODE (type
);
4989 if (code
== VOID_TYPE
)
4990 return gen_rtx (CONST_INT
, VOIDmode
, void_type_class
);
4991 if (code
== INTEGER_TYPE
)
4992 return gen_rtx (CONST_INT
, VOIDmode
, integer_type_class
);
4993 if (code
== CHAR_TYPE
)
4994 return gen_rtx (CONST_INT
, VOIDmode
, char_type_class
);
4995 if (code
== ENUMERAL_TYPE
)
4996 return gen_rtx (CONST_INT
, VOIDmode
, enumeral_type_class
);
4997 if (code
== BOOLEAN_TYPE
)
4998 return gen_rtx (CONST_INT
, VOIDmode
, boolean_type_class
);
4999 if (code
== POINTER_TYPE
)
5000 return gen_rtx (CONST_INT
, VOIDmode
, pointer_type_class
);
5001 if (code
== REFERENCE_TYPE
)
5002 return gen_rtx (CONST_INT
, VOIDmode
, reference_type_class
);
5003 if (code
== OFFSET_TYPE
)
5004 return gen_rtx (CONST_INT
, VOIDmode
, offset_type_class
);
5005 if (code
== REAL_TYPE
)
5006 return gen_rtx (CONST_INT
, VOIDmode
, real_type_class
);
5007 if (code
== COMPLEX_TYPE
)
5008 return gen_rtx (CONST_INT
, VOIDmode
, complex_type_class
);
5009 if (code
== FUNCTION_TYPE
)
5010 return gen_rtx (CONST_INT
, VOIDmode
, function_type_class
);
5011 if (code
== METHOD_TYPE
)
5012 return gen_rtx (CONST_INT
, VOIDmode
, method_type_class
);
5013 if (code
== RECORD_TYPE
)
5014 return gen_rtx (CONST_INT
, VOIDmode
, record_type_class
);
5015 if (code
== UNION_TYPE
)
5016 return gen_rtx (CONST_INT
, VOIDmode
, union_type_class
);
5017 if (code
== ARRAY_TYPE
)
5018 return gen_rtx (CONST_INT
, VOIDmode
, array_type_class
);
5019 if (code
== STRING_TYPE
)
5020 return gen_rtx (CONST_INT
, VOIDmode
, string_type_class
);
5021 if (code
== SET_TYPE
)
5022 return gen_rtx (CONST_INT
, VOIDmode
, set_type_class
);
5023 if (code
== FILE_TYPE
)
5024 return gen_rtx (CONST_INT
, VOIDmode
, file_type_class
);
5025 if (code
== LANG_TYPE
)
5026 return gen_rtx (CONST_INT
, VOIDmode
, lang_type_class
);
5028 return gen_rtx (CONST_INT
, VOIDmode
, no_type_class
);
5030 case BUILT_IN_CONSTANT_P
:
5034 return (TREE_CODE_CLASS (TREE_VALUE (arglist
)) == 'c'
5035 ? const1_rtx
: const0_rtx
);
5037 case BUILT_IN_FRAME_ADDRESS
:
5038 /* The argument must be a nonnegative integer constant.
5039 It counts the number of frames to scan up the stack.
5040 The value is the address of that frame. */
5041 case BUILT_IN_RETURN_ADDRESS
:
5042 /* The argument must be a nonnegative integer constant.
5043 It counts the number of frames to scan up the stack.
5044 The value is the return address saved in that frame. */
5046 /* Warning about missing arg was already issued. */
5048 else if (TREE_CODE (TREE_VALUE (arglist
)) != INTEGER_CST
)
5050 error ("invalid arg to __builtin_return_address");
5053 else if (tree_int_cst_lt (TREE_VALUE (arglist
), integer_zero_node
))
5055 error ("invalid arg to __builtin_return_address");
5060 int count
= TREE_INT_CST_LOW (TREE_VALUE (arglist
));
5061 rtx tem
= frame_pointer_rtx
;
5064 /* Scan back COUNT frames to the specified frame. */
5065 for (i
= 0; i
< count
; i
++)
5067 /* Assume the dynamic chain pointer is in the word that
5068 the frame address points to, unless otherwise specified. */
5069 #ifdef DYNAMIC_CHAIN_ADDRESS
5070 tem
= DYNAMIC_CHAIN_ADDRESS (tem
);
5072 tem
= memory_address (Pmode
, tem
);
5073 tem
= copy_to_reg (gen_rtx (MEM
, Pmode
, tem
));
5076 /* For __builtin_frame_address, return what we've got. */
5077 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FRAME_ADDRESS
)
5080 /* For __builtin_return_address,
5081 Get the return address from that frame. */
5082 #ifdef RETURN_ADDR_RTX
5083 return RETURN_ADDR_RTX (count
, tem
);
5085 tem
= memory_address (Pmode
,
5086 plus_constant (tem
, GET_MODE_SIZE (Pmode
)));
5087 return copy_to_reg (gen_rtx (MEM
, Pmode
, tem
));
5091 case BUILT_IN_ALLOCA
:
5093 /* Arg could be non-integer if user redeclared this fcn wrong. */
5094 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
)
5096 current_function_calls_alloca
= 1;
5097 /* Compute the argument. */
5098 op0
= expand_expr (TREE_VALUE (arglist
), 0, VOIDmode
, 0);
5100 /* Allocate the desired space. */
5101 target
= allocate_dynamic_stack_space (op0
, target
, BITS_PER_UNIT
);
5103 /* Record the new stack level for nonlocal gotos. */
5104 if (nonlocal_goto_handler_slot
!= 0)
5105 emit_stack_save (SAVE_NONLOCAL
, &nonlocal_goto_stack_level
, 0);
5109 /* If not optimizing, call the library function. */
5114 /* Arg could be non-integer if user redeclared this fcn wrong. */
5115 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != INTEGER_TYPE
)
5118 /* Compute the argument. */
5119 op0
= expand_expr (TREE_VALUE (arglist
), subtarget
, VOIDmode
, 0);
5120 /* Compute ffs, into TARGET if possible.
5121 Set TARGET to wherever the result comes back. */
5122 target
= expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist
))),
5123 ffs_optab
, op0
, target
, 1);
5128 case BUILT_IN_STRLEN
:
5129 /* If not optimizing, call the library function. */
5134 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5135 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
5139 tree src
= TREE_VALUE (arglist
);
5140 tree len
= c_strlen (src
);
5143 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5145 rtx result
, src_rtx
, char_rtx
;
5146 enum machine_mode insn_mode
= value_mode
, char_mode
;
5147 enum insn_code icode
;
5149 /* If the length is known, just return it. */
5151 return expand_expr (len
, target
, mode
, 0);
5153 /* If SRC is not a pointer type, don't do this operation inline. */
5157 /* Call a function if we can't compute strlen in the right mode. */
5159 while (insn_mode
!= VOIDmode
)
5161 icode
= strlen_optab
->handlers
[(int) insn_mode
].insn_code
;
5162 if (icode
!= CODE_FOR_nothing
)
5165 insn_mode
= GET_MODE_WIDER_MODE (insn_mode
);
5167 if (insn_mode
== VOIDmode
)
5170 /* Make a place to write the result of the instruction. */
5173 && GET_CODE (result
) == REG
5174 && GET_MODE (result
) == insn_mode
5175 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
5176 result
= gen_reg_rtx (insn_mode
);
5178 /* Make sure the operands are acceptable to the predicates. */
5180 if (! (*insn_operand_predicate
[(int)icode
][0]) (result
, insn_mode
))
5181 result
= gen_reg_rtx (insn_mode
);
5183 src_rtx
= memory_address (BLKmode
,
5184 expand_expr (src
, 0, Pmode
,
5186 if (! (*insn_operand_predicate
[(int)icode
][1]) (src_rtx
, Pmode
))
5187 src_rtx
= copy_to_mode_reg (Pmode
, src_rtx
);
5189 char_rtx
= const0_rtx
;
5190 char_mode
= insn_operand_mode
[(int)icode
][2];
5191 if (! (*insn_operand_predicate
[(int)icode
][2]) (char_rtx
, char_mode
))
5192 char_rtx
= copy_to_mode_reg (char_mode
, char_rtx
);
5194 emit_insn (GEN_FCN (icode
) (result
,
5195 gen_rtx (MEM
, BLKmode
, src_rtx
),
5197 gen_rtx (CONST_INT
, VOIDmode
, align
)));
5199 /* Return the value in the proper mode for this function. */
5200 if (GET_MODE (result
) == value_mode
)
5202 else if (target
!= 0)
5204 convert_move (target
, result
, 0);
5208 return convert_to_mode (value_mode
, result
, 0);
5211 case BUILT_IN_STRCPY
:
5212 /* If not optimizing, call the library function. */
5217 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5218 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5219 || TREE_CHAIN (arglist
) == 0
5220 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
)
5224 tree len
= c_strlen (TREE_VALUE (TREE_CHAIN (arglist
)));
5229 len
= size_binop (PLUS_EXPR
, len
, integer_one_node
);
5231 chainon (arglist
, build_tree_list (0, len
));
5235 case BUILT_IN_MEMCPY
:
5236 /* If not optimizing, call the library function. */
5241 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5242 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5243 || TREE_CHAIN (arglist
) == 0
5244 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
5245 || TREE_CHAIN (TREE_CHAIN (arglist
)) == 0
5246 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))))) != INTEGER_TYPE
)
5250 tree dest
= TREE_VALUE (arglist
);
5251 tree src
= TREE_VALUE (TREE_CHAIN (arglist
));
5252 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
5255 = get_pointer_alignment (src
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5257 = get_pointer_alignment (dest
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5260 /* If either SRC or DEST is not a pointer type, don't do
5261 this operation in-line. */
5262 if (src_align
== 0 || dest_align
== 0)
5264 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRCPY
)
5265 TREE_CHAIN (TREE_CHAIN (arglist
)) = 0;
5269 dest_rtx
= expand_expr (dest
, 0, Pmode
, EXPAND_NORMAL
);
5271 /* Copy word part most expediently. */
5272 emit_block_move (gen_rtx (MEM
, BLKmode
,
5273 memory_address (BLKmode
, dest_rtx
)),
5274 gen_rtx (MEM
, BLKmode
,
5275 memory_address (BLKmode
,
5276 expand_expr (src
, 0, Pmode
,
5278 expand_expr (len
, 0, VOIDmode
, 0),
5279 MIN (src_align
, dest_align
));
5283 /* These comparison functions need an instruction that returns an actual
5284 index. An ordinary compare that just sets the condition codes
5286 #ifdef HAVE_cmpstrsi
5287 case BUILT_IN_STRCMP
:
5288 /* If not optimizing, call the library function. */
5293 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5294 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5295 || TREE_CHAIN (arglist
) == 0
5296 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
)
5298 else if (!HAVE_cmpstrsi
)
5301 tree arg1
= TREE_VALUE (arglist
);
5302 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
5306 len
= c_strlen (arg1
);
5308 len
= size_binop (PLUS_EXPR
, integer_one_node
, len
);
5309 len2
= c_strlen (arg2
);
5311 len2
= size_binop (PLUS_EXPR
, integer_one_node
, len2
);
5313 /* If we don't have a constant length for the first, use the length
5314 of the second, if we know it. We don't require a constant for
5315 this case; some cost analysis could be done if both are available
5316 but neither is constant. For now, assume they're equally cheap.
5318 If both strings have constant lengths, use the smaller. This
5319 could arise if optimization results in strcpy being called with
5320 two fixed strings, or if the code was machine-generated. We should
5321 add some code to the `memcmp' handler below to deal with such
5322 situations, someday. */
5323 if (!len
|| TREE_CODE (len
) != INTEGER_CST
)
5330 else if (len2
&& TREE_CODE (len2
) == INTEGER_CST
)
5332 if (tree_int_cst_lt (len2
, len
))
5336 chainon (arglist
, build_tree_list (0, len
));
5340 case BUILT_IN_MEMCMP
:
5341 /* If not optimizing, call the library function. */
5346 /* Arg could be non-pointer if user redeclared this fcn wrong. */
5347 || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
5348 || TREE_CHAIN (arglist
) == 0
5349 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) != POINTER_TYPE
5350 || TREE_CHAIN (TREE_CHAIN (arglist
)) == 0
5351 || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))))) != INTEGER_TYPE
)
5353 else if (!HAVE_cmpstrsi
)
5356 tree arg1
= TREE_VALUE (arglist
);
5357 tree arg2
= TREE_VALUE (TREE_CHAIN (arglist
));
5358 tree len
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
)));
5362 = get_pointer_alignment (arg1
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5364 = get_pointer_alignment (arg2
, BIGGEST_ALIGNMENT
) / BITS_PER_UNIT
;
5365 enum machine_mode insn_mode
5366 = insn_operand_mode
[(int) CODE_FOR_cmpstrsi
][0];
5368 /* If we don't have POINTER_TYPE, call the function. */
5369 if (arg1_align
== 0 || arg2_align
== 0)
5371 if (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRCMP
)
5372 TREE_CHAIN (TREE_CHAIN (arglist
)) = 0;
5376 /* Make a place to write the result of the instruction. */
5379 && GET_CODE (result
) == REG
&& GET_MODE (result
) == insn_mode
5380 && REGNO (result
) >= FIRST_PSEUDO_REGISTER
))
5381 result
= gen_reg_rtx (insn_mode
);
5383 emit_insn (gen_cmpstrsi (result
,
5384 gen_rtx (MEM
, BLKmode
,
5385 expand_expr (arg1
, 0, Pmode
, EXPAND_NORMAL
)),
5386 gen_rtx (MEM
, BLKmode
,
5387 expand_expr (arg2
, 0, Pmode
, EXPAND_NORMAL
)),
5388 expand_expr (len
, 0, VOIDmode
, 0),
5389 gen_rtx (CONST_INT
, VOIDmode
,
5390 MIN (arg1_align
, arg2_align
))));
5392 /* Return the value in the proper mode for this function. */
5393 mode
= TYPE_MODE (TREE_TYPE (exp
));
5394 if (GET_MODE (result
) == mode
)
5396 else if (target
!= 0)
5398 convert_move (target
, result
, 0);
5402 return convert_to_mode (mode
, result
, 0);
5405 case BUILT_IN_STRCMP
:
5406 case BUILT_IN_MEMCMP
:
5410 default: /* just do library call, if unknown builtin */
5411 error ("built-in function %s not currently supported",
5412 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
5415 /* The switch statement above can drop through to cause the function
5416 to be called normally. */
5418 return expand_call (exp
, target
, ignore
);
5421 /* Expand code for a post- or pre- increment or decrement
5422 and return the RTX for the result.
5423 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
5426 expand_increment (exp
, post
)
5430 register rtx op0
, op1
;
5431 register rtx temp
, value
;
5432 register tree incremented
= TREE_OPERAND (exp
, 0);
5433 optab this_optab
= add_optab
;
5435 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
5436 int op0_is_copy
= 0;
5438 /* Stabilize any component ref that might need to be
5439 evaluated more than once below. */
5440 if (TREE_CODE (incremented
) == BIT_FIELD_REF
5441 || (TREE_CODE (incremented
) == COMPONENT_REF
5442 && (TREE_CODE (TREE_OPERAND (incremented
, 0)) != INDIRECT_REF
5443 || DECL_BIT_FIELD (TREE_OPERAND (incremented
, 1)))))
5444 incremented
= stabilize_reference (incremented
);
5446 /* Compute the operands as RTX.
5447 Note whether OP0 is the actual lvalue or a copy of it:
5448 I believe it is a copy iff it is a register and insns were
5449 generated in computing it or if it is a SUBREG (generated when
5450 the low-order field in a register was referenced). */
5451 temp
= get_last_insn ();
5452 op0
= expand_expr (incremented
, 0, VOIDmode
, 0);
5453 op0_is_copy
= (GET_CODE (op0
) == SUBREG
5454 || (GET_CODE (op0
) == REG
&& temp
!= get_last_insn ()));
5455 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
5457 /* Decide whether incrementing or decrementing. */
5458 if (TREE_CODE (exp
) == POSTDECREMENT_EXPR
5459 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
5460 this_optab
= sub_optab
;
5462 /* If OP0 is not the actual lvalue, but rather a copy in a register,
5463 then we cannot just increment OP0. We must
5464 therefore contrive to increment the original value.
5465 Then we can return OP0 since it is a copy of the old value. */
5468 /* This is the easiest way to increment the value wherever it is.
5469 Problems with multiple evaluation of INCREMENTED
5470 are prevented because either (1) it is a component_ref,
5471 in which case it was stabilized above, or (2) it is an array_ref
5472 with constant index in an array in a register, which is
5473 safe to reevaluate. */
5474 tree newexp
= build ((this_optab
== add_optab
5475 ? PLUS_EXPR
: MINUS_EXPR
),
5478 TREE_OPERAND (exp
, 1));
5479 temp
= expand_assignment (incremented
, newexp
, ! post
, 0);
5480 return post
? op0
: temp
;
5483 /* Convert decrement by a constant into a negative increment. */
5484 if (this_optab
== sub_optab
5485 && GET_CODE (op1
) == CONST_INT
)
5487 op1
= gen_rtx (CONST_INT
, VOIDmode
, - INTVAL (op1
));
5488 this_optab
= add_optab
;
5493 /* We have a true reference to the value in OP0.
5494 If there is an insn to add or subtract in this mode, queue it. */
5496 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
5497 op0
= stabilize (op0
);
5500 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
5501 if (icode
!= (int) CODE_FOR_nothing
5502 /* Make sure that OP0 is valid for operands 0 and 1
5503 of the insn we want to queue. */
5504 && (*insn_operand_predicate
[icode
][0]) (op0
, mode
)
5505 && (*insn_operand_predicate
[icode
][1]) (op0
, mode
))
5507 if (! (*insn_operand_predicate
[icode
][2]) (op1
, mode
))
5508 op1
= force_reg (mode
, op1
);
5510 return enqueue_insn (op0
, GEN_FCN (icode
) (op0
, op0
, op1
));
5514 /* Preincrement, or we can't increment with one simple insn. */
5516 /* Save a copy of the value before inc or dec, to return it later. */
5517 temp
= value
= copy_to_reg (op0
);
5519 /* Arrange to return the incremented value. */
5520 /* Copy the rtx because expand_binop will protect from the queue,
5521 and the results of that would be invalid for us to return
5522 if our caller does emit_queue before using our result. */
5523 temp
= copy_rtx (value
= op0
);
5525 /* Increment however we can. */
5526 op1
= expand_binop (mode
, this_optab
, value
, op1
, op0
,
5527 TREE_UNSIGNED (TREE_TYPE (exp
)), OPTAB_LIB_WIDEN
);
5528 /* Make sure the value is stored into OP0. */
5530 emit_move_insn (op0
, op1
);
5535 /* Expand all function calls contained within EXP, innermost ones first.
5536 But don't look within expressions that have sequence points.
5537 For each CALL_EXPR, record the rtx for its value
5538 in the CALL_EXPR_RTL field. */
5541 preexpand_calls (exp
)
5544 register int nops
, i
;
5545 int type
= TREE_CODE_CLASS (TREE_CODE (exp
));
5547 if (! do_preexpand_calls
)
5550 /* Only expressions and references can contain calls. */
5552 if (type
!= 'e' && type
!= '<' && type
!= '1' && type
!= '2' && type
!= 'r')
5555 switch (TREE_CODE (exp
))
5558 /* Do nothing if already expanded. */
5559 if (CALL_EXPR_RTL (exp
) != 0)
5562 /* Do nothing to built-in functions. */
5563 if (TREE_CODE (TREE_OPERAND (exp
, 0)) != ADDR_EXPR
5564 || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)) != FUNCTION_DECL
5565 || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
5566 CALL_EXPR_RTL (exp
) = expand_call (exp
, 0, 0);
5571 case TRUTH_ANDIF_EXPR
:
5572 case TRUTH_ORIF_EXPR
:
5573 /* If we find one of these, then we can be sure
5574 the adjust will be done for it (since it makes jumps).
5575 Do it now, so that if this is inside an argument
5576 of a function, we don't get the stack adjustment
5577 after some other args have already been pushed. */
5578 do_pending_stack_adjust ();
5583 case WITH_CLEANUP_EXPR
:
5587 if (SAVE_EXPR_RTL (exp
) != 0)
5591 nops
= tree_code_length
[(int) TREE_CODE (exp
)];
5592 for (i
= 0; i
< nops
; i
++)
5593 if (TREE_OPERAND (exp
, i
) != 0)
5595 type
= TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, i
)));
5596 if (type
== 'e' || type
== '<' || type
== '1' || type
== '2'
5598 preexpand_calls (TREE_OPERAND (exp
, i
));
5602 /* At the start of a function, record that we have no previously-pushed
5603 arguments waiting to be popped. */
5606 init_pending_stack_adjust ()
5608 pending_stack_adjust
= 0;
5611 /* When exiting from function, if safe, clear out any pending stack adjust
5612 so the adjustment won't get done. */
5615 clear_pending_stack_adjust ()
5617 #ifdef EXIT_IGNORE_STACK
5618 if (! flag_omit_frame_pointer
&& EXIT_IGNORE_STACK
5619 && ! (TREE_INLINE (current_function_decl
) && ! flag_no_inline
)
5620 && ! flag_inline_functions
)
5621 pending_stack_adjust
= 0;
5625 /* Pop any previously-pushed arguments that have not been popped yet. */
5628 do_pending_stack_adjust ()
5630 if (inhibit_defer_pop
== 0)
5632 if (pending_stack_adjust
!= 0)
5633 adjust_stack (gen_rtx (CONST_INT
, VOIDmode
, pending_stack_adjust
));
5634 pending_stack_adjust
= 0;
5638 /* Expand all cleanups up to OLD_CLEANUPS.
5639 Needed here, and also for language-dependent calls. */
5642 expand_cleanups_to (old_cleanups
)
5645 while (cleanups_this_call
!= old_cleanups
)
5647 expand_expr (TREE_VALUE (cleanups_this_call
), 0, VOIDmode
, 0);
5648 cleanups_this_call
= TREE_CHAIN (cleanups_this_call
);
5652 /* Expand conditional expressions. */
5654 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
5655 LABEL is an rtx of code CODE_LABEL, in this function and all the
5659 jumpifnot (exp
, label
)
5663 do_jump (exp
, label
, 0);
5666 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
5673 do_jump (exp
, 0, label
);
5676 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
5677 the result is zero, or IF_TRUE_LABEL if the result is one.
5678 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
5679 meaning fall through in that case.
5681 do_jump always does any pending stack adjust except when it does not
5682 actually perform a jump. An example where there is no jump
5683 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
5685 This function is responsible for optimizing cases such as
5686 &&, || and comparison operators in EXP. */
5689 do_jump (exp
, if_false_label
, if_true_label
)
5691 rtx if_false_label
, if_true_label
;
5693 register enum tree_code code
= TREE_CODE (exp
);
5694 /* Some cases need to create a label to jump to
5695 in order to properly fall through.
5696 These cases set DROP_THROUGH_LABEL nonzero. */
5697 rtx drop_through_label
= 0;
5711 temp
= integer_zerop (exp
) ? if_false_label
: if_true_label
;
5717 /* This is not true with #pragma weak */
5719 /* The address of something can never be zero. */
5721 emit_jump (if_true_label
);
5726 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == COMPONENT_REF
5727 || TREE_CODE (TREE_OPERAND (exp
, 0)) == BIT_FIELD_REF
5728 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_REF
)
5731 /* If we are narrowing the operand, we have to do the compare in the
5733 if ((TYPE_PRECISION (TREE_TYPE (exp
))
5734 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5736 case NON_LVALUE_EXPR
:
5737 case REFERENCE_EXPR
:
5742 /* These cannot change zero->non-zero or vice versa. */
5743 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5747 /* This is never less insns than evaluating the PLUS_EXPR followed by
5748 a test and can be longer if the test is eliminated. */
5750 /* Reduce to minus. */
5751 exp
= build (MINUS_EXPR
, TREE_TYPE (exp
),
5752 TREE_OPERAND (exp
, 0),
5753 fold (build1 (NEGATE_EXPR
, TREE_TYPE (TREE_OPERAND (exp
, 1)),
5754 TREE_OPERAND (exp
, 1))));
5755 /* Process as MINUS. */
5759 /* Non-zero iff operands of minus differ. */
5760 comparison
= compare (build (NE_EXPR
, TREE_TYPE (exp
),
5761 TREE_OPERAND (exp
, 0),
5762 TREE_OPERAND (exp
, 1)),
5767 /* If we are AND'ing with a small constant, do this comparison in the
5768 smallest type that fits. If the machine doesn't have comparisons
5769 that small, it will be converted back to the wider comparison.
5770 This helps if we are testing the sign bit of a narrower object.
5771 combine can't do this for us because it can't know whether a
5772 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
5774 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
5775 && TYPE_PRECISION (TREE_TYPE (exp
)) <= HOST_BITS_PER_INT
5776 && (i
= floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)))) >= 0
5777 && (type
= type_for_size (i
+ 1, 1)) != 0
5778 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
)))
5780 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
5785 case TRUTH_NOT_EXPR
:
5786 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5789 case TRUTH_ANDIF_EXPR
:
5790 if (if_false_label
== 0)
5791 if_false_label
= drop_through_label
= gen_label_rtx ();
5792 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, 0);
5793 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5796 case TRUTH_ORIF_EXPR
:
5797 if (if_true_label
== 0)
5798 if_true_label
= drop_through_label
= gen_label_rtx ();
5799 do_jump (TREE_OPERAND (exp
, 0), 0, if_true_label
);
5800 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5804 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
5807 do_pending_stack_adjust ();
5808 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
5815 int bitsize
, bitpos
, unsignedp
;
5816 enum machine_mode mode
;
5820 /* Get description of this reference. We don't actually care
5821 about the underlying object here. */
5822 get_inner_reference (exp
, &bitsize
, &bitpos
, &mode
, &unsignedp
,
5825 type
= type_for_size (bitsize
, unsignedp
);
5826 if (type
!= 0 && bitsize
>= 0
5827 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
)))
5829 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
5836 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
5837 if (integer_onep (TREE_OPERAND (exp
, 1))
5838 && integer_zerop (TREE_OPERAND (exp
, 2)))
5839 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5841 else if (integer_zerop (TREE_OPERAND (exp
, 1))
5842 && integer_onep (TREE_OPERAND (exp
, 2)))
5843 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5847 register rtx label1
= gen_label_rtx ();
5848 drop_through_label
= gen_label_rtx ();
5849 do_jump (TREE_OPERAND (exp
, 0), label1
, 0);
5850 /* Now the THEN-expression. */
5851 do_jump (TREE_OPERAND (exp
, 1),
5852 if_false_label
? if_false_label
: drop_through_label
,
5853 if_true_label
? if_true_label
: drop_through_label
);
5854 /* In case the do_jump just above never jumps. */
5855 do_pending_stack_adjust ();
5856 emit_label (label1
);
5857 /* Now the ELSE-expression. */
5858 do_jump (TREE_OPERAND (exp
, 2),
5859 if_false_label
? if_false_label
: drop_through_label
,
5860 if_true_label
? if_true_label
: drop_through_label
);
5865 if (integer_zerop (TREE_OPERAND (exp
, 1)))
5866 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
5867 else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5870 !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5871 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
);
5873 comparison
= compare (exp
, EQ
, EQ
);
5877 if (integer_zerop (TREE_OPERAND (exp
, 1)))
5878 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
5879 else if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5882 !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5883 do_jump_by_parts_equality (exp
, if_true_label
, if_false_label
);
5885 comparison
= compare (exp
, NE
, NE
);
5889 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5891 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5892 do_jump_by_parts_greater (exp
, 1, if_false_label
, if_true_label
);
5894 comparison
= compare (exp
, LT
, LTU
);
5898 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5900 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5901 do_jump_by_parts_greater (exp
, 0, if_true_label
, if_false_label
);
5903 comparison
= compare (exp
, LE
, LEU
);
5907 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5909 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5910 do_jump_by_parts_greater (exp
, 0, if_false_label
, if_true_label
);
5912 comparison
= compare (exp
, GT
, GTU
);
5916 if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
5918 && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
5919 do_jump_by_parts_greater (exp
, 1, if_true_label
, if_false_label
);
5921 comparison
= compare (exp
, GE
, GEU
);
5926 temp
= expand_expr (exp
, 0, VOIDmode
, 0);
5928 /* This is not needed any more and causes poor code since it causes
5929 comparisons and tests from non-SI objects to have different code
5931 /* Copy to register to avoid generating bad insns by cse
5932 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
5933 if (!cse_not_expected
&& GET_CODE (temp
) == MEM
)
5934 temp
= copy_to_reg (temp
);
5936 do_pending_stack_adjust ();
5937 if (GET_CODE (temp
) == CONST_INT
)
5938 comparison
= (temp
== const0_rtx
? const0_rtx
: const_true_rtx
);
5939 else if (GET_CODE (temp
) == LABEL_REF
)
5940 comparison
= const_true_rtx
;
5941 else if (GET_MODE_CLASS (GET_MODE (temp
)) == MODE_INT
5942 && !can_compare_p (GET_MODE (temp
)))
5943 /* Note swapping the labels gives us not-equal. */
5944 do_jump_by_parts_equality_rtx (temp
, if_true_label
, if_false_label
);
5945 else if (GET_MODE (temp
) != VOIDmode
)
5946 comparison
= compare_from_rtx (temp
, CONST0_RTX (GET_MODE (temp
)),
5947 NE
, 1, GET_MODE (temp
), 0, 0);
5952 /* Do any postincrements in the expression that was tested. */
5955 /* If COMPARISON is nonzero here, it is an rtx that can be substituted
5956 straight into a conditional jump instruction as the jump condition.
5957 Otherwise, all the work has been done already. */
5959 if (comparison
== const_true_rtx
)
5962 emit_jump (if_true_label
);
5964 else if (comparison
== const0_rtx
)
5967 emit_jump (if_false_label
);
5969 else if (comparison
)
5970 do_jump_for_compare (comparison
, if_false_label
, if_true_label
);
5974 if (drop_through_label
)
5976 /* If do_jump produces code that might be jumped around,
5977 do any stack adjusts from that code, before the place
5978 where control merges in. */
5979 do_pending_stack_adjust ();
5980 emit_label (drop_through_label
);
5984 /* Given a comparison expression EXP for values too wide to be compared
5985 with one insn, test the comparison and jump to the appropriate label.
5986 The code of EXP is ignored; we always test GT if SWAP is 0,
5987 and LT if SWAP is 1. */
5990 do_jump_by_parts_greater (exp
, swap
, if_false_label
, if_true_label
)
5993 rtx if_false_label
, if_true_label
;
5995 rtx op0
= expand_expr (TREE_OPERAND (exp
, swap
), 0, VOIDmode
, 0);
5996 rtx op1
= expand_expr (TREE_OPERAND (exp
, !swap
), 0, VOIDmode
, 0);
5997 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5998 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
5999 rtx drop_through_label
= 0;
6000 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
6003 if (! if_true_label
|| ! if_false_label
)
6004 drop_through_label
= gen_label_rtx ();
6005 if (! if_true_label
)
6006 if_true_label
= drop_through_label
;
6007 if (! if_false_label
)
6008 if_false_label
= drop_through_label
;
6010 /* Compare a word at a time, high order first. */
6011 for (i
= 0; i
< nwords
; i
++)
6014 rtx op0_word
, op1_word
;
6016 if (WORDS_BIG_ENDIAN
)
6018 op0_word
= operand_subword_force (op0
, i
, mode
);
6019 op1_word
= operand_subword_force (op1
, i
, mode
);
6023 op0_word
= operand_subword_force (op0
, nwords
- 1 - i
, mode
);
6024 op1_word
= operand_subword_force (op1
, nwords
- 1 - i
, mode
);
6027 /* All but high-order word must be compared as unsigned. */
6028 comp
= compare_from_rtx (op0_word
, op1_word
,
6029 (unsignedp
|| i
> 0) ? GTU
: GT
,
6030 unsignedp
, word_mode
, 0, 0);
6031 if (comp
== const_true_rtx
)
6032 emit_jump (if_true_label
);
6033 else if (comp
!= const0_rtx
)
6034 do_jump_for_compare (comp
, 0, if_true_label
);
6036 /* Consider lower words only if these are equal. */
6037 comp
= compare_from_rtx (op0_word
, op1_word
, NE
, unsignedp
, word_mode
,
6039 if (comp
== const_true_rtx
)
6040 emit_jump (if_false_label
);
6041 else if (comp
!= const0_rtx
)
6042 do_jump_for_compare (comp
, 0, if_false_label
);
6046 emit_jump (if_false_label
);
6047 if (drop_through_label
)
6048 emit_label (drop_through_label
);
6051 /* Given an EQ_EXPR expression EXP for values too wide to be compared
6052 with one insn, test the comparison and jump to the appropriate label. */
6055 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
)
6057 rtx if_false_label
, if_true_label
;
6059 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
6060 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
6061 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
6062 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
6064 rtx drop_through_label
= 0;
6066 if (! if_false_label
)
6067 drop_through_label
= if_false_label
= gen_label_rtx ();
6069 for (i
= 0; i
< nwords
; i
++)
6071 rtx comp
= compare_from_rtx (operand_subword_force (op0
, i
, mode
),
6072 operand_subword_force (op1
, i
, mode
),
6073 EQ
, 0, word_mode
, 0, 0);
6074 if (comp
== const_true_rtx
)
6075 emit_jump (if_false_label
);
6076 else if (comp
!= const0_rtx
)
6077 do_jump_for_compare (comp
, if_false_label
, 0);
6081 emit_jump (if_true_label
);
6082 if (drop_through_label
)
6083 emit_label (drop_through_label
);
6086 /* Jump according to whether OP0 is 0.
6087 We assume that OP0 has an integer mode that is too wide
6088 for the available compare insns. */
6091 do_jump_by_parts_equality_rtx (op0
, if_false_label
, if_true_label
)
6093 rtx if_false_label
, if_true_label
;
6095 int nwords
= GET_MODE_SIZE (GET_MODE (op0
)) / UNITS_PER_WORD
;
6097 rtx drop_through_label
= 0;
6099 if (! if_false_label
)
6100 drop_through_label
= if_false_label
= gen_label_rtx ();
6102 for (i
= 0; i
< nwords
; i
++)
6104 rtx comp
= compare_from_rtx (operand_subword_force (op0
, i
,
6106 const0_rtx
, EQ
, 0, word_mode
, 0, 0);
6107 if (comp
== const_true_rtx
)
6108 emit_jump (if_false_label
);
6109 else if (comp
!= const0_rtx
)
6110 do_jump_for_compare (comp
, if_false_label
, 0);
6114 emit_jump (if_true_label
);
6115 if (drop_through_label
)
6116 emit_label (drop_through_label
);
6119 /* Given a comparison expression in rtl form, output conditional branches to
6120 IF_TRUE_LABEL, IF_FALSE_LABEL, or both. */
6123 do_jump_for_compare (comparison
, if_false_label
, if_true_label
)
6124 rtx comparison
, if_false_label
, if_true_label
;
6128 if (bcc_gen_fctn
[(int) GET_CODE (comparison
)] != 0)
6129 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (comparison
)]) (if_true_label
));
6134 emit_jump (if_false_label
);
6136 else if (if_false_label
)
6139 rtx prev
= PREV_INSN (get_last_insn ());
6142 /* Output the branch with the opposite condition. Then try to invert
6143 what is generated. If more than one insn is a branch, or if the
6144 branch is not the last insn written, abort. If we can't invert
6145 the branch, emit make a true label, redirect this jump to that,
6146 emit a jump to the false label and define the true label. */
6148 if (bcc_gen_fctn
[(int) GET_CODE (comparison
)] != 0)
6149 emit_jump_insn ((*bcc_gen_fctn
[(int) GET_CODE (comparison
)]) (if_false_label
));
6153 /* Here we get the insn before what was just emitted.
6154 On some machines, emitting the branch can discard
6155 the previous compare insn and emit a replacement. */
6157 /* If there's only one preceding insn... */
6158 insn
= get_insns ();
6160 insn
= NEXT_INSN (prev
);
6162 for (insn
= NEXT_INSN (insn
); insn
; insn
= NEXT_INSN (insn
))
6163 if (GET_CODE (insn
) == JUMP_INSN
)
6170 if (branch
!= get_last_insn ())
6173 if (! invert_jump (branch
, if_false_label
))
6175 if_true_label
= gen_label_rtx ();
6176 redirect_jump (branch
, if_true_label
);
6177 emit_jump (if_false_label
);
6178 emit_label (if_true_label
);
6183 /* Generate code for a comparison expression EXP
6184 (including code to compute the values to be compared)
6185 and set (CC0) according to the result.
6186 SIGNED_CODE should be the rtx operation for this comparison for
6187 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
6189 We force a stack adjustment unless there are currently
6190 things pushed on the stack that aren't yet used. */
6193 compare (exp
, signed_code
, unsigned_code
)
6195 enum rtx_code signed_code
, unsigned_code
;
6197 register rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
6198 register rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
6199 register tree type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
6200 register enum machine_mode mode
= TYPE_MODE (type
);
6201 int unsignedp
= TREE_UNSIGNED (type
);
6202 enum rtx_code code
= unsignedp
? unsigned_code
: signed_code
;
6204 return compare_from_rtx (op0
, op1
, code
, unsignedp
, mode
,
6206 ? expr_size (TREE_OPERAND (exp
, 0)) : 0),
6207 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
6210 /* Like compare but expects the values to compare as two rtx's.
6211 The decision as to signed or unsigned comparison must be made by the caller.
6213 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
6216 If ALIGN is non-zero, it is the alignment of this type; if zero, the
6217 size of MODE should be used. */
6220 compare_from_rtx (op0
, op1
, code
, unsignedp
, mode
, size
, align
)
6221 register rtx op0
, op1
;
6224 enum machine_mode mode
;
6228 /* If one operand is constant, make it the second one. */
6230 if (GET_CODE (op0
) == CONST_INT
|| GET_CODE (op0
) == CONST_DOUBLE
)
6235 code
= swap_condition (code
);
6240 op0
= force_not_mem (op0
);
6241 op1
= force_not_mem (op1
);
6244 do_pending_stack_adjust ();
6246 if (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) == CONST_INT
)
6247 return simplify_relational_operation (code
, mode
, op0
, op1
);
6249 /* If this is a signed equality comparison, we can do it as an
6250 unsigned comparison since zero-extension is cheaper than sign
6251 extension and comparisons with zero are done as unsigned. If we
6252 are comparing against a constant, we must convert it to what it
6253 would look like unsigned. */
6254 if ((code
== EQ
|| code
== NE
) && ! unsignedp
6255 && GET_MODE_BITSIZE (GET_MODE (op0
)) <= HOST_BITS_PER_INT
)
6257 if (GET_CODE (op1
) == CONST_INT
6258 && (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
))) != INTVAL (op1
))
6259 op1
= gen_rtx (CONST_INT
, VOIDmode
,
6260 INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
)));
6264 emit_cmp_insn (op0
, op1
, code
, size
, mode
, unsignedp
, align
);
6266 return gen_rtx (code
, VOIDmode
, cc0_rtx
, const0_rtx
);
6269 /* Generate code to calculate EXP using a store-flag instruction
6270 and return an rtx for the result. EXP is either a comparison
6271 or a TRUTH_NOT_EXPR whose operand is a comparison.
6273 If TARGET is nonzero, store the result there if convenient.
6275 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
6278 Return zero if there is no suitable set-flag instruction
6279 available on this machine.
6281 Once expand_expr has been called on the arguments of the comparison,
6282 we are committed to doing the store flag, since it is not safe to
6283 re-evaluate the expression. We emit the store-flag insn by calling
6284 emit_store_flag, but only expand the arguments if we have a reason
6285 to believe that emit_store_flag will be successful. If we think that
6286 it will, but it isn't, we have to simulate the store-flag with a
6287 set/jump/set sequence. */
6290 do_store_flag (exp
, target
, mode
, only_cheap
)
6293 enum machine_mode mode
;
6297 tree arg0
, arg1
, type
;
6299 enum machine_mode operand_mode
;
6303 enum insn_code icode
;
6304 rtx subtarget
= target
;
6305 rtx result
, label
, pattern
, jump_pat
;
6307 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
6308 result at the end. We can't simply invert the test since it would
6309 have already been inverted if it were valid. This case occurs for
6310 some floating-point comparisons. */
6312 if (TREE_CODE (exp
) == TRUTH_NOT_EXPR
)
6313 invert
= 1, exp
= TREE_OPERAND (exp
, 0);
6315 arg0
= TREE_OPERAND (exp
, 0);
6316 arg1
= TREE_OPERAND (exp
, 1);
6317 type
= TREE_TYPE (arg0
);
6318 operand_mode
= TYPE_MODE (type
);
6319 unsignedp
= TREE_UNSIGNED (type
);
6321 /* We won't bother with BLKmode store-flag operations because it would mean
6322 passing a lot of information to emit_store_flag. */
6323 if (operand_mode
== BLKmode
)
6326 while (TREE_CODE (arg0
) == NON_LVALUE_EXPR
)
6327 arg0
= TREE_OPERAND (arg0
, 0);
6329 while (TREE_CODE (arg1
) == NON_LVALUE_EXPR
)
6330 arg1
= TREE_OPERAND (arg1
, 0);
6332 /* Get the rtx comparison code to use. We know that EXP is a comparison
6333 operation of some type. Some comparisons against 1 and -1 can be
6334 converted to comparisons with zero. Do so here so that the tests
6335 below will be aware that we have a comparison with zero. These
6336 tests will not catch constants in the first operand, but constants
6337 are rarely passed as the first operand. */
6339 switch (TREE_CODE (exp
))
6348 if (integer_onep (arg1
))
6349 arg1
= integer_zero_node
, code
= unsignedp
? LEU
: LE
;
6351 code
= unsignedp
? LTU
: LT
;
6354 if (integer_all_onesp (arg1
))
6355 arg1
= integer_zero_node
, code
= unsignedp
? LTU
: LT
;
6357 code
= unsignedp
? LEU
: LE
;
6360 if (integer_all_onesp (arg1
))
6361 arg1
= integer_zero_node
, code
= unsignedp
? GEU
: GE
;
6363 code
= unsignedp
? GTU
: GT
;
6366 if (integer_onep (arg1
))
6367 arg1
= integer_zero_node
, code
= unsignedp
? GTU
: GT
;
6369 code
= unsignedp
? GEU
: GE
;
6375 /* Put a constant second. */
6376 if (TREE_CODE (arg0
) == REAL_CST
|| TREE_CODE (arg0
) == INTEGER_CST
)
6378 tem
= arg0
; arg0
= arg1
; arg1
= tem
;
6379 code
= swap_condition (code
);
6382 /* If this is an equality or inequality test of a single bit, we can
6383 do this by shifting the bit being tested to the low-order bit and
6384 masking the result with the constant 1. If the condition was EQ,
6385 we xor it with 1. This does not require an scc insn and is faster
6386 than an scc insn even if we have it. */
6388 if ((code
== NE
|| code
== EQ
)
6389 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6390 && integer_pow2p (TREE_OPERAND (arg0
, 1))
6391 && TYPE_PRECISION (type
) <= HOST_BITS_PER_INT
)
6393 int bitnum
= exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0
, 1),
6396 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
6397 || GET_MODE (subtarget
) != operand_mode
6398 || ! safe_from_p (subtarget
, TREE_OPERAND (arg0
, 0)))
6401 op0
= expand_expr (TREE_OPERAND (arg0
, 0), subtarget
, VOIDmode
, 0);
6404 op0
= expand_shift (RSHIFT_EXPR
, GET_MODE (op0
), op0
,
6405 size_int (bitnum
), target
, 1);
6407 if (GET_MODE (op0
) != mode
)
6408 op0
= convert_to_mode (mode
, op0
, 1);
6410 if (bitnum
!= TYPE_PRECISION (type
) - 1)
6411 op0
= expand_and (op0
, const1_rtx
, target
);
6413 if ((code
== EQ
&& ! invert
) || (code
== NE
&& invert
))
6414 op0
= expand_binop (mode
, xor_optab
, op0
, const1_rtx
, target
, 0,
6420 /* Now see if we are likely to be able to do this. Return if not. */
6421 if (! can_compare_p (operand_mode
))
6423 icode
= setcc_gen_code
[(int) code
];
6424 if (icode
== CODE_FOR_nothing
6425 || (only_cheap
&& insn_operand_mode
[(int) icode
][0] != mode
))
6427 /* We can only do this if it is one of the special cases that
6428 can be handled without an scc insn. */
6429 if ((code
== LT
&& integer_zerop (arg1
))
6430 || (! only_cheap
&& code
== GE
&& integer_zerop (arg1
)))
6432 else if (BRANCH_COST
>= 0
6433 && ! only_cheap
&& (code
== NE
|| code
== EQ
)
6434 && TREE_CODE (type
) != REAL_TYPE
6435 && ((abs_optab
->handlers
[(int) operand_mode
].insn_code
6436 != CODE_FOR_nothing
)
6437 || (ffs_optab
->handlers
[(int) operand_mode
].insn_code
6438 != CODE_FOR_nothing
)))
6444 preexpand_calls (exp
);
6445 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
6446 || GET_MODE (subtarget
) != operand_mode
6447 || ! safe_from_p (subtarget
, arg1
))
6450 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
6451 op1
= expand_expr (arg1
, 0, VOIDmode
, 0);
6454 target
= gen_reg_rtx (mode
);
6456 result
= emit_store_flag (target
, code
, op0
, op1
, operand_mode
,
6462 result
= expand_binop (mode
, xor_optab
, result
, const1_rtx
,
6463 result
, 0, OPTAB_LIB_WIDEN
);
6467 /* If this failed, we have to do this with set/compare/jump/set code. */
6468 if (target
== 0 || GET_CODE (target
) != REG
6469 || reg_mentioned_p (target
, op0
) || reg_mentioned_p (target
, op1
))
6470 target
= gen_reg_rtx (GET_MODE (target
));
6472 emit_move_insn (target
, invert
? const0_rtx
: const1_rtx
);
6473 result
= compare_from_rtx (op0
, op1
, code
, unsignedp
, operand_mode
, 0, 0);
6474 if (GET_CODE (result
) == CONST_INT
)
6475 return (((result
== const0_rtx
&& ! invert
)
6476 || (result
!= const0_rtx
&& invert
))
6477 ? const0_rtx
: const1_rtx
);
6479 label
= gen_label_rtx ();
6480 if (bcc_gen_fctn
[(int) code
] == 0)
6483 emit_jump_insn ((*bcc_gen_fctn
[(int) code
]) (label
));
6484 emit_move_insn (target
, invert
? const1_rtx
: const0_rtx
);
6490 /* Generate a tablejump instruction (used for switch statements). */
6492 #ifdef HAVE_tablejump
6494 /* INDEX is the value being switched on, with the lowest value
6495 in the table already subtracted.
6496 MODE is its expected mode (needed if INDEX is constant).
6497 RANGE is the length of the jump table.
6498 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
6500 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
6501 index value is out of range. */
6504 do_tablejump (index
, mode
, range
, table_label
, default_label
)
6505 rtx index
, range
, table_label
, default_label
;
6506 enum machine_mode mode
;
6508 register rtx temp
, vector
;
6510 /* Do an unsigned comparison (in the proper mode) between the index
6511 expression and the value which represents the length of the range.
6512 Since we just finished subtracting the lower bound of the range
6513 from the index expression, this comparison allows us to simultaneously
6514 check that the original index expression value is both greater than
6515 or equal to the minimum value of the range and less than or equal to
6516 the maximum value of the range. */
6518 emit_cmp_insn (range
, index
, LTU
, 0, mode
, 0, 0);
6519 emit_jump_insn (gen_bltu (default_label
));
6521 /* If index is in range, it must fit in Pmode.
6522 Convert to Pmode so we can index with it. */
6524 index
= convert_to_mode (Pmode
, index
, 1);
6526 /* If flag_force_addr were to affect this address
6527 it could interfere with the tricky assumptions made
6528 about addresses that contain label-refs,
6529 which may be valid only very near the tablejump itself. */
6530 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
6531 GET_MODE_SIZE, because this indicates how large insns are. The other
6532 uses should all be Pmode, because they are addresses. This code
6533 could fail if addresses and insns are not the same size. */
6534 index
= memory_address_noforce
6536 gen_rtx (PLUS
, Pmode
,
6537 gen_rtx (MULT
, Pmode
, index
,
6538 gen_rtx (CONST_INT
, VOIDmode
,
6539 GET_MODE_SIZE (CASE_VECTOR_MODE
))),
6540 gen_rtx (LABEL_REF
, Pmode
, table_label
)));
6541 temp
= gen_reg_rtx (CASE_VECTOR_MODE
);
6542 vector
= gen_rtx (MEM
, CASE_VECTOR_MODE
, index
);
6543 RTX_UNCHANGING_P (vector
) = 1;
6544 convert_move (temp
, vector
, 0);
6546 emit_jump_insn (gen_tablejump (temp
, table_label
));
6548 #ifndef CASE_VECTOR_PC_RELATIVE
6549 /* If we are generating PIC code or if the table is PC-relative, the
6550 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
6556 #endif /* HAVE_tablejump */