1 /* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
31 #include "hard-reg-set.h"
34 #include "insn-flags.h"
35 #include "insn-codes.h"
36 #include "insn-config.h"
37 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
41 #include "typeclass.h"
48 /* Decide whether a function's arguments should be processed
49 from first to last or from last to first.
51 They should if the stack and args grow in opposite directions, but
52 only if we have push insns. */
56 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
57 #define PUSH_ARGS_REVERSED /* If it's last to first */
62 #ifndef STACK_PUSH_CODE
63 #ifdef STACK_GROWS_DOWNWARD
64 #define STACK_PUSH_CODE PRE_DEC
66 #define STACK_PUSH_CODE PRE_INC
70 /* Assume that case vectors are not pc-relative. */
71 #ifndef CASE_VECTOR_PC_RELATIVE
72 #define CASE_VECTOR_PC_RELATIVE 0
75 /* If this is nonzero, we do not bother generating VOLATILE
76 around volatile memory references, and we are willing to
77 output indirect addresses. If cse is to follow, we reject
78 indirect addresses so a useful potential cse is generated;
79 if it is used only once, instruction combination will produce
80 the same indirect address eventually. */
83 /* Nonzero to generate code for all the subroutines within an
84 expression before generating the upper levels of the expression.
85 Nowadays this is never zero. */
86 int do_preexpand_calls
= 1;
88 /* Don't check memory usage, since code is being emitted to check a memory
89 usage. Used when current_function_check_memory_usage is true, to avoid
90 infinite recursion. */
91 static int in_check_memory_usage
;
93 /* Chain of pending expressions for PLACEHOLDER_EXPR to replace. */
94 static tree placeholder_list
= 0;
96 /* This structure is used by move_by_pieces to describe the move to
109 int explicit_inc_from
;
117 /* This structure is used by clear_by_pieces to describe the clear to
120 struct clear_by_pieces
132 extern struct obstack permanent_obstack
;
134 static rtx get_push_address
PARAMS ((int));
136 static rtx enqueue_insn
PARAMS ((rtx
, rtx
));
137 static int move_by_pieces_ninsns
PARAMS ((unsigned int, unsigned int));
138 static void move_by_pieces_1
PARAMS ((rtx (*) (rtx
, ...), enum machine_mode
,
139 struct move_by_pieces
*));
140 static void clear_by_pieces
PARAMS ((rtx
, int, unsigned int));
141 static void clear_by_pieces_1
PARAMS ((rtx (*) (rtx
, ...),
143 struct clear_by_pieces
*));
144 static int is_zeros_p
PARAMS ((tree
));
145 static int mostly_zeros_p
PARAMS ((tree
));
146 static void store_constructor_field
PARAMS ((rtx
, unsigned HOST_WIDE_INT
,
147 HOST_WIDE_INT
, enum machine_mode
,
148 tree
, tree
, unsigned int, int));
149 static void store_constructor
PARAMS ((tree
, rtx
, unsigned int, int,
150 unsigned HOST_WIDE_INT
));
151 static rtx store_field
PARAMS ((rtx
, HOST_WIDE_INT
,
152 HOST_WIDE_INT
, enum machine_mode
,
153 tree
, enum machine_mode
, int,
154 unsigned int, HOST_WIDE_INT
, int));
155 static enum memory_use_mode
156 get_memory_usage_from_modifier
PARAMS ((enum expand_modifier
));
157 static tree save_noncopied_parts
PARAMS ((tree
, tree
));
158 static tree init_noncopied_parts
PARAMS ((tree
, tree
));
159 static int safe_from_p
PARAMS ((rtx
, tree
, int));
160 static int fixed_type_p
PARAMS ((tree
));
161 static rtx var_rtx
PARAMS ((tree
));
162 static int readonly_fields_p
PARAMS ((tree
));
163 static rtx expand_expr_unaligned
PARAMS ((tree
, unsigned int *));
164 static rtx expand_increment
PARAMS ((tree
, int, int));
165 static void preexpand_calls
PARAMS ((tree
));
166 static void do_jump_by_parts_greater
PARAMS ((tree
, int, rtx
, rtx
));
167 static void do_jump_by_parts_equality
PARAMS ((tree
, rtx
, rtx
));
168 static void do_compare_and_jump
PARAMS ((tree
, enum rtx_code
, enum rtx_code
,
170 static rtx do_store_flag
PARAMS ((tree
, rtx
, enum machine_mode
, int));
172 /* Record for each mode whether we can move a register directly to or
173 from an object of that mode in memory. If we can't, we won't try
174 to use that mode directly when accessing a field of that mode. */
176 static char direct_load
[NUM_MACHINE_MODES
];
177 static char direct_store
[NUM_MACHINE_MODES
];
179 /* If a memory-to-memory move would take MOVE_RATIO or more simple
180 move-instruction sequences, we will do a movstr or libcall instead. */
183 #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
186 /* If we are optimizing for space (-Os), cut down the default move ratio */
187 #define MOVE_RATIO (optimize_size ? 3 : 15)
191 /* This macro is used to determine whether move_by_pieces should be called
192 to perform a structure copy. */
193 #ifndef MOVE_BY_PIECES_P
194 #define MOVE_BY_PIECES_P(SIZE, ALIGN) (move_by_pieces_ninsns \
195 (SIZE, ALIGN) < MOVE_RATIO)
198 /* This array records the insn_code of insns to perform block moves. */
199 enum insn_code movstr_optab
[NUM_MACHINE_MODES
];
201 /* This array records the insn_code of insns to perform block clears. */
202 enum insn_code clrstr_optab
[NUM_MACHINE_MODES
];
204 /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
206 #ifndef SLOW_UNALIGNED_ACCESS
207 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
210 /* This is run once per compilation to set up which modes can be used
211 directly in memory and to initialize the block move optab. */
217 enum machine_mode mode
;
224 /* Since we are on the permanent obstack, we must be sure we save this
225 spot AFTER we call start_sequence, since it will reuse the rtl it
227 free_point
= (char *) oballoc (0);
229 /* Try indexing by frame ptr and try by stack ptr.
230 It is known that on the Convex the stack ptr isn't a valid index.
231 With luck, one or the other is valid on any machine. */
232 mem
= gen_rtx_MEM (VOIDmode
, stack_pointer_rtx
);
233 mem1
= gen_rtx_MEM (VOIDmode
, frame_pointer_rtx
);
235 insn
= emit_insn (gen_rtx_SET (0, NULL_RTX
, NULL_RTX
));
236 pat
= PATTERN (insn
);
238 for (mode
= VOIDmode
; (int) mode
< NUM_MACHINE_MODES
;
239 mode
= (enum machine_mode
) ((int) mode
+ 1))
244 direct_load
[(int) mode
] = direct_store
[(int) mode
] = 0;
245 PUT_MODE (mem
, mode
);
246 PUT_MODE (mem1
, mode
);
248 /* See if there is some register that can be used in this mode and
249 directly loaded or stored from memory. */
251 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
252 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
253 && (direct_load
[(int) mode
] == 0 || direct_store
[(int) mode
] == 0);
256 if (! HARD_REGNO_MODE_OK (regno
, mode
))
259 reg
= gen_rtx_REG (mode
, regno
);
262 SET_DEST (pat
) = reg
;
263 if (recog (pat
, insn
, &num_clobbers
) >= 0)
264 direct_load
[(int) mode
] = 1;
266 SET_SRC (pat
) = mem1
;
267 SET_DEST (pat
) = reg
;
268 if (recog (pat
, insn
, &num_clobbers
) >= 0)
269 direct_load
[(int) mode
] = 1;
272 SET_DEST (pat
) = mem
;
273 if (recog (pat
, insn
, &num_clobbers
) >= 0)
274 direct_store
[(int) mode
] = 1;
277 SET_DEST (pat
) = mem1
;
278 if (recog (pat
, insn
, &num_clobbers
) >= 0)
279 direct_store
[(int) mode
] = 1;
287 /* This is run at the start of compiling a function. */
292 cfun
->expr
= (struct expr_status
*) xmalloc (sizeof (struct expr_status
));
295 pending_stack_adjust
= 0;
296 arg_space_so_far
= 0;
297 inhibit_defer_pop
= 0;
299 apply_args_value
= 0;
305 struct expr_status
*p
;
310 ggc_mark_rtx (p
->x_saveregs_value
);
311 ggc_mark_rtx (p
->x_apply_args_value
);
312 ggc_mark_rtx (p
->x_forced_labels
);
323 /* Small sanity check that the queue is empty at the end of a function. */
325 finish_expr_for_function ()
331 /* Manage the queue of increment instructions to be output
332 for POSTINCREMENT_EXPR expressions, etc. */
334 /* Queue up to increment (or change) VAR later. BODY says how:
335 BODY should be the same thing you would pass to emit_insn
336 to increment right away. It will go to emit_insn later on.
338 The value is a QUEUED expression to be used in place of VAR
339 where you want to guarantee the pre-incrementation value of VAR. */
342 enqueue_insn (var
, body
)
345 pending_chain
= gen_rtx_QUEUED (GET_MODE (var
), var
, NULL_RTX
, NULL_RTX
,
346 body
, pending_chain
);
347 return pending_chain
;
350 /* Use protect_from_queue to convert a QUEUED expression
351 into something that you can put immediately into an instruction.
352 If the queued incrementation has not happened yet,
353 protect_from_queue returns the variable itself.
354 If the incrementation has happened, protect_from_queue returns a temp
355 that contains a copy of the old value of the variable.
357 Any time an rtx which might possibly be a QUEUED is to be put
358 into an instruction, it must be passed through protect_from_queue first.
359 QUEUED expressions are not meaningful in instructions.
361 Do not pass a value through protect_from_queue and then hold
362 on to it for a while before putting it in an instruction!
363 If the queue is flushed in between, incorrect code will result. */
366 protect_from_queue (x
, modify
)
370 register RTX_CODE code
= GET_CODE (x
);
372 #if 0 /* A QUEUED can hang around after the queue is forced out. */
373 /* Shortcut for most common case. */
374 if (pending_chain
== 0)
380 /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
381 use of autoincrement. Make a copy of the contents of the memory
382 location rather than a copy of the address, but not if the value is
383 of mode BLKmode. Don't modify X in place since it might be
385 if (code
== MEM
&& GET_MODE (x
) != BLKmode
386 && GET_CODE (XEXP (x
, 0)) == QUEUED
&& !modify
)
388 register rtx y
= XEXP (x
, 0);
389 register rtx
new = gen_rtx_MEM (GET_MODE (x
), QUEUED_VAR (y
));
391 RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x
);
392 MEM_COPY_ATTRIBUTES (new, x
);
393 MEM_ALIAS_SET (new) = MEM_ALIAS_SET (x
);
397 register rtx temp
= gen_reg_rtx (GET_MODE (new));
398 emit_insn_before (gen_move_insn (temp
, new),
404 /* Otherwise, recursively protect the subexpressions of all
405 the kinds of rtx's that can contain a QUEUED. */
408 rtx tem
= protect_from_queue (XEXP (x
, 0), 0);
409 if (tem
!= XEXP (x
, 0))
415 else if (code
== PLUS
|| code
== MULT
)
417 rtx new0
= protect_from_queue (XEXP (x
, 0), 0);
418 rtx new1
= protect_from_queue (XEXP (x
, 1), 0);
419 if (new0
!= XEXP (x
, 0) || new1
!= XEXP (x
, 1))
428 /* If the increment has not happened, use the variable itself. */
429 if (QUEUED_INSN (x
) == 0)
430 return QUEUED_VAR (x
);
431 /* If the increment has happened and a pre-increment copy exists,
433 if (QUEUED_COPY (x
) != 0)
434 return QUEUED_COPY (x
);
435 /* The increment has happened but we haven't set up a pre-increment copy.
436 Set one up now, and use it. */
437 QUEUED_COPY (x
) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x
)));
438 emit_insn_before (gen_move_insn (QUEUED_COPY (x
), QUEUED_VAR (x
)),
440 return QUEUED_COPY (x
);
443 /* Return nonzero if X contains a QUEUED expression:
444 if it contains anything that will be altered by a queued increment.
445 We handle only combinations of MEM, PLUS, MINUS and MULT operators
446 since memory addresses generally contain only those. */
452 register enum rtx_code code
= GET_CODE (x
);
458 return queued_subexp_p (XEXP (x
, 0));
462 return (queued_subexp_p (XEXP (x
, 0))
463 || queued_subexp_p (XEXP (x
, 1)));
469 /* Perform all the pending incrementations. */
475 while ((p
= pending_chain
))
477 rtx body
= QUEUED_BODY (p
);
479 if (GET_CODE (body
) == SEQUENCE
)
481 QUEUED_INSN (p
) = XVECEXP (QUEUED_BODY (p
), 0, 0);
482 emit_insn (QUEUED_BODY (p
));
485 QUEUED_INSN (p
) = emit_insn (QUEUED_BODY (p
));
486 pending_chain
= QUEUED_NEXT (p
);
490 /* Copy data from FROM to TO, where the machine modes are not the same.
491 Both modes may be integer, or both may be floating.
492 UNSIGNEDP should be nonzero if FROM is an unsigned type.
493 This causes zero-extension instead of sign-extension. */
496 convert_move (to
, from
, unsignedp
)
497 register rtx to
, from
;
500 enum machine_mode to_mode
= GET_MODE (to
);
501 enum machine_mode from_mode
= GET_MODE (from
);
502 int to_real
= GET_MODE_CLASS (to_mode
) == MODE_FLOAT
;
503 int from_real
= GET_MODE_CLASS (from_mode
) == MODE_FLOAT
;
507 /* rtx code for making an equivalent value. */
508 enum rtx_code equiv_code
= (unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
);
510 to
= protect_from_queue (to
, 1);
511 from
= protect_from_queue (from
, 0);
513 if (to_real
!= from_real
)
516 /* If FROM is a SUBREG that indicates that we have already done at least
517 the required extension, strip it. We don't handle such SUBREGs as
520 if (GET_CODE (from
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (from
)
521 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from
)))
522 >= GET_MODE_SIZE (to_mode
))
523 && SUBREG_PROMOTED_UNSIGNED_P (from
) == unsignedp
)
524 from
= gen_lowpart (to_mode
, from
), from_mode
= to_mode
;
526 if (GET_CODE (to
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (to
))
529 if (to_mode
== from_mode
530 || (from_mode
== VOIDmode
&& CONSTANT_P (from
)))
532 emit_move_insn (to
, from
);
540 if (GET_MODE_BITSIZE (from_mode
) < GET_MODE_BITSIZE (to_mode
))
542 /* Try converting directly if the insn is supported. */
543 if ((code
= can_extend_p (to_mode
, from_mode
, 0))
546 emit_unop_insn (code
, to
, from
, UNKNOWN
);
551 #ifdef HAVE_trunchfqf2
552 if (HAVE_trunchfqf2
&& from_mode
== HFmode
&& to_mode
== QFmode
)
554 emit_unop_insn (CODE_FOR_trunchfqf2
, to
, from
, UNKNOWN
);
558 #ifdef HAVE_trunctqfqf2
559 if (HAVE_trunctqfqf2
&& from_mode
== TQFmode
&& to_mode
== QFmode
)
561 emit_unop_insn (CODE_FOR_trunctqfqf2
, to
, from
, UNKNOWN
);
565 #ifdef HAVE_truncsfqf2
566 if (HAVE_truncsfqf2
&& from_mode
== SFmode
&& to_mode
== QFmode
)
568 emit_unop_insn (CODE_FOR_truncsfqf2
, to
, from
, UNKNOWN
);
572 #ifdef HAVE_truncdfqf2
573 if (HAVE_truncdfqf2
&& from_mode
== DFmode
&& to_mode
== QFmode
)
575 emit_unop_insn (CODE_FOR_truncdfqf2
, to
, from
, UNKNOWN
);
579 #ifdef HAVE_truncxfqf2
580 if (HAVE_truncxfqf2
&& from_mode
== XFmode
&& to_mode
== QFmode
)
582 emit_unop_insn (CODE_FOR_truncxfqf2
, to
, from
, UNKNOWN
);
586 #ifdef HAVE_trunctfqf2
587 if (HAVE_trunctfqf2
&& from_mode
== TFmode
&& to_mode
== QFmode
)
589 emit_unop_insn (CODE_FOR_trunctfqf2
, to
, from
, UNKNOWN
);
594 #ifdef HAVE_trunctqfhf2
595 if (HAVE_trunctqfhf2
&& from_mode
== TQFmode
&& to_mode
== HFmode
)
597 emit_unop_insn (CODE_FOR_trunctqfhf2
, to
, from
, UNKNOWN
);
601 #ifdef HAVE_truncsfhf2
602 if (HAVE_truncsfhf2
&& from_mode
== SFmode
&& to_mode
== HFmode
)
604 emit_unop_insn (CODE_FOR_truncsfhf2
, to
, from
, UNKNOWN
);
608 #ifdef HAVE_truncdfhf2
609 if (HAVE_truncdfhf2
&& from_mode
== DFmode
&& to_mode
== HFmode
)
611 emit_unop_insn (CODE_FOR_truncdfhf2
, to
, from
, UNKNOWN
);
615 #ifdef HAVE_truncxfhf2
616 if (HAVE_truncxfhf2
&& from_mode
== XFmode
&& to_mode
== HFmode
)
618 emit_unop_insn (CODE_FOR_truncxfhf2
, to
, from
, UNKNOWN
);
622 #ifdef HAVE_trunctfhf2
623 if (HAVE_trunctfhf2
&& from_mode
== TFmode
&& to_mode
== HFmode
)
625 emit_unop_insn (CODE_FOR_trunctfhf2
, to
, from
, UNKNOWN
);
630 #ifdef HAVE_truncsftqf2
631 if (HAVE_truncsftqf2
&& from_mode
== SFmode
&& to_mode
== TQFmode
)
633 emit_unop_insn (CODE_FOR_truncsftqf2
, to
, from
, UNKNOWN
);
637 #ifdef HAVE_truncdftqf2
638 if (HAVE_truncdftqf2
&& from_mode
== DFmode
&& to_mode
== TQFmode
)
640 emit_unop_insn (CODE_FOR_truncdftqf2
, to
, from
, UNKNOWN
);
644 #ifdef HAVE_truncxftqf2
645 if (HAVE_truncxftqf2
&& from_mode
== XFmode
&& to_mode
== TQFmode
)
647 emit_unop_insn (CODE_FOR_truncxftqf2
, to
, from
, UNKNOWN
);
651 #ifdef HAVE_trunctftqf2
652 if (HAVE_trunctftqf2
&& from_mode
== TFmode
&& to_mode
== TQFmode
)
654 emit_unop_insn (CODE_FOR_trunctftqf2
, to
, from
, UNKNOWN
);
659 #ifdef HAVE_truncdfsf2
660 if (HAVE_truncdfsf2
&& from_mode
== DFmode
&& to_mode
== SFmode
)
662 emit_unop_insn (CODE_FOR_truncdfsf2
, to
, from
, UNKNOWN
);
666 #ifdef HAVE_truncxfsf2
667 if (HAVE_truncxfsf2
&& from_mode
== XFmode
&& to_mode
== SFmode
)
669 emit_unop_insn (CODE_FOR_truncxfsf2
, to
, from
, UNKNOWN
);
673 #ifdef HAVE_trunctfsf2
674 if (HAVE_trunctfsf2
&& from_mode
== TFmode
&& to_mode
== SFmode
)
676 emit_unop_insn (CODE_FOR_trunctfsf2
, to
, from
, UNKNOWN
);
680 #ifdef HAVE_truncxfdf2
681 if (HAVE_truncxfdf2
&& from_mode
== XFmode
&& to_mode
== DFmode
)
683 emit_unop_insn (CODE_FOR_truncxfdf2
, to
, from
, UNKNOWN
);
687 #ifdef HAVE_trunctfdf2
688 if (HAVE_trunctfdf2
&& from_mode
== TFmode
&& to_mode
== DFmode
)
690 emit_unop_insn (CODE_FOR_trunctfdf2
, to
, from
, UNKNOWN
);
702 libcall
= extendsfdf2_libfunc
;
706 libcall
= extendsfxf2_libfunc
;
710 libcall
= extendsftf2_libfunc
;
722 libcall
= truncdfsf2_libfunc
;
726 libcall
= extenddfxf2_libfunc
;
730 libcall
= extenddftf2_libfunc
;
742 libcall
= truncxfsf2_libfunc
;
746 libcall
= truncxfdf2_libfunc
;
758 libcall
= trunctfsf2_libfunc
;
762 libcall
= trunctfdf2_libfunc
;
774 if (libcall
== (rtx
) 0)
775 /* This conversion is not implemented yet. */
778 value
= emit_library_call_value (libcall
, NULL_RTX
, 1, to_mode
,
780 emit_move_insn (to
, value
);
784 /* Now both modes are integers. */
786 /* Handle expanding beyond a word. */
787 if (GET_MODE_BITSIZE (from_mode
) < GET_MODE_BITSIZE (to_mode
)
788 && GET_MODE_BITSIZE (to_mode
) > BITS_PER_WORD
)
795 enum machine_mode lowpart_mode
;
796 int nwords
= CEIL (GET_MODE_SIZE (to_mode
), UNITS_PER_WORD
);
798 /* Try converting directly if the insn is supported. */
799 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
802 /* If FROM is a SUBREG, put it into a register. Do this
803 so that we always generate the same set of insns for
804 better cse'ing; if an intermediate assignment occurred,
805 we won't be doing the operation directly on the SUBREG. */
806 if (optimize
> 0 && GET_CODE (from
) == SUBREG
)
807 from
= force_reg (from_mode
, from
);
808 emit_unop_insn (code
, to
, from
, equiv_code
);
811 /* Next, try converting via full word. */
812 else if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
813 && ((code
= can_extend_p (to_mode
, word_mode
, unsignedp
))
814 != CODE_FOR_nothing
))
816 if (GET_CODE (to
) == REG
)
817 emit_insn (gen_rtx_CLOBBER (VOIDmode
, to
));
818 convert_move (gen_lowpart (word_mode
, to
), from
, unsignedp
);
819 emit_unop_insn (code
, to
,
820 gen_lowpart (word_mode
, to
), equiv_code
);
824 /* No special multiword conversion insn; do it by hand. */
827 /* Since we will turn this into a no conflict block, we must ensure
828 that the source does not overlap the target. */
830 if (reg_overlap_mentioned_p (to
, from
))
831 from
= force_reg (from_mode
, from
);
833 /* Get a copy of FROM widened to a word, if necessary. */
834 if (GET_MODE_BITSIZE (from_mode
) < BITS_PER_WORD
)
835 lowpart_mode
= word_mode
;
837 lowpart_mode
= from_mode
;
839 lowfrom
= convert_to_mode (lowpart_mode
, from
, unsignedp
);
841 lowpart
= gen_lowpart (lowpart_mode
, to
);
842 emit_move_insn (lowpart
, lowfrom
);
844 /* Compute the value to put in each remaining word. */
846 fill_value
= const0_rtx
;
851 && insn_data
[(int) CODE_FOR_slt
].operand
[0].mode
== word_mode
852 && STORE_FLAG_VALUE
== -1)
854 emit_cmp_insn (lowfrom
, const0_rtx
, NE
, NULL_RTX
,
856 fill_value
= gen_reg_rtx (word_mode
);
857 emit_insn (gen_slt (fill_value
));
863 = expand_shift (RSHIFT_EXPR
, lowpart_mode
, lowfrom
,
864 size_int (GET_MODE_BITSIZE (lowpart_mode
) - 1),
866 fill_value
= convert_to_mode (word_mode
, fill_value
, 1);
870 /* Fill the remaining words. */
871 for (i
= GET_MODE_SIZE (lowpart_mode
) / UNITS_PER_WORD
; i
< nwords
; i
++)
873 int index
= (WORDS_BIG_ENDIAN
? nwords
- i
- 1 : i
);
874 rtx subword
= operand_subword (to
, index
, 1, to_mode
);
879 if (fill_value
!= subword
)
880 emit_move_insn (subword
, fill_value
);
883 insns
= get_insns ();
886 emit_no_conflict_block (insns
, to
, from
, NULL_RTX
,
887 gen_rtx_fmt_e (equiv_code
, to_mode
, copy_rtx (from
)));
891 /* Truncating multi-word to a word or less. */
892 if (GET_MODE_BITSIZE (from_mode
) > BITS_PER_WORD
893 && GET_MODE_BITSIZE (to_mode
) <= BITS_PER_WORD
)
895 if (!((GET_CODE (from
) == MEM
896 && ! MEM_VOLATILE_P (from
)
897 && direct_load
[(int) to_mode
]
898 && ! mode_dependent_address_p (XEXP (from
, 0)))
899 || GET_CODE (from
) == REG
900 || GET_CODE (from
) == SUBREG
))
901 from
= force_reg (from_mode
, from
);
902 convert_move (to
, gen_lowpart (word_mode
, from
), 0);
906 /* Handle pointer conversion */ /* SPEE 900220 */
907 if (to_mode
== PQImode
)
909 if (from_mode
!= QImode
)
910 from
= convert_to_mode (QImode
, from
, unsignedp
);
912 #ifdef HAVE_truncqipqi2
913 if (HAVE_truncqipqi2
)
915 emit_unop_insn (CODE_FOR_truncqipqi2
, to
, from
, UNKNOWN
);
918 #endif /* HAVE_truncqipqi2 */
922 if (from_mode
== PQImode
)
924 if (to_mode
!= QImode
)
926 from
= convert_to_mode (QImode
, from
, unsignedp
);
931 #ifdef HAVE_extendpqiqi2
932 if (HAVE_extendpqiqi2
)
934 emit_unop_insn (CODE_FOR_extendpqiqi2
, to
, from
, UNKNOWN
);
937 #endif /* HAVE_extendpqiqi2 */
942 if (to_mode
== PSImode
)
944 if (from_mode
!= SImode
)
945 from
= convert_to_mode (SImode
, from
, unsignedp
);
947 #ifdef HAVE_truncsipsi2
948 if (HAVE_truncsipsi2
)
950 emit_unop_insn (CODE_FOR_truncsipsi2
, to
, from
, UNKNOWN
);
953 #endif /* HAVE_truncsipsi2 */
957 if (from_mode
== PSImode
)
959 if (to_mode
!= SImode
)
961 from
= convert_to_mode (SImode
, from
, unsignedp
);
966 #ifdef HAVE_extendpsisi2
967 if (HAVE_extendpsisi2
)
969 emit_unop_insn (CODE_FOR_extendpsisi2
, to
, from
, UNKNOWN
);
972 #endif /* HAVE_extendpsisi2 */
977 if (to_mode
== PDImode
)
979 if (from_mode
!= DImode
)
980 from
= convert_to_mode (DImode
, from
, unsignedp
);
982 #ifdef HAVE_truncdipdi2
983 if (HAVE_truncdipdi2
)
985 emit_unop_insn (CODE_FOR_truncdipdi2
, to
, from
, UNKNOWN
);
988 #endif /* HAVE_truncdipdi2 */
992 if (from_mode
== PDImode
)
994 if (to_mode
!= DImode
)
996 from
= convert_to_mode (DImode
, from
, unsignedp
);
1001 #ifdef HAVE_extendpdidi2
1002 if (HAVE_extendpdidi2
)
1004 emit_unop_insn (CODE_FOR_extendpdidi2
, to
, from
, UNKNOWN
);
1007 #endif /* HAVE_extendpdidi2 */
1012 /* Now follow all the conversions between integers
1013 no more than a word long. */
1015 /* For truncation, usually we can just refer to FROM in a narrower mode. */
1016 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
)
1017 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode
),
1018 GET_MODE_BITSIZE (from_mode
)))
1020 if (!((GET_CODE (from
) == MEM
1021 && ! MEM_VOLATILE_P (from
)
1022 && direct_load
[(int) to_mode
]
1023 && ! mode_dependent_address_p (XEXP (from
, 0)))
1024 || GET_CODE (from
) == REG
1025 || GET_CODE (from
) == SUBREG
))
1026 from
= force_reg (from_mode
, from
);
1027 if (GET_CODE (from
) == REG
&& REGNO (from
) < FIRST_PSEUDO_REGISTER
1028 && ! HARD_REGNO_MODE_OK (REGNO (from
), to_mode
))
1029 from
= copy_to_reg (from
);
1030 emit_move_insn (to
, gen_lowpart (to_mode
, from
));
1034 /* Handle extension. */
1035 if (GET_MODE_BITSIZE (to_mode
) > GET_MODE_BITSIZE (from_mode
))
1037 /* Convert directly if that works. */
1038 if ((code
= can_extend_p (to_mode
, from_mode
, unsignedp
))
1039 != CODE_FOR_nothing
)
1041 emit_unop_insn (code
, to
, from
, equiv_code
);
1046 enum machine_mode intermediate
;
1050 /* Search for a mode to convert via. */
1051 for (intermediate
= from_mode
; intermediate
!= VOIDmode
;
1052 intermediate
= GET_MODE_WIDER_MODE (intermediate
))
1053 if (((can_extend_p (to_mode
, intermediate
, unsignedp
)
1054 != CODE_FOR_nothing
)
1055 || (GET_MODE_SIZE (to_mode
) < GET_MODE_SIZE (intermediate
)
1056 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode
),
1057 GET_MODE_BITSIZE (intermediate
))))
1058 && (can_extend_p (intermediate
, from_mode
, unsignedp
)
1059 != CODE_FOR_nothing
))
1061 convert_move (to
, convert_to_mode (intermediate
, from
,
1062 unsignedp
), unsignedp
);
1066 /* No suitable intermediate mode.
1067 Generate what we need with shifts. */
1068 shift_amount
= build_int_2 (GET_MODE_BITSIZE (to_mode
)
1069 - GET_MODE_BITSIZE (from_mode
), 0);
1070 from
= gen_lowpart (to_mode
, force_reg (from_mode
, from
));
1071 tmp
= expand_shift (LSHIFT_EXPR
, to_mode
, from
, shift_amount
,
1073 tmp
= expand_shift (RSHIFT_EXPR
, to_mode
, tmp
, shift_amount
,
1076 emit_move_insn (to
, tmp
);
1081 /* Support special truncate insns for certain modes. */
1083 if (from_mode
== DImode
&& to_mode
== SImode
)
1085 #ifdef HAVE_truncdisi2
1086 if (HAVE_truncdisi2
)
1088 emit_unop_insn (CODE_FOR_truncdisi2
, to
, from
, UNKNOWN
);
1092 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1096 if (from_mode
== DImode
&& to_mode
== HImode
)
1098 #ifdef HAVE_truncdihi2
1099 if (HAVE_truncdihi2
)
1101 emit_unop_insn (CODE_FOR_truncdihi2
, to
, from
, UNKNOWN
);
1105 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1109 if (from_mode
== DImode
&& to_mode
== QImode
)
1111 #ifdef HAVE_truncdiqi2
1112 if (HAVE_truncdiqi2
)
1114 emit_unop_insn (CODE_FOR_truncdiqi2
, to
, from
, UNKNOWN
);
1118 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1122 if (from_mode
== SImode
&& to_mode
== HImode
)
1124 #ifdef HAVE_truncsihi2
1125 if (HAVE_truncsihi2
)
1127 emit_unop_insn (CODE_FOR_truncsihi2
, to
, from
, UNKNOWN
);
1131 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1135 if (from_mode
== SImode
&& to_mode
== QImode
)
1137 #ifdef HAVE_truncsiqi2
1138 if (HAVE_truncsiqi2
)
1140 emit_unop_insn (CODE_FOR_truncsiqi2
, to
, from
, UNKNOWN
);
1144 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1148 if (from_mode
== HImode
&& to_mode
== QImode
)
1150 #ifdef HAVE_trunchiqi2
1151 if (HAVE_trunchiqi2
)
1153 emit_unop_insn (CODE_FOR_trunchiqi2
, to
, from
, UNKNOWN
);
1157 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1161 if (from_mode
== TImode
&& to_mode
== DImode
)
1163 #ifdef HAVE_trunctidi2
1164 if (HAVE_trunctidi2
)
1166 emit_unop_insn (CODE_FOR_trunctidi2
, to
, from
, UNKNOWN
);
1170 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1174 if (from_mode
== TImode
&& to_mode
== SImode
)
1176 #ifdef HAVE_trunctisi2
1177 if (HAVE_trunctisi2
)
1179 emit_unop_insn (CODE_FOR_trunctisi2
, to
, from
, UNKNOWN
);
1183 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1187 if (from_mode
== TImode
&& to_mode
== HImode
)
1189 #ifdef HAVE_trunctihi2
1190 if (HAVE_trunctihi2
)
1192 emit_unop_insn (CODE_FOR_trunctihi2
, to
, from
, UNKNOWN
);
1196 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1200 if (from_mode
== TImode
&& to_mode
== QImode
)
1202 #ifdef HAVE_trunctiqi2
1203 if (HAVE_trunctiqi2
)
1205 emit_unop_insn (CODE_FOR_trunctiqi2
, to
, from
, UNKNOWN
);
1209 convert_move (to
, force_reg (from_mode
, from
), unsignedp
);
1213 /* Handle truncation of volatile memrefs, and so on;
1214 the things that couldn't be truncated directly,
1215 and for which there was no special instruction. */
1216 if (GET_MODE_BITSIZE (to_mode
) < GET_MODE_BITSIZE (from_mode
))
1218 rtx temp
= force_reg (to_mode
, gen_lowpart (to_mode
, from
));
1219 emit_move_insn (to
, temp
);
1223 /* Mode combination is not recognized. */
1227 /* Return an rtx for a value that would result
1228 from converting X to mode MODE.
1229 Both X and MODE may be floating, or both integer.
1230 UNSIGNEDP is nonzero if X is an unsigned value.
1231 This can be done by referring to a part of X in place
1232 or by copying to a new temporary with conversion.
1234 This function *must not* call protect_from_queue
1235 except when putting X into an insn (in which case convert_move does it). */
1238 convert_to_mode (mode
, x
, unsignedp
)
1239 enum machine_mode mode
;
1243 return convert_modes (mode
, VOIDmode
, x
, unsignedp
);
1246 /* Return an rtx for a value that would result
1247 from converting X from mode OLDMODE to mode MODE.
1248 Both modes may be floating, or both integer.
1249 UNSIGNEDP is nonzero if X is an unsigned value.
1251 This can be done by referring to a part of X in place
1252 or by copying to a new temporary with conversion.
1254 You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1256 This function *must not* call protect_from_queue
1257 except when putting X into an insn (in which case convert_move does it). */
1260 convert_modes (mode
, oldmode
, x
, unsignedp
)
1261 enum machine_mode mode
, oldmode
;
1267 /* If FROM is a SUBREG that indicates that we have already done at least
1268 the required extension, strip it. */
1270 if (GET_CODE (x
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (x
)
1271 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
))) >= GET_MODE_SIZE (mode
)
1272 && SUBREG_PROMOTED_UNSIGNED_P (x
) == unsignedp
)
1273 x
= gen_lowpart (mode
, x
);
1275 if (GET_MODE (x
) != VOIDmode
)
1276 oldmode
= GET_MODE (x
);
1278 if (mode
== oldmode
)
1281 /* There is one case that we must handle specially: If we are converting
1282 a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1283 we are to interpret the constant as unsigned, gen_lowpart will do
1284 the wrong if the constant appears negative. What we want to do is
1285 make the high-order word of the constant zero, not all ones. */
1287 if (unsignedp
&& GET_MODE_CLASS (mode
) == MODE_INT
1288 && GET_MODE_BITSIZE (mode
) == 2 * HOST_BITS_PER_WIDE_INT
1289 && GET_CODE (x
) == CONST_INT
&& INTVAL (x
) < 0)
1291 HOST_WIDE_INT val
= INTVAL (x
);
1293 if (oldmode
!= VOIDmode
1294 && HOST_BITS_PER_WIDE_INT
> GET_MODE_BITSIZE (oldmode
))
1296 int width
= GET_MODE_BITSIZE (oldmode
);
1298 /* We need to zero extend VAL. */
1299 val
&= ((HOST_WIDE_INT
) 1 << width
) - 1;
1302 return immed_double_const (val
, (HOST_WIDE_INT
) 0, mode
);
1305 /* We can do this with a gen_lowpart if both desired and current modes
1306 are integer, and this is either a constant integer, a register, or a
1307 non-volatile MEM. Except for the constant case where MODE is no
1308 wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
1310 if ((GET_CODE (x
) == CONST_INT
1311 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
1312 || (GET_MODE_CLASS (mode
) == MODE_INT
1313 && GET_MODE_CLASS (oldmode
) == MODE_INT
1314 && (GET_CODE (x
) == CONST_DOUBLE
1315 || (GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (oldmode
)
1316 && ((GET_CODE (x
) == MEM
&& ! MEM_VOLATILE_P (x
)
1317 && direct_load
[(int) mode
])
1318 || (GET_CODE (x
) == REG
1319 && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode
),
1320 GET_MODE_BITSIZE (GET_MODE (x
)))))))))
1322 /* ?? If we don't know OLDMODE, we have to assume here that
1323 X does not need sign- or zero-extension. This may not be
1324 the case, but it's the best we can do. */
1325 if (GET_CODE (x
) == CONST_INT
&& oldmode
!= VOIDmode
1326 && GET_MODE_SIZE (mode
) > GET_MODE_SIZE (oldmode
))
1328 HOST_WIDE_INT val
= INTVAL (x
);
1329 int width
= GET_MODE_BITSIZE (oldmode
);
1331 /* We must sign or zero-extend in this case. Start by
1332 zero-extending, then sign extend if we need to. */
1333 val
&= ((HOST_WIDE_INT
) 1 << width
) - 1;
1335 && (val
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
1336 val
|= (HOST_WIDE_INT
) (-1) << width
;
1338 return GEN_INT (val
);
1341 return gen_lowpart (mode
, x
);
1344 temp
= gen_reg_rtx (mode
);
1345 convert_move (temp
, x
, unsignedp
);
1350 /* This macro is used to determine what the largest unit size that
1351 move_by_pieces can use is. */
1353 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1354 move efficiently, as opposed to MOVE_MAX which is the maximum
1355 number of bhytes we can move with a single instruction. */
1357 #ifndef MOVE_MAX_PIECES
1358 #define MOVE_MAX_PIECES MOVE_MAX
1361 /* Generate several move instructions to copy LEN bytes
1362 from block FROM to block TO. (These are MEM rtx's with BLKmode).
1363 The caller must pass FROM and TO
1364 through protect_from_queue before calling.
1365 ALIGN (in bytes) is maximum alignment we can assume. */
1368 move_by_pieces (to
, from
, len
, align
)
1373 struct move_by_pieces data
;
1374 rtx to_addr
= XEXP (to
, 0), from_addr
= XEXP (from
, 0);
1375 unsigned int max_size
= MOVE_MAX_PIECES
+ 1;
1376 enum machine_mode mode
= VOIDmode
, tmode
;
1377 enum insn_code icode
;
1380 data
.to_addr
= to_addr
;
1381 data
.from_addr
= from_addr
;
1385 = (GET_CODE (to_addr
) == PRE_INC
|| GET_CODE (to_addr
) == PRE_DEC
1386 || GET_CODE (to_addr
) == POST_INC
|| GET_CODE (to_addr
) == POST_DEC
);
1388 = (GET_CODE (from_addr
) == PRE_INC
|| GET_CODE (from_addr
) == PRE_DEC
1389 || GET_CODE (from_addr
) == POST_INC
1390 || GET_CODE (from_addr
) == POST_DEC
);
1392 data
.explicit_inc_from
= 0;
1393 data
.explicit_inc_to
= 0;
1395 = (GET_CODE (to_addr
) == PRE_DEC
|| GET_CODE (to_addr
) == POST_DEC
);
1396 if (data
.reverse
) data
.offset
= len
;
1399 data
.to_struct
= MEM_IN_STRUCT_P (to
);
1400 data
.from_struct
= MEM_IN_STRUCT_P (from
);
1401 data
.to_readonly
= RTX_UNCHANGING_P (to
);
1402 data
.from_readonly
= RTX_UNCHANGING_P (from
);
1404 /* If copying requires more than two move insns,
1405 copy addresses to registers (to make displacements shorter)
1406 and use post-increment if available. */
1407 if (!(data
.autinc_from
&& data
.autinc_to
)
1408 && move_by_pieces_ninsns (len
, align
) > 2)
1410 /* Find the mode of the largest move... */
1411 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1412 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1413 if (GET_MODE_SIZE (tmode
) < max_size
)
1416 if (USE_LOAD_PRE_DECREMENT (mode
) && data
.reverse
&& ! data
.autinc_from
)
1418 data
.from_addr
= copy_addr_to_reg (plus_constant (from_addr
, len
));
1419 data
.autinc_from
= 1;
1420 data
.explicit_inc_from
= -1;
1422 if (USE_LOAD_POST_INCREMENT (mode
) && ! data
.autinc_from
)
1424 data
.from_addr
= copy_addr_to_reg (from_addr
);
1425 data
.autinc_from
= 1;
1426 data
.explicit_inc_from
= 1;
1428 if (!data
.autinc_from
&& CONSTANT_P (from_addr
))
1429 data
.from_addr
= copy_addr_to_reg (from_addr
);
1430 if (USE_STORE_PRE_DECREMENT (mode
) && data
.reverse
&& ! data
.autinc_to
)
1432 data
.to_addr
= copy_addr_to_reg (plus_constant (to_addr
, len
));
1434 data
.explicit_inc_to
= -1;
1436 if (USE_STORE_POST_INCREMENT (mode
) && ! data
.reverse
&& ! data
.autinc_to
)
1438 data
.to_addr
= copy_addr_to_reg (to_addr
);
1440 data
.explicit_inc_to
= 1;
1442 if (!data
.autinc_to
&& CONSTANT_P (to_addr
))
1443 data
.to_addr
= copy_addr_to_reg (to_addr
);
1446 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
1447 || align
> MOVE_MAX
|| align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1450 /* First move what we can in the largest integer mode, then go to
1451 successively smaller modes. */
1453 while (max_size
> 1)
1455 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1456 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1457 if (GET_MODE_SIZE (tmode
) < max_size
)
1460 if (mode
== VOIDmode
)
1463 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
1464 if (icode
!= CODE_FOR_nothing
1465 && align
>= MIN (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
,
1466 (unsigned int) GET_MODE_SIZE (mode
)))
1467 move_by_pieces_1 (GEN_FCN (icode
), mode
, &data
);
1469 max_size
= GET_MODE_SIZE (mode
);
1472 /* The code above should have handled everything. */
1477 /* Return number of insns required to move L bytes by pieces.
1478 ALIGN (in bytes) is maximum alignment we can assume. */
1481 move_by_pieces_ninsns (l
, align
)
1485 register int n_insns
= 0;
1486 unsigned int max_size
= MOVE_MAX
+ 1;
1488 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
1489 || align
> MOVE_MAX
|| align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1492 while (max_size
> 1)
1494 enum machine_mode mode
= VOIDmode
, tmode
;
1495 enum insn_code icode
;
1497 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
1498 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
1499 if (GET_MODE_SIZE (tmode
) < max_size
)
1502 if (mode
== VOIDmode
)
1505 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
1506 if (icode
!= CODE_FOR_nothing
1507 && align
>= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
)
1508 n_insns
+= l
/ GET_MODE_SIZE (mode
), l
%= GET_MODE_SIZE (mode
);
1510 max_size
= GET_MODE_SIZE (mode
);
1516 /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1517 with move instructions for mode MODE. GENFUN is the gen_... function
1518 to make a move insn for that mode. DATA has all the other info. */
1521 move_by_pieces_1 (genfun
, mode
, data
)
1522 rtx (*genfun
) PARAMS ((rtx
, ...));
1523 enum machine_mode mode
;
1524 struct move_by_pieces
*data
;
1526 register int size
= GET_MODE_SIZE (mode
);
1527 register rtx to1
, from1
;
1529 while (data
->len
>= size
)
1531 if (data
->reverse
) data
->offset
-= size
;
1533 to1
= (data
->autinc_to
1534 ? gen_rtx_MEM (mode
, data
->to_addr
)
1535 : copy_rtx (change_address (data
->to
, mode
,
1536 plus_constant (data
->to_addr
,
1538 MEM_IN_STRUCT_P (to1
) = data
->to_struct
;
1539 RTX_UNCHANGING_P (to1
) = data
->to_readonly
;
1542 = (data
->autinc_from
1543 ? gen_rtx_MEM (mode
, data
->from_addr
)
1544 : copy_rtx (change_address (data
->from
, mode
,
1545 plus_constant (data
->from_addr
,
1547 MEM_IN_STRUCT_P (from1
) = data
->from_struct
;
1548 RTX_UNCHANGING_P (from1
) = data
->from_readonly
;
1550 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_to
< 0)
1551 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (-size
)));
1552 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_from
< 0)
1553 emit_insn (gen_add2_insn (data
->from_addr
, GEN_INT (-size
)));
1555 emit_insn ((*genfun
) (to1
, from1
));
1556 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_to
> 0)
1557 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (size
)));
1558 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_from
> 0)
1559 emit_insn (gen_add2_insn (data
->from_addr
, GEN_INT (size
)));
1561 if (! data
->reverse
) data
->offset
+= size
;
1567 /* Emit code to move a block Y to a block X.
1568 This may be done with string-move instructions,
1569 with multiple scalar move instructions, or with a library call.
1571 Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1573 SIZE is an rtx that says how long they are.
1574 ALIGN is the maximum alignment we can assume they have,
1577 Return the address of the new block, if memcpy is called and returns it,
1581 emit_block_move (x
, y
, size
, align
)
1587 #ifdef TARGET_MEM_FUNCTIONS
1589 tree call_expr
, arg_list
;
1592 if (GET_MODE (x
) != BLKmode
)
1595 if (GET_MODE (y
) != BLKmode
)
1598 x
= protect_from_queue (x
, 1);
1599 y
= protect_from_queue (y
, 0);
1600 size
= protect_from_queue (size
, 0);
1602 if (GET_CODE (x
) != MEM
)
1604 if (GET_CODE (y
) != MEM
)
1609 if (GET_CODE (size
) == CONST_INT
&& MOVE_BY_PIECES_P (INTVAL (size
), align
))
1610 move_by_pieces (x
, y
, INTVAL (size
), align
);
1613 /* Try the most limited insn first, because there's no point
1614 including more than one in the machine description unless
1615 the more limited one has some advantage. */
1617 rtx opalign
= GEN_INT (align
);
1618 enum machine_mode mode
;
1620 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1621 mode
= GET_MODE_WIDER_MODE (mode
))
1623 enum insn_code code
= movstr_optab
[(int) mode
];
1624 insn_operand_predicate_fn pred
;
1626 if (code
!= CODE_FOR_nothing
1627 /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1628 here because if SIZE is less than the mode mask, as it is
1629 returned by the macro, it will definitely be less than the
1630 actual mode mask. */
1631 && ((GET_CODE (size
) == CONST_INT
1632 && ((unsigned HOST_WIDE_INT
) INTVAL (size
)
1633 <= (GET_MODE_MASK (mode
) >> 1)))
1634 || GET_MODE_BITSIZE (mode
) >= BITS_PER_WORD
)
1635 && ((pred
= insn_data
[(int) code
].operand
[0].predicate
) == 0
1636 || (*pred
) (x
, BLKmode
))
1637 && ((pred
= insn_data
[(int) code
].operand
[1].predicate
) == 0
1638 || (*pred
) (y
, BLKmode
))
1639 && ((pred
= insn_data
[(int) code
].operand
[3].predicate
) == 0
1640 || (*pred
) (opalign
, VOIDmode
)))
1643 rtx last
= get_last_insn ();
1646 op2
= convert_to_mode (mode
, size
, 1);
1647 pred
= insn_data
[(int) code
].operand
[2].predicate
;
1648 if (pred
!= 0 && ! (*pred
) (op2
, mode
))
1649 op2
= copy_to_mode_reg (mode
, op2
);
1651 pat
= GEN_FCN ((int) code
) (x
, y
, op2
, opalign
);
1658 delete_insns_since (last
);
1662 /* X, Y, or SIZE may have been passed through protect_from_queue.
1664 It is unsafe to save the value generated by protect_from_queue
1665 and reuse it later. Consider what happens if emit_queue is
1666 called before the return value from protect_from_queue is used.
1668 Expansion of the CALL_EXPR below will call emit_queue before
1669 we are finished emitting RTL for argument setup. So if we are
1670 not careful we could get the wrong value for an argument.
1672 To avoid this problem we go ahead and emit code to copy X, Y &
1673 SIZE into new pseudos. We can then place those new pseudos
1674 into an RTL_EXPR and use them later, even after a call to
1677 Note this is not strictly needed for library calls since they
1678 do not call emit_queue before loading their arguments. However,
1679 we may need to have library calls call emit_queue in the future
1680 since failing to do so could cause problems for targets which
1681 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
1682 x
= copy_to_mode_reg (Pmode
, XEXP (x
, 0));
1683 y
= copy_to_mode_reg (Pmode
, XEXP (y
, 0));
1685 #ifdef TARGET_MEM_FUNCTIONS
1686 size
= copy_to_mode_reg (TYPE_MODE (sizetype
), size
);
1688 size
= convert_to_mode (TYPE_MODE (integer_type_node
), size
,
1689 TREE_UNSIGNED (integer_type_node
));
1690 size
= copy_to_mode_reg (TYPE_MODE (integer_type_node
), size
);
1693 #ifdef TARGET_MEM_FUNCTIONS
1694 /* It is incorrect to use the libcall calling conventions to call
1695 memcpy in this context.
1697 This could be a user call to memcpy and the user may wish to
1698 examine the return value from memcpy.
1700 For targets where libcalls and normal calls have different conventions
1701 for returning pointers, we could end up generating incorrect code.
1703 So instead of using a libcall sequence we build up a suitable
1704 CALL_EXPR and expand the call in the normal fashion. */
1705 if (fn
== NULL_TREE
)
1709 /* This was copied from except.c, I don't know if all this is
1710 necessary in this context or not. */
1711 fn
= get_identifier ("memcpy");
1712 push_obstacks_nochange ();
1713 end_temporary_allocation ();
1714 fntype
= build_pointer_type (void_type_node
);
1715 fntype
= build_function_type (fntype
, NULL_TREE
);
1716 fn
= build_decl (FUNCTION_DECL
, fn
, fntype
);
1717 ggc_add_tree_root (&fn
, 1);
1718 DECL_EXTERNAL (fn
) = 1;
1719 TREE_PUBLIC (fn
) = 1;
1720 DECL_ARTIFICIAL (fn
) = 1;
1721 make_decl_rtl (fn
, NULL_PTR
, 1);
1722 assemble_external (fn
);
1726 /* We need to make an argument list for the function call.
1728 memcpy has three arguments, the first two are void * addresses and
1729 the last is a size_t byte count for the copy. */
1731 = build_tree_list (NULL_TREE
,
1732 make_tree (build_pointer_type (void_type_node
), x
));
1733 TREE_CHAIN (arg_list
)
1734 = build_tree_list (NULL_TREE
,
1735 make_tree (build_pointer_type (void_type_node
), y
));
1736 TREE_CHAIN (TREE_CHAIN (arg_list
))
1737 = build_tree_list (NULL_TREE
, make_tree (sizetype
, size
));
1738 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list
))) = NULL_TREE
;
1740 /* Now we have to build up the CALL_EXPR itself. */
1741 call_expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (fn
)), fn
);
1742 call_expr
= build (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
1743 call_expr
, arg_list
, NULL_TREE
);
1744 TREE_SIDE_EFFECTS (call_expr
) = 1;
1746 retval
= expand_expr (call_expr
, NULL_RTX
, VOIDmode
, 0);
1748 emit_library_call (bcopy_libfunc
, 0,
1749 VOIDmode
, 3, y
, Pmode
, x
, Pmode
,
1750 convert_to_mode (TYPE_MODE (integer_type_node
), size
,
1751 TREE_UNSIGNED (integer_type_node
)),
1752 TYPE_MODE (integer_type_node
));
1759 /* Copy all or part of a value X into registers starting at REGNO.
1760 The number of registers to be filled is NREGS. */
1763 move_block_to_reg (regno
, x
, nregs
, mode
)
1767 enum machine_mode mode
;
1770 #ifdef HAVE_load_multiple
1778 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
1779 x
= validize_mem (force_const_mem (mode
, x
));
1781 /* See if the machine can do this with a load multiple insn. */
1782 #ifdef HAVE_load_multiple
1783 if (HAVE_load_multiple
)
1785 last
= get_last_insn ();
1786 pat
= gen_load_multiple (gen_rtx_REG (word_mode
, regno
), x
,
1794 delete_insns_since (last
);
1798 for (i
= 0; i
< nregs
; i
++)
1799 emit_move_insn (gen_rtx_REG (word_mode
, regno
+ i
),
1800 operand_subword_force (x
, i
, mode
));
1803 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1804 The number of registers to be filled is NREGS. SIZE indicates the number
1805 of bytes in the object X. */
1809 move_block_from_reg (regno
, x
, nregs
, size
)
1816 #ifdef HAVE_store_multiple
1820 enum machine_mode mode
;
1822 /* If SIZE is that of a mode no bigger than a word, just use that
1823 mode's store operation. */
1824 if (size
<= UNITS_PER_WORD
1825 && (mode
= mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0)) != BLKmode
)
1827 emit_move_insn (change_address (x
, mode
, NULL
),
1828 gen_rtx_REG (mode
, regno
));
1832 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1833 to the left before storing to memory. Note that the previous test
1834 doesn't handle all cases (e.g. SIZE == 3). */
1835 if (size
< UNITS_PER_WORD
&& BYTES_BIG_ENDIAN
)
1837 rtx tem
= operand_subword (x
, 0, 1, BLKmode
);
1843 shift
= expand_shift (LSHIFT_EXPR
, word_mode
,
1844 gen_rtx_REG (word_mode
, regno
),
1845 build_int_2 ((UNITS_PER_WORD
- size
)
1846 * BITS_PER_UNIT
, 0), NULL_RTX
, 0);
1847 emit_move_insn (tem
, shift
);
1851 /* See if the machine can do this with a store multiple insn. */
1852 #ifdef HAVE_store_multiple
1853 if (HAVE_store_multiple
)
1855 last
= get_last_insn ();
1856 pat
= gen_store_multiple (x
, gen_rtx_REG (word_mode
, regno
),
1864 delete_insns_since (last
);
1868 for (i
= 0; i
< nregs
; i
++)
1870 rtx tem
= operand_subword (x
, i
, 1, BLKmode
);
1875 emit_move_insn (tem
, gen_rtx_REG (word_mode
, regno
+ i
));
1879 /* Emit code to move a block SRC to a block DST, where DST is non-consecutive
1880 registers represented by a PARALLEL. SSIZE represents the total size of
1881 block SRC in bytes, or -1 if not known. ALIGN is the known alignment of
1883 /* ??? If SSIZE % UNITS_PER_WORD != 0, we make the blatent assumption that
1884 the balance will be in what would be the low-order memory addresses, i.e.
1885 left justified for big endian, right justified for little endian. This
1886 happens to be true for the targets currently using this support. If this
1887 ever changes, a new target macro along the lines of FUNCTION_ARG_PADDING
1891 emit_group_load (dst
, orig_src
, ssize
, align
)
1899 if (GET_CODE (dst
) != PARALLEL
)
1902 /* Check for a NULL entry, used to indicate that the parameter goes
1903 both on the stack and in registers. */
1904 if (XEXP (XVECEXP (dst
, 0, 0), 0))
1909 tmps
= (rtx
*) alloca (sizeof(rtx
) * XVECLEN (dst
, 0));
1911 /* If we won't be loading directly from memory, protect the real source
1912 from strange tricks we might play. */
1914 if (GET_CODE (src
) != MEM
)
1916 if (GET_CODE (src
) == VOIDmode
)
1917 src
= gen_reg_rtx (GET_MODE (dst
));
1919 src
= gen_reg_rtx (GET_MODE (orig_src
));
1920 emit_move_insn (src
, orig_src
);
1923 /* Process the pieces. */
1924 for (i
= start
; i
< XVECLEN (dst
, 0); i
++)
1926 enum machine_mode mode
= GET_MODE (XEXP (XVECEXP (dst
, 0, i
), 0));
1927 HOST_WIDE_INT bytepos
= INTVAL (XEXP (XVECEXP (dst
, 0, i
), 1));
1928 unsigned int bytelen
= GET_MODE_SIZE (mode
);
1931 /* Handle trailing fragments that run over the size of the struct. */
1932 if (ssize
>= 0 && bytepos
+ bytelen
> ssize
)
1934 shift
= (bytelen
- (ssize
- bytepos
)) * BITS_PER_UNIT
;
1935 bytelen
= ssize
- bytepos
;
1940 /* Optimize the access just a bit. */
1941 if (GET_CODE (src
) == MEM
1942 && align
* BITS_PER_UNIT
>= GET_MODE_ALIGNMENT (mode
)
1943 && bytepos
* BITS_PER_UNIT
% GET_MODE_ALIGNMENT (mode
) == 0
1944 && bytelen
== GET_MODE_SIZE (mode
))
1946 tmps
[i
] = gen_reg_rtx (mode
);
1947 emit_move_insn (tmps
[i
],
1948 change_address (src
, mode
,
1949 plus_constant (XEXP (src
, 0),
1952 else if (GET_CODE (src
) == CONCAT
)
1955 && bytelen
== GET_MODE_SIZE (GET_MODE (XEXP (src
, 0))))
1956 tmps
[i
] = XEXP (src
, 0);
1957 else if (bytepos
== GET_MODE_SIZE (GET_MODE (XEXP (src
, 0)))
1958 && bytelen
== GET_MODE_SIZE (GET_MODE (XEXP (src
, 1))))
1959 tmps
[i
] = XEXP (src
, 1);
1965 tmps
[i
] = extract_bit_field (src
, bytelen
*BITS_PER_UNIT
,
1966 bytepos
*BITS_PER_UNIT
, 1, NULL_RTX
,
1967 mode
, mode
, align
, ssize
);
1970 if (BYTES_BIG_ENDIAN
&& shift
)
1972 expand_binop (mode
, ashl_optab
, tmps
[i
], GEN_INT (shift
),
1973 tmps
[i
], 0, OPTAB_WIDEN
);
1978 /* Copy the extracted pieces into the proper (probable) hard regs. */
1979 for (i
= start
; i
< XVECLEN (dst
, 0); i
++)
1980 emit_move_insn (XEXP (XVECEXP (dst
, 0, i
), 0), tmps
[i
]);
1983 /* Emit code to move a block SRC to a block DST, where SRC is non-consecutive
1984 registers represented by a PARALLEL. SSIZE represents the total size of
1985 block DST, or -1 if not known. ALIGN is the known alignment of DST. */
1988 emit_group_store (orig_dst
, src
, ssize
, align
)
1996 if (GET_CODE (src
) != PARALLEL
)
1999 /* Check for a NULL entry, used to indicate that the parameter goes
2000 both on the stack and in registers. */
2001 if (XEXP (XVECEXP (src
, 0, 0), 0))
2006 tmps
= (rtx
*) alloca (sizeof(rtx
) * XVECLEN (src
, 0));
2008 /* Copy the (probable) hard regs into pseudos. */
2009 for (i
= start
; i
< XVECLEN (src
, 0); i
++)
2011 rtx reg
= XEXP (XVECEXP (src
, 0, i
), 0);
2012 tmps
[i
] = gen_reg_rtx (GET_MODE (reg
));
2013 emit_move_insn (tmps
[i
], reg
);
2017 /* If we won't be storing directly into memory, protect the real destination
2018 from strange tricks we might play. */
2020 if (GET_CODE (dst
) == PARALLEL
)
2024 /* We can get a PARALLEL dst if there is a conditional expression in
2025 a return statement. In that case, the dst and src are the same,
2026 so no action is necessary. */
2027 if (rtx_equal_p (dst
, src
))
2030 /* It is unclear if we can ever reach here, but we may as well handle
2031 it. Allocate a temporary, and split this into a store/load to/from
2034 temp
= assign_stack_temp (GET_MODE (dst
), ssize
, 0);
2035 emit_group_store (temp
, src
, ssize
, align
);
2036 emit_group_load (dst
, temp
, ssize
, align
);
2039 else if (GET_CODE (dst
) != MEM
)
2041 dst
= gen_reg_rtx (GET_MODE (orig_dst
));
2042 /* Make life a bit easier for combine. */
2043 emit_move_insn (dst
, const0_rtx
);
2045 else if (! MEM_IN_STRUCT_P (dst
))
2047 /* store_bit_field requires that memory operations have
2048 mem_in_struct_p set; we might not. */
2050 dst
= copy_rtx (orig_dst
);
2051 MEM_SET_IN_STRUCT_P (dst
, 1);
2054 /* Process the pieces. */
2055 for (i
= start
; i
< XVECLEN (src
, 0); i
++)
2057 HOST_WIDE_INT bytepos
= INTVAL (XEXP (XVECEXP (src
, 0, i
), 1));
2058 enum machine_mode mode
= GET_MODE (tmps
[i
]);
2059 unsigned int bytelen
= GET_MODE_SIZE (mode
);
2061 /* Handle trailing fragments that run over the size of the struct. */
2062 if (ssize
>= 0 && bytepos
+ bytelen
> ssize
)
2064 if (BYTES_BIG_ENDIAN
)
2066 int shift
= (bytelen
- (ssize
- bytepos
)) * BITS_PER_UNIT
;
2067 expand_binop (mode
, ashr_optab
, tmps
[i
], GEN_INT (shift
),
2068 tmps
[i
], 0, OPTAB_WIDEN
);
2070 bytelen
= ssize
- bytepos
;
2073 /* Optimize the access just a bit. */
2074 if (GET_CODE (dst
) == MEM
2075 && align
* BITS_PER_UNIT
>= GET_MODE_ALIGNMENT (mode
)
2076 && bytepos
* BITS_PER_UNIT
% GET_MODE_ALIGNMENT (mode
) == 0
2077 && bytelen
== GET_MODE_SIZE (mode
))
2078 emit_move_insn (change_address (dst
, mode
,
2079 plus_constant (XEXP (dst
, 0),
2083 store_bit_field (dst
, bytelen
* BITS_PER_UNIT
, bytepos
* BITS_PER_UNIT
,
2084 mode
, tmps
[i
], align
, ssize
);
2089 /* Copy from the pseudo into the (probable) hard reg. */
2090 if (GET_CODE (dst
) == REG
)
2091 emit_move_insn (orig_dst
, dst
);
2094 /* Generate code to copy a BLKmode object of TYPE out of a
2095 set of registers starting with SRCREG into TGTBLK. If TGTBLK
2096 is null, a stack temporary is created. TGTBLK is returned.
2098 The primary purpose of this routine is to handle functions
2099 that return BLKmode structures in registers. Some machines
2100 (the PA for example) want to return all small structures
2101 in registers regardless of the structure's alignment. */
2104 copy_blkmode_from_reg (tgtblk
,srcreg
,type
)
2109 int bytes
= int_size_in_bytes (type
);
2110 rtx src
= NULL
, dst
= NULL
;
2111 int bitsize
= MIN (TYPE_ALIGN (type
), BITS_PER_WORD
);
2112 int bitpos
, xbitpos
, big_endian_correction
= 0;
2116 tgtblk
= assign_stack_temp (BLKmode
, bytes
, 0);
2117 MEM_SET_IN_STRUCT_P (tgtblk
, AGGREGATE_TYPE_P (type
));
2118 preserve_temp_slots (tgtblk
);
2121 /* This code assumes srcreg is at least a full word. If it isn't,
2122 copy it into a new pseudo which is a full word. */
2123 if (GET_MODE (srcreg
) != BLKmode
2124 && GET_MODE_SIZE (GET_MODE (srcreg
)) < UNITS_PER_WORD
)
2125 srcreg
= convert_to_mode (word_mode
, srcreg
,
2126 TREE_UNSIGNED (type
));
2128 /* Structures whose size is not a multiple of a word are aligned
2129 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2130 machine, this means we must skip the empty high order bytes when
2131 calculating the bit offset. */
2132 if (BYTES_BIG_ENDIAN
&& bytes
% UNITS_PER_WORD
)
2133 big_endian_correction
= (BITS_PER_WORD
- ((bytes
% UNITS_PER_WORD
)
2136 /* Copy the structure BITSIZE bites at a time.
2138 We could probably emit more efficient code for machines
2139 which do not use strict alignment, but it doesn't seem
2140 worth the effort at the current time. */
2141 for (bitpos
= 0, xbitpos
= big_endian_correction
;
2142 bitpos
< bytes
* BITS_PER_UNIT
;
2143 bitpos
+= bitsize
, xbitpos
+= bitsize
)
2146 /* We need a new source operand each time xbitpos is on a
2147 word boundary and when xbitpos == big_endian_correction
2148 (the first time through). */
2149 if (xbitpos
% BITS_PER_WORD
== 0
2150 || xbitpos
== big_endian_correction
)
2151 src
= operand_subword_force (srcreg
,
2152 xbitpos
/ BITS_PER_WORD
,
2155 /* We need a new destination operand each time bitpos is on
2157 if (bitpos
% BITS_PER_WORD
== 0)
2158 dst
= operand_subword (tgtblk
, bitpos
/ BITS_PER_WORD
, 1, BLKmode
);
2160 /* Use xbitpos for the source extraction (right justified) and
2161 xbitpos for the destination store (left justified). */
2162 store_bit_field (dst
, bitsize
, bitpos
% BITS_PER_WORD
, word_mode
,
2163 extract_bit_field (src
, bitsize
,
2164 xbitpos
% BITS_PER_WORD
, 1,
2165 NULL_RTX
, word_mode
,
2167 bitsize
/ BITS_PER_UNIT
,
2169 bitsize
/ BITS_PER_UNIT
, BITS_PER_WORD
);
2175 /* Add a USE expression for REG to the (possibly empty) list pointed
2176 to by CALL_FUSAGE. REG must denote a hard register. */
2179 use_reg (call_fusage
, reg
)
2180 rtx
*call_fusage
, reg
;
2182 if (GET_CODE (reg
) != REG
2183 || REGNO (reg
) >= FIRST_PSEUDO_REGISTER
)
2187 = gen_rtx_EXPR_LIST (VOIDmode
,
2188 gen_rtx_USE (VOIDmode
, reg
), *call_fusage
);
2191 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2192 starting at REGNO. All of these registers must be hard registers. */
2195 use_regs (call_fusage
, regno
, nregs
)
2202 if (regno
+ nregs
> FIRST_PSEUDO_REGISTER
)
2205 for (i
= 0; i
< nregs
; i
++)
2206 use_reg (call_fusage
, gen_rtx_REG (reg_raw_mode
[regno
+ i
], regno
+ i
));
2209 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2210 PARALLEL REGS. This is for calls that pass values in multiple
2211 non-contiguous locations. The Irix 6 ABI has examples of this. */
2214 use_group_regs (call_fusage
, regs
)
2220 for (i
= 0; i
< XVECLEN (regs
, 0); i
++)
2222 rtx reg
= XEXP (XVECEXP (regs
, 0, i
), 0);
2224 /* A NULL entry means the parameter goes both on the stack and in
2225 registers. This can also be a MEM for targets that pass values
2226 partially on the stack and partially in registers. */
2227 if (reg
!= 0 && GET_CODE (reg
) == REG
)
2228 use_reg (call_fusage
, reg
);
2232 /* Generate several move instructions to clear LEN bytes of block TO.
2233 (A MEM rtx with BLKmode). The caller must pass TO through
2234 protect_from_queue before calling. ALIGN (in bytes) is maximum alignment
2238 clear_by_pieces (to
, len
, align
)
2243 struct clear_by_pieces data
;
2244 rtx to_addr
= XEXP (to
, 0);
2245 unsigned int max_size
= MOVE_MAX_PIECES
+ 1;
2246 enum machine_mode mode
= VOIDmode
, tmode
;
2247 enum insn_code icode
;
2250 data
.to_addr
= to_addr
;
2253 = (GET_CODE (to_addr
) == PRE_INC
|| GET_CODE (to_addr
) == PRE_DEC
2254 || GET_CODE (to_addr
) == POST_INC
|| GET_CODE (to_addr
) == POST_DEC
);
2256 data
.explicit_inc_to
= 0;
2258 = (GET_CODE (to_addr
) == PRE_DEC
|| GET_CODE (to_addr
) == POST_DEC
);
2259 if (data
.reverse
) data
.offset
= len
;
2262 data
.to_struct
= MEM_IN_STRUCT_P (to
);
2264 /* If copying requires more than two move insns,
2265 copy addresses to registers (to make displacements shorter)
2266 and use post-increment if available. */
2268 && move_by_pieces_ninsns (len
, align
) > 2)
2270 /* Determine the main mode we'll be using */
2271 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2272 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
2273 if (GET_MODE_SIZE (tmode
) < max_size
)
2276 if (USE_STORE_PRE_DECREMENT (mode
) && data
.reverse
&& ! data
.autinc_to
)
2278 data
.to_addr
= copy_addr_to_reg (plus_constant (to_addr
, len
));
2280 data
.explicit_inc_to
= -1;
2282 if (USE_STORE_POST_INCREMENT (mode
) && ! data
.reverse
&& ! data
.autinc_to
)
2284 data
.to_addr
= copy_addr_to_reg (to_addr
);
2286 data
.explicit_inc_to
= 1;
2288 if (!data
.autinc_to
&& CONSTANT_P (to_addr
))
2289 data
.to_addr
= copy_addr_to_reg (to_addr
);
2292 if (! SLOW_UNALIGNED_ACCESS (word_mode
, align
)
2293 || align
> MOVE_MAX
|| align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2296 /* First move what we can in the largest integer mode, then go to
2297 successively smaller modes. */
2299 while (max_size
> 1)
2301 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2302 tmode
!= VOIDmode
; tmode
= GET_MODE_WIDER_MODE (tmode
))
2303 if (GET_MODE_SIZE (tmode
) < max_size
)
2306 if (mode
== VOIDmode
)
2309 icode
= mov_optab
->handlers
[(int) mode
].insn_code
;
2310 if (icode
!= CODE_FOR_nothing
2311 && align
>= GET_MODE_ALIGNMENT (mode
) / BITS_PER_UNIT
)
2312 clear_by_pieces_1 (GEN_FCN (icode
), mode
, &data
);
2314 max_size
= GET_MODE_SIZE (mode
);
2317 /* The code above should have handled everything. */
2322 /* Subroutine of clear_by_pieces. Clear as many bytes as appropriate
2323 with move instructions for mode MODE. GENFUN is the gen_... function
2324 to make a move insn for that mode. DATA has all the other info. */
2327 clear_by_pieces_1 (genfun
, mode
, data
)
2328 rtx (*genfun
) PARAMS ((rtx
, ...));
2329 enum machine_mode mode
;
2330 struct clear_by_pieces
*data
;
2332 register int size
= GET_MODE_SIZE (mode
);
2335 while (data
->len
>= size
)
2337 if (data
->reverse
) data
->offset
-= size
;
2339 to1
= (data
->autinc_to
2340 ? gen_rtx_MEM (mode
, data
->to_addr
)
2341 : copy_rtx (change_address (data
->to
, mode
,
2342 plus_constant (data
->to_addr
,
2344 MEM_IN_STRUCT_P (to1
) = data
->to_struct
;
2346 if (HAVE_PRE_DECREMENT
&& data
->explicit_inc_to
< 0)
2347 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (-size
)));
2349 emit_insn ((*genfun
) (to1
, const0_rtx
));
2350 if (HAVE_POST_INCREMENT
&& data
->explicit_inc_to
> 0)
2351 emit_insn (gen_add2_insn (data
->to_addr
, GEN_INT (size
)));
2353 if (! data
->reverse
) data
->offset
+= size
;
2359 /* Write zeros through the storage of OBJECT.
2360 If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is
2361 the maximum alignment we can is has, measured in bytes.
2363 If we call a function that returns the length of the block, return it. */
2366 clear_storage (object
, size
, align
)
2371 #ifdef TARGET_MEM_FUNCTIONS
2373 tree call_expr
, arg_list
;
2377 if (GET_MODE (object
) == BLKmode
)
2379 object
= protect_from_queue (object
, 1);
2380 size
= protect_from_queue (size
, 0);
2382 if (GET_CODE (size
) == CONST_INT
2383 && MOVE_BY_PIECES_P (INTVAL (size
), align
))
2384 clear_by_pieces (object
, INTVAL (size
), align
);
2388 /* Try the most limited insn first, because there's no point
2389 including more than one in the machine description unless
2390 the more limited one has some advantage. */
2392 rtx opalign
= GEN_INT (align
);
2393 enum machine_mode mode
;
2395 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
2396 mode
= GET_MODE_WIDER_MODE (mode
))
2398 enum insn_code code
= clrstr_optab
[(int) mode
];
2399 insn_operand_predicate_fn pred
;
2401 if (code
!= CODE_FOR_nothing
2402 /* We don't need MODE to be narrower than
2403 BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2404 the mode mask, as it is returned by the macro, it will
2405 definitely be less than the actual mode mask. */
2406 && ((GET_CODE (size
) == CONST_INT
2407 && ((unsigned HOST_WIDE_INT
) INTVAL (size
)
2408 <= (GET_MODE_MASK (mode
) >> 1)))
2409 || GET_MODE_BITSIZE (mode
) >= BITS_PER_WORD
)
2410 && ((pred
= insn_data
[(int) code
].operand
[0].predicate
) == 0
2411 || (*pred
) (object
, BLKmode
))
2412 && ((pred
= insn_data
[(int) code
].operand
[2].predicate
) == 0
2413 || (*pred
) (opalign
, VOIDmode
)))
2416 rtx last
= get_last_insn ();
2419 op1
= convert_to_mode (mode
, size
, 1);
2420 pred
= insn_data
[(int) code
].operand
[1].predicate
;
2421 if (pred
!= 0 && ! (*pred
) (op1
, mode
))
2422 op1
= copy_to_mode_reg (mode
, op1
);
2424 pat
= GEN_FCN ((int) code
) (object
, op1
, opalign
);
2431 delete_insns_since (last
);
2435 /* OBJECT or SIZE may have been passed through protect_from_queue.
2437 It is unsafe to save the value generated by protect_from_queue
2438 and reuse it later. Consider what happens if emit_queue is
2439 called before the return value from protect_from_queue is used.
2441 Expansion of the CALL_EXPR below will call emit_queue before
2442 we are finished emitting RTL for argument setup. So if we are
2443 not careful we could get the wrong value for an argument.
2445 To avoid this problem we go ahead and emit code to copy OBJECT
2446 and SIZE into new pseudos. We can then place those new pseudos
2447 into an RTL_EXPR and use them later, even after a call to
2450 Note this is not strictly needed for library calls since they
2451 do not call emit_queue before loading their arguments. However,
2452 we may need to have library calls call emit_queue in the future
2453 since failing to do so could cause problems for targets which
2454 define SMALL_REGISTER_CLASSES and pass arguments in registers. */
2455 object
= copy_to_mode_reg (Pmode
, XEXP (object
, 0));
2457 #ifdef TARGET_MEM_FUNCTIONS
2458 size
= copy_to_mode_reg (TYPE_MODE (sizetype
), size
);
2460 size
= convert_to_mode (TYPE_MODE (integer_type_node
), size
,
2461 TREE_UNSIGNED (integer_type_node
));
2462 size
= copy_to_mode_reg (TYPE_MODE (integer_type_node
), size
);
2466 #ifdef TARGET_MEM_FUNCTIONS
2467 /* It is incorrect to use the libcall calling conventions to call
2468 memset in this context.
2470 This could be a user call to memset and the user may wish to
2471 examine the return value from memset.
2473 For targets where libcalls and normal calls have different
2474 conventions for returning pointers, we could end up generating
2477 So instead of using a libcall sequence we build up a suitable
2478 CALL_EXPR and expand the call in the normal fashion. */
2479 if (fn
== NULL_TREE
)
2483 /* This was copied from except.c, I don't know if all this is
2484 necessary in this context or not. */
2485 fn
= get_identifier ("memset");
2486 push_obstacks_nochange ();
2487 end_temporary_allocation ();
2488 fntype
= build_pointer_type (void_type_node
);
2489 fntype
= build_function_type (fntype
, NULL_TREE
);
2490 fn
= build_decl (FUNCTION_DECL
, fn
, fntype
);
2491 ggc_add_tree_root (&fn
, 1);
2492 DECL_EXTERNAL (fn
) = 1;
2493 TREE_PUBLIC (fn
) = 1;
2494 DECL_ARTIFICIAL (fn
) = 1;
2495 make_decl_rtl (fn
, NULL_PTR
, 1);
2496 assemble_external (fn
);
2500 /* We need to make an argument list for the function call.
2502 memset has three arguments, the first is a void * addresses, the
2503 second a integer with the initialization value, the last is a
2504 size_t byte count for the copy. */
2506 = build_tree_list (NULL_TREE
,
2507 make_tree (build_pointer_type (void_type_node
),
2509 TREE_CHAIN (arg_list
)
2510 = build_tree_list (NULL_TREE
,
2511 make_tree (integer_type_node
, const0_rtx
));
2512 TREE_CHAIN (TREE_CHAIN (arg_list
))
2513 = build_tree_list (NULL_TREE
, make_tree (sizetype
, size
));
2514 TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list
))) = NULL_TREE
;
2516 /* Now we have to build up the CALL_EXPR itself. */
2517 call_expr
= build1 (ADDR_EXPR
,
2518 build_pointer_type (TREE_TYPE (fn
)), fn
);
2519 call_expr
= build (CALL_EXPR
, TREE_TYPE (TREE_TYPE (fn
)),
2520 call_expr
, arg_list
, NULL_TREE
);
2521 TREE_SIDE_EFFECTS (call_expr
) = 1;
2523 retval
= expand_expr (call_expr
, NULL_RTX
, VOIDmode
, 0);
2525 emit_library_call (bzero_libfunc
, 0,
2526 VOIDmode
, 2, object
, Pmode
, size
,
2527 TYPE_MODE (integer_type_node
));
2532 emit_move_insn (object
, CONST0_RTX (GET_MODE (object
)));
2537 /* Generate code to copy Y into X.
2538 Both Y and X must have the same mode, except that
2539 Y can be a constant with VOIDmode.
2540 This mode cannot be BLKmode; use emit_block_move for that.
2542 Return the last instruction emitted. */
2545 emit_move_insn (x
, y
)
2548 enum machine_mode mode
= GET_MODE (x
);
2550 x
= protect_from_queue (x
, 1);
2551 y
= protect_from_queue (y
, 0);
2553 if (mode
== BLKmode
|| (GET_MODE (y
) != mode
&& GET_MODE (y
) != VOIDmode
))
2556 /* Never force constant_p_rtx to memory. */
2557 if (GET_CODE (y
) == CONSTANT_P_RTX
)
2559 else if (CONSTANT_P (y
) && ! LEGITIMATE_CONSTANT_P (y
))
2560 y
= force_const_mem (mode
, y
);
2562 /* If X or Y are memory references, verify that their addresses are valid
2564 if (GET_CODE (x
) == MEM
2565 && ((! memory_address_p (GET_MODE (x
), XEXP (x
, 0))
2566 && ! push_operand (x
, GET_MODE (x
)))
2568 && CONSTANT_ADDRESS_P (XEXP (x
, 0)))))
2569 x
= change_address (x
, VOIDmode
, XEXP (x
, 0));
2571 if (GET_CODE (y
) == MEM
2572 && (! memory_address_p (GET_MODE (y
), XEXP (y
, 0))
2574 && CONSTANT_ADDRESS_P (XEXP (y
, 0)))))
2575 y
= change_address (y
, VOIDmode
, XEXP (y
, 0));
2577 if (mode
== BLKmode
)
2580 return emit_move_insn_1 (x
, y
);
2583 /* Low level part of emit_move_insn.
2584 Called just like emit_move_insn, but assumes X and Y
2585 are basically valid. */
2588 emit_move_insn_1 (x
, y
)
2591 enum machine_mode mode
= GET_MODE (x
);
2592 enum machine_mode submode
;
2593 enum mode_class
class = GET_MODE_CLASS (mode
);
2596 if (mode
>= MAX_MACHINE_MODE
)
2599 if (mov_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
2601 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) mode
].insn_code
) (x
, y
));
2603 /* Expand complex moves by moving real part and imag part, if possible. */
2604 else if ((class == MODE_COMPLEX_FLOAT
|| class == MODE_COMPLEX_INT
)
2605 && BLKmode
!= (submode
= mode_for_size ((GET_MODE_UNIT_SIZE (mode
)
2607 (class == MODE_COMPLEX_INT
2608 ? MODE_INT
: MODE_FLOAT
),
2610 && (mov_optab
->handlers
[(int) submode
].insn_code
2611 != CODE_FOR_nothing
))
2613 /* Don't split destination if it is a stack push. */
2614 int stack
= push_operand (x
, GET_MODE (x
));
2616 /* If this is a stack, push the highpart first, so it
2617 will be in the argument order.
2619 In that case, change_address is used only to convert
2620 the mode, not to change the address. */
2623 /* Note that the real part always precedes the imag part in memory
2624 regardless of machine's endianness. */
2625 #ifdef STACK_GROWS_DOWNWARD
2626 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2627 (gen_rtx_MEM (submode
, (XEXP (x
, 0))),
2628 gen_imagpart (submode
, y
)));
2629 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2630 (gen_rtx_MEM (submode
, (XEXP (x
, 0))),
2631 gen_realpart (submode
, y
)));
2633 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2634 (gen_rtx_MEM (submode
, (XEXP (x
, 0))),
2635 gen_realpart (submode
, y
)));
2636 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2637 (gen_rtx_MEM (submode
, (XEXP (x
, 0))),
2638 gen_imagpart (submode
, y
)));
2643 rtx realpart_x
, realpart_y
;
2644 rtx imagpart_x
, imagpart_y
;
2646 /* If this is a complex value with each part being smaller than a
2647 word, the usual calling sequence will likely pack the pieces into
2648 a single register. Unfortunately, SUBREG of hard registers only
2649 deals in terms of words, so we have a problem converting input
2650 arguments to the CONCAT of two registers that is used elsewhere
2651 for complex values. If this is before reload, we can copy it into
2652 memory and reload. FIXME, we should see about using extract and
2653 insert on integer registers, but complex short and complex char
2654 variables should be rarely used. */
2655 if (GET_MODE_BITSIZE (mode
) < 2*BITS_PER_WORD
2656 && (reload_in_progress
| reload_completed
) == 0)
2658 int packed_dest_p
= (REG_P (x
) && REGNO (x
) < FIRST_PSEUDO_REGISTER
);
2659 int packed_src_p
= (REG_P (y
) && REGNO (y
) < FIRST_PSEUDO_REGISTER
);
2661 if (packed_dest_p
|| packed_src_p
)
2663 enum mode_class reg_class
= ((class == MODE_COMPLEX_FLOAT
)
2664 ? MODE_FLOAT
: MODE_INT
);
2666 enum machine_mode reg_mode
=
2667 mode_for_size (GET_MODE_BITSIZE (mode
), reg_class
, 1);
2669 if (reg_mode
!= BLKmode
)
2671 rtx mem
= assign_stack_temp (reg_mode
,
2672 GET_MODE_SIZE (mode
), 0);
2674 rtx cmem
= change_address (mem
, mode
, NULL_RTX
);
2676 cfun
->cannot_inline
= N_("function using short complex types cannot be inline");
2680 rtx sreg
= gen_rtx_SUBREG (reg_mode
, x
, 0);
2681 emit_move_insn_1 (cmem
, y
);
2682 return emit_move_insn_1 (sreg
, mem
);
2686 rtx sreg
= gen_rtx_SUBREG (reg_mode
, y
, 0);
2687 emit_move_insn_1 (mem
, sreg
);
2688 return emit_move_insn_1 (x
, cmem
);
2694 realpart_x
= gen_realpart (submode
, x
);
2695 realpart_y
= gen_realpart (submode
, y
);
2696 imagpart_x
= gen_imagpart (submode
, x
);
2697 imagpart_y
= gen_imagpart (submode
, y
);
2699 /* Show the output dies here. This is necessary for SUBREGs
2700 of pseudos since we cannot track their lifetimes correctly;
2701 hard regs shouldn't appear here except as return values.
2702 We never want to emit such a clobber after reload. */
2704 && ! (reload_in_progress
|| reload_completed
)
2705 && (GET_CODE (realpart_x
) == SUBREG
2706 || GET_CODE (imagpart_x
) == SUBREG
))
2708 emit_insn (gen_rtx_CLOBBER (VOIDmode
, x
));
2711 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2712 (realpart_x
, realpart_y
));
2713 emit_insn (GEN_FCN (mov_optab
->handlers
[(int) submode
].insn_code
)
2714 (imagpart_x
, imagpart_y
));
2717 return get_last_insn ();
2720 /* This will handle any multi-word mode that lacks a move_insn pattern.
2721 However, you will get better code if you define such patterns,
2722 even if they must turn into multiple assembler instructions. */
2723 else if (GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
2729 #ifdef PUSH_ROUNDING
2731 /* If X is a push on the stack, do the push now and replace
2732 X with a reference to the stack pointer. */
2733 if (push_operand (x
, GET_MODE (x
)))
2735 anti_adjust_stack (GEN_INT (GET_MODE_SIZE (GET_MODE (x
))));
2736 x
= change_address (x
, VOIDmode
, stack_pointer_rtx
);
2744 i
< (GET_MODE_SIZE (mode
) + (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
2747 rtx xpart
= operand_subword (x
, i
, 1, mode
);
2748 rtx ypart
= operand_subword (y
, i
, 1, mode
);
2750 /* If we can't get a part of Y, put Y into memory if it is a
2751 constant. Otherwise, force it into a register. If we still
2752 can't get a part of Y, abort. */
2753 if (ypart
== 0 && CONSTANT_P (y
))
2755 y
= force_const_mem (mode
, y
);
2756 ypart
= operand_subword (y
, i
, 1, mode
);
2758 else if (ypart
== 0)
2759 ypart
= operand_subword_force (y
, i
, mode
);
2761 if (xpart
== 0 || ypart
== 0)
2764 need_clobber
|= (GET_CODE (xpart
) == SUBREG
);
2766 last_insn
= emit_move_insn (xpart
, ypart
);
2769 seq
= gen_sequence ();
2772 /* Show the output dies here. This is necessary for SUBREGs
2773 of pseudos since we cannot track their lifetimes correctly;
2774 hard regs shouldn't appear here except as return values.
2775 We never want to emit such a clobber after reload. */
2777 && ! (reload_in_progress
|| reload_completed
)
2778 && need_clobber
!= 0)
2780 emit_insn (gen_rtx_CLOBBER (VOIDmode
, x
));
2791 /* Pushing data onto the stack. */
2793 /* Push a block of length SIZE (perhaps variable)
2794 and return an rtx to address the beginning of the block.
2795 Note that it is not possible for the value returned to be a QUEUED.
2796 The value may be virtual_outgoing_args_rtx.
2798 EXTRA is the number of bytes of padding to push in addition to SIZE.
2799 BELOW nonzero means this padding comes at low addresses;
2800 otherwise, the padding comes at high addresses. */
2803 push_block (size
, extra
, below
)
2809 size
= convert_modes (Pmode
, ptr_mode
, size
, 1);
2810 if (CONSTANT_P (size
))
2811 anti_adjust_stack (plus_constant (size
, extra
));
2812 else if (GET_CODE (size
) == REG
&& extra
== 0)
2813 anti_adjust_stack (size
);
2816 rtx temp
= copy_to_mode_reg (Pmode
, size
);
2818 temp
= expand_binop (Pmode
, add_optab
, temp
, GEN_INT (extra
),
2819 temp
, 0, OPTAB_LIB_WIDEN
);
2820 anti_adjust_stack (temp
);
2823 #if defined (STACK_GROWS_DOWNWARD) \
2824 || (defined (ARGS_GROW_DOWNWARD) \
2825 && !defined (ACCUMULATE_OUTGOING_ARGS))
2827 /* Return the lowest stack address when STACK or ARGS grow downward and
2828 we are not aaccumulating outgoing arguments (the c4x port uses such
2830 temp
= virtual_outgoing_args_rtx
;
2831 if (extra
!= 0 && below
)
2832 temp
= plus_constant (temp
, extra
);
2834 if (GET_CODE (size
) == CONST_INT
)
2835 temp
= plus_constant (virtual_outgoing_args_rtx
,
2836 - INTVAL (size
) - (below
? 0 : extra
));
2837 else if (extra
!= 0 && !below
)
2838 temp
= gen_rtx_PLUS (Pmode
, virtual_outgoing_args_rtx
,
2839 negate_rtx (Pmode
, plus_constant (size
, extra
)));
2841 temp
= gen_rtx_PLUS (Pmode
, virtual_outgoing_args_rtx
,
2842 negate_rtx (Pmode
, size
));
2845 return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT
), temp
);
2851 return gen_rtx_fmt_e (STACK_PUSH_CODE
, Pmode
, stack_pointer_rtx
);
2854 /* Return an rtx for the address of the beginning of a as-if-it-was-pushed
2855 block of SIZE bytes. */
2858 get_push_address (size
)
2863 if (STACK_PUSH_CODE
== POST_DEC
)
2864 temp
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
, GEN_INT (size
));
2865 else if (STACK_PUSH_CODE
== POST_INC
)
2866 temp
= gen_rtx_MINUS (Pmode
, stack_pointer_rtx
, GEN_INT (size
));
2868 temp
= stack_pointer_rtx
;
2870 return copy_to_reg (temp
);
2873 /* Generate code to push X onto the stack, assuming it has mode MODE and
2875 MODE is redundant except when X is a CONST_INT (since they don't
2877 SIZE is an rtx for the size of data to be copied (in bytes),
2878 needed only if X is BLKmode.
2880 ALIGN (in bytes) is maximum alignment we can assume.
2882 If PARTIAL and REG are both nonzero, then copy that many of the first
2883 words of X into registers starting with REG, and push the rest of X.
2884 The amount of space pushed is decreased by PARTIAL words,
2885 rounded *down* to a multiple of PARM_BOUNDARY.
2886 REG must be a hard register in this case.
2887 If REG is zero but PARTIAL is not, take any all others actions for an
2888 argument partially in registers, but do not actually load any
2891 EXTRA is the amount in bytes of extra space to leave next to this arg.
2892 This is ignored if an argument block has already been allocated.
2894 On a machine that lacks real push insns, ARGS_ADDR is the address of
2895 the bottom of the argument block for this call. We use indexing off there
2896 to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
2897 argument block has not been preallocated.
2899 ARGS_SO_FAR is the size of args previously pushed for this call.
2901 REG_PARM_STACK_SPACE is nonzero if functions require stack space
2902 for arguments passed in registers. If nonzero, it will be the number
2903 of bytes required. */
2906 emit_push_insn (x
, mode
, type
, size
, align
, partial
, reg
, extra
,
2907 args_addr
, args_so_far
, reg_parm_stack_space
,
2910 enum machine_mode mode
;
2919 int reg_parm_stack_space
;
2923 enum direction stack_direction
2924 #ifdef STACK_GROWS_DOWNWARD
2930 /* Decide where to pad the argument: `downward' for below,
2931 `upward' for above, or `none' for don't pad it.
2932 Default is below for small data on big-endian machines; else above. */
2933 enum direction where_pad
= FUNCTION_ARG_PADDING (mode
, type
);
2935 /* Invert direction if stack is post-update. */
2936 if (STACK_PUSH_CODE
== POST_INC
|| STACK_PUSH_CODE
== POST_DEC
)
2937 if (where_pad
!= none
)
2938 where_pad
= (where_pad
== downward
? upward
: downward
);
2940 xinner
= x
= protect_from_queue (x
, 0);
2942 if (mode
== BLKmode
)
2944 /* Copy a block into the stack, entirely or partially. */
2947 int used
= partial
* UNITS_PER_WORD
;
2948 int offset
= used
% (PARM_BOUNDARY
/ BITS_PER_UNIT
);
2956 /* USED is now the # of bytes we need not copy to the stack
2957 because registers will take care of them. */
2960 xinner
= change_address (xinner
, BLKmode
,
2961 plus_constant (XEXP (xinner
, 0), used
));
2963 /* If the partial register-part of the arg counts in its stack size,
2964 skip the part of stack space corresponding to the registers.
2965 Otherwise, start copying to the beginning of the stack space,
2966 by setting SKIP to 0. */
2967 skip
= (reg_parm_stack_space
== 0) ? 0 : used
;
2969 #ifdef PUSH_ROUNDING
2970 /* Do it with several push insns if that doesn't take lots of insns
2971 and if there is no difficulty with push insns that skip bytes
2972 on the stack for alignment purposes. */
2974 && GET_CODE (size
) == CONST_INT
2976 && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size
) - used
, align
))
2977 /* Here we avoid the case of a structure whose weak alignment
2978 forces many pushes of a small amount of data,
2979 and such small pushes do rounding that causes trouble. */
2980 && ((! SLOW_UNALIGNED_ACCESS (word_mode
, align
))
2981 || align
>= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
2982 || PUSH_ROUNDING (align
) == align
)
2983 && PUSH_ROUNDING (INTVAL (size
)) == INTVAL (size
))
2985 /* Push padding now if padding above and stack grows down,
2986 or if padding below and stack grows up.
2987 But if space already allocated, this has already been done. */
2988 if (extra
&& args_addr
== 0
2989 && where_pad
!= none
&& where_pad
!= stack_direction
)
2990 anti_adjust_stack (GEN_INT (extra
));
2992 move_by_pieces (gen_rtx_MEM (BLKmode
, gen_push_operand ()), xinner
,
2993 INTVAL (size
) - used
, align
);
2995 if (current_function_check_memory_usage
&& ! in_check_memory_usage
)
2999 in_check_memory_usage
= 1;
3000 temp
= get_push_address (INTVAL(size
) - used
);
3001 if (GET_CODE (x
) == MEM
&& type
&& AGGREGATE_TYPE_P (type
))
3002 emit_library_call (chkr_copy_bitmap_libfunc
, 1, VOIDmode
, 3,
3004 XEXP (xinner
, 0), Pmode
,
3005 GEN_INT (INTVAL(size
) - used
),
3006 TYPE_MODE (sizetype
));
3008 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
3010 GEN_INT (INTVAL(size
) - used
),
3011 TYPE_MODE (sizetype
),
3012 GEN_INT (MEMORY_USE_RW
),
3013 TYPE_MODE (integer_type_node
));
3014 in_check_memory_usage
= 0;
3018 #endif /* PUSH_ROUNDING */
3020 /* Otherwise make space on the stack and copy the data
3021 to the address of that space. */
3023 /* Deduct words put into registers from the size we must copy. */
3026 if (GET_CODE (size
) == CONST_INT
)
3027 size
= GEN_INT (INTVAL (size
) - used
);
3029 size
= expand_binop (GET_MODE (size
), sub_optab
, size
,
3030 GEN_INT (used
), NULL_RTX
, 0,
3034 /* Get the address of the stack space.
3035 In this case, we do not deal with EXTRA separately.
3036 A single stack adjust will do. */
3039 temp
= push_block (size
, extra
, where_pad
== downward
);
3042 else if (GET_CODE (args_so_far
) == CONST_INT
)
3043 temp
= memory_address (BLKmode
,
3044 plus_constant (args_addr
,
3045 skip
+ INTVAL (args_so_far
)));
3047 temp
= memory_address (BLKmode
,
3048 plus_constant (gen_rtx_PLUS (Pmode
,
3052 if (current_function_check_memory_usage
&& ! in_check_memory_usage
)
3056 in_check_memory_usage
= 1;
3057 target
= copy_to_reg (temp
);
3058 if (GET_CODE (x
) == MEM
&& type
&& AGGREGATE_TYPE_P (type
))
3059 emit_library_call (chkr_copy_bitmap_libfunc
, 1, VOIDmode
, 3,
3061 XEXP (xinner
, 0), Pmode
,
3062 size
, TYPE_MODE (sizetype
));
3064 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
3066 size
, TYPE_MODE (sizetype
),
3067 GEN_INT (MEMORY_USE_RW
),
3068 TYPE_MODE (integer_type_node
));
3069 in_check_memory_usage
= 0;
3072 /* TEMP is the address of the block. Copy the data there. */
3073 if (GET_CODE (size
) == CONST_INT
3074 && MOVE_BY_PIECES_P ((unsigned) INTVAL (size
), align
))
3076 move_by_pieces (gen_rtx_MEM (BLKmode
, temp
), xinner
,
3077 INTVAL (size
), align
);
3082 rtx opalign
= GEN_INT (align
);
3083 enum machine_mode mode
;
3084 rtx target
= gen_rtx_MEM (BLKmode
, temp
);
3086 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
3088 mode
= GET_MODE_WIDER_MODE (mode
))
3090 enum insn_code code
= movstr_optab
[(int) mode
];
3091 insn_operand_predicate_fn pred
;
3093 if (code
!= CODE_FOR_nothing
3094 && ((GET_CODE (size
) == CONST_INT
3095 && ((unsigned HOST_WIDE_INT
) INTVAL (size
)
3096 <= (GET_MODE_MASK (mode
) >> 1)))
3097 || GET_MODE_BITSIZE (mode
) >= BITS_PER_WORD
)
3098 && (!(pred
= insn_data
[(int) code
].operand
[0].predicate
)
3099 || ((*pred
) (target
, BLKmode
)))
3100 && (!(pred
= insn_data
[(int) code
].operand
[1].predicate
)
3101 || ((*pred
) (xinner
, BLKmode
)))
3102 && (!(pred
= insn_data
[(int) code
].operand
[3].predicate
)
3103 || ((*pred
) (opalign
, VOIDmode
))))
3105 rtx op2
= convert_to_mode (mode
, size
, 1);
3106 rtx last
= get_last_insn ();
3109 pred
= insn_data
[(int) code
].operand
[2].predicate
;
3110 if (pred
!= 0 && ! (*pred
) (op2
, mode
))
3111 op2
= copy_to_mode_reg (mode
, op2
);
3113 pat
= GEN_FCN ((int) code
) (target
, xinner
,
3121 delete_insns_since (last
);
3126 #ifndef ACCUMULATE_OUTGOING_ARGS
3127 /* If the source is referenced relative to the stack pointer,
3128 copy it to another register to stabilize it. We do not need
3129 to do this if we know that we won't be changing sp. */
3131 if (reg_mentioned_p (virtual_stack_dynamic_rtx
, temp
)
3132 || reg_mentioned_p (virtual_outgoing_args_rtx
, temp
))
3133 temp
= copy_to_reg (temp
);
3136 /* Make inhibit_defer_pop nonzero around the library call
3137 to force it to pop the bcopy-arguments right away. */
3139 #ifdef TARGET_MEM_FUNCTIONS
3140 emit_library_call (memcpy_libfunc
, 0,
3141 VOIDmode
, 3, temp
, Pmode
, XEXP (xinner
, 0), Pmode
,
3142 convert_to_mode (TYPE_MODE (sizetype
),
3143 size
, TREE_UNSIGNED (sizetype
)),
3144 TYPE_MODE (sizetype
));
3146 emit_library_call (bcopy_libfunc
, 0,
3147 VOIDmode
, 3, XEXP (xinner
, 0), Pmode
, temp
, Pmode
,
3148 convert_to_mode (TYPE_MODE (integer_type_node
),
3150 TREE_UNSIGNED (integer_type_node
)),
3151 TYPE_MODE (integer_type_node
));
3156 else if (partial
> 0)
3158 /* Scalar partly in registers. */
3160 int size
= GET_MODE_SIZE (mode
) / UNITS_PER_WORD
;
3163 /* # words of start of argument
3164 that we must make space for but need not store. */
3165 int offset
= partial
% (PARM_BOUNDARY
/ BITS_PER_WORD
);
3166 int args_offset
= INTVAL (args_so_far
);
3169 /* Push padding now if padding above and stack grows down,
3170 or if padding below and stack grows up.
3171 But if space already allocated, this has already been done. */
3172 if (extra
&& args_addr
== 0
3173 && where_pad
!= none
&& where_pad
!= stack_direction
)
3174 anti_adjust_stack (GEN_INT (extra
));
3176 /* If we make space by pushing it, we might as well push
3177 the real data. Otherwise, we can leave OFFSET nonzero
3178 and leave the space uninitialized. */
3182 /* Now NOT_STACK gets the number of words that we don't need to
3183 allocate on the stack. */
3184 not_stack
= partial
- offset
;
3186 /* If the partial register-part of the arg counts in its stack size,
3187 skip the part of stack space corresponding to the registers.
3188 Otherwise, start copying to the beginning of the stack space,
3189 by setting SKIP to 0. */
3190 skip
= (reg_parm_stack_space
== 0) ? 0 : not_stack
;
3192 if (CONSTANT_P (x
) && ! LEGITIMATE_CONSTANT_P (x
))
3193 x
= validize_mem (force_const_mem (mode
, x
));
3195 /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3196 SUBREGs of such registers are not allowed. */
3197 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
3198 && GET_MODE_CLASS (GET_MODE (x
)) != MODE_INT
))
3199 x
= copy_to_reg (x
);
3201 /* Loop over all the words allocated on the stack for this arg. */
3202 /* We can do it by words, because any scalar bigger than a word
3203 has a size a multiple of a word. */
3204 #ifndef PUSH_ARGS_REVERSED
3205 for (i
= not_stack
; i
< size
; i
++)
3207 for (i
= size
- 1; i
>= not_stack
; i
--)
3209 if (i
>= not_stack
+ offset
)
3210 emit_push_insn (operand_subword_force (x
, i
, mode
),
3211 word_mode
, NULL_TREE
, NULL_RTX
, align
, 0, NULL_RTX
,
3213 GEN_INT (args_offset
+ ((i
- not_stack
+ skip
)
3215 reg_parm_stack_space
, alignment_pad
);
3220 rtx target
= NULL_RTX
;
3222 /* Push padding now if padding above and stack grows down,
3223 or if padding below and stack grows up.
3224 But if space already allocated, this has already been done. */
3225 if (extra
&& args_addr
== 0
3226 && where_pad
!= none
&& where_pad
!= stack_direction
)
3227 anti_adjust_stack (GEN_INT (extra
));
3229 #ifdef PUSH_ROUNDING
3231 addr
= gen_push_operand ();
3235 if (GET_CODE (args_so_far
) == CONST_INT
)
3237 = memory_address (mode
,
3238 plus_constant (args_addr
,
3239 INTVAL (args_so_far
)));
3241 addr
= memory_address (mode
, gen_rtx_PLUS (Pmode
, args_addr
,
3246 emit_move_insn (gen_rtx_MEM (mode
, addr
), x
);
3248 if (current_function_check_memory_usage
&& ! in_check_memory_usage
)
3250 in_check_memory_usage
= 1;
3252 target
= get_push_address (GET_MODE_SIZE (mode
));
3254 if (GET_CODE (x
) == MEM
&& type
&& AGGREGATE_TYPE_P (type
))
3255 emit_library_call (chkr_copy_bitmap_libfunc
, 1, VOIDmode
, 3,
3258 GEN_INT (GET_MODE_SIZE (mode
)),
3259 TYPE_MODE (sizetype
));
3261 emit_library_call (chkr_set_right_libfunc
, 1, VOIDmode
, 3,
3263 GEN_INT (GET_MODE_SIZE (mode
)),
3264 TYPE_MODE (sizetype
),
3265 GEN_INT (MEMORY_USE_RW
),
3266 TYPE_MODE (integer_type_node
));
3267 in_check_memory_usage
= 0;
3272 /* If part should go in registers, copy that part
3273 into the appropriate registers. Do this now, at the end,
3274 since mem-to-mem copies above may do function calls. */
3275 if (partial
> 0 && reg
!= 0)
3277 /* Handle calls that pass values in multiple non-contiguous locations.
3278 The Irix 6 ABI has examples of this. */
3279 if (GET_CODE (reg
) == PARALLEL
)
3280 emit_group_load (reg
, x
, -1, align
); /* ??? size? */
3282 move_block_to_reg (REGNO (reg
), x
, partial
, mode
);
3285 if (extra
&& args_addr
== 0 && where_pad
== stack_direction
)
3286 anti_adjust_stack (GEN_INT (extra
));
3289 anti_adjust_stack (alignment_pad
);
3292 /* Expand an assignment that stores the value of FROM into TO.
3293 If WANT_VALUE is nonzero, return an rtx for the value of TO.
3294 (This may contain a QUEUED rtx;
3295 if the value is constant, this rtx is a constant.)
3296 Otherwise, the returned value is NULL_RTX.
3298 SUGGEST_REG is no longer actually used.
3299 It used to mean, copy the value through a register
3300 and return that register, if that is possible.
3301 We now use WANT_VALUE to decide whether to do this. */
3304 expand_assignment (to
, from
, want_value
, suggest_reg
)
3307 int suggest_reg ATTRIBUTE_UNUSED
;
3309 register rtx to_rtx
= 0;
3312 /* Don't crash if the lhs of the assignment was erroneous. */
3314 if (TREE_CODE (to
) == ERROR_MARK
)
3316 result
= expand_expr (from
, NULL_RTX
, VOIDmode
, 0);
3317 return want_value
? result
: NULL_RTX
;
3320 /* Assignment of a structure component needs special treatment
3321 if the structure component's rtx is not simply a MEM.
3322 Assignment of an array element at a constant index, and assignment of
3323 an array element in an unaligned packed structure field, has the same
3326 if (TREE_CODE (to
) == COMPONENT_REF
|| TREE_CODE (to
) == BIT_FIELD_REF
3327 || TREE_CODE (to
) == ARRAY_REF
)
3329 enum machine_mode mode1
;
3330 HOST_WIDE_INT bitsize
, bitpos
;
3335 unsigned int alignment
;
3338 tem
= get_inner_reference (to
, &bitsize
, &bitpos
, &offset
, &mode1
,
3339 &unsignedp
, &volatilep
, &alignment
);
3341 /* If we are going to use store_bit_field and extract_bit_field,
3342 make sure to_rtx will be safe for multiple use. */
3344 if (mode1
== VOIDmode
&& want_value
)
3345 tem
= stabilize_reference (tem
);
3347 to_rtx
= expand_expr (tem
, NULL_RTX
, VOIDmode
, EXPAND_MEMORY_USE_DONT
);
3350 rtx offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, 0);
3352 if (GET_CODE (to_rtx
) != MEM
)
3355 if (GET_MODE (offset_rtx
) != ptr_mode
)
3357 #ifdef POINTERS_EXTEND_UNSIGNED
3358 offset_rtx
= convert_memory_address (ptr_mode
, offset_rtx
);
3360 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
3364 /* A constant address in TO_RTX can have VOIDmode, we must not try
3365 to call force_reg for that case. Avoid that case. */
3366 if (GET_CODE (to_rtx
) == MEM
3367 && GET_MODE (to_rtx
) == BLKmode
3368 && GET_MODE (XEXP (to_rtx
, 0)) != VOIDmode
3370 && (bitpos
% bitsize
) == 0
3371 && (bitsize
% GET_MODE_ALIGNMENT (mode1
)) == 0
3372 && (alignment
* BITS_PER_UNIT
) == GET_MODE_ALIGNMENT (mode1
))
3374 rtx temp
= change_address (to_rtx
, mode1
,
3375 plus_constant (XEXP (to_rtx
, 0),
3378 if (GET_CODE (XEXP (temp
, 0)) == REG
)
3381 to_rtx
= change_address (to_rtx
, mode1
,
3382 force_reg (GET_MODE (XEXP (temp
, 0)),
3387 to_rtx
= change_address (to_rtx
, VOIDmode
,
3388 gen_rtx_PLUS (ptr_mode
, XEXP (to_rtx
, 0),
3389 force_reg (ptr_mode
,
3395 if (GET_CODE (to_rtx
) == MEM
)
3397 /* When the offset is zero, to_rtx is the address of the
3398 structure we are storing into, and hence may be shared.
3399 We must make a new MEM before setting the volatile bit. */
3401 to_rtx
= copy_rtx (to_rtx
);
3403 MEM_VOLATILE_P (to_rtx
) = 1;
3405 #if 0 /* This was turned off because, when a field is volatile
3406 in an object which is not volatile, the object may be in a register,
3407 and then we would abort over here. */
3413 if (TREE_CODE (to
) == COMPONENT_REF
3414 && TREE_READONLY (TREE_OPERAND (to
, 1)))
3417 to_rtx
= copy_rtx (to_rtx
);
3419 RTX_UNCHANGING_P (to_rtx
) = 1;
3422 /* Check the access. */
3423 if (current_function_check_memory_usage
&& GET_CODE (to_rtx
) == MEM
)
3428 enum machine_mode best_mode
;
3430 best_mode
= get_best_mode (bitsize
, bitpos
,
3431 TYPE_ALIGN (TREE_TYPE (tem
)),
3433 if (best_mode
== VOIDmode
)
3436 best_mode_size
= GET_MODE_BITSIZE (best_mode
);
3437 to_addr
= plus_constant (XEXP (to_rtx
, 0), (bitpos
/ BITS_PER_UNIT
));
3438 size
= CEIL ((bitpos
% best_mode_size
) + bitsize
, best_mode_size
);
3439 size
*= GET_MODE_SIZE (best_mode
);
3441 /* Check the access right of the pointer. */
3443 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
3445 GEN_INT (size
), TYPE_MODE (sizetype
),
3446 GEN_INT (MEMORY_USE_WO
),
3447 TYPE_MODE (integer_type_node
));
3450 result
= store_field (to_rtx
, bitsize
, bitpos
, mode1
, from
,
3452 /* Spurious cast makes HPUX compiler happy. */
3453 ? (enum machine_mode
) TYPE_MODE (TREE_TYPE (to
))
3456 /* Required alignment of containing datum. */
3458 int_size_in_bytes (TREE_TYPE (tem
)),
3459 get_alias_set (to
));
3460 preserve_temp_slots (result
);
3464 /* If the value is meaningful, convert RESULT to the proper mode.
3465 Otherwise, return nothing. */
3466 return (want_value
? convert_modes (TYPE_MODE (TREE_TYPE (to
)),
3467 TYPE_MODE (TREE_TYPE (from
)),
3469 TREE_UNSIGNED (TREE_TYPE (to
)))
3473 /* If the rhs is a function call and its value is not an aggregate,
3474 call the function before we start to compute the lhs.
3475 This is needed for correct code for cases such as
3476 val = setjmp (buf) on machines where reference to val
3477 requires loading up part of an address in a separate insn.
3479 Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3480 since it might be a promoted variable where the zero- or sign- extension
3481 needs to be done. Handling this in the normal way is safe because no
3482 computation is done before the call. */
3483 if (TREE_CODE (from
) == CALL_EXPR
&& ! aggregate_value_p (from
)
3484 && TREE_CODE (TYPE_SIZE (TREE_TYPE (from
))) == INTEGER_CST
3485 && ! ((TREE_CODE (to
) == VAR_DECL
|| TREE_CODE (to
) == PARM_DECL
)
3486 && GET_CODE (DECL_RTL (to
)) == REG
))
3491 value
= expand_expr (from
, NULL_RTX
, VOIDmode
, 0);
3493 to_rtx
= expand_expr (to
, NULL_RTX
, VOIDmode
, EXPAND_MEMORY_USE_WO
);
3495 /* Handle calls that return values in multiple non-contiguous locations.
3496 The Irix 6 ABI has examples of this. */
3497 if (GET_CODE (to_rtx
) == PARALLEL
)
3498 emit_group_load (to_rtx
, value
, int_size_in_bytes (TREE_TYPE (from
)),
3499 TYPE_ALIGN (TREE_TYPE (from
)) / BITS_PER_UNIT
);
3500 else if (GET_MODE (to_rtx
) == BLKmode
)
3501 emit_block_move (to_rtx
, value
, expr_size (from
),
3502 TYPE_ALIGN (TREE_TYPE (from
)) / BITS_PER_UNIT
);
3505 #ifdef POINTERS_EXTEND_UNSIGNED
3506 if (TREE_CODE (TREE_TYPE (to
)) == REFERENCE_TYPE
3507 || TREE_CODE (TREE_TYPE (to
)) == POINTER_TYPE
)
3508 value
= convert_memory_address (GET_MODE (to_rtx
), value
);
3510 emit_move_insn (to_rtx
, value
);
3512 preserve_temp_slots (to_rtx
);
3515 return want_value
? to_rtx
: NULL_RTX
;
3518 /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
3519 Don't re-expand if it was expanded already (in COMPONENT_REF case). */
3523 to_rtx
= expand_expr (to
, NULL_RTX
, VOIDmode
, EXPAND_MEMORY_USE_WO
);
3524 if (GET_CODE (to_rtx
) == MEM
)
3525 MEM_ALIAS_SET (to_rtx
) = get_alias_set (to
);
3528 /* Don't move directly into a return register. */
3529 if (TREE_CODE (to
) == RESULT_DECL
3530 && (GET_CODE (to_rtx
) == REG
|| GET_CODE (to_rtx
) == PARALLEL
))
3535 temp
= expand_expr (from
, 0, GET_MODE (to_rtx
), 0);
3537 if (GET_CODE (to_rtx
) == PARALLEL
)
3538 emit_group_load (to_rtx
, temp
, int_size_in_bytes (TREE_TYPE (from
)),
3539 TYPE_ALIGN (TREE_TYPE (from
)) / BITS_PER_UNIT
);
3541 emit_move_insn (to_rtx
, temp
);
3543 preserve_temp_slots (to_rtx
);
3546 return want_value
? to_rtx
: NULL_RTX
;
3549 /* In case we are returning the contents of an object which overlaps
3550 the place the value is being stored, use a safe function when copying
3551 a value through a pointer into a structure value return block. */
3552 if (TREE_CODE (to
) == RESULT_DECL
&& TREE_CODE (from
) == INDIRECT_REF
3553 && current_function_returns_struct
3554 && !current_function_returns_pcc_struct
)
3559 size
= expr_size (from
);
3560 from_rtx
= expand_expr (from
, NULL_RTX
, VOIDmode
,
3561 EXPAND_MEMORY_USE_DONT
);
3563 /* Copy the rights of the bitmap. */
3564 if (current_function_check_memory_usage
)
3565 emit_library_call (chkr_copy_bitmap_libfunc
, 1, VOIDmode
, 3,
3566 XEXP (to_rtx
, 0), Pmode
,
3567 XEXP (from_rtx
, 0), Pmode
,
3568 convert_to_mode (TYPE_MODE (sizetype
),
3569 size
, TREE_UNSIGNED (sizetype
)),
3570 TYPE_MODE (sizetype
));
3572 #ifdef TARGET_MEM_FUNCTIONS
3573 emit_library_call (memcpy_libfunc
, 0,
3574 VOIDmode
, 3, XEXP (to_rtx
, 0), Pmode
,
3575 XEXP (from_rtx
, 0), Pmode
,
3576 convert_to_mode (TYPE_MODE (sizetype
),
3577 size
, TREE_UNSIGNED (sizetype
)),
3578 TYPE_MODE (sizetype
));
3580 emit_library_call (bcopy_libfunc
, 0,
3581 VOIDmode
, 3, XEXP (from_rtx
, 0), Pmode
,
3582 XEXP (to_rtx
, 0), Pmode
,
3583 convert_to_mode (TYPE_MODE (integer_type_node
),
3584 size
, TREE_UNSIGNED (integer_type_node
)),
3585 TYPE_MODE (integer_type_node
));
3588 preserve_temp_slots (to_rtx
);
3591 return want_value
? to_rtx
: NULL_RTX
;
3594 /* Compute FROM and store the value in the rtx we got. */
3597 result
= store_expr (from
, to_rtx
, want_value
);
3598 preserve_temp_slots (result
);
3601 return want_value
? result
: NULL_RTX
;
3604 /* Generate code for computing expression EXP,
3605 and storing the value into TARGET.
3606 TARGET may contain a QUEUED rtx.
3608 If WANT_VALUE is nonzero, return a copy of the value
3609 not in TARGET, so that we can be sure to use the proper
3610 value in a containing expression even if TARGET has something
3611 else stored in it. If possible, we copy the value through a pseudo
3612 and return that pseudo. Or, if the value is constant, we try to
3613 return the constant. In some cases, we return a pseudo
3614 copied *from* TARGET.
3616 If the mode is BLKmode then we may return TARGET itself.
3617 It turns out that in BLKmode it doesn't cause a problem.
3618 because C has no operators that could combine two different
3619 assignments into the same BLKmode object with different values
3620 with no sequence point. Will other languages need this to
3623 If WANT_VALUE is 0, we return NULL, to make sure
3624 to catch quickly any cases where the caller uses the value
3625 and fails to set WANT_VALUE. */
3628 store_expr (exp
, target
, want_value
)
3630 register rtx target
;
3634 int dont_return_target
= 0;
3636 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
3638 /* Perform first part of compound expression, then assign from second
3640 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
3642 return store_expr (TREE_OPERAND (exp
, 1), target
, want_value
);
3644 else if (TREE_CODE (exp
) == COND_EXPR
&& GET_MODE (target
) == BLKmode
)
3646 /* For conditional expression, get safe form of the target. Then
3647 test the condition, doing the appropriate assignment on either
3648 side. This avoids the creation of unnecessary temporaries.
3649 For non-BLKmode, it is more efficient not to do this. */
3651 rtx lab1
= gen_label_rtx (), lab2
= gen_label_rtx ();
3654 target
= protect_from_queue (target
, 1);
3656 do_pending_stack_adjust ();
3658 jumpifnot (TREE_OPERAND (exp
, 0), lab1
);
3659 start_cleanup_deferral ();
3660 store_expr (TREE_OPERAND (exp
, 1), target
, 0);
3661 end_cleanup_deferral ();
3663 emit_jump_insn (gen_jump (lab2
));
3666 start_cleanup_deferral ();
3667 store_expr (TREE_OPERAND (exp
, 2), target
, 0);
3668 end_cleanup_deferral ();
3673 return want_value
? target
: NULL_RTX
;
3675 else if (queued_subexp_p (target
))
3676 /* If target contains a postincrement, let's not risk
3677 using it as the place to generate the rhs. */
3679 if (GET_MODE (target
) != BLKmode
&& GET_MODE (target
) != VOIDmode
)
3681 /* Expand EXP into a new pseudo. */
3682 temp
= gen_reg_rtx (GET_MODE (target
));
3683 temp
= expand_expr (exp
, temp
, GET_MODE (target
), 0);
3686 temp
= expand_expr (exp
, NULL_RTX
, GET_MODE (target
), 0);
3688 /* If target is volatile, ANSI requires accessing the value
3689 *from* the target, if it is accessed. So make that happen.
3690 In no case return the target itself. */
3691 if (! MEM_VOLATILE_P (target
) && want_value
)
3692 dont_return_target
= 1;
3694 else if (want_value
&& GET_CODE (target
) == MEM
&& ! MEM_VOLATILE_P (target
)
3695 && GET_MODE (target
) != BLKmode
)
3696 /* If target is in memory and caller wants value in a register instead,
3697 arrange that. Pass TARGET as target for expand_expr so that,
3698 if EXP is another assignment, WANT_VALUE will be nonzero for it.
3699 We know expand_expr will not use the target in that case.
3700 Don't do this if TARGET is volatile because we are supposed
3701 to write it and then read it. */
3703 temp
= expand_expr (exp
, target
, GET_MODE (target
), 0);
3704 if (GET_MODE (temp
) != BLKmode
&& GET_MODE (temp
) != VOIDmode
)
3705 temp
= copy_to_reg (temp
);
3706 dont_return_target
= 1;
3708 else if (GET_CODE (target
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (target
))
3709 /* If this is an scalar in a register that is stored in a wider mode
3710 than the declared mode, compute the result into its declared mode
3711 and then convert to the wider mode. Our value is the computed
3714 /* If we don't want a value, we can do the conversion inside EXP,
3715 which will often result in some optimizations. Do the conversion
3716 in two steps: first change the signedness, if needed, then
3717 the extend. But don't do this if the type of EXP is a subtype
3718 of something else since then the conversion might involve
3719 more than just converting modes. */
3720 if (! want_value
&& INTEGRAL_TYPE_P (TREE_TYPE (exp
))
3721 && TREE_TYPE (TREE_TYPE (exp
)) == 0)
3723 if (TREE_UNSIGNED (TREE_TYPE (exp
))
3724 != SUBREG_PROMOTED_UNSIGNED_P (target
))
3727 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target
),
3731 exp
= convert (type_for_mode (GET_MODE (SUBREG_REG (target
)),
3732 SUBREG_PROMOTED_UNSIGNED_P (target
)),
3736 temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
3738 /* If TEMP is a volatile MEM and we want a result value, make
3739 the access now so it gets done only once. Likewise if
3740 it contains TARGET. */
3741 if (GET_CODE (temp
) == MEM
&& want_value
3742 && (MEM_VOLATILE_P (temp
)
3743 || reg_mentioned_p (SUBREG_REG (target
), XEXP (temp
, 0))))
3744 temp
= copy_to_reg (temp
);
3746 /* If TEMP is a VOIDmode constant, use convert_modes to make
3747 sure that we properly convert it. */
3748 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
)
3749 temp
= convert_modes (GET_MODE (SUBREG_REG (target
)),
3750 TYPE_MODE (TREE_TYPE (exp
)), temp
,
3751 SUBREG_PROMOTED_UNSIGNED_P (target
));
3753 convert_move (SUBREG_REG (target
), temp
,
3754 SUBREG_PROMOTED_UNSIGNED_P (target
));
3756 /* If we promoted a constant, change the mode back down to match
3757 target. Otherwise, the caller might get confused by a result whose
3758 mode is larger than expected. */
3760 if (want_value
&& GET_MODE (temp
) != GET_MODE (target
)
3761 && GET_MODE (temp
) != VOIDmode
)
3763 temp
= gen_rtx_SUBREG (GET_MODE (target
), temp
, 0);
3764 SUBREG_PROMOTED_VAR_P (temp
) = 1;
3765 SUBREG_PROMOTED_UNSIGNED_P (temp
)
3766 = SUBREG_PROMOTED_UNSIGNED_P (target
);
3769 return want_value
? temp
: NULL_RTX
;
3773 temp
= expand_expr (exp
, target
, GET_MODE (target
), 0);
3774 /* Return TARGET if it's a specified hardware register.
3775 If TARGET is a volatile mem ref, either return TARGET
3776 or return a reg copied *from* TARGET; ANSI requires this.
3778 Otherwise, if TEMP is not TARGET, return TEMP
3779 if it is constant (for efficiency),
3780 or if we really want the correct value. */
3781 if (!(target
&& GET_CODE (target
) == REG
3782 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)
3783 && !(GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
))
3784 && ! rtx_equal_p (temp
, target
)
3785 && (CONSTANT_P (temp
) || want_value
))
3786 dont_return_target
= 1;
3789 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
3790 the same as that of TARGET, adjust the constant. This is needed, for
3791 example, in case it is a CONST_DOUBLE and we want only a word-sized
3793 if (CONSTANT_P (temp
) && GET_MODE (temp
) == VOIDmode
3794 && TREE_CODE (exp
) != ERROR_MARK
3795 && GET_MODE (target
) != TYPE_MODE (TREE_TYPE (exp
)))
3796 temp
= convert_modes (GET_MODE (target
), TYPE_MODE (TREE_TYPE (exp
)),
3797 temp
, TREE_UNSIGNED (TREE_TYPE (exp
)));
3799 if (current_function_check_memory_usage
3800 && GET_CODE (target
) == MEM
3801 && AGGREGATE_TYPE_P (TREE_TYPE (exp
)))
3803 if (GET_CODE (temp
) == MEM
)
3804 emit_library_call (chkr_copy_bitmap_libfunc
, 1, VOIDmode
, 3,
3805 XEXP (target
, 0), Pmode
,
3806 XEXP (temp
, 0), Pmode
,
3807 expr_size (exp
), TYPE_MODE (sizetype
));
3809 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
3810 XEXP (target
, 0), Pmode
,
3811 expr_size (exp
), TYPE_MODE (sizetype
),
3812 GEN_INT (MEMORY_USE_WO
),
3813 TYPE_MODE (integer_type_node
));
3816 /* If value was not generated in the target, store it there.
3817 Convert the value to TARGET's type first if nec. */
3818 /* If TEMP and TARGET compare equal according to rtx_equal_p, but
3819 one or both of them are volatile memory refs, we have to distinguish
3821 - expand_expr has used TARGET. In this case, we must not generate
3822 another copy. This can be detected by TARGET being equal according
3824 - expand_expr has not used TARGET - that means that the source just
3825 happens to have the same RTX form. Since temp will have been created
3826 by expand_expr, it will compare unequal according to == .
3827 We must generate a copy in this case, to reach the correct number
3828 of volatile memory references. */
3830 if ((! rtx_equal_p (temp
, target
)
3831 || (temp
!= target
&& (side_effects_p (temp
)
3832 || side_effects_p (target
))))
3833 && TREE_CODE (exp
) != ERROR_MARK
)
3835 target
= protect_from_queue (target
, 1);
3836 if (GET_MODE (temp
) != GET_MODE (target
)
3837 && GET_MODE (temp
) != VOIDmode
)
3839 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (exp
));
3840 if (dont_return_target
)
3842 /* In this case, we will return TEMP,
3843 so make sure it has the proper mode.
3844 But don't forget to store the value into TARGET. */
3845 temp
= convert_to_mode (GET_MODE (target
), temp
, unsignedp
);
3846 emit_move_insn (target
, temp
);
3849 convert_move (target
, temp
, unsignedp
);
3852 else if (GET_MODE (temp
) == BLKmode
&& TREE_CODE (exp
) == STRING_CST
)
3854 /* Handle copying a string constant into an array.
3855 The string constant may be shorter than the array.
3856 So copy just the string's actual length, and clear the rest. */
3860 /* Get the size of the data type of the string,
3861 which is actually the size of the target. */
3862 size
= expr_size (exp
);
3863 if (GET_CODE (size
) == CONST_INT
3864 && INTVAL (size
) < TREE_STRING_LENGTH (exp
))
3865 emit_block_move (target
, temp
, size
,
3866 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
3869 /* Compute the size of the data to copy from the string. */
3871 = size_binop (MIN_EXPR
,
3872 make_tree (sizetype
, size
),
3873 size_int (TREE_STRING_LENGTH (exp
)));
3874 rtx copy_size_rtx
= expand_expr (copy_size
, NULL_RTX
,
3878 /* Copy that much. */
3879 emit_block_move (target
, temp
, copy_size_rtx
,
3880 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
3882 /* Figure out how much is left in TARGET that we have to clear.
3883 Do all calculations in ptr_mode. */
3885 addr
= XEXP (target
, 0);
3886 addr
= convert_modes (ptr_mode
, Pmode
, addr
, 1);
3888 if (GET_CODE (copy_size_rtx
) == CONST_INT
)
3890 addr
= plus_constant (addr
, TREE_STRING_LENGTH (exp
));
3891 size
= plus_constant (size
, - TREE_STRING_LENGTH (exp
));
3895 addr
= force_reg (ptr_mode
, addr
);
3896 addr
= expand_binop (ptr_mode
, add_optab
, addr
,
3897 copy_size_rtx
, NULL_RTX
, 0,
3900 size
= expand_binop (ptr_mode
, sub_optab
, size
,
3901 copy_size_rtx
, NULL_RTX
, 0,
3904 label
= gen_label_rtx ();
3905 emit_cmp_and_jump_insns (size
, const0_rtx
, LT
, NULL_RTX
,
3906 GET_MODE (size
), 0, 0, label
);
3909 if (size
!= const0_rtx
)
3911 /* Be sure we can write on ADDR. */
3912 if (current_function_check_memory_usage
)
3913 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
3915 size
, TYPE_MODE (sizetype
),
3916 GEN_INT (MEMORY_USE_WO
),
3917 TYPE_MODE (integer_type_node
));
3918 #ifdef TARGET_MEM_FUNCTIONS
3919 emit_library_call (memset_libfunc
, 0, VOIDmode
, 3,
3921 const0_rtx
, TYPE_MODE (integer_type_node
),
3922 convert_to_mode (TYPE_MODE (sizetype
),
3924 TREE_UNSIGNED (sizetype
)),
3925 TYPE_MODE (sizetype
));
3927 emit_library_call (bzero_libfunc
, 0, VOIDmode
, 2,
3929 convert_to_mode (TYPE_MODE (integer_type_node
),
3931 TREE_UNSIGNED (integer_type_node
)),
3932 TYPE_MODE (integer_type_node
));
3940 /* Handle calls that return values in multiple non-contiguous locations.
3941 The Irix 6 ABI has examples of this. */
3942 else if (GET_CODE (target
) == PARALLEL
)
3943 emit_group_load (target
, temp
, int_size_in_bytes (TREE_TYPE (exp
)),
3944 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
3945 else if (GET_MODE (temp
) == BLKmode
)
3946 emit_block_move (target
, temp
, expr_size (exp
),
3947 TYPE_ALIGN (TREE_TYPE (exp
)) / BITS_PER_UNIT
);
3949 emit_move_insn (target
, temp
);
3952 /* If we don't want a value, return NULL_RTX. */
3956 /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
3957 ??? The latter test doesn't seem to make sense. */
3958 else if (dont_return_target
&& GET_CODE (temp
) != MEM
)
3961 /* Return TARGET itself if it is a hard register. */
3962 else if (want_value
&& GET_MODE (target
) != BLKmode
3963 && ! (GET_CODE (target
) == REG
3964 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3965 return copy_to_reg (target
);
3971 /* Return 1 if EXP just contains zeros. */
3979 switch (TREE_CODE (exp
))
3983 case NON_LVALUE_EXPR
:
3984 return is_zeros_p (TREE_OPERAND (exp
, 0));
3987 return integer_zerop (exp
);
3991 is_zeros_p (TREE_REALPART (exp
)) && is_zeros_p (TREE_IMAGPART (exp
));
3994 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp
), dconst0
);
3997 if (TREE_TYPE (exp
) && TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
3998 return CONSTRUCTOR_ELTS (exp
) == NULL_TREE
;
3999 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
4000 if (! is_zeros_p (TREE_VALUE (elt
)))
4010 /* Return 1 if EXP contains mostly (3/4) zeros. */
4013 mostly_zeros_p (exp
)
4016 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4018 int elts
= 0, zeros
= 0;
4019 tree elt
= CONSTRUCTOR_ELTS (exp
);
4020 if (TREE_TYPE (exp
) && TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
4022 /* If there are no ranges of true bits, it is all zero. */
4023 return elt
== NULL_TREE
;
4025 for (; elt
; elt
= TREE_CHAIN (elt
))
4027 /* We do not handle the case where the index is a RANGE_EXPR,
4028 so the statistic will be somewhat inaccurate.
4029 We do make a more accurate count in store_constructor itself,
4030 so since this function is only used for nested array elements,
4031 this should be close enough. */
4032 if (mostly_zeros_p (TREE_VALUE (elt
)))
4037 return 4 * zeros
>= 3 * elts
;
4040 return is_zeros_p (exp
);
4043 /* Helper function for store_constructor.
4044 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4045 TYPE is the type of the CONSTRUCTOR, not the element type.
4046 ALIGN and CLEARED are as for store_constructor.
4048 This provides a recursive shortcut back to store_constructor when it isn't
4049 necessary to go through store_field. This is so that we can pass through
4050 the cleared field to let store_constructor know that we may not have to
4051 clear a substructure if the outer structure has already been cleared. */
4054 store_constructor_field (target
, bitsize
, bitpos
,
4055 mode
, exp
, type
, align
, cleared
)
4057 unsigned HOST_WIDE_INT bitsize
;
4058 HOST_WIDE_INT bitpos
;
4059 enum machine_mode mode
;
4064 if (TREE_CODE (exp
) == CONSTRUCTOR
4065 && bitpos
% BITS_PER_UNIT
== 0
4066 /* If we have a non-zero bitpos for a register target, then we just
4067 let store_field do the bitfield handling. This is unlikely to
4068 generate unnecessary clear instructions anyways. */
4069 && (bitpos
== 0 || GET_CODE (target
) == MEM
))
4073 = change_address (target
,
4074 GET_MODE (target
) == BLKmode
4076 % GET_MODE_ALIGNMENT (GET_MODE (target
)))
4077 ? BLKmode
: VOIDmode
,
4078 plus_constant (XEXP (target
, 0),
4079 bitpos
/ BITS_PER_UNIT
));
4080 store_constructor (exp
, target
, align
, cleared
, bitsize
/ BITS_PER_UNIT
);
4083 store_field (target
, bitsize
, bitpos
, mode
, exp
, VOIDmode
, 0,
4084 (align
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
,
4085 int_size_in_bytes (type
), 0);
4088 /* Store the value of constructor EXP into the rtx TARGET.
4089 TARGET is either a REG or a MEM.
4090 ALIGN is the maximum known alignment for TARGET, in bits.
4091 CLEARED is true if TARGET is known to have been zero'd.
4092 SIZE is the number of bytes of TARGET we are allowed to modify: this
4093 may not be the same as the size of EXP if we are assigning to a field
4094 which has been packed to exclude padding bits. */
4097 store_constructor (exp
, target
, align
, cleared
, size
)
4102 unsigned HOST_WIDE_INT size
;
4104 tree type
= TREE_TYPE (exp
);
4105 #ifdef WORD_REGISTER_OPERATIONS
4106 rtx exp_size
= expr_size (exp
);
4109 /* We know our target cannot conflict, since safe_from_p has been called. */
4111 /* Don't try copying piece by piece into a hard register
4112 since that is vulnerable to being clobbered by EXP.
4113 Instead, construct in a pseudo register and then copy it all. */
4114 if (GET_CODE (target
) == REG
&& REGNO (target
) < FIRST_PSEUDO_REGISTER
)
4116 rtx temp
= gen_reg_rtx (GET_MODE (target
));
4117 store_constructor (exp
, temp
, align
, cleared
, size
);
4118 emit_move_insn (target
, temp
);
4123 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4124 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4128 /* Inform later passes that the whole union value is dead. */
4129 if ((TREE_CODE (type
) == UNION_TYPE
4130 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4133 emit_insn (gen_rtx_CLOBBER (VOIDmode
, target
));
4135 /* If the constructor is empty, clear the union. */
4136 if (! CONSTRUCTOR_ELTS (exp
) && ! cleared
)
4137 clear_storage (target
, expr_size (exp
),
4138 TYPE_ALIGN (type
) / BITS_PER_UNIT
);
4141 /* If we are building a static constructor into a register,
4142 set the initial value as zero so we can fold the value into
4143 a constant. But if more than one register is involved,
4144 this probably loses. */
4145 else if (GET_CODE (target
) == REG
&& TREE_STATIC (exp
)
4146 && GET_MODE_SIZE (GET_MODE (target
)) <= UNITS_PER_WORD
)
4149 emit_move_insn (target
, CONST0_RTX (GET_MODE (target
)));
4154 /* If the constructor has fewer fields than the structure
4155 or if we are initializing the structure to mostly zeros,
4156 clear the whole structure first. */
4158 && ((list_length (CONSTRUCTOR_ELTS (exp
))
4159 != fields_length (type
))
4160 || mostly_zeros_p (exp
)))
4163 clear_storage (target
, GEN_INT (size
),
4164 (align
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
4169 /* Inform later passes that the old value is dead. */
4170 emit_insn (gen_rtx_CLOBBER (VOIDmode
, target
));
4172 /* Store each element of the constructor into
4173 the corresponding field of TARGET. */
4175 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
4177 register tree field
= TREE_PURPOSE (elt
);
4178 #ifdef WORD_REGISTER_OPERATIONS
4179 tree value
= TREE_VALUE (elt
);
4181 register enum machine_mode mode
;
4182 HOST_WIDE_INT bitsize
;
4183 HOST_WIDE_INT bitpos
= 0;
4186 rtx to_rtx
= target
;
4188 /* Just ignore missing fields.
4189 We cleared the whole structure, above,
4190 if any fields are missing. */
4194 if (cleared
&& is_zeros_p (TREE_VALUE (elt
)))
4197 if (host_integerp (DECL_SIZE (field
), 1))
4198 bitsize
= tree_low_cst (DECL_SIZE (field
), 1);
4202 unsignedp
= TREE_UNSIGNED (field
);
4203 mode
= DECL_MODE (field
);
4204 if (DECL_BIT_FIELD (field
))
4207 offset
= DECL_FIELD_OFFSET (field
);
4208 if (host_integerp (offset
, 0)
4209 && host_integerp (bit_position (field
), 0))
4211 bitpos
= int_bit_position (field
);
4215 bitpos
= tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 0);
4221 if (contains_placeholder_p (offset
))
4222 offset
= build (WITH_RECORD_EXPR
, bitsizetype
,
4223 offset
, make_tree (TREE_TYPE (exp
), target
));
4225 offset
= size_binop (EXACT_DIV_EXPR
, offset
, bitsize_unit_node
);
4226 offset
= convert (sizetype
, offset
);
4228 offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, 0);
4229 if (GET_CODE (to_rtx
) != MEM
)
4232 if (GET_MODE (offset_rtx
) != ptr_mode
)
4234 #ifdef POINTERS_EXTEND_UNSIGNED
4235 offset_rtx
= convert_memory_address (ptr_mode
, offset_rtx
);
4237 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
4242 = change_address (to_rtx
, VOIDmode
,
4243 gen_rtx_PLUS (ptr_mode
, XEXP (to_rtx
, 0),
4244 force_reg (ptr_mode
,
4248 if (TREE_READONLY (field
))
4250 if (GET_CODE (to_rtx
) == MEM
)
4251 to_rtx
= copy_rtx (to_rtx
);
4253 RTX_UNCHANGING_P (to_rtx
) = 1;
4256 #ifdef WORD_REGISTER_OPERATIONS
4257 /* If this initializes a field that is smaller than a word, at the
4258 start of a word, try to widen it to a full word.
4259 This special case allows us to output C++ member function
4260 initializations in a form that the optimizers can understand. */
4261 if (GET_CODE (target
) == REG
4262 && bitsize
< BITS_PER_WORD
4263 && bitpos
% BITS_PER_WORD
== 0
4264 && GET_MODE_CLASS (mode
) == MODE_INT
4265 && TREE_CODE (value
) == INTEGER_CST
4266 && GET_CODE (exp_size
) == CONST_INT
4267 && bitpos
+ BITS_PER_WORD
<= INTVAL (exp_size
) * BITS_PER_UNIT
)
4269 tree type
= TREE_TYPE (value
);
4270 if (TYPE_PRECISION (type
) < BITS_PER_WORD
)
4272 type
= type_for_size (BITS_PER_WORD
, TREE_UNSIGNED (type
));
4273 value
= convert (type
, value
);
4275 if (BYTES_BIG_ENDIAN
)
4277 = fold (build (LSHIFT_EXPR
, type
, value
,
4278 build_int_2 (BITS_PER_WORD
- bitsize
, 0)));
4279 bitsize
= BITS_PER_WORD
;
4283 store_constructor_field (to_rtx
, bitsize
, bitpos
, mode
,
4284 TREE_VALUE (elt
), type
,
4286 DECL_ALIGN (TREE_PURPOSE (elt
))),
4290 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4295 tree domain
= TYPE_DOMAIN (type
);
4296 HOST_WIDE_INT minelt
= TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain
));
4297 HOST_WIDE_INT maxelt
= TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain
));
4298 tree elttype
= TREE_TYPE (type
);
4300 /* If the constructor has fewer elements than the array,
4301 clear the whole array first. Similarly if this is
4302 static constructor of a non-BLKmode object. */
4303 if (cleared
|| (GET_CODE (target
) == REG
&& TREE_STATIC (exp
)))
4307 HOST_WIDE_INT count
= 0, zero_count
= 0;
4309 /* This loop is a more accurate version of the loop in
4310 mostly_zeros_p (it handles RANGE_EXPR in an index).
4311 It is also needed to check for missing elements. */
4312 for (elt
= CONSTRUCTOR_ELTS (exp
);
4314 elt
= TREE_CHAIN (elt
))
4316 tree index
= TREE_PURPOSE (elt
);
4317 HOST_WIDE_INT this_node_count
;
4318 if (index
!= NULL_TREE
&& TREE_CODE (index
) == RANGE_EXPR
)
4320 tree lo_index
= TREE_OPERAND (index
, 0);
4321 tree hi_index
= TREE_OPERAND (index
, 1);
4323 if (TREE_CODE (lo_index
) != INTEGER_CST
4324 || TREE_CODE (hi_index
) != INTEGER_CST
)
4329 this_node_count
= (TREE_INT_CST_LOW (hi_index
)
4330 - TREE_INT_CST_LOW (lo_index
) + 1);
4333 this_node_count
= 1;
4334 count
+= this_node_count
;
4335 if (mostly_zeros_p (TREE_VALUE (elt
)))
4336 zero_count
+= this_node_count
;
4338 /* Clear the entire array first if there are any missing elements,
4339 or if the incidence of zero elements is >= 75%. */
4340 if (count
< maxelt
- minelt
+ 1
4341 || 4 * zero_count
>= 3 * count
)
4344 if (need_to_clear
&& size
> 0)
4347 clear_storage (target
, GEN_INT (size
),
4348 (align
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
4352 /* Inform later passes that the old value is dead. */
4353 emit_insn (gen_rtx_CLOBBER (VOIDmode
, target
));
4355 /* Store each element of the constructor into
4356 the corresponding element of TARGET, determined
4357 by counting the elements. */
4358 for (elt
= CONSTRUCTOR_ELTS (exp
), i
= 0;
4360 elt
= TREE_CHAIN (elt
), i
++)
4362 register enum machine_mode mode
;
4366 tree value
= TREE_VALUE (elt
);
4367 unsigned int align
= TYPE_ALIGN (TREE_TYPE (value
));
4368 tree index
= TREE_PURPOSE (elt
);
4369 rtx xtarget
= target
;
4371 if (cleared
&& is_zeros_p (value
))
4374 unsignedp
= TREE_UNSIGNED (elttype
);
4375 mode
= TYPE_MODE (elttype
);
4376 if (mode
== BLKmode
)
4378 if (TREE_CODE (TYPE_SIZE (elttype
)) == INTEGER_CST
4379 && TREE_INT_CST_HIGH (TYPE_SIZE (elttype
)) == 0)
4380 bitsize
= TREE_INT_CST_LOW (TYPE_SIZE (elttype
));
4385 bitsize
= GET_MODE_BITSIZE (mode
);
4387 if (index
!= NULL_TREE
&& TREE_CODE (index
) == RANGE_EXPR
)
4389 tree lo_index
= TREE_OPERAND (index
, 0);
4390 tree hi_index
= TREE_OPERAND (index
, 1);
4391 rtx index_r
, pos_rtx
, addr
, hi_r
, loop_top
, loop_end
;
4392 struct nesting
*loop
;
4393 HOST_WIDE_INT lo
, hi
, count
;
4396 /* If the range is constant and "small", unroll the loop. */
4397 if (TREE_CODE (lo_index
) == INTEGER_CST
4398 && TREE_CODE (hi_index
) == INTEGER_CST
4399 && (lo
= TREE_INT_CST_LOW (lo_index
),
4400 hi
= TREE_INT_CST_LOW (hi_index
),
4401 count
= hi
- lo
+ 1,
4402 (GET_CODE (target
) != MEM
4404 || (TREE_CODE (TYPE_SIZE (elttype
)) == INTEGER_CST
4405 && TREE_INT_CST_LOW (TYPE_SIZE (elttype
)) * count
4408 lo
-= minelt
; hi
-= minelt
;
4409 for (; lo
<= hi
; lo
++)
4411 bitpos
= lo
* TREE_INT_CST_LOW (TYPE_SIZE (elttype
));
4412 store_constructor_field (target
, bitsize
, bitpos
, mode
,
4413 value
, type
, align
, cleared
);
4418 hi_r
= expand_expr (hi_index
, NULL_RTX
, VOIDmode
, 0);
4419 loop_top
= gen_label_rtx ();
4420 loop_end
= gen_label_rtx ();
4422 unsignedp
= TREE_UNSIGNED (domain
);
4424 index
= build_decl (VAR_DECL
, NULL_TREE
, domain
);
4426 DECL_RTL (index
) = index_r
4427 = gen_reg_rtx (promote_mode (domain
, DECL_MODE (index
),
4430 if (TREE_CODE (value
) == SAVE_EXPR
4431 && SAVE_EXPR_RTL (value
) == 0)
4433 /* Make sure value gets expanded once before the
4435 expand_expr (value
, const0_rtx
, VOIDmode
, 0);
4438 store_expr (lo_index
, index_r
, 0);
4439 loop
= expand_start_loop (0);
4441 /* Assign value to element index. */
4443 = convert (ssizetype
,
4444 fold (build (MINUS_EXPR
, TREE_TYPE (index
),
4445 index
, TYPE_MIN_VALUE (domain
))));
4446 position
= size_binop (MULT_EXPR
, position
,
4448 TYPE_SIZE_UNIT (elttype
)));
4450 pos_rtx
= expand_expr (position
, 0, VOIDmode
, 0);
4451 addr
= gen_rtx_PLUS (Pmode
, XEXP (target
, 0), pos_rtx
);
4452 xtarget
= change_address (target
, mode
, addr
);
4453 if (TREE_CODE (value
) == CONSTRUCTOR
)
4454 store_constructor (value
, xtarget
, align
, cleared
,
4455 bitsize
/ BITS_PER_UNIT
);
4457 store_expr (value
, xtarget
, 0);
4459 expand_exit_loop_if_false (loop
,
4460 build (LT_EXPR
, integer_type_node
,
4463 expand_increment (build (PREINCREMENT_EXPR
,
4465 index
, integer_one_node
), 0, 0);
4467 emit_label (loop_end
);
4470 else if ((index
!= 0 && TREE_CODE (index
) != INTEGER_CST
)
4471 || TREE_CODE (TYPE_SIZE (elttype
)) != INTEGER_CST
)
4477 index
= ssize_int (1);
4480 index
= convert (ssizetype
,
4481 fold (build (MINUS_EXPR
, index
,
4482 TYPE_MIN_VALUE (domain
))));
4483 position
= size_binop (MULT_EXPR
, index
,
4485 TYPE_SIZE_UNIT (elttype
)));
4486 pos_rtx
= expand_expr (position
, 0, VOIDmode
, 0);
4487 addr
= gen_rtx_PLUS (Pmode
, XEXP (target
, 0), pos_rtx
);
4488 xtarget
= change_address (target
, mode
, addr
);
4489 store_expr (value
, xtarget
, 0);
4494 bitpos
= ((TREE_INT_CST_LOW (index
) - minelt
)
4495 * TREE_INT_CST_LOW (TYPE_SIZE (elttype
)));
4497 bitpos
= (i
* TREE_INT_CST_LOW (TYPE_SIZE (elttype
)));
4498 store_constructor_field (target
, bitsize
, bitpos
, mode
, value
,
4499 type
, align
, cleared
);
4503 /* set constructor assignments */
4504 else if (TREE_CODE (type
) == SET_TYPE
)
4506 tree elt
= CONSTRUCTOR_ELTS (exp
);
4507 int nbytes
= int_size_in_bytes (type
), nbits
;
4508 tree domain
= TYPE_DOMAIN (type
);
4509 tree domain_min
, domain_max
, bitlength
;
4511 /* The default implementation strategy is to extract the constant
4512 parts of the constructor, use that to initialize the target,
4513 and then "or" in whatever non-constant ranges we need in addition.
4515 If a large set is all zero or all ones, it is
4516 probably better to set it using memset (if available) or bzero.
4517 Also, if a large set has just a single range, it may also be
4518 better to first clear all the first clear the set (using
4519 bzero/memset), and set the bits we want. */
4521 /* Check for all zeros. */
4522 if (elt
== NULL_TREE
&& size
> 0)
4525 clear_storage (target
, GEN_INT (size
),
4526 TYPE_ALIGN (type
) / BITS_PER_UNIT
);
4530 domain_min
= convert (sizetype
, TYPE_MIN_VALUE (domain
));
4531 domain_max
= convert (sizetype
, TYPE_MAX_VALUE (domain
));
4532 bitlength
= size_binop (PLUS_EXPR
,
4533 size_diffop (domain_max
, domain_min
),
4536 if (nbytes
< 0 || TREE_CODE (bitlength
) != INTEGER_CST
)
4538 nbits
= TREE_INT_CST_LOW (bitlength
);
4540 /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4541 are "complicated" (more than one range), initialize (the
4542 constant parts) by copying from a constant. */
4543 if (GET_MODE (target
) != BLKmode
|| nbits
<= 2 * BITS_PER_WORD
4544 || (nbytes
<= 32 && TREE_CHAIN (elt
) != NULL_TREE
))
4546 int set_word_size
= TYPE_ALIGN (TREE_TYPE (exp
));
4547 enum machine_mode mode
= mode_for_size (set_word_size
, MODE_INT
, 1);
4548 char *bit_buffer
= (char *) alloca (nbits
);
4549 HOST_WIDE_INT word
= 0;
4552 int offset
= 0; /* In bytes from beginning of set. */
4553 elt
= get_set_constructor_bits (exp
, bit_buffer
, nbits
);
4556 if (bit_buffer
[ibit
])
4558 if (BYTES_BIG_ENDIAN
)
4559 word
|= (1 << (set_word_size
- 1 - bit_pos
));
4561 word
|= 1 << bit_pos
;
4564 if (bit_pos
>= set_word_size
|| ibit
== nbits
)
4566 if (word
!= 0 || ! cleared
)
4568 rtx datum
= GEN_INT (word
);
4570 /* The assumption here is that it is safe to use
4571 XEXP if the set is multi-word, but not if
4572 it's single-word. */
4573 if (GET_CODE (target
) == MEM
)
4575 to_rtx
= plus_constant (XEXP (target
, 0), offset
);
4576 to_rtx
= change_address (target
, mode
, to_rtx
);
4578 else if (offset
== 0)
4582 emit_move_insn (to_rtx
, datum
);
4588 offset
+= set_word_size
/ BITS_PER_UNIT
;
4594 /* Don't bother clearing storage if the set is all ones. */
4595 if (TREE_CHAIN (elt
) != NULL_TREE
4596 || (TREE_PURPOSE (elt
) == NULL_TREE
4598 : (TREE_CODE (TREE_VALUE (elt
)) != INTEGER_CST
4599 || TREE_CODE (TREE_PURPOSE (elt
)) != INTEGER_CST
4600 || ((HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (elt
))
4601 - (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_PURPOSE (elt
)) + 1
4603 clear_storage (target
, expr_size (exp
),
4604 TYPE_ALIGN (type
) / BITS_PER_UNIT
);
4607 for (; elt
!= NULL_TREE
; elt
= TREE_CHAIN (elt
))
4609 /* start of range of element or NULL */
4610 tree startbit
= TREE_PURPOSE (elt
);
4611 /* end of range of element, or element value */
4612 tree endbit
= TREE_VALUE (elt
);
4613 #ifdef TARGET_MEM_FUNCTIONS
4614 HOST_WIDE_INT startb
, endb
;
4616 rtx bitlength_rtx
, startbit_rtx
, endbit_rtx
, targetx
;
4618 bitlength_rtx
= expand_expr (bitlength
,
4619 NULL_RTX
, MEM
, EXPAND_CONST_ADDRESS
);
4621 /* handle non-range tuple element like [ expr ] */
4622 if (startbit
== NULL_TREE
)
4624 startbit
= save_expr (endbit
);
4627 startbit
= convert (sizetype
, startbit
);
4628 endbit
= convert (sizetype
, endbit
);
4629 if (! integer_zerop (domain_min
))
4631 startbit
= size_binop (MINUS_EXPR
, startbit
, domain_min
);
4632 endbit
= size_binop (MINUS_EXPR
, endbit
, domain_min
);
4634 startbit_rtx
= expand_expr (startbit
, NULL_RTX
, MEM
,
4635 EXPAND_CONST_ADDRESS
);
4636 endbit_rtx
= expand_expr (endbit
, NULL_RTX
, MEM
,
4637 EXPAND_CONST_ADDRESS
);
4641 targetx
= assign_stack_temp (GET_MODE (target
),
4642 GET_MODE_SIZE (GET_MODE (target
)),
4644 emit_move_insn (targetx
, target
);
4646 else if (GET_CODE (target
) == MEM
)
4651 #ifdef TARGET_MEM_FUNCTIONS
4652 /* Optimization: If startbit and endbit are
4653 constants divisible by BITS_PER_UNIT,
4654 call memset instead. */
4655 if (TREE_CODE (startbit
) == INTEGER_CST
4656 && TREE_CODE (endbit
) == INTEGER_CST
4657 && (startb
= TREE_INT_CST_LOW (startbit
)) % BITS_PER_UNIT
== 0
4658 && (endb
= TREE_INT_CST_LOW (endbit
) + 1) % BITS_PER_UNIT
== 0)
4660 emit_library_call (memset_libfunc
, 0,
4662 plus_constant (XEXP (targetx
, 0),
4663 startb
/ BITS_PER_UNIT
),
4665 constm1_rtx
, TYPE_MODE (integer_type_node
),
4666 GEN_INT ((endb
- startb
) / BITS_PER_UNIT
),
4667 TYPE_MODE (sizetype
));
4672 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, "__setbits"),
4673 0, VOIDmode
, 4, XEXP (targetx
, 0), Pmode
,
4674 bitlength_rtx
, TYPE_MODE (sizetype
),
4675 startbit_rtx
, TYPE_MODE (sizetype
),
4676 endbit_rtx
, TYPE_MODE (sizetype
));
4679 emit_move_insn (target
, targetx
);
4687 /* Store the value of EXP (an expression tree)
4688 into a subfield of TARGET which has mode MODE and occupies
4689 BITSIZE bits, starting BITPOS bits from the start of TARGET.
4690 If MODE is VOIDmode, it means that we are storing into a bit-field.
4692 If VALUE_MODE is VOIDmode, return nothing in particular.
4693 UNSIGNEDP is not used in this case.
4695 Otherwise, return an rtx for the value stored. This rtx
4696 has mode VALUE_MODE if that is convenient to do.
4697 In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
4699 ALIGN is the alignment that TARGET is known to have, measured in bytes.
4700 TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.
4702 ALIAS_SET is the alias set for the destination. This value will
4703 (in general) be different from that for TARGET, since TARGET is a
4704 reference to the containing structure. */
4707 store_field (target
, bitsize
, bitpos
, mode
, exp
, value_mode
,
4708 unsignedp
, align
, total_size
, alias_set
)
4710 HOST_WIDE_INT bitsize
;
4711 HOST_WIDE_INT bitpos
;
4712 enum machine_mode mode
;
4714 enum machine_mode value_mode
;
4717 HOST_WIDE_INT total_size
;
4720 HOST_WIDE_INT width_mask
= 0;
4722 if (TREE_CODE (exp
) == ERROR_MARK
)
4725 if (bitsize
< HOST_BITS_PER_WIDE_INT
)
4726 width_mask
= ((HOST_WIDE_INT
) 1 << bitsize
) - 1;
4728 /* If we are storing into an unaligned field of an aligned union that is
4729 in a register, we may have the mode of TARGET being an integer mode but
4730 MODE == BLKmode. In that case, get an aligned object whose size and
4731 alignment are the same as TARGET and store TARGET into it (we can avoid
4732 the store if the field being stored is the entire width of TARGET). Then
4733 call ourselves recursively to store the field into a BLKmode version of
4734 that object. Finally, load from the object into TARGET. This is not
4735 very efficient in general, but should only be slightly more expensive
4736 than the otherwise-required unaligned accesses. Perhaps this can be
4737 cleaned up later. */
4740 && (GET_CODE (target
) == REG
|| GET_CODE (target
) == SUBREG
))
4742 rtx object
= assign_stack_temp (GET_MODE (target
),
4743 GET_MODE_SIZE (GET_MODE (target
)), 0);
4744 rtx blk_object
= copy_rtx (object
);
4746 MEM_SET_IN_STRUCT_P (object
, 1);
4747 MEM_SET_IN_STRUCT_P (blk_object
, 1);
4748 PUT_MODE (blk_object
, BLKmode
);
4750 if (bitsize
!= GET_MODE_BITSIZE (GET_MODE (target
)))
4751 emit_move_insn (object
, target
);
4753 store_field (blk_object
, bitsize
, bitpos
, mode
, exp
, VOIDmode
, 0,
4754 align
, total_size
, alias_set
);
4756 /* Even though we aren't returning target, we need to
4757 give it the updated value. */
4758 emit_move_insn (target
, object
);
4763 if (GET_CODE (target
) == CONCAT
)
4765 /* We're storing into a struct containing a single __complex. */
4769 return store_expr (exp
, target
, 0);
4772 /* If the structure is in a register or if the component
4773 is a bit field, we cannot use addressing to access it.
4774 Use bit-field techniques or SUBREG to store in it. */
4776 if (mode
== VOIDmode
4777 || (mode
!= BLKmode
&& ! direct_store
[(int) mode
]
4778 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
4779 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_FLOAT
)
4780 || GET_CODE (target
) == REG
4781 || GET_CODE (target
) == SUBREG
4782 /* If the field isn't aligned enough to store as an ordinary memref,
4783 store it as a bit field. */
4784 || (mode
!= BLKmode
&& SLOW_UNALIGNED_ACCESS (mode
, align
)
4785 && (align
* BITS_PER_UNIT
< GET_MODE_ALIGNMENT (mode
)
4786 || bitpos
% GET_MODE_ALIGNMENT (mode
)))
4787 || (mode
== BLKmode
&& SLOW_UNALIGNED_ACCESS (mode
, align
)
4788 && (TYPE_ALIGN (TREE_TYPE (exp
)) > align
* BITS_PER_UNIT
4789 || bitpos
% TYPE_ALIGN (TREE_TYPE (exp
)) != 0))
4790 /* If the RHS and field are a constant size and the size of the
4791 RHS isn't the same size as the bitfield, we must use bitfield
4794 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) == INTEGER_CST
4795 && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp
)), bitsize
) != 0))
4797 rtx temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
4799 /* If BITSIZE is narrower than the size of the type of EXP
4800 we will be narrowing TEMP. Normally, what's wanted are the
4801 low-order bits. However, if EXP's type is a record and this is
4802 big-endian machine, we want the upper BITSIZE bits. */
4803 if (BYTES_BIG_ENDIAN
&& GET_MODE_CLASS (GET_MODE (temp
)) == MODE_INT
4804 && bitsize
< GET_MODE_BITSIZE (GET_MODE (temp
))
4805 && TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
4806 temp
= expand_shift (RSHIFT_EXPR
, GET_MODE (temp
), temp
,
4807 size_int (GET_MODE_BITSIZE (GET_MODE (temp
))
4811 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
4813 if (mode
!= VOIDmode
&& mode
!= BLKmode
4814 && mode
!= TYPE_MODE (TREE_TYPE (exp
)))
4815 temp
= convert_modes (mode
, TYPE_MODE (TREE_TYPE (exp
)), temp
, 1);
4817 /* If the modes of TARGET and TEMP are both BLKmode, both
4818 must be in memory and BITPOS must be aligned on a byte
4819 boundary. If so, we simply do a block copy. */
4820 if (GET_MODE (target
) == BLKmode
&& GET_MODE (temp
) == BLKmode
)
4822 unsigned int exp_align
= expr_align (exp
) / BITS_PER_UNIT
;
4824 if (GET_CODE (target
) != MEM
|| GET_CODE (temp
) != MEM
4825 || bitpos
% BITS_PER_UNIT
!= 0)
4828 target
= change_address (target
, VOIDmode
,
4829 plus_constant (XEXP (target
, 0),
4830 bitpos
/ BITS_PER_UNIT
));
4832 /* Make sure that ALIGN is no stricter than the alignment of EXP. */
4833 align
= MIN (exp_align
, align
);
4835 /* Find an alignment that is consistent with the bit position. */
4836 while ((bitpos
% (align
* BITS_PER_UNIT
)) != 0)
4839 emit_block_move (target
, temp
,
4840 GEN_INT ((bitsize
+ BITS_PER_UNIT
- 1)
4844 return value_mode
== VOIDmode
? const0_rtx
: target
;
4847 /* Store the value in the bitfield. */
4848 store_bit_field (target
, bitsize
, bitpos
, mode
, temp
, align
, total_size
);
4849 if (value_mode
!= VOIDmode
)
4851 /* The caller wants an rtx for the value. */
4852 /* If possible, avoid refetching from the bitfield itself. */
4854 && ! (GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
)))
4857 enum machine_mode tmode
;
4860 return expand_and (temp
, GEN_INT (width_mask
), NULL_RTX
);
4861 tmode
= GET_MODE (temp
);
4862 if (tmode
== VOIDmode
)
4864 count
= build_int_2 (GET_MODE_BITSIZE (tmode
) - bitsize
, 0);
4865 temp
= expand_shift (LSHIFT_EXPR
, tmode
, temp
, count
, 0, 0);
4866 return expand_shift (RSHIFT_EXPR
, tmode
, temp
, count
, 0, 0);
4868 return extract_bit_field (target
, bitsize
, bitpos
, unsignedp
,
4869 NULL_RTX
, value_mode
, 0, align
,
4876 rtx addr
= XEXP (target
, 0);
4879 /* If a value is wanted, it must be the lhs;
4880 so make the address stable for multiple use. */
4882 if (value_mode
!= VOIDmode
&& GET_CODE (addr
) != REG
4883 && ! CONSTANT_ADDRESS_P (addr
)
4884 /* A frame-pointer reference is already stable. */
4885 && ! (GET_CODE (addr
) == PLUS
4886 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
4887 && (XEXP (addr
, 0) == virtual_incoming_args_rtx
4888 || XEXP (addr
, 0) == virtual_stack_vars_rtx
)))
4889 addr
= copy_to_reg (addr
);
4891 /* Now build a reference to just the desired component. */
4893 to_rtx
= copy_rtx (change_address (target
, mode
,
4894 plus_constant (addr
,
4896 / BITS_PER_UNIT
))));
4897 MEM_SET_IN_STRUCT_P (to_rtx
, 1);
4898 MEM_ALIAS_SET (to_rtx
) = alias_set
;
4900 return store_expr (exp
, to_rtx
, value_mode
!= VOIDmode
);
4904 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
4905 or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
4906 ARRAY_REFs and find the ultimate containing object, which we return.
4908 We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
4909 bit position, and *PUNSIGNEDP to the signedness of the field.
4910 If the position of the field is variable, we store a tree
4911 giving the variable offset (in units) in *POFFSET.
4912 This offset is in addition to the bit position.
4913 If the position is not variable, we store 0 in *POFFSET.
4914 We set *PALIGNMENT to the alignment in bytes of the address that will be
4915 computed. This is the alignment of the thing we return if *POFFSET
4916 is zero, but can be more less strictly aligned if *POFFSET is nonzero.
4918 If any of the extraction expressions is volatile,
4919 we store 1 in *PVOLATILEP. Otherwise we don't change that.
4921 If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
4922 is a mode that can be used to access the field. In that case, *PBITSIZE
4925 If the field describes a variable-sized object, *PMODE is set to
4926 VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
4927 this case, but the address of the object can be found. */
4930 get_inner_reference (exp
, pbitsize
, pbitpos
, poffset
, pmode
,
4931 punsignedp
, pvolatilep
, palignment
)
4933 HOST_WIDE_INT
*pbitsize
;
4934 HOST_WIDE_INT
*pbitpos
;
4936 enum machine_mode
*pmode
;
4939 unsigned int *palignment
;
4942 enum machine_mode mode
= VOIDmode
;
4943 tree offset
= size_zero_node
;
4944 tree bit_offset
= bitsize_zero_node
;
4945 unsigned int alignment
= BIGGEST_ALIGNMENT
;
4948 /* First get the mode, signedness, and size. We do this from just the
4949 outermost expression. */
4950 if (TREE_CODE (exp
) == COMPONENT_REF
)
4952 size_tree
= DECL_SIZE (TREE_OPERAND (exp
, 1));
4953 if (! DECL_BIT_FIELD (TREE_OPERAND (exp
, 1)))
4954 mode
= DECL_MODE (TREE_OPERAND (exp
, 1));
4956 *punsignedp
= TREE_UNSIGNED (TREE_OPERAND (exp
, 1));
4958 else if (TREE_CODE (exp
) == BIT_FIELD_REF
)
4960 size_tree
= TREE_OPERAND (exp
, 1);
4961 *punsignedp
= TREE_UNSIGNED (exp
);
4965 mode
= TYPE_MODE (TREE_TYPE (exp
));
4966 *punsignedp
= TREE_UNSIGNED (TREE_TYPE (exp
));
4968 if (mode
== BLKmode
)
4969 size_tree
= TYPE_SIZE (TREE_TYPE (exp
));
4971 *pbitsize
= GET_MODE_BITSIZE (mode
);
4976 if (! host_integerp (size_tree
, 1))
4977 mode
= BLKmode
, *pbitsize
= -1;
4979 *pbitsize
= tree_low_cst (size_tree
, 1);
4982 /* Compute cumulative bit-offset for nested component-refs and array-refs,
4983 and find the ultimate containing object. */
4986 if (TREE_CODE (exp
) == BIT_FIELD_REF
)
4987 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
, TREE_OPERAND (exp
, 2));
4988 else if (TREE_CODE (exp
) == COMPONENT_REF
)
4990 tree field
= TREE_OPERAND (exp
, 1);
4991 tree this_offset
= DECL_FIELD_OFFSET (field
);
4993 /* If this field hasn't been filled in yet, don't go
4994 past it. This should only happen when folding expressions
4995 made during type construction. */
4996 if (this_offset
== 0)
4998 else if (! TREE_CONSTANT (this_offset
)
4999 && contains_placeholder_p (this_offset
))
5000 this_offset
= build (WITH_RECORD_EXPR
, sizetype
, this_offset
, exp
);
5002 offset
= size_binop (PLUS_EXPR
, offset
, DECL_FIELD_OFFSET (field
));
5003 bit_offset
= size_binop (PLUS_EXPR
, bit_offset
,
5004 DECL_FIELD_BIT_OFFSET (field
));
5006 if (! host_integerp (offset
, 0))
5007 alignment
= MIN (alignment
, DECL_OFFSET_ALIGN (field
));
5009 else if (TREE_CODE (exp
) == ARRAY_REF
)
5011 tree index
= TREE_OPERAND (exp
, 1);
5012 tree domain
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5013 tree low_bound
= (domain
? TYPE_MIN_VALUE (domain
) : 0);
5015 /* We assume all arrays have sizes that are a multiple of a byte.
5016 First subtract the lower bound, if any, in the type of the
5017 index, then convert to sizetype and multiply by the size of the
5019 if (low_bound
!= 0 && ! integer_zerop (low_bound
))
5020 index
= fold (build (MINUS_EXPR
, TREE_TYPE (index
),
5023 if (! TREE_CONSTANT (index
)
5024 && contains_placeholder_p (index
))
5025 index
= build (WITH_RECORD_EXPR
, TREE_TYPE (index
), index
, exp
);
5027 offset
= size_binop (PLUS_EXPR
, offset
,
5028 size_binop (MULT_EXPR
,
5029 convert (sizetype
, index
),
5030 TYPE_SIZE_UNIT (TREE_TYPE (exp
))));
5032 else if (TREE_CODE (exp
) != NON_LVALUE_EXPR
5033 && ! ((TREE_CODE (exp
) == NOP_EXPR
5034 || TREE_CODE (exp
) == CONVERT_EXPR
)
5035 && (TYPE_MODE (TREE_TYPE (exp
))
5036 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))))
5039 /* If any reference in the chain is volatile, the effect is volatile. */
5040 if (TREE_THIS_VOLATILE (exp
))
5043 /* If the offset is non-constant already, then we can't assume any
5044 alignment more than the alignment here. */
5045 if (! TREE_CONSTANT (offset
))
5046 alignment
= MIN (alignment
, TYPE_ALIGN (TREE_TYPE (exp
)));
5048 exp
= TREE_OPERAND (exp
, 0);
5052 alignment
= MIN (alignment
, DECL_ALIGN (exp
));
5053 else if (TREE_TYPE (exp
) != 0)
5054 alignment
= MIN (alignment
, TYPE_ALIGN (TREE_TYPE (exp
)));
5056 /* If OFFSET is constant, see if we can return the whole thing as a
5057 constant bit position. Otherwise, split it up. */
5058 if (host_integerp (offset
, 0)
5059 && 0 != (tem
= size_binop (MULT_EXPR
, convert (bitsizetype
, offset
),
5061 && 0 != (tem
= size_binop (PLUS_EXPR
, tem
, bit_offset
))
5062 && host_integerp (tem
, 0))
5063 *pbitpos
= tree_low_cst (tem
, 0), *poffset
= 0;
5065 *pbitpos
= tree_low_cst (bit_offset
, 0), *poffset
= offset
;
5068 *palignment
= alignment
/ BITS_PER_UNIT
;
5072 /* Subroutine of expand_exp: compute memory_usage from modifier. */
5074 static enum memory_use_mode
5075 get_memory_usage_from_modifier (modifier
)
5076 enum expand_modifier modifier
;
5082 return MEMORY_USE_RO
;
5084 case EXPAND_MEMORY_USE_WO
:
5085 return MEMORY_USE_WO
;
5087 case EXPAND_MEMORY_USE_RW
:
5088 return MEMORY_USE_RW
;
5090 case EXPAND_MEMORY_USE_DONT
:
5091 /* EXPAND_CONST_ADDRESS and EXPAND_INITIALIZER are converted into
5092 MEMORY_USE_DONT, because they are modifiers to a call of
5093 expand_expr in the ADDR_EXPR case of expand_expr. */
5094 case EXPAND_CONST_ADDRESS
:
5095 case EXPAND_INITIALIZER
:
5096 return MEMORY_USE_DONT
;
5097 case EXPAND_MEMORY_USE_BAD
:
5103 /* Given an rtx VALUE that may contain additions and multiplications,
5104 return an equivalent value that just refers to a register or memory.
5105 This is done by generating instructions to perform the arithmetic
5106 and returning a pseudo-register containing the value.
5108 The returned value may be a REG, SUBREG, MEM or constant. */
5111 force_operand (value
, target
)
5114 register optab binoptab
= 0;
5115 /* Use a temporary to force order of execution of calls to
5119 /* Use subtarget as the target for operand 0 of a binary operation. */
5120 register rtx subtarget
= (target
!= 0 && GET_CODE (target
) == REG
? target
: 0);
5122 /* Check for a PIC address load. */
5124 && (GET_CODE (value
) == PLUS
|| GET_CODE (value
) == MINUS
)
5125 && XEXP (value
, 0) == pic_offset_table_rtx
5126 && (GET_CODE (XEXP (value
, 1)) == SYMBOL_REF
5127 || GET_CODE (XEXP (value
, 1)) == LABEL_REF
5128 || GET_CODE (XEXP (value
, 1)) == CONST
))
5131 subtarget
= gen_reg_rtx (GET_MODE (value
));
5132 emit_move_insn (subtarget
, value
);
5136 if (GET_CODE (value
) == PLUS
)
5137 binoptab
= add_optab
;
5138 else if (GET_CODE (value
) == MINUS
)
5139 binoptab
= sub_optab
;
5140 else if (GET_CODE (value
) == MULT
)
5142 op2
= XEXP (value
, 1);
5143 if (!CONSTANT_P (op2
)
5144 && !(GET_CODE (op2
) == REG
&& op2
!= subtarget
))
5146 tmp
= force_operand (XEXP (value
, 0), subtarget
);
5147 return expand_mult (GET_MODE (value
), tmp
,
5148 force_operand (op2
, NULL_RTX
),
5154 op2
= XEXP (value
, 1);
5155 if (!CONSTANT_P (op2
)
5156 && !(GET_CODE (op2
) == REG
&& op2
!= subtarget
))
5158 if (binoptab
== sub_optab
&& GET_CODE (op2
) == CONST_INT
)
5160 binoptab
= add_optab
;
5161 op2
= negate_rtx (GET_MODE (value
), op2
);
5164 /* Check for an addition with OP2 a constant integer and our first
5165 operand a PLUS of a virtual register and something else. In that
5166 case, we want to emit the sum of the virtual register and the
5167 constant first and then add the other value. This allows virtual
5168 register instantiation to simply modify the constant rather than
5169 creating another one around this addition. */
5170 if (binoptab
== add_optab
&& GET_CODE (op2
) == CONST_INT
5171 && GET_CODE (XEXP (value
, 0)) == PLUS
5172 && GET_CODE (XEXP (XEXP (value
, 0), 0)) == REG
5173 && REGNO (XEXP (XEXP (value
, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5174 && REGNO (XEXP (XEXP (value
, 0), 0)) <= LAST_VIRTUAL_REGISTER
)
5176 rtx temp
= expand_binop (GET_MODE (value
), binoptab
,
5177 XEXP (XEXP (value
, 0), 0), op2
,
5178 subtarget
, 0, OPTAB_LIB_WIDEN
);
5179 return expand_binop (GET_MODE (value
), binoptab
, temp
,
5180 force_operand (XEXP (XEXP (value
, 0), 1), 0),
5181 target
, 0, OPTAB_LIB_WIDEN
);
5184 tmp
= force_operand (XEXP (value
, 0), subtarget
);
5185 return expand_binop (GET_MODE (value
), binoptab
, tmp
,
5186 force_operand (op2
, NULL_RTX
),
5187 target
, 0, OPTAB_LIB_WIDEN
);
5188 /* We give UNSIGNEDP = 0 to expand_binop
5189 because the only operations we are expanding here are signed ones. */
5194 /* Subroutine of expand_expr:
5195 save the non-copied parts (LIST) of an expr (LHS), and return a list
5196 which can restore these values to their previous values,
5197 should something modify their storage. */
5200 save_noncopied_parts (lhs
, list
)
5207 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5208 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5209 parts
= chainon (parts
, save_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5212 tree part
= TREE_VALUE (tail
);
5213 tree part_type
= TREE_TYPE (part
);
5214 tree to_be_saved
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5215 rtx target
= assign_temp (part_type
, 0, 1, 1);
5216 if (! memory_address_p (TYPE_MODE (part_type
), XEXP (target
, 0)))
5217 target
= change_address (target
, TYPE_MODE (part_type
), NULL_RTX
);
5218 parts
= tree_cons (to_be_saved
,
5219 build (RTL_EXPR
, part_type
, NULL_TREE
,
5222 store_expr (TREE_PURPOSE (parts
), RTL_EXPR_RTL (TREE_VALUE (parts
)), 0);
5227 /* Subroutine of expand_expr:
5228 record the non-copied parts (LIST) of an expr (LHS), and return a list
5229 which specifies the initial values of these parts. */
5232 init_noncopied_parts (lhs
, list
)
5239 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
5240 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
5241 parts
= chainon (parts
, init_noncopied_parts (lhs
, TREE_VALUE (tail
)));
5242 else if (TREE_PURPOSE (tail
))
5244 tree part
= TREE_VALUE (tail
);
5245 tree part_type
= TREE_TYPE (part
);
5246 tree to_be_initialized
= build (COMPONENT_REF
, part_type
, lhs
, part
);
5247 parts
= tree_cons (TREE_PURPOSE (tail
), to_be_initialized
, parts
);
5252 /* Subroutine of expand_expr: return nonzero iff there is no way that
5253 EXP can reference X, which is being modified. TOP_P is nonzero if this
5254 call is going to be used to determine whether we need a temporary
5255 for EXP, as opposed to a recursive call to this function.
5257 It is always safe for this routine to return zero since it merely
5258 searches for optimization opportunities. */
5261 safe_from_p (x
, exp
, top_p
)
5268 static int save_expr_count
;
5269 static int save_expr_size
= 0;
5270 static tree
*save_expr_rewritten
;
5271 static tree save_expr_trees
[256];
5274 /* If EXP has varying size, we MUST use a target since we currently
5275 have no way of allocating temporaries of variable size
5276 (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5277 So we assume here that something at a higher level has prevented a
5278 clash. This is somewhat bogus, but the best we can do. Only
5279 do this when X is BLKmode and when we are at the top level. */
5280 || (top_p
&& TREE_TYPE (exp
) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp
))
5281 && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
))) != INTEGER_CST
5282 && (TREE_CODE (TREE_TYPE (exp
)) != ARRAY_TYPE
5283 || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp
)) == NULL_TREE
5284 || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp
)))
5286 && GET_MODE (x
) == BLKmode
))
5289 if (top_p
&& save_expr_size
== 0)
5293 save_expr_count
= 0;
5294 save_expr_size
= sizeof (save_expr_trees
) / sizeof (save_expr_trees
[0]);
5295 save_expr_rewritten
= &save_expr_trees
[0];
5297 rtn
= safe_from_p (x
, exp
, 1);
5299 for (i
= 0; i
< save_expr_count
; ++i
)
5301 if (TREE_CODE (save_expr_trees
[i
]) != ERROR_MARK
)
5303 TREE_SET_CODE (save_expr_trees
[i
], SAVE_EXPR
);
5311 /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5312 find the underlying pseudo. */
5313 if (GET_CODE (x
) == SUBREG
)
5316 if (GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5320 /* If X is a location in the outgoing argument area, it is always safe. */
5321 if (GET_CODE (x
) == MEM
5322 && (XEXP (x
, 0) == virtual_outgoing_args_rtx
5323 || (GET_CODE (XEXP (x
, 0)) == PLUS
5324 && XEXP (XEXP (x
, 0), 0) == virtual_outgoing_args_rtx
)))
5327 switch (TREE_CODE_CLASS (TREE_CODE (exp
)))
5330 exp_rtl
= DECL_RTL (exp
);
5337 if (TREE_CODE (exp
) == TREE_LIST
)
5338 return ((TREE_VALUE (exp
) == 0
5339 || safe_from_p (x
, TREE_VALUE (exp
), 0))
5340 && (TREE_CHAIN (exp
) == 0
5341 || safe_from_p (x
, TREE_CHAIN (exp
), 0)));
5342 else if (TREE_CODE (exp
) == ERROR_MARK
)
5343 return 1; /* An already-visited SAVE_EXPR? */
5348 return safe_from_p (x
, TREE_OPERAND (exp
, 0), 0);
5352 return (safe_from_p (x
, TREE_OPERAND (exp
, 0), 0)
5353 && safe_from_p (x
, TREE_OPERAND (exp
, 1), 0));
5357 /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
5358 the expression. If it is set, we conflict iff we are that rtx or
5359 both are in memory. Otherwise, we check all operands of the
5360 expression recursively. */
5362 switch (TREE_CODE (exp
))
5365 return (staticp (TREE_OPERAND (exp
, 0))
5366 || safe_from_p (x
, TREE_OPERAND (exp
, 0), 0)
5367 || TREE_STATIC (exp
));
5370 if (GET_CODE (x
) == MEM
)
5375 exp_rtl
= CALL_EXPR_RTL (exp
);
5378 /* Assume that the call will clobber all hard registers and
5380 if ((GET_CODE (x
) == REG
&& REGNO (x
) < FIRST_PSEUDO_REGISTER
)
5381 || GET_CODE (x
) == MEM
)
5388 /* If a sequence exists, we would have to scan every instruction
5389 in the sequence to see if it was safe. This is probably not
5391 if (RTL_EXPR_SEQUENCE (exp
))
5394 exp_rtl
= RTL_EXPR_RTL (exp
);
5397 case WITH_CLEANUP_EXPR
:
5398 exp_rtl
= RTL_EXPR_RTL (exp
);
5401 case CLEANUP_POINT_EXPR
:
5402 return safe_from_p (x
, TREE_OPERAND (exp
, 0), 0);
5405 exp_rtl
= SAVE_EXPR_RTL (exp
);
5409 /* This SAVE_EXPR might appear many times in the top-level
5410 safe_from_p() expression, and if it has a complex
5411 subexpression, examining it multiple times could result
5412 in a combinatorial explosion. E.g. on an Alpha
5413 running at least 200MHz, a Fortran test case compiled with
5414 optimization took about 28 minutes to compile -- even though
5415 it was only a few lines long, and the complicated line causing
5416 so much time to be spent in the earlier version of safe_from_p()
5417 had only 293 or so unique nodes.
5419 So, turn this SAVE_EXPR into an ERROR_MARK for now, but remember
5420 where it is so we can turn it back in the top-level safe_from_p()
5423 /* For now, don't bother re-sizing the array. */
5424 if (save_expr_count
>= save_expr_size
)
5426 save_expr_rewritten
[save_expr_count
++] = exp
;
5428 nops
= tree_code_length
[(int) SAVE_EXPR
];
5429 for (i
= 0; i
< nops
; i
++)
5431 tree operand
= TREE_OPERAND (exp
, i
);
5432 if (operand
== NULL_TREE
)
5434 TREE_SET_CODE (exp
, ERROR_MARK
);
5435 if (!safe_from_p (x
, operand
, 0))
5437 TREE_SET_CODE (exp
, SAVE_EXPR
);
5439 TREE_SET_CODE (exp
, ERROR_MARK
);
5443 /* The only operand we look at is operand 1. The rest aren't
5444 part of the expression. */
5445 return safe_from_p (x
, TREE_OPERAND (exp
, 1), 0);
5447 case METHOD_CALL_EXPR
:
5448 /* This takes a rtx argument, but shouldn't appear here. */
5455 /* If we have an rtx, we do not need to scan our operands. */
5459 nops
= tree_code_length
[(int) TREE_CODE (exp
)];
5460 for (i
= 0; i
< nops
; i
++)
5461 if (TREE_OPERAND (exp
, i
) != 0
5462 && ! safe_from_p (x
, TREE_OPERAND (exp
, i
), 0))
5466 /* If we have an rtl, find any enclosed object. Then see if we conflict
5470 if (GET_CODE (exp_rtl
) == SUBREG
)
5472 exp_rtl
= SUBREG_REG (exp_rtl
);
5473 if (GET_CODE (exp_rtl
) == REG
5474 && REGNO (exp_rtl
) < FIRST_PSEUDO_REGISTER
)
5478 /* If the rtl is X, then it is not safe. Otherwise, it is unless both
5479 are memory and EXP is not readonly. */
5480 return ! (rtx_equal_p (x
, exp_rtl
)
5481 || (GET_CODE (x
) == MEM
&& GET_CODE (exp_rtl
) == MEM
5482 && ! TREE_READONLY (exp
)));
5485 /* If we reach here, it is safe. */
5489 /* Subroutine of expand_expr: return nonzero iff EXP is an
5490 expression whose type is statically determinable. */
5496 if (TREE_CODE (exp
) == PARM_DECL
5497 || TREE_CODE (exp
) == VAR_DECL
5498 || TREE_CODE (exp
) == CALL_EXPR
|| TREE_CODE (exp
) == TARGET_EXPR
5499 || TREE_CODE (exp
) == COMPONENT_REF
5500 || TREE_CODE (exp
) == ARRAY_REF
)
5505 /* Subroutine of expand_expr: return rtx if EXP is a
5506 variable or parameter; else return 0. */
5513 switch (TREE_CODE (exp
))
5517 return DECL_RTL (exp
);
5523 #ifdef MAX_INTEGER_COMPUTATION_MODE
5525 check_max_integer_computation_mode (exp
)
5528 enum tree_code code
;
5529 enum machine_mode mode
;
5531 /* Strip any NOPs that don't change the mode. */
5533 code
= TREE_CODE (exp
);
5535 /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE. */
5536 if (code
== NOP_EXPR
5537 && TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
)
5540 /* First check the type of the overall operation. We need only look at
5541 unary, binary and relational operations. */
5542 if (TREE_CODE_CLASS (code
) == '1'
5543 || TREE_CODE_CLASS (code
) == '2'
5544 || TREE_CODE_CLASS (code
) == '<')
5546 mode
= TYPE_MODE (TREE_TYPE (exp
));
5547 if (GET_MODE_CLASS (mode
) == MODE_INT
5548 && mode
> MAX_INTEGER_COMPUTATION_MODE
)
5549 fatal ("unsupported wide integer operation");
5552 /* Check operand of a unary op. */
5553 if (TREE_CODE_CLASS (code
) == '1')
5555 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5556 if (GET_MODE_CLASS (mode
) == MODE_INT
5557 && mode
> MAX_INTEGER_COMPUTATION_MODE
)
5558 fatal ("unsupported wide integer operation");
5561 /* Check operands of a binary/comparison op. */
5562 if (TREE_CODE_CLASS (code
) == '2' || TREE_CODE_CLASS (code
) == '<')
5564 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
5565 if (GET_MODE_CLASS (mode
) == MODE_INT
5566 && mode
> MAX_INTEGER_COMPUTATION_MODE
)
5567 fatal ("unsupported wide integer operation");
5569 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1)));
5570 if (GET_MODE_CLASS (mode
) == MODE_INT
5571 && mode
> MAX_INTEGER_COMPUTATION_MODE
)
5572 fatal ("unsupported wide integer operation");
5578 /* Utility function used by expand_expr to see if TYPE, a RECORD_TYPE,
5579 has any readonly fields. If any of the fields have types that
5580 contain readonly fields, return true as well. */
5583 readonly_fields_p (type
)
5588 for (field
= TYPE_FIELDS (type
); field
!= 0; field
= TREE_CHAIN (field
))
5589 if (TREE_CODE (field
) == FIELD_DECL
5590 && (TREE_READONLY (field
)
5591 || (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
5592 && readonly_fields_p (TREE_TYPE (field
)))))
5598 /* expand_expr: generate code for computing expression EXP.
5599 An rtx for the computed value is returned. The value is never null.
5600 In the case of a void EXP, const0_rtx is returned.
5602 The value may be stored in TARGET if TARGET is nonzero.
5603 TARGET is just a suggestion; callers must assume that
5604 the rtx returned may not be the same as TARGET.
5606 If TARGET is CONST0_RTX, it means that the value will be ignored.
5608 If TMODE is not VOIDmode, it suggests generating the
5609 result in mode TMODE. But this is done only when convenient.
5610 Otherwise, TMODE is ignored and the value generated in its natural mode.
5611 TMODE is just a suggestion; callers must assume that
5612 the rtx returned may not have mode TMODE.
5614 Note that TARGET may have neither TMODE nor MODE. In that case, it
5615 probably will not be used.
5617 If MODIFIER is EXPAND_SUM then when EXP is an addition
5618 we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
5619 or a nest of (PLUS ...) and (MINUS ...) where the terms are
5620 products as above, or REG or MEM, or constant.
5621 Ordinarily in such cases we would output mul or add instructions
5622 and then return a pseudo reg containing the sum.
5624 EXPAND_INITIALIZER is much like EXPAND_SUM except that
5625 it also marks a label as absolutely required (it can't be dead).
5626 It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
5627 This is used for outputting expressions used in initializers.
5629 EXPAND_CONST_ADDRESS says that it is okay to return a MEM
5630 with a constant address even if that address is not normally legitimate.
5631 EXPAND_INITIALIZER and EXPAND_SUM also have this effect. */
5634 expand_expr (exp
, target
, tmode
, modifier
)
5637 enum machine_mode tmode
;
5638 enum expand_modifier modifier
;
5640 register rtx op0
, op1
, temp
;
5641 tree type
= TREE_TYPE (exp
);
5642 int unsignedp
= TREE_UNSIGNED (type
);
5643 register enum machine_mode mode
;
5644 register enum tree_code code
= TREE_CODE (exp
);
5646 rtx subtarget
, original_target
;
5649 /* Used by check-memory-usage to make modifier read only. */
5650 enum expand_modifier ro_modifier
;
5652 /* Handle ERROR_MARK before anybody tries to access its type. */
5653 if (TREE_CODE (exp
) == ERROR_MARK
)
5655 op0
= CONST0_RTX (tmode
);
5661 mode
= TYPE_MODE (type
);
5662 /* Use subtarget as the target for operand 0 of a binary operation. */
5663 subtarget
= (target
!= 0 && GET_CODE (target
) == REG
? target
: 0);
5664 original_target
= target
;
5665 ignore
= (target
== const0_rtx
5666 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
5667 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
5668 || code
== COND_EXPR
)
5669 && TREE_CODE (type
) == VOID_TYPE
));
5671 /* Make a read-only version of the modifier. */
5672 if (modifier
== EXPAND_NORMAL
|| modifier
== EXPAND_SUM
5673 || modifier
== EXPAND_CONST_ADDRESS
|| modifier
== EXPAND_INITIALIZER
)
5674 ro_modifier
= modifier
;
5676 ro_modifier
= EXPAND_NORMAL
;
5678 /* Don't use hard regs as subtargets, because the combiner
5679 can only handle pseudo regs. */
5680 if (subtarget
&& REGNO (subtarget
) < FIRST_PSEUDO_REGISTER
)
5682 /* Avoid subtargets inside loops,
5683 since they hide some invariant expressions. */
5684 if (preserve_subexpressions_p ())
5687 /* If we are going to ignore this result, we need only do something
5688 if there is a side-effect somewhere in the expression. If there
5689 is, short-circuit the most common cases here. Note that we must
5690 not call expand_expr with anything but const0_rtx in case this
5691 is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
5695 if (! TREE_SIDE_EFFECTS (exp
))
5698 /* Ensure we reference a volatile object even if value is ignored, but
5699 don't do this if all we are doing is taking its address. */
5700 if (TREE_THIS_VOLATILE (exp
)
5701 && TREE_CODE (exp
) != FUNCTION_DECL
5702 && mode
!= VOIDmode
&& mode
!= BLKmode
5703 && modifier
!= EXPAND_CONST_ADDRESS
)
5705 temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, ro_modifier
);
5706 if (GET_CODE (temp
) == MEM
)
5707 temp
= copy_to_reg (temp
);
5711 if (TREE_CODE_CLASS (code
) == '1' || code
== COMPONENT_REF
5712 || code
== INDIRECT_REF
|| code
== BUFFER_REF
)
5713 return expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
,
5714 VOIDmode
, ro_modifier
);
5715 else if (TREE_CODE_CLASS (code
) == '2' || TREE_CODE_CLASS (code
) == '<'
5716 || code
== ARRAY_REF
)
5718 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, ro_modifier
);
5719 expand_expr (TREE_OPERAND (exp
, 1), const0_rtx
, VOIDmode
, ro_modifier
);
5722 else if ((code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
5723 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
5724 /* If the second operand has no side effects, just evaluate
5726 return expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
,
5727 VOIDmode
, ro_modifier
);
5728 else if (code
== BIT_FIELD_REF
)
5730 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, ro_modifier
);
5731 expand_expr (TREE_OPERAND (exp
, 1), const0_rtx
, VOIDmode
, ro_modifier
);
5732 expand_expr (TREE_OPERAND (exp
, 2), const0_rtx
, VOIDmode
, ro_modifier
);
5739 #ifdef MAX_INTEGER_COMPUTATION_MODE
5740 /* Only check stuff here if the mode we want is different from the mode
5741 of the expression; if it's the same, check_max_integer_computiation_mode
5742 will handle it. Do we really need to check this stuff at all? */
5745 && GET_MODE (target
) != mode
5746 && TREE_CODE (exp
) != INTEGER_CST
5747 && TREE_CODE (exp
) != PARM_DECL
5748 && TREE_CODE (exp
) != ARRAY_REF
5749 && TREE_CODE (exp
) != COMPONENT_REF
5750 && TREE_CODE (exp
) != BIT_FIELD_REF
5751 && TREE_CODE (exp
) != INDIRECT_REF
5752 && TREE_CODE (exp
) != CALL_EXPR
5753 && TREE_CODE (exp
) != VAR_DECL
5754 && TREE_CODE (exp
) != RTL_EXPR
)
5756 enum machine_mode mode
= GET_MODE (target
);
5758 if (GET_MODE_CLASS (mode
) == MODE_INT
5759 && mode
> MAX_INTEGER_COMPUTATION_MODE
)
5760 fatal ("unsupported wide integer operation");
5764 && TREE_CODE (exp
) != INTEGER_CST
5765 && TREE_CODE (exp
) != PARM_DECL
5766 && TREE_CODE (exp
) != ARRAY_REF
5767 && TREE_CODE (exp
) != COMPONENT_REF
5768 && TREE_CODE (exp
) != BIT_FIELD_REF
5769 && TREE_CODE (exp
) != INDIRECT_REF
5770 && TREE_CODE (exp
) != VAR_DECL
5771 && TREE_CODE (exp
) != CALL_EXPR
5772 && TREE_CODE (exp
) != RTL_EXPR
5773 && GET_MODE_CLASS (tmode
) == MODE_INT
5774 && tmode
> MAX_INTEGER_COMPUTATION_MODE
)
5775 fatal ("unsupported wide integer operation");
5777 check_max_integer_computation_mode (exp
);
5780 /* If will do cse, generate all results into pseudo registers
5781 since 1) that allows cse to find more things
5782 and 2) otherwise cse could produce an insn the machine
5785 if (! cse_not_expected
&& mode
!= BLKmode
&& target
5786 && (GET_CODE (target
) != REG
|| REGNO (target
) < FIRST_PSEUDO_REGISTER
))
5793 tree function
= decl_function_context (exp
);
5794 /* Handle using a label in a containing function. */
5795 if (function
!= current_function_decl
5796 && function
!= inline_function_decl
&& function
!= 0)
5798 struct function
*p
= find_function_data (function
);
5799 /* Allocate in the memory associated with the function
5800 that the label is in. */
5801 push_obstacks (p
->function_obstack
,
5802 p
->function_maybepermanent_obstack
);
5804 p
->expr
->x_forced_labels
5805 = gen_rtx_EXPR_LIST (VOIDmode
, label_rtx (exp
),
5806 p
->expr
->x_forced_labels
);
5811 if (modifier
== EXPAND_INITIALIZER
)
5812 forced_labels
= gen_rtx_EXPR_LIST (VOIDmode
,
5817 temp
= gen_rtx_MEM (FUNCTION_MODE
,
5818 gen_rtx_LABEL_REF (Pmode
, label_rtx (exp
)));
5819 if (function
!= current_function_decl
5820 && function
!= inline_function_decl
&& function
!= 0)
5821 LABEL_REF_NONLOCAL_P (XEXP (temp
, 0)) = 1;
5826 if (DECL_RTL (exp
) == 0)
5828 error_with_decl (exp
, "prior parameter's size depends on `%s'");
5829 return CONST0_RTX (mode
);
5832 /* ... fall through ... */
5835 /* If a static var's type was incomplete when the decl was written,
5836 but the type is complete now, lay out the decl now. */
5837 if (DECL_SIZE (exp
) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp
))
5838 && (TREE_STATIC (exp
) || DECL_EXTERNAL (exp
)))
5840 push_obstacks_nochange ();
5841 end_temporary_allocation ();
5842 layout_decl (exp
, 0);
5843 PUT_MODE (DECL_RTL (exp
), DECL_MODE (exp
));
5847 /* Although static-storage variables start off initialized, according to
5848 ANSI C, a memcpy could overwrite them with uninitialized values. So
5849 we check them too. This also lets us check for read-only variables
5850 accessed via a non-const declaration, in case it won't be detected
5851 any other way (e.g., in an embedded system or OS kernel without
5854 Aggregates are not checked here; they're handled elsewhere. */
5855 if (cfun
&& current_function_check_memory_usage
5857 && GET_CODE (DECL_RTL (exp
)) == MEM
5858 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp
)))
5860 enum memory_use_mode memory_usage
;
5861 memory_usage
= get_memory_usage_from_modifier (modifier
);
5863 if (memory_usage
!= MEMORY_USE_DONT
)
5864 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
5865 XEXP (DECL_RTL (exp
), 0), Pmode
,
5866 GEN_INT (int_size_in_bytes (type
)),
5867 TYPE_MODE (sizetype
),
5868 GEN_INT (memory_usage
),
5869 TYPE_MODE (integer_type_node
));
5872 /* ... fall through ... */
5876 if (DECL_RTL (exp
) == 0)
5879 /* Ensure variable marked as used even if it doesn't go through
5880 a parser. If it hasn't be used yet, write out an external
5882 if (! TREE_USED (exp
))
5884 assemble_external (exp
);
5885 TREE_USED (exp
) = 1;
5888 /* Show we haven't gotten RTL for this yet. */
5891 /* Handle variables inherited from containing functions. */
5892 context
= decl_function_context (exp
);
5894 /* We treat inline_function_decl as an alias for the current function
5895 because that is the inline function whose vars, types, etc.
5896 are being merged into the current function.
5897 See expand_inline_function. */
5899 if (context
!= 0 && context
!= current_function_decl
5900 && context
!= inline_function_decl
5901 /* If var is static, we don't need a static chain to access it. */
5902 && ! (GET_CODE (DECL_RTL (exp
)) == MEM
5903 && CONSTANT_P (XEXP (DECL_RTL (exp
), 0))))
5907 /* Mark as non-local and addressable. */
5908 DECL_NONLOCAL (exp
) = 1;
5909 if (DECL_NO_STATIC_CHAIN (current_function_decl
))
5911 mark_addressable (exp
);
5912 if (GET_CODE (DECL_RTL (exp
)) != MEM
)
5914 addr
= XEXP (DECL_RTL (exp
), 0);
5915 if (GET_CODE (addr
) == MEM
)
5916 addr
= gen_rtx_MEM (Pmode
,
5917 fix_lexical_addr (XEXP (addr
, 0), exp
));
5919 addr
= fix_lexical_addr (addr
, exp
);
5920 temp
= change_address (DECL_RTL (exp
), mode
, addr
);
5923 /* This is the case of an array whose size is to be determined
5924 from its initializer, while the initializer is still being parsed.
5927 else if (GET_CODE (DECL_RTL (exp
)) == MEM
5928 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) == REG
)
5929 temp
= change_address (DECL_RTL (exp
), GET_MODE (DECL_RTL (exp
)),
5930 XEXP (DECL_RTL (exp
), 0));
5932 /* If DECL_RTL is memory, we are in the normal case and either
5933 the address is not valid or it is not a register and -fforce-addr
5934 is specified, get the address into a register. */
5936 else if (GET_CODE (DECL_RTL (exp
)) == MEM
5937 && modifier
!= EXPAND_CONST_ADDRESS
5938 && modifier
!= EXPAND_SUM
5939 && modifier
!= EXPAND_INITIALIZER
5940 && (! memory_address_p (DECL_MODE (exp
),
5941 XEXP (DECL_RTL (exp
), 0))
5943 && GET_CODE (XEXP (DECL_RTL (exp
), 0)) != REG
)))
5944 temp
= change_address (DECL_RTL (exp
), VOIDmode
,
5945 copy_rtx (XEXP (DECL_RTL (exp
), 0)));
5947 /* If we got something, return it. But first, set the alignment
5948 the address is a register. */
5951 if (GET_CODE (temp
) == MEM
&& GET_CODE (XEXP (temp
, 0)) == REG
)
5952 mark_reg_pointer (XEXP (temp
, 0),
5953 DECL_ALIGN (exp
) / BITS_PER_UNIT
);
5958 /* If the mode of DECL_RTL does not match that of the decl, it
5959 must be a promoted value. We return a SUBREG of the wanted mode,
5960 but mark it so that we know that it was already extended. */
5962 if (GET_CODE (DECL_RTL (exp
)) == REG
5963 && GET_MODE (DECL_RTL (exp
)) != mode
)
5965 /* Get the signedness used for this variable. Ensure we get the
5966 same mode we got when the variable was declared. */
5967 if (GET_MODE (DECL_RTL (exp
))
5968 != promote_mode (type
, DECL_MODE (exp
), &unsignedp
, 0))
5971 temp
= gen_rtx_SUBREG (mode
, DECL_RTL (exp
), 0);
5972 SUBREG_PROMOTED_VAR_P (temp
) = 1;
5973 SUBREG_PROMOTED_UNSIGNED_P (temp
) = unsignedp
;
5977 return DECL_RTL (exp
);
5980 return immed_double_const (TREE_INT_CST_LOW (exp
),
5981 TREE_INT_CST_HIGH (exp
), mode
);
5984 return expand_expr (DECL_INITIAL (exp
), target
, VOIDmode
,
5985 EXPAND_MEMORY_USE_BAD
);
5988 /* If optimized, generate immediate CONST_DOUBLE
5989 which will be turned into memory by reload if necessary.
5991 We used to force a register so that loop.c could see it. But
5992 this does not allow gen_* patterns to perform optimizations with
5993 the constants. It also produces two insns in cases like "x = 1.0;".
5994 On most machines, floating-point constants are not permitted in
5995 many insns, so we'd end up copying it to a register in any case.
5997 Now, we do the copying in expand_binop, if appropriate. */
5998 return immed_real_const (exp
);
6002 if (! TREE_CST_RTL (exp
))
6003 output_constant_def (exp
);
6005 /* TREE_CST_RTL probably contains a constant address.
6006 On RISC machines where a constant address isn't valid,
6007 make some insns to get that address into a register. */
6008 if (GET_CODE (TREE_CST_RTL (exp
)) == MEM
6009 && modifier
!= EXPAND_CONST_ADDRESS
6010 && modifier
!= EXPAND_INITIALIZER
6011 && modifier
!= EXPAND_SUM
6012 && (! memory_address_p (mode
, XEXP (TREE_CST_RTL (exp
), 0))
6014 && GET_CODE (XEXP (TREE_CST_RTL (exp
), 0)) != REG
)))
6015 return change_address (TREE_CST_RTL (exp
), VOIDmode
,
6016 copy_rtx (XEXP (TREE_CST_RTL (exp
), 0)));
6017 return TREE_CST_RTL (exp
);
6019 case EXPR_WITH_FILE_LOCATION
:
6022 char *saved_input_filename
= input_filename
;
6023 int saved_lineno
= lineno
;
6024 input_filename
= EXPR_WFL_FILENAME (exp
);
6025 lineno
= EXPR_WFL_LINENO (exp
);
6026 if (EXPR_WFL_EMIT_LINE_NOTE (exp
))
6027 emit_line_note (input_filename
, lineno
);
6028 /* Possibly avoid switching back and force here */
6029 to_return
= expand_expr (EXPR_WFL_NODE (exp
), target
, tmode
, modifier
);
6030 input_filename
= saved_input_filename
;
6031 lineno
= saved_lineno
;
6036 context
= decl_function_context (exp
);
6038 /* If this SAVE_EXPR was at global context, assume we are an
6039 initialization function and move it into our context. */
6041 SAVE_EXPR_CONTEXT (exp
) = current_function_decl
;
6043 /* We treat inline_function_decl as an alias for the current function
6044 because that is the inline function whose vars, types, etc.
6045 are being merged into the current function.
6046 See expand_inline_function. */
6047 if (context
== current_function_decl
|| context
== inline_function_decl
)
6050 /* If this is non-local, handle it. */
6053 /* The following call just exists to abort if the context is
6054 not of a containing function. */
6055 find_function_data (context
);
6057 temp
= SAVE_EXPR_RTL (exp
);
6058 if (temp
&& GET_CODE (temp
) == REG
)
6060 put_var_into_stack (exp
);
6061 temp
= SAVE_EXPR_RTL (exp
);
6063 if (temp
== 0 || GET_CODE (temp
) != MEM
)
6065 return change_address (temp
, mode
,
6066 fix_lexical_addr (XEXP (temp
, 0), exp
));
6068 if (SAVE_EXPR_RTL (exp
) == 0)
6070 if (mode
== VOIDmode
)
6073 temp
= assign_temp (type
, 3, 0, 0);
6075 SAVE_EXPR_RTL (exp
) = temp
;
6076 if (!optimize
&& GET_CODE (temp
) == REG
)
6077 save_expr_regs
= gen_rtx_EXPR_LIST (VOIDmode
, temp
,
6080 /* If the mode of TEMP does not match that of the expression, it
6081 must be a promoted value. We pass store_expr a SUBREG of the
6082 wanted mode but mark it so that we know that it was already
6083 extended. Note that `unsignedp' was modified above in
6086 if (GET_CODE (temp
) == REG
&& GET_MODE (temp
) != mode
)
6088 temp
= gen_rtx_SUBREG (mode
, SAVE_EXPR_RTL (exp
), 0);
6089 SUBREG_PROMOTED_VAR_P (temp
) = 1;
6090 SUBREG_PROMOTED_UNSIGNED_P (temp
) = unsignedp
;
6093 if (temp
== const0_rtx
)
6094 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
6095 EXPAND_MEMORY_USE_BAD
);
6097 store_expr (TREE_OPERAND (exp
, 0), temp
, 0);
6099 TREE_USED (exp
) = 1;
6102 /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6103 must be a promoted value. We return a SUBREG of the wanted mode,
6104 but mark it so that we know that it was already extended. */
6106 if (GET_CODE (SAVE_EXPR_RTL (exp
)) == REG
6107 && GET_MODE (SAVE_EXPR_RTL (exp
)) != mode
)
6109 /* Compute the signedness and make the proper SUBREG. */
6110 promote_mode (type
, mode
, &unsignedp
, 0);
6111 temp
= gen_rtx_SUBREG (mode
, SAVE_EXPR_RTL (exp
), 0);
6112 SUBREG_PROMOTED_VAR_P (temp
) = 1;
6113 SUBREG_PROMOTED_UNSIGNED_P (temp
) = unsignedp
;
6117 return SAVE_EXPR_RTL (exp
);
6122 temp
= expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, modifier
);
6123 TREE_OPERAND (exp
, 0) = unsave_expr_now (TREE_OPERAND (exp
, 0));
6127 case PLACEHOLDER_EXPR
:
6129 tree placeholder_expr
;
6131 /* If there is an object on the head of the placeholder list,
6132 see if some object in it of type TYPE or a pointer to it. For
6133 further information, see tree.def. */
6134 for (placeholder_expr
= placeholder_list
;
6135 placeholder_expr
!= 0;
6136 placeholder_expr
= TREE_CHAIN (placeholder_expr
))
6138 tree need_type
= TYPE_MAIN_VARIANT (type
);
6140 tree old_list
= placeholder_list
;
6143 /* Find the outermost reference that is of the type we want.
6144 If none, see if any object has a type that is a pointer to
6145 the type we want. */
6146 for (elt
= TREE_PURPOSE (placeholder_expr
);
6147 elt
!= 0 && object
== 0;
6149 = ((TREE_CODE (elt
) == COMPOUND_EXPR
6150 || TREE_CODE (elt
) == COND_EXPR
)
6151 ? TREE_OPERAND (elt
, 1)
6152 : (TREE_CODE_CLASS (TREE_CODE (elt
)) == 'r'
6153 || TREE_CODE_CLASS (TREE_CODE (elt
)) == '1'
6154 || TREE_CODE_CLASS (TREE_CODE (elt
)) == '2'
6155 || TREE_CODE_CLASS (TREE_CODE (elt
)) == 'e')
6156 ? TREE_OPERAND (elt
, 0) : 0))
6157 if (TYPE_MAIN_VARIANT (TREE_TYPE (elt
)) == need_type
)
6160 for (elt
= TREE_PURPOSE (placeholder_expr
);
6161 elt
!= 0 && object
== 0;
6163 = ((TREE_CODE (elt
) == COMPOUND_EXPR
6164 || TREE_CODE (elt
) == COND_EXPR
)
6165 ? TREE_OPERAND (elt
, 1)
6166 : (TREE_CODE_CLASS (TREE_CODE (elt
)) == 'r'
6167 || TREE_CODE_CLASS (TREE_CODE (elt
)) == '1'
6168 || TREE_CODE_CLASS (TREE_CODE (elt
)) == '2'
6169 || TREE_CODE_CLASS (TREE_CODE (elt
)) == 'e')
6170 ? TREE_OPERAND (elt
, 0) : 0))
6171 if (POINTER_TYPE_P (TREE_TYPE (elt
))
6172 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt
)))
6174 object
= build1 (INDIRECT_REF
, need_type
, elt
);
6178 /* Expand this object skipping the list entries before
6179 it was found in case it is also a PLACEHOLDER_EXPR.
6180 In that case, we want to translate it using subsequent
6182 placeholder_list
= TREE_CHAIN (placeholder_expr
);
6183 temp
= expand_expr (object
, original_target
, tmode
,
6185 placeholder_list
= old_list
;
6191 /* We can't find the object or there was a missing WITH_RECORD_EXPR. */
6194 case WITH_RECORD_EXPR
:
6195 /* Put the object on the placeholder list, expand our first operand,
6196 and pop the list. */
6197 placeholder_list
= tree_cons (TREE_OPERAND (exp
, 1), NULL_TREE
,
6199 target
= expand_expr (TREE_OPERAND (exp
, 0), original_target
,
6200 tmode
, ro_modifier
);
6201 placeholder_list
= TREE_CHAIN (placeholder_list
);
6205 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == LABEL_DECL
)
6206 expand_goto (TREE_OPERAND (exp
, 0));
6208 expand_computed_goto (TREE_OPERAND (exp
, 0));
6212 expand_exit_loop_if_false (NULL_PTR
,
6213 invert_truthvalue (TREE_OPERAND (exp
, 0)));
6216 case LABELED_BLOCK_EXPR
:
6217 if (LABELED_BLOCK_BODY (exp
))
6218 expand_expr_stmt (LABELED_BLOCK_BODY (exp
));
6219 emit_label (label_rtx (LABELED_BLOCK_LABEL (exp
)));
6222 case EXIT_BLOCK_EXPR
:
6223 if (EXIT_BLOCK_RETURN (exp
))
6224 sorry ("returned value in block_exit_expr");
6225 expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp
)));
6230 expand_start_loop (1);
6231 expand_expr_stmt (TREE_OPERAND (exp
, 0));
6239 tree vars
= TREE_OPERAND (exp
, 0);
6240 int vars_need_expansion
= 0;
6242 /* Need to open a binding contour here because
6243 if there are any cleanups they must be contained here. */
6244 expand_start_bindings (2);
6246 /* Mark the corresponding BLOCK for output in its proper place. */
6247 if (TREE_OPERAND (exp
, 2) != 0
6248 && ! TREE_USED (TREE_OPERAND (exp
, 2)))
6249 insert_block (TREE_OPERAND (exp
, 2));
6251 /* If VARS have not yet been expanded, expand them now. */
6254 if (DECL_RTL (vars
) == 0)
6256 vars_need_expansion
= 1;
6259 expand_decl_init (vars
);
6260 vars
= TREE_CHAIN (vars
);
6263 temp
= expand_expr (TREE_OPERAND (exp
, 1), target
, tmode
, ro_modifier
);
6265 expand_end_bindings (TREE_OPERAND (exp
, 0), 0, 0);
6271 if (RTL_EXPR_SEQUENCE (exp
))
6273 if (RTL_EXPR_SEQUENCE (exp
) == const0_rtx
)
6275 emit_insns (RTL_EXPR_SEQUENCE (exp
));
6276 RTL_EXPR_SEQUENCE (exp
) = const0_rtx
;
6278 preserve_rtl_expr_result (RTL_EXPR_RTL (exp
));
6279 free_temps_for_rtl_expr (exp
);
6280 return RTL_EXPR_RTL (exp
);
6283 /* If we don't need the result, just ensure we evaluate any
6288 for (elt
= CONSTRUCTOR_ELTS (exp
); elt
; elt
= TREE_CHAIN (elt
))
6289 expand_expr (TREE_VALUE (elt
), const0_rtx
, VOIDmode
,
6290 EXPAND_MEMORY_USE_BAD
);
6294 /* All elts simple constants => refer to a constant in memory. But
6295 if this is a non-BLKmode mode, let it store a field at a time
6296 since that should make a CONST_INT or CONST_DOUBLE when we
6297 fold. Likewise, if we have a target we can use, it is best to
6298 store directly into the target unless the type is large enough
6299 that memcpy will be used. If we are making an initializer and
6300 all operands are constant, put it in memory as well. */
6301 else if ((TREE_STATIC (exp
)
6302 && ((mode
== BLKmode
6303 && ! (target
!= 0 && safe_from_p (target
, exp
, 1)))
6304 || TREE_ADDRESSABLE (exp
)
6305 || (TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
6306 && TREE_INT_CST_HIGH (TYPE_SIZE_UNIT (type
)) == 0
6307 && (! MOVE_BY_PIECES_P
6308 (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type
)),
6309 TYPE_ALIGN (type
) / BITS_PER_UNIT
))
6310 && ! mostly_zeros_p (exp
))))
6311 || (modifier
== EXPAND_INITIALIZER
&& TREE_CONSTANT (exp
)))
6313 rtx constructor
= output_constant_def (exp
);
6314 if (modifier
!= EXPAND_CONST_ADDRESS
6315 && modifier
!= EXPAND_INITIALIZER
6316 && modifier
!= EXPAND_SUM
6317 && (! memory_address_p (GET_MODE (constructor
),
6318 XEXP (constructor
, 0))
6320 && GET_CODE (XEXP (constructor
, 0)) != REG
)))
6321 constructor
= change_address (constructor
, VOIDmode
,
6322 XEXP (constructor
, 0));
6328 /* Handle calls that pass values in multiple non-contiguous
6329 locations. The Irix 6 ABI has examples of this. */
6330 if (target
== 0 || ! safe_from_p (target
, exp
, 1)
6331 || GET_CODE (target
) == PARALLEL
)
6333 if (mode
!= BLKmode
&& ! TREE_ADDRESSABLE (exp
))
6334 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
6336 target
= assign_temp (type
, 0, 1, 1);
6339 if (TREE_READONLY (exp
))
6341 if (GET_CODE (target
) == MEM
)
6342 target
= copy_rtx (target
);
6344 RTX_UNCHANGING_P (target
) = 1;
6347 store_constructor (exp
, target
, TYPE_ALIGN (TREE_TYPE (exp
)), 0,
6348 int_size_in_bytes (TREE_TYPE (exp
)));
6354 tree exp1
= TREE_OPERAND (exp
, 0);
6357 tree string
= string_constant (exp1
, &index
);
6359 /* Try to optimize reads from const strings. */
6361 && TREE_CODE (string
) == STRING_CST
6362 && TREE_CODE (index
) == INTEGER_CST
6363 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
6364 && GET_MODE_CLASS (mode
) == MODE_INT
6365 && GET_MODE_SIZE (mode
) == 1
6366 && modifier
!= EXPAND_MEMORY_USE_WO
)
6368 GEN_INT (TREE_STRING_POINTER (string
)[TREE_INT_CST_LOW (index
)]);
6370 op0
= expand_expr (exp1
, NULL_RTX
, VOIDmode
, EXPAND_SUM
);
6371 op0
= memory_address (mode
, op0
);
6373 if (cfun
&& current_function_check_memory_usage
6374 && ! AGGREGATE_TYPE_P (TREE_TYPE (exp
)))
6376 enum memory_use_mode memory_usage
;
6377 memory_usage
= get_memory_usage_from_modifier (modifier
);
6379 if (memory_usage
!= MEMORY_USE_DONT
)
6381 in_check_memory_usage
= 1;
6382 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
6384 GEN_INT (int_size_in_bytes (type
)),
6385 TYPE_MODE (sizetype
),
6386 GEN_INT (memory_usage
),
6387 TYPE_MODE (integer_type_node
));
6388 in_check_memory_usage
= 0;
6392 temp
= gen_rtx_MEM (mode
, op0
);
6393 /* If address was computed by addition,
6394 mark this as an element of an aggregate. */
6395 if (TREE_CODE (exp1
) == PLUS_EXPR
6396 || (TREE_CODE (exp1
) == SAVE_EXPR
6397 && TREE_CODE (TREE_OPERAND (exp1
, 0)) == PLUS_EXPR
)
6398 || AGGREGATE_TYPE_P (TREE_TYPE (exp
))
6399 || (TREE_CODE (exp1
) == ADDR_EXPR
6400 && (exp2
= TREE_OPERAND (exp1
, 0))
6401 && AGGREGATE_TYPE_P (TREE_TYPE (exp2
))))
6402 MEM_SET_IN_STRUCT_P (temp
, 1);
6404 MEM_VOLATILE_P (temp
) = TREE_THIS_VOLATILE (exp
) | flag_volatile
;
6405 MEM_ALIAS_SET (temp
) = get_alias_set (exp
);
6407 /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
6408 here, because, in C and C++, the fact that a location is accessed
6409 through a pointer to const does not mean that the value there can
6410 never change. Languages where it can never change should
6411 also set TREE_STATIC. */
6412 RTX_UNCHANGING_P (temp
) = TREE_READONLY (exp
) & TREE_STATIC (exp
);
6414 /* If we are writing to this object and its type is a record with
6415 readonly fields, we must mark it as readonly so it will
6416 conflict with readonly references to those fields. */
6417 if (modifier
== EXPAND_MEMORY_USE_WO
6418 && TREE_CODE (type
) == RECORD_TYPE
&& readonly_fields_p (type
))
6419 RTX_UNCHANGING_P (temp
) = 1;
6425 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) != ARRAY_TYPE
)
6429 tree array
= TREE_OPERAND (exp
, 0);
6430 tree domain
= TYPE_DOMAIN (TREE_TYPE (array
));
6431 tree low_bound
= domain
? TYPE_MIN_VALUE (domain
) : integer_zero_node
;
6432 tree index
= convert (sizetype
, TREE_OPERAND (exp
, 1));
6435 /* Optimize the special-case of a zero lower bound.
6437 We convert the low_bound to sizetype to avoid some problems
6438 with constant folding. (E.g. suppose the lower bound is 1,
6439 and its mode is QI. Without the conversion, (ARRAY
6440 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6441 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
6443 if (! integer_zerop (low_bound
))
6444 index
= size_diffop (index
, convert (sizetype
, low_bound
));
6446 /* Fold an expression like: "foo"[2].
6447 This is not done in fold so it won't happen inside &.
6448 Don't fold if this is for wide characters since it's too
6449 difficult to do correctly and this is a very rare case. */
6451 if (TREE_CODE (array
) == STRING_CST
6452 && TREE_CODE (index
) == INTEGER_CST
6453 && compare_tree_int (index
, TREE_STRING_LENGTH (array
)) < 0
6454 && GET_MODE_CLASS (mode
) == MODE_INT
6455 && GET_MODE_SIZE (mode
) == 1)
6457 GEN_INT (TREE_STRING_POINTER (array
)[TREE_INT_CST_LOW (index
)]);
6459 /* If this is a constant index into a constant array,
6460 just get the value from the array. Handle both the cases when
6461 we have an explicit constructor and when our operand is a variable
6462 that was declared const. */
6464 if (TREE_CODE (array
) == CONSTRUCTOR
&& ! TREE_SIDE_EFFECTS (array
)
6465 && TREE_CODE (index
) == INTEGER_CST
6466 && 0 > compare_tree_int (index
,
6467 list_length (CONSTRUCTOR_ELTS
6468 (TREE_OPERAND (exp
, 0)))))
6472 for (elem
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)),
6473 i
= TREE_INT_CST_LOW (index
);
6474 elem
!= 0 && i
!= 0; i
--, elem
= TREE_CHAIN (elem
))
6478 return expand_expr (fold (TREE_VALUE (elem
)), target
,
6479 tmode
, ro_modifier
);
6482 else if (optimize
>= 1
6483 && TREE_READONLY (array
) && ! TREE_SIDE_EFFECTS (array
)
6484 && TREE_CODE (array
) == VAR_DECL
&& DECL_INITIAL (array
)
6485 && TREE_CODE (DECL_INITIAL (array
)) != ERROR_MARK
)
6487 if (TREE_CODE (index
) == INTEGER_CST
)
6489 tree init
= DECL_INITIAL (array
);
6491 if (TREE_CODE (init
) == CONSTRUCTOR
)
6495 for (elem
= CONSTRUCTOR_ELTS (init
);
6497 && !tree_int_cst_equal (TREE_PURPOSE (elem
), index
));
6498 elem
= TREE_CHAIN (elem
))
6502 return expand_expr (fold (TREE_VALUE (elem
)), target
,
6503 tmode
, ro_modifier
);
6505 else if (TREE_CODE (init
) == STRING_CST
6506 && 0 > compare_tree_int (index
,
6507 TREE_STRING_LENGTH (init
)))
6509 (TREE_STRING_POINTER
6510 (init
)[TREE_INT_CST_LOW (index
)]));
6515 /* ... fall through ... */
6519 /* If the operand is a CONSTRUCTOR, we can just extract the
6520 appropriate field if it is present. Don't do this if we have
6521 already written the data since we want to refer to that copy
6522 and varasm.c assumes that's what we'll do. */
6523 if (code
!= ARRAY_REF
6524 && TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
6525 && TREE_CST_RTL (TREE_OPERAND (exp
, 0)) == 0)
6529 for (elt
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)); elt
;
6530 elt
= TREE_CHAIN (elt
))
6531 if (TREE_PURPOSE (elt
) == TREE_OPERAND (exp
, 1)
6532 /* We can normally use the value of the field in the
6533 CONSTRUCTOR. However, if this is a bitfield in
6534 an integral mode that we can fit in a HOST_WIDE_INT,
6535 we must mask only the number of bits in the bitfield,
6536 since this is done implicitly by the constructor. If
6537 the bitfield does not meet either of those conditions,
6538 we can't do this optimization. */
6539 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt
))
6540 || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt
)))
6542 && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt
)))
6543 <= HOST_BITS_PER_WIDE_INT
))))
6545 op0
= expand_expr (TREE_VALUE (elt
), target
, tmode
, modifier
);
6546 if (DECL_BIT_FIELD (TREE_PURPOSE (elt
)))
6548 HOST_WIDE_INT bitsize
6549 = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt
)));
6551 if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt
))))
6553 op1
= GEN_INT (((HOST_WIDE_INT
) 1 << bitsize
) - 1);
6554 op0
= expand_and (op0
, op1
, target
);
6558 enum machine_mode imode
6559 = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt
)));
6561 = build_int_2 (GET_MODE_BITSIZE (imode
) - bitsize
,
6564 op0
= expand_shift (LSHIFT_EXPR
, imode
, op0
, count
,
6566 op0
= expand_shift (RSHIFT_EXPR
, imode
, op0
, count
,
6576 enum machine_mode mode1
;
6577 HOST_WIDE_INT bitsize
, bitpos
;
6580 unsigned int alignment
;
6581 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
6582 &mode1
, &unsignedp
, &volatilep
,
6585 /* If we got back the original object, something is wrong. Perhaps
6586 we are evaluating an expression too early. In any event, don't
6587 infinitely recurse. */
6591 /* If TEM's type is a union of variable size, pass TARGET to the inner
6592 computation, since it will need a temporary and TARGET is known
6593 to have to do. This occurs in unchecked conversion in Ada. */
6595 op0
= expand_expr (tem
,
6596 (TREE_CODE (TREE_TYPE (tem
)) == UNION_TYPE
6597 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem
)))
6599 ? target
: NULL_RTX
),
6601 (modifier
== EXPAND_INITIALIZER
6602 || modifier
== EXPAND_CONST_ADDRESS
)
6603 ? modifier
: EXPAND_NORMAL
);
6605 /* If this is a constant, put it into a register if it is a
6606 legitimate constant and OFFSET is 0 and memory if it isn't. */
6607 if (CONSTANT_P (op0
))
6609 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (tem
));
6610 if (mode
!= BLKmode
&& LEGITIMATE_CONSTANT_P (op0
)
6612 op0
= force_reg (mode
, op0
);
6614 op0
= validize_mem (force_const_mem (mode
, op0
));
6619 rtx offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, 0);
6621 /* If this object is in memory, put it into a register.
6622 This case can't occur in C, but can in Ada if we have
6623 unchecked conversion of an expression from a scalar type to
6624 an array or record type. */
6625 if (GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
6626 || GET_CODE (op0
) == CONCAT
|| GET_CODE (op0
) == ADDRESSOF
)
6628 rtx memloc
= assign_temp (TREE_TYPE (tem
), 1, 1, 1);
6630 mark_temp_addr_taken (memloc
);
6631 emit_move_insn (memloc
, op0
);
6635 if (GET_CODE (op0
) != MEM
)
6638 if (GET_MODE (offset_rtx
) != ptr_mode
)
6640 #ifdef POINTERS_EXTEND_UNSIGNED
6641 offset_rtx
= convert_memory_address (ptr_mode
, offset_rtx
);
6643 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
6647 /* A constant address in OP0 can have VOIDmode, we must not try
6648 to call force_reg for that case. Avoid that case. */
6649 if (GET_CODE (op0
) == MEM
6650 && GET_MODE (op0
) == BLKmode
6651 && GET_MODE (XEXP (op0
, 0)) != VOIDmode
6653 && (bitpos
% bitsize
) == 0
6654 && (bitsize
% GET_MODE_ALIGNMENT (mode1
)) == 0
6655 && (alignment
* BITS_PER_UNIT
) == GET_MODE_ALIGNMENT (mode1
))
6657 rtx temp
= change_address (op0
, mode1
,
6658 plus_constant (XEXP (op0
, 0),
6661 if (GET_CODE (XEXP (temp
, 0)) == REG
)
6664 op0
= change_address (op0
, mode1
,
6665 force_reg (GET_MODE (XEXP (temp
, 0)),
6671 op0
= change_address (op0
, VOIDmode
,
6672 gen_rtx_PLUS (ptr_mode
, XEXP (op0
, 0),
6673 force_reg (ptr_mode
,
6677 /* Don't forget about volatility even if this is a bitfield. */
6678 if (GET_CODE (op0
) == MEM
&& volatilep
&& ! MEM_VOLATILE_P (op0
))
6680 op0
= copy_rtx (op0
);
6681 MEM_VOLATILE_P (op0
) = 1;
6684 /* Check the access. */
6685 if (current_function_check_memory_usage
&& GET_CODE (op0
) == MEM
)
6687 enum memory_use_mode memory_usage
;
6688 memory_usage
= get_memory_usage_from_modifier (modifier
);
6690 if (memory_usage
!= MEMORY_USE_DONT
)
6695 to
= plus_constant (XEXP (op0
, 0), (bitpos
/ BITS_PER_UNIT
));
6696 size
= (bitpos
% BITS_PER_UNIT
) + bitsize
+ BITS_PER_UNIT
- 1;
6698 /* Check the access right of the pointer. */
6699 if (size
> BITS_PER_UNIT
)
6700 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
6702 GEN_INT (size
/ BITS_PER_UNIT
),
6703 TYPE_MODE (sizetype
),
6704 GEN_INT (memory_usage
),
6705 TYPE_MODE (integer_type_node
));
6709 /* In cases where an aligned union has an unaligned object
6710 as a field, we might be extracting a BLKmode value from
6711 an integer-mode (e.g., SImode) object. Handle this case
6712 by doing the extract into an object as wide as the field
6713 (which we know to be the width of a basic mode), then
6714 storing into memory, and changing the mode to BLKmode.
6715 If we ultimately want the address (EXPAND_CONST_ADDRESS or
6716 EXPAND_INITIALIZER), then we must not copy to a temporary. */
6717 if (mode1
== VOIDmode
6718 || GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
6719 || (modifier
!= EXPAND_CONST_ADDRESS
6720 && modifier
!= EXPAND_INITIALIZER
6721 && ((mode1
!= BLKmode
&& ! direct_load
[(int) mode1
]
6722 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
6723 && GET_MODE_CLASS (mode
) != MODE_COMPLEX_FLOAT
)
6724 /* If the field isn't aligned enough to fetch as a memref,
6725 fetch it as a bit field. */
6726 || (mode1
!= BLKmode
6727 && SLOW_UNALIGNED_ACCESS (mode1
, alignment
)
6728 && ((TYPE_ALIGN (TREE_TYPE (tem
))
6729 < (unsigned int) GET_MODE_ALIGNMENT (mode
))
6730 || (bitpos
% GET_MODE_ALIGNMENT (mode
) != 0)))
6731 /* If the type and the field are a constant size and the
6732 size of the type isn't the same size as the bitfield,
6733 we must use bitfield operations. */
6735 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp
)))
6737 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp
)),
6739 || (modifier
!= EXPAND_CONST_ADDRESS
6740 && modifier
!= EXPAND_INITIALIZER
6742 && SLOW_UNALIGNED_ACCESS (mode
, alignment
)
6743 && (TYPE_ALIGN (type
) > alignment
* BITS_PER_UNIT
6744 || bitpos
% TYPE_ALIGN (type
) != 0)))
6746 enum machine_mode ext_mode
= mode
;
6748 if (ext_mode
== BLKmode
6749 && ! (target
!= 0 && GET_CODE (op0
) == MEM
6750 && GET_CODE (target
) == MEM
6751 && bitpos
% BITS_PER_UNIT
== 0))
6752 ext_mode
= mode_for_size (bitsize
, MODE_INT
, 1);
6754 if (ext_mode
== BLKmode
)
6756 /* In this case, BITPOS must start at a byte boundary and
6757 TARGET, if specified, must be a MEM. */
6758 if (GET_CODE (op0
) != MEM
6759 || (target
!= 0 && GET_CODE (target
) != MEM
)
6760 || bitpos
% BITS_PER_UNIT
!= 0)
6763 op0
= change_address (op0
, VOIDmode
,
6764 plus_constant (XEXP (op0
, 0),
6765 bitpos
/ BITS_PER_UNIT
));
6767 target
= assign_temp (type
, 0, 1, 1);
6769 emit_block_move (target
, op0
,
6770 GEN_INT ((bitsize
+ BITS_PER_UNIT
- 1)
6777 op0
= validize_mem (op0
);
6779 if (GET_CODE (op0
) == MEM
&& GET_CODE (XEXP (op0
, 0)) == REG
)
6780 mark_reg_pointer (XEXP (op0
, 0), alignment
);
6782 op0
= extract_bit_field (op0
, bitsize
, bitpos
,
6783 unsignedp
, target
, ext_mode
, ext_mode
,
6785 int_size_in_bytes (TREE_TYPE (tem
)));
6787 /* If the result is a record type and BITSIZE is narrower than
6788 the mode of OP0, an integral mode, and this is a big endian
6789 machine, we must put the field into the high-order bits. */
6790 if (TREE_CODE (type
) == RECORD_TYPE
&& BYTES_BIG_ENDIAN
6791 && GET_MODE_CLASS (GET_MODE (op0
)) == MODE_INT
6792 && bitsize
< GET_MODE_BITSIZE (GET_MODE (op0
)))
6793 op0
= expand_shift (LSHIFT_EXPR
, GET_MODE (op0
), op0
,
6794 size_int (GET_MODE_BITSIZE (GET_MODE (op0
))
6798 if (mode
== BLKmode
)
6800 rtx
new = assign_stack_temp (ext_mode
,
6801 bitsize
/ BITS_PER_UNIT
, 0);
6803 emit_move_insn (new, op0
);
6804 op0
= copy_rtx (new);
6805 PUT_MODE (op0
, BLKmode
);
6806 MEM_SET_IN_STRUCT_P (op0
, 1);
6812 /* If the result is BLKmode, use that to access the object
6814 if (mode
== BLKmode
)
6817 /* Get a reference to just this component. */
6818 if (modifier
== EXPAND_CONST_ADDRESS
6819 || modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
6820 op0
= gen_rtx_MEM (mode1
, plus_constant (XEXP (op0
, 0),
6821 (bitpos
/ BITS_PER_UNIT
)));
6823 op0
= change_address (op0
, mode1
,
6824 plus_constant (XEXP (op0
, 0),
6825 (bitpos
/ BITS_PER_UNIT
)));
6827 if (GET_CODE (op0
) == MEM
)
6828 MEM_ALIAS_SET (op0
) = get_alias_set (exp
);
6830 if (GET_CODE (XEXP (op0
, 0)) == REG
)
6831 mark_reg_pointer (XEXP (op0
, 0), alignment
);
6833 MEM_SET_IN_STRUCT_P (op0
, 1);
6834 MEM_VOLATILE_P (op0
) |= volatilep
;
6835 if (mode
== mode1
|| mode1
== BLKmode
|| mode1
== tmode
6836 || modifier
== EXPAND_CONST_ADDRESS
6837 || modifier
== EXPAND_INITIALIZER
)
6839 else if (target
== 0)
6840 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
6842 convert_move (target
, op0
, unsignedp
);
6846 /* Intended for a reference to a buffer of a file-object in Pascal.
6847 But it's not certain that a special tree code will really be
6848 necessary for these. INDIRECT_REF might work for them. */
6854 /* Pascal set IN expression.
6857 rlo = set_low - (set_low%bits_per_word);
6858 the_word = set [ (index - rlo)/bits_per_word ];
6859 bit_index = index % bits_per_word;
6860 bitmask = 1 << bit_index;
6861 return !!(the_word & bitmask); */
6863 tree set
= TREE_OPERAND (exp
, 0);
6864 tree index
= TREE_OPERAND (exp
, 1);
6865 int iunsignedp
= TREE_UNSIGNED (TREE_TYPE (index
));
6866 tree set_type
= TREE_TYPE (set
);
6867 tree set_low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (set_type
));
6868 tree set_high_bound
= TYPE_MAX_VALUE (TYPE_DOMAIN (set_type
));
6869 rtx index_val
= expand_expr (index
, 0, VOIDmode
, 0);
6870 rtx lo_r
= expand_expr (set_low_bound
, 0, VOIDmode
, 0);
6871 rtx hi_r
= expand_expr (set_high_bound
, 0, VOIDmode
, 0);
6872 rtx setval
= expand_expr (set
, 0, VOIDmode
, 0);
6873 rtx setaddr
= XEXP (setval
, 0);
6874 enum machine_mode index_mode
= TYPE_MODE (TREE_TYPE (index
));
6876 rtx diff
, quo
, rem
, addr
, bit
, result
;
6878 preexpand_calls (exp
);
6880 /* If domain is empty, answer is no. Likewise if index is constant
6881 and out of bounds. */
6882 if (((TREE_CODE (set_high_bound
) == INTEGER_CST
6883 && TREE_CODE (set_low_bound
) == INTEGER_CST
6884 && tree_int_cst_lt (set_high_bound
, set_low_bound
))
6885 || (TREE_CODE (index
) == INTEGER_CST
6886 && TREE_CODE (set_low_bound
) == INTEGER_CST
6887 && tree_int_cst_lt (index
, set_low_bound
))
6888 || (TREE_CODE (set_high_bound
) == INTEGER_CST
6889 && TREE_CODE (index
) == INTEGER_CST
6890 && tree_int_cst_lt (set_high_bound
, index
))))
6894 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
6896 /* If we get here, we have to generate the code for both cases
6897 (in range and out of range). */
6899 op0
= gen_label_rtx ();
6900 op1
= gen_label_rtx ();
6902 if (! (GET_CODE (index_val
) == CONST_INT
6903 && GET_CODE (lo_r
) == CONST_INT
))
6905 emit_cmp_and_jump_insns (index_val
, lo_r
, LT
, NULL_RTX
,
6906 GET_MODE (index_val
), iunsignedp
, 0, op1
);
6909 if (! (GET_CODE (index_val
) == CONST_INT
6910 && GET_CODE (hi_r
) == CONST_INT
))
6912 emit_cmp_and_jump_insns (index_val
, hi_r
, GT
, NULL_RTX
,
6913 GET_MODE (index_val
), iunsignedp
, 0, op1
);
6916 /* Calculate the element number of bit zero in the first word
6918 if (GET_CODE (lo_r
) == CONST_INT
)
6919 rlow
= GEN_INT (INTVAL (lo_r
)
6920 & ~ ((HOST_WIDE_INT
) 1 << BITS_PER_UNIT
));
6922 rlow
= expand_binop (index_mode
, and_optab
, lo_r
,
6923 GEN_INT (~((HOST_WIDE_INT
) 1 << BITS_PER_UNIT
)),
6924 NULL_RTX
, iunsignedp
, OPTAB_LIB_WIDEN
);
6926 diff
= expand_binop (index_mode
, sub_optab
, index_val
, rlow
,
6927 NULL_RTX
, iunsignedp
, OPTAB_LIB_WIDEN
);
6929 quo
= expand_divmod (0, TRUNC_DIV_EXPR
, index_mode
, diff
,
6930 GEN_INT (BITS_PER_UNIT
), NULL_RTX
, iunsignedp
);
6931 rem
= expand_divmod (1, TRUNC_MOD_EXPR
, index_mode
, index_val
,
6932 GEN_INT (BITS_PER_UNIT
), NULL_RTX
, iunsignedp
);
6934 addr
= memory_address (byte_mode
,
6935 expand_binop (index_mode
, add_optab
, diff
,
6936 setaddr
, NULL_RTX
, iunsignedp
,
6939 /* Extract the bit we want to examine */
6940 bit
= expand_shift (RSHIFT_EXPR
, byte_mode
,
6941 gen_rtx_MEM (byte_mode
, addr
),
6942 make_tree (TREE_TYPE (index
), rem
),
6944 result
= expand_binop (byte_mode
, and_optab
, bit
, const1_rtx
,
6945 GET_MODE (target
) == byte_mode
? target
: 0,
6946 1, OPTAB_LIB_WIDEN
);
6948 if (result
!= target
)
6949 convert_move (target
, result
, 1);
6951 /* Output the code to handle the out-of-range case. */
6954 emit_move_insn (target
, const0_rtx
);
6959 case WITH_CLEANUP_EXPR
:
6960 if (RTL_EXPR_RTL (exp
) == 0)
6963 = expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, ro_modifier
);
6964 expand_decl_cleanup (NULL_TREE
, TREE_OPERAND (exp
, 2));
6966 /* That's it for this cleanup. */
6967 TREE_OPERAND (exp
, 2) = 0;
6969 return RTL_EXPR_RTL (exp
);
6971 case CLEANUP_POINT_EXPR
:
6973 /* Start a new binding layer that will keep track of all cleanup
6974 actions to be performed. */
6975 expand_start_bindings (2);
6977 target_temp_slot_level
= temp_slot_level
;
6979 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
, ro_modifier
);
6980 /* If we're going to use this value, load it up now. */
6982 op0
= force_not_mem (op0
);
6983 preserve_temp_slots (op0
);
6984 expand_end_bindings (NULL_TREE
, 0, 0);
6989 /* Check for a built-in function. */
6990 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
6991 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
6993 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
6994 return expand_builtin (exp
, target
, subtarget
, tmode
, ignore
);
6996 /* If this call was expanded already by preexpand_calls,
6997 just return the result we got. */
6998 if (CALL_EXPR_RTL (exp
) != 0)
6999 return CALL_EXPR_RTL (exp
);
7001 return expand_call (exp
, target
, ignore
);
7003 case NON_LVALUE_EXPR
:
7006 case REFERENCE_EXPR
:
7007 if (TREE_CODE (type
) == UNION_TYPE
)
7009 tree valtype
= TREE_TYPE (TREE_OPERAND (exp
, 0));
7011 /* If both input and output are BLKmode, this conversion
7012 isn't actually doing anything unless we need to make the
7013 alignment stricter. */
7014 if (mode
== BLKmode
&& TYPE_MODE (valtype
) == BLKmode
7015 && (TYPE_ALIGN (type
) <= TYPE_ALIGN (valtype
)
7016 || TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
))
7017 return expand_expr (TREE_OPERAND (exp
, 0), target
, tmode
,
7022 if (mode
!= BLKmode
)
7023 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
7025 target
= assign_temp (type
, 0, 1, 1);
7028 if (GET_CODE (target
) == MEM
)
7029 /* Store data into beginning of memory target. */
7030 store_expr (TREE_OPERAND (exp
, 0),
7031 change_address (target
, TYPE_MODE (valtype
), 0), 0);
7033 else if (GET_CODE (target
) == REG
)
7034 /* Store this field into a union of the proper type. */
7035 store_field (target
,
7036 MIN ((int_size_in_bytes (TREE_TYPE
7037 (TREE_OPERAND (exp
, 0)))
7039 GET_MODE_BITSIZE (mode
)),
7040 0, TYPE_MODE (valtype
), TREE_OPERAND (exp
, 0),
7041 VOIDmode
, 0, 1, int_size_in_bytes (type
), 0);
7045 /* Return the entire union. */
7049 if (mode
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
7051 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
,
7054 /* If the signedness of the conversion differs and OP0 is
7055 a promoted SUBREG, clear that indication since we now
7056 have to do the proper extension. */
7057 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))) != unsignedp
7058 && GET_CODE (op0
) == SUBREG
)
7059 SUBREG_PROMOTED_VAR_P (op0
) = 0;
7064 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, mode
, 0);
7065 if (GET_MODE (op0
) == mode
)
7068 /* If OP0 is a constant, just convert it into the proper mode. */
7069 if (CONSTANT_P (op0
))
7071 convert_modes (mode
, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
7072 op0
, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7074 if (modifier
== EXPAND_INITIALIZER
)
7075 return gen_rtx_fmt_e (unsignedp
? ZERO_EXTEND
: SIGN_EXTEND
, mode
, op0
);
7079 convert_to_mode (mode
, op0
,
7080 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7082 convert_move (target
, op0
,
7083 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7087 /* We come here from MINUS_EXPR when the second operand is a
7090 this_optab
= add_optab
;
7092 /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7093 something else, make sure we add the register to the constant and
7094 then to the other thing. This case can occur during strength
7095 reduction and doing it this way will produce better code if the
7096 frame pointer or argument pointer is eliminated.
7098 fold-const.c will ensure that the constant is always in the inner
7099 PLUS_EXPR, so the only case we need to do anything about is if
7100 sp, ap, or fp is our second argument, in which case we must swap
7101 the innermost first argument and our second argument. */
7103 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == PLUS_EXPR
7104 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1)) == INTEGER_CST
7105 && TREE_CODE (TREE_OPERAND (exp
, 1)) == RTL_EXPR
7106 && (RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == frame_pointer_rtx
7107 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == stack_pointer_rtx
7108 || RTL_EXPR_RTL (TREE_OPERAND (exp
, 1)) == arg_pointer_rtx
))
7110 tree t
= TREE_OPERAND (exp
, 1);
7112 TREE_OPERAND (exp
, 1) = TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
7113 TREE_OPERAND (TREE_OPERAND (exp
, 0), 0) = t
;
7116 /* If the result is to be ptr_mode and we are adding an integer to
7117 something, we might be forming a constant. So try to use
7118 plus_constant. If it produces a sum and we can't accept it,
7119 use force_operand. This allows P = &ARR[const] to generate
7120 efficient code on machines where a SYMBOL_REF is not a valid
7123 If this is an EXPAND_SUM call, always return the sum. */
7124 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
7125 || mode
== ptr_mode
)
7127 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
7128 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
7129 && TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
7133 op1
= expand_expr (TREE_OPERAND (exp
, 1), subtarget
, VOIDmode
,
7135 /* Use immed_double_const to ensure that the constant is
7136 truncated according to the mode of OP1, then sign extended
7137 to a HOST_WIDE_INT. Using the constant directly can result
7138 in non-canonical RTL in a 64x32 cross compile. */
7140 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 0)),
7142 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))));
7143 op1
= plus_constant (op1
, INTVAL (constant_part
));
7144 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7145 op1
= force_operand (op1
, target
);
7149 else if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
7150 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_INT
7151 && TREE_CONSTANT (TREE_OPERAND (exp
, 0)))
7155 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
7157 if (! CONSTANT_P (op0
))
7159 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
,
7160 VOIDmode
, modifier
);
7161 /* Don't go to both_summands if modifier
7162 says it's not right to return a PLUS. */
7163 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7167 /* Use immed_double_const to ensure that the constant is
7168 truncated according to the mode of OP1, then sign extended
7169 to a HOST_WIDE_INT. Using the constant directly can result
7170 in non-canonical RTL in a 64x32 cross compile. */
7172 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)),
7174 TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7175 op0
= plus_constant (op0
, INTVAL (constant_part
));
7176 if (modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7177 op0
= force_operand (op0
, target
);
7182 /* No sense saving up arithmetic to be done
7183 if it's all in the wrong mode to form part of an address.
7184 And force_operand won't know whether to sign-extend or
7186 if ((modifier
!= EXPAND_SUM
&& modifier
!= EXPAND_INITIALIZER
)
7187 || mode
!= ptr_mode
)
7190 preexpand_calls (exp
);
7191 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
7194 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, ro_modifier
);
7195 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, ro_modifier
);
7198 /* Make sure any term that's a sum with a constant comes last. */
7199 if (GET_CODE (op0
) == PLUS
7200 && CONSTANT_P (XEXP (op0
, 1)))
7206 /* If adding to a sum including a constant,
7207 associate it to put the constant outside. */
7208 if (GET_CODE (op1
) == PLUS
7209 && CONSTANT_P (XEXP (op1
, 1)))
7211 rtx constant_term
= const0_rtx
;
7213 temp
= simplify_binary_operation (PLUS
, mode
, XEXP (op1
, 0), op0
);
7216 /* Ensure that MULT comes first if there is one. */
7217 else if (GET_CODE (op0
) == MULT
)
7218 op0
= gen_rtx_PLUS (mode
, op0
, XEXP (op1
, 0));
7220 op0
= gen_rtx_PLUS (mode
, XEXP (op1
, 0), op0
);
7222 /* Let's also eliminate constants from op0 if possible. */
7223 op0
= eliminate_constant_term (op0
, &constant_term
);
7225 /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7226 their sum should be a constant. Form it into OP1, since the
7227 result we want will then be OP0 + OP1. */
7229 temp
= simplify_binary_operation (PLUS
, mode
, constant_term
,
7234 op1
= gen_rtx_PLUS (mode
, constant_term
, XEXP (op1
, 1));
7237 /* Put a constant term last and put a multiplication first. */
7238 if (CONSTANT_P (op0
) || GET_CODE (op1
) == MULT
)
7239 temp
= op1
, op1
= op0
, op0
= temp
;
7241 temp
= simplify_binary_operation (PLUS
, mode
, op0
, op1
);
7242 return temp
? temp
: gen_rtx_PLUS (mode
, op0
, op1
);
7245 /* For initializers, we are allowed to return a MINUS of two
7246 symbolic constants. Here we handle all cases when both operands
7248 /* Handle difference of two symbolic constants,
7249 for the sake of an initializer. */
7250 if ((modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
7251 && really_constant_p (TREE_OPERAND (exp
, 0))
7252 && really_constant_p (TREE_OPERAND (exp
, 1)))
7254 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
,
7255 VOIDmode
, ro_modifier
);
7256 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
,
7257 VOIDmode
, ro_modifier
);
7259 /* If the last operand is a CONST_INT, use plus_constant of
7260 the negated constant. Else make the MINUS. */
7261 if (GET_CODE (op1
) == CONST_INT
)
7262 return plus_constant (op0
, - INTVAL (op1
));
7264 return gen_rtx_MINUS (mode
, op0
, op1
);
7266 /* Convert A - const to A + (-const). */
7267 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
7269 tree negated
= fold (build1 (NEGATE_EXPR
, type
,
7270 TREE_OPERAND (exp
, 1)));
7272 if (TREE_UNSIGNED (type
) || TREE_OVERFLOW (negated
))
7273 /* If we can't negate the constant in TYPE, leave it alone and
7274 expand_binop will negate it for us. We used to try to do it
7275 here in the signed version of TYPE, but that doesn't work
7276 on POINTER_TYPEs. */;
7279 exp
= build (PLUS_EXPR
, type
, TREE_OPERAND (exp
, 0), negated
);
7283 this_optab
= sub_optab
;
7287 preexpand_calls (exp
);
7288 /* If first operand is constant, swap them.
7289 Thus the following special case checks need only
7290 check the second operand. */
7291 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
)
7293 register tree t1
= TREE_OPERAND (exp
, 0);
7294 TREE_OPERAND (exp
, 0) = TREE_OPERAND (exp
, 1);
7295 TREE_OPERAND (exp
, 1) = t1
;
7298 /* Attempt to return something suitable for generating an
7299 indexed address, for machines that support that. */
7301 if (modifier
== EXPAND_SUM
&& mode
== ptr_mode
7302 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
7303 && GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
7305 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
,
7308 /* Apply distributive law if OP0 is x+c. */
7309 if (GET_CODE (op0
) == PLUS
7310 && GET_CODE (XEXP (op0
, 1)) == CONST_INT
)
7315 (mode
, XEXP (op0
, 0),
7316 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1)))),
7317 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))
7318 * INTVAL (XEXP (op0
, 1))));
7320 if (GET_CODE (op0
) != REG
)
7321 op0
= force_operand (op0
, NULL_RTX
);
7322 if (GET_CODE (op0
) != REG
)
7323 op0
= copy_to_mode_reg (mode
, op0
);
7326 gen_rtx_MULT (mode
, op0
,
7327 GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))));
7330 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
7333 /* Check for multiplying things that have been extended
7334 from a narrower type. If this machine supports multiplying
7335 in that narrower type with a result in the desired type,
7336 do it that way, and avoid the explicit type-conversion. */
7337 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == NOP_EXPR
7338 && TREE_CODE (type
) == INTEGER_TYPE
7339 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7340 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))))
7341 && ((TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
7342 && int_fits_type_p (TREE_OPERAND (exp
, 1),
7343 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7344 /* Don't use a widening multiply if a shift will do. */
7345 && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
7346 > HOST_BITS_PER_WIDE_INT
)
7347 || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp
, 1))) < 0))
7349 (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
7350 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
7352 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))))
7353 /* If both operands are extended, they must either both
7354 be zero-extended or both be sign-extended. */
7355 && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0)))
7357 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))))))
7359 enum machine_mode innermode
7360 = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)));
7361 optab other_optab
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7362 ? smul_widen_optab
: umul_widen_optab
);
7363 this_optab
= (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0)))
7364 ? umul_widen_optab
: smul_widen_optab
);
7365 if (mode
== GET_MODE_WIDER_MODE (innermode
))
7367 if (this_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
)
7369 op0
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7370 NULL_RTX
, VOIDmode
, 0);
7371 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
7372 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
,
7375 op1
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
7376 NULL_RTX
, VOIDmode
, 0);
7379 else if (other_optab
->handlers
[(int) mode
].insn_code
!= CODE_FOR_nothing
7380 && innermode
== word_mode
)
7383 op0
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7384 NULL_RTX
, VOIDmode
, 0);
7385 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
7386 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
,
7389 op1
= expand_expr (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0),
7390 NULL_RTX
, VOIDmode
, 0);
7391 temp
= expand_binop (mode
, other_optab
, op0
, op1
, target
,
7392 unsignedp
, OPTAB_LIB_WIDEN
);
7393 htem
= expand_mult_highpart_adjust (innermode
,
7394 gen_highpart (innermode
, temp
),
7396 gen_highpart (innermode
, temp
),
7398 emit_move_insn (gen_highpart (innermode
, temp
), htem
);
7403 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7404 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
7405 return expand_mult (mode
, op0
, op1
, target
, unsignedp
);
7407 case TRUNC_DIV_EXPR
:
7408 case FLOOR_DIV_EXPR
:
7410 case ROUND_DIV_EXPR
:
7411 case EXACT_DIV_EXPR
:
7412 preexpand_calls (exp
);
7413 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
7415 /* Possible optimization: compute the dividend with EXPAND_SUM
7416 then if the divisor is constant can optimize the case
7417 where some terms of the dividend have coeffs divisible by it. */
7418 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7419 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
7420 return expand_divmod (0, code
, mode
, op0
, op1
, target
, unsignedp
);
7423 this_optab
= flodiv_optab
;
7426 case TRUNC_MOD_EXPR
:
7427 case FLOOR_MOD_EXPR
:
7429 case ROUND_MOD_EXPR
:
7430 preexpand_calls (exp
);
7431 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
7433 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7434 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
7435 return expand_divmod (1, code
, mode
, op0
, op1
, target
, unsignedp
);
7437 case FIX_ROUND_EXPR
:
7438 case FIX_FLOOR_EXPR
:
7440 abort (); /* Not used for C. */
7442 case FIX_TRUNC_EXPR
:
7443 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, VOIDmode
, 0);
7445 target
= gen_reg_rtx (mode
);
7446 expand_fix (target
, op0
, unsignedp
);
7450 op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, VOIDmode
, 0);
7452 target
= gen_reg_rtx (mode
);
7453 /* expand_float can't figure out what to do if FROM has VOIDmode.
7454 So give it the correct mode. With -O, cse will optimize this. */
7455 if (GET_MODE (op0
) == VOIDmode
)
7456 op0
= copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
7458 expand_float (target
, op0
,
7459 TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0))));
7463 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7464 temp
= expand_unop (mode
, neg_optab
, op0
, target
, 0);
7470 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7472 /* Handle complex values specially. */
7473 if (GET_MODE_CLASS (mode
) == MODE_COMPLEX_INT
7474 || GET_MODE_CLASS (mode
) == MODE_COMPLEX_FLOAT
)
7475 return expand_complex_abs (mode
, op0
, target
, unsignedp
);
7477 /* Unsigned abs is simply the operand. Testing here means we don't
7478 risk generating incorrect code below. */
7479 if (TREE_UNSIGNED (type
))
7482 return expand_abs (mode
, op0
, target
,
7483 safe_from_p (target
, TREE_OPERAND (exp
, 0), 1));
7487 target
= original_target
;
7488 if (target
== 0 || ! safe_from_p (target
, TREE_OPERAND (exp
, 1), 1)
7489 || (GET_CODE (target
) == MEM
&& MEM_VOLATILE_P (target
))
7490 || GET_MODE (target
) != mode
7491 || (GET_CODE (target
) == REG
7492 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
7493 target
= gen_reg_rtx (mode
);
7494 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
7495 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
7497 /* First try to do it with a special MIN or MAX instruction.
7498 If that does not win, use a conditional jump to select the proper
7500 this_optab
= (TREE_UNSIGNED (type
)
7501 ? (code
== MIN_EXPR
? umin_optab
: umax_optab
)
7502 : (code
== MIN_EXPR
? smin_optab
: smax_optab
));
7504 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
, unsignedp
,
7509 /* At this point, a MEM target is no longer useful; we will get better
7512 if (GET_CODE (target
) == MEM
)
7513 target
= gen_reg_rtx (mode
);
7516 emit_move_insn (target
, op0
);
7518 op0
= gen_label_rtx ();
7520 /* If this mode is an integer too wide to compare properly,
7521 compare word by word. Rely on cse to optimize constant cases. */
7522 if (GET_MODE_CLASS (mode
) == MODE_INT
7523 && ! can_compare_p (GE
, mode
, ccp_jump
))
7525 if (code
== MAX_EXPR
)
7526 do_jump_by_parts_greater_rtx (mode
, TREE_UNSIGNED (type
),
7527 target
, op1
, NULL_RTX
, op0
);
7529 do_jump_by_parts_greater_rtx (mode
, TREE_UNSIGNED (type
),
7530 op1
, target
, NULL_RTX
, op0
);
7534 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 1)));
7535 do_compare_rtx_and_jump (target
, op1
, code
== MAX_EXPR
? GE
: LE
,
7536 unsignedp
, mode
, NULL_RTX
, 0, NULL_RTX
,
7539 emit_move_insn (target
, op1
);
7544 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7545 temp
= expand_unop (mode
, one_cmpl_optab
, op0
, target
, 1);
7551 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7552 temp
= expand_unop (mode
, ffs_optab
, op0
, target
, 1);
7557 /* ??? Can optimize bitwise operations with one arg constant.
7558 Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7559 and (a bitwise1 b) bitwise2 b (etc)
7560 but that is probably not worth while. */
7562 /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
7563 boolean values when we want in all cases to compute both of them. In
7564 general it is fastest to do TRUTH_AND_EXPR by computing both operands
7565 as actual zero-or-1 values and then bitwise anding. In cases where
7566 there cannot be any side effects, better code would be made by
7567 treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
7568 how to recognize those cases. */
7570 case TRUTH_AND_EXPR
:
7572 this_optab
= and_optab
;
7577 this_optab
= ior_optab
;
7580 case TRUTH_XOR_EXPR
:
7582 this_optab
= xor_optab
;
7589 preexpand_calls (exp
);
7590 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
7592 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
7593 return expand_shift (code
, mode
, op0
, TREE_OPERAND (exp
, 1), target
,
7596 /* Could determine the answer when only additive constants differ. Also,
7597 the addition of one can be handled by changing the condition. */
7604 case UNORDERED_EXPR
:
7611 preexpand_calls (exp
);
7612 temp
= do_store_flag (exp
, target
, tmode
!= VOIDmode
? tmode
: mode
, 0);
7616 /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
7617 if (code
== NE_EXPR
&& integer_zerop (TREE_OPERAND (exp
, 1))
7619 && GET_CODE (original_target
) == REG
7620 && (GET_MODE (original_target
)
7621 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
7623 temp
= expand_expr (TREE_OPERAND (exp
, 0), original_target
,
7626 if (temp
!= original_target
)
7627 temp
= copy_to_reg (temp
);
7629 op1
= gen_label_rtx ();
7630 emit_cmp_and_jump_insns (temp
, const0_rtx
, EQ
, NULL_RTX
,
7631 GET_MODE (temp
), unsignedp
, 0, op1
);
7632 emit_move_insn (temp
, const1_rtx
);
7637 /* If no set-flag instruction, must generate a conditional
7638 store into a temporary variable. Drop through
7639 and handle this like && and ||. */
7641 case TRUTH_ANDIF_EXPR
:
7642 case TRUTH_ORIF_EXPR
:
7644 && (target
== 0 || ! safe_from_p (target
, exp
, 1)
7645 /* Make sure we don't have a hard reg (such as function's return
7646 value) live across basic blocks, if not optimizing. */
7647 || (!optimize
&& GET_CODE (target
) == REG
7648 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)))
7649 target
= gen_reg_rtx (tmode
!= VOIDmode
? tmode
: mode
);
7652 emit_clr_insn (target
);
7654 op1
= gen_label_rtx ();
7655 jumpifnot (exp
, op1
);
7658 emit_0_to_1_insn (target
);
7661 return ignore
? const0_rtx
: target
;
7663 case TRUTH_NOT_EXPR
:
7664 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, VOIDmode
, 0);
7665 /* The parser is careful to generate TRUTH_NOT_EXPR
7666 only with operands that are always zero or one. */
7667 temp
= expand_binop (mode
, xor_optab
, op0
, const1_rtx
,
7668 target
, 1, OPTAB_LIB_WIDEN
);
7674 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
7676 return expand_expr (TREE_OPERAND (exp
, 1),
7677 (ignore
? const0_rtx
: target
),
7681 /* If we would have a "singleton" (see below) were it not for a
7682 conversion in each arm, bring that conversion back out. */
7683 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == NOP_EXPR
7684 && TREE_CODE (TREE_OPERAND (exp
, 2)) == NOP_EXPR
7685 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 1), 0))
7686 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp
, 2), 0))))
7688 tree
true = TREE_OPERAND (TREE_OPERAND (exp
, 1), 0);
7689 tree
false = TREE_OPERAND (TREE_OPERAND (exp
, 2), 0);
7691 if ((TREE_CODE_CLASS (TREE_CODE (true)) == '2'
7692 && operand_equal_p (false, TREE_OPERAND (true, 0), 0))
7693 || (TREE_CODE_CLASS (TREE_CODE (false)) == '2'
7694 && operand_equal_p (true, TREE_OPERAND (false, 0), 0))
7695 || (TREE_CODE_CLASS (TREE_CODE (true)) == '1'
7696 && operand_equal_p (false, TREE_OPERAND (true, 0), 0))
7697 || (TREE_CODE_CLASS (TREE_CODE (false)) == '1'
7698 && operand_equal_p (true, TREE_OPERAND (false, 0), 0)))
7699 return expand_expr (build1 (NOP_EXPR
, type
,
7700 build (COND_EXPR
, TREE_TYPE (true),
7701 TREE_OPERAND (exp
, 0),
7703 target
, tmode
, modifier
);
7707 /* Note that COND_EXPRs whose type is a structure or union
7708 are required to be constructed to contain assignments of
7709 a temporary variable, so that we can evaluate them here
7710 for side effect only. If type is void, we must do likewise. */
7712 /* If an arm of the branch requires a cleanup,
7713 only that cleanup is performed. */
7716 tree binary_op
= 0, unary_op
= 0;
7718 /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
7719 convert it to our mode, if necessary. */
7720 if (integer_onep (TREE_OPERAND (exp
, 1))
7721 && integer_zerop (TREE_OPERAND (exp
, 2))
7722 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
7726 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
,
7731 op0
= expand_expr (TREE_OPERAND (exp
, 0), target
, mode
, ro_modifier
);
7732 if (GET_MODE (op0
) == mode
)
7736 target
= gen_reg_rtx (mode
);
7737 convert_move (target
, op0
, unsignedp
);
7741 /* Check for X ? A + B : A. If we have this, we can copy A to the
7742 output and conditionally add B. Similarly for unary operations.
7743 Don't do this if X has side-effects because those side effects
7744 might affect A or B and the "?" operation is a sequence point in
7745 ANSI. (operand_equal_p tests for side effects.) */
7747 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '2'
7748 && operand_equal_p (TREE_OPERAND (exp
, 2),
7749 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
7750 singleton
= TREE_OPERAND (exp
, 2), binary_op
= TREE_OPERAND (exp
, 1);
7751 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '2'
7752 && operand_equal_p (TREE_OPERAND (exp
, 1),
7753 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
7754 singleton
= TREE_OPERAND (exp
, 1), binary_op
= TREE_OPERAND (exp
, 2);
7755 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 1))) == '1'
7756 && operand_equal_p (TREE_OPERAND (exp
, 2),
7757 TREE_OPERAND (TREE_OPERAND (exp
, 1), 0), 0))
7758 singleton
= TREE_OPERAND (exp
, 2), unary_op
= TREE_OPERAND (exp
, 1);
7759 else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 2))) == '1'
7760 && operand_equal_p (TREE_OPERAND (exp
, 1),
7761 TREE_OPERAND (TREE_OPERAND (exp
, 2), 0), 0))
7762 singleton
= TREE_OPERAND (exp
, 1), unary_op
= TREE_OPERAND (exp
, 2);
7764 /* If we are not to produce a result, we have no target. Otherwise,
7765 if a target was specified use it; it will not be used as an
7766 intermediate target unless it is safe. If no target, use a
7771 else if (original_target
7772 && (safe_from_p (original_target
, TREE_OPERAND (exp
, 0), 1)
7773 || (singleton
&& GET_CODE (original_target
) == REG
7774 && REGNO (original_target
) >= FIRST_PSEUDO_REGISTER
7775 && original_target
== var_rtx (singleton
)))
7776 && GET_MODE (original_target
) == mode
7777 #ifdef HAVE_conditional_move
7778 && (! can_conditionally_move_p (mode
)
7779 || GET_CODE (original_target
) == REG
7780 || TREE_ADDRESSABLE (type
))
7782 && ! (GET_CODE (original_target
) == MEM
7783 && MEM_VOLATILE_P (original_target
)))
7784 temp
= original_target
;
7785 else if (TREE_ADDRESSABLE (type
))
7788 temp
= assign_temp (type
, 0, 0, 1);
7790 /* If we had X ? A + C : A, with C a constant power of 2, and we can
7791 do the test of X as a store-flag operation, do this as
7792 A + ((X != 0) << log C). Similarly for other simple binary
7793 operators. Only do for C == 1 if BRANCH_COST is low. */
7794 if (temp
&& singleton
&& binary_op
7795 && (TREE_CODE (binary_op
) == PLUS_EXPR
7796 || TREE_CODE (binary_op
) == MINUS_EXPR
7797 || TREE_CODE (binary_op
) == BIT_IOR_EXPR
7798 || TREE_CODE (binary_op
) == BIT_XOR_EXPR
)
7799 && (BRANCH_COST
>= 3 ? integer_pow2p (TREE_OPERAND (binary_op
, 1))
7800 : integer_onep (TREE_OPERAND (binary_op
, 1)))
7801 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<')
7804 optab boptab
= (TREE_CODE (binary_op
) == PLUS_EXPR
? add_optab
7805 : TREE_CODE (binary_op
) == MINUS_EXPR
? sub_optab
7806 : TREE_CODE (binary_op
) == BIT_IOR_EXPR
? ior_optab
7809 /* If we had X ? A : A + 1, do this as A + (X == 0).
7811 We have to invert the truth value here and then put it
7812 back later if do_store_flag fails. We cannot simply copy
7813 TREE_OPERAND (exp, 0) to another variable and modify that
7814 because invert_truthvalue can modify the tree pointed to
7816 if (singleton
== TREE_OPERAND (exp
, 1))
7817 TREE_OPERAND (exp
, 0)
7818 = invert_truthvalue (TREE_OPERAND (exp
, 0));
7820 result
= do_store_flag (TREE_OPERAND (exp
, 0),
7821 (safe_from_p (temp
, singleton
, 1)
7823 mode
, BRANCH_COST
<= 1);
7825 if (result
!= 0 && ! integer_onep (TREE_OPERAND (binary_op
, 1)))
7826 result
= expand_shift (LSHIFT_EXPR
, mode
, result
,
7827 build_int_2 (tree_log2
7831 (safe_from_p (temp
, singleton
, 1)
7832 ? temp
: NULL_RTX
), 0);
7836 op1
= expand_expr (singleton
, NULL_RTX
, VOIDmode
, 0);
7837 return expand_binop (mode
, boptab
, op1
, result
, temp
,
7838 unsignedp
, OPTAB_LIB_WIDEN
);
7840 else if (singleton
== TREE_OPERAND (exp
, 1))
7841 TREE_OPERAND (exp
, 0)
7842 = invert_truthvalue (TREE_OPERAND (exp
, 0));
7845 do_pending_stack_adjust ();
7847 op0
= gen_label_rtx ();
7849 if (singleton
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0)))
7853 /* If the target conflicts with the other operand of the
7854 binary op, we can't use it. Also, we can't use the target
7855 if it is a hard register, because evaluating the condition
7856 might clobber it. */
7858 && ! safe_from_p (temp
, TREE_OPERAND (binary_op
, 1), 1))
7859 || (GET_CODE (temp
) == REG
7860 && REGNO (temp
) < FIRST_PSEUDO_REGISTER
))
7861 temp
= gen_reg_rtx (mode
);
7862 store_expr (singleton
, temp
, 0);
7865 expand_expr (singleton
,
7866 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
7867 if (singleton
== TREE_OPERAND (exp
, 1))
7868 jumpif (TREE_OPERAND (exp
, 0), op0
);
7870 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
7872 start_cleanup_deferral ();
7873 if (binary_op
&& temp
== 0)
7874 /* Just touch the other operand. */
7875 expand_expr (TREE_OPERAND (binary_op
, 1),
7876 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
7878 store_expr (build (TREE_CODE (binary_op
), type
,
7879 make_tree (type
, temp
),
7880 TREE_OPERAND (binary_op
, 1)),
7883 store_expr (build1 (TREE_CODE (unary_op
), type
,
7884 make_tree (type
, temp
)),
7888 /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
7889 comparison operator. If we have one of these cases, set the
7890 output to A, branch on A (cse will merge these two references),
7891 then set the output to FOO. */
7893 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
7894 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
7895 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7896 TREE_OPERAND (exp
, 1), 0)
7897 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
7898 || TREE_CODE (TREE_OPERAND (exp
, 1)) == SAVE_EXPR
)
7899 && safe_from_p (temp
, TREE_OPERAND (exp
, 2), 1))
7901 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
7902 temp
= gen_reg_rtx (mode
);
7903 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
7904 jumpif (TREE_OPERAND (exp
, 0), op0
);
7906 start_cleanup_deferral ();
7907 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
7911 && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == '<'
7912 && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp
, 0), 1))
7913 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
7914 TREE_OPERAND (exp
, 2), 0)
7915 && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 0))
7916 || TREE_CODE (TREE_OPERAND (exp
, 2)) == SAVE_EXPR
)
7917 && safe_from_p (temp
, TREE_OPERAND (exp
, 1), 1))
7919 if (GET_CODE (temp
) == REG
&& REGNO (temp
) < FIRST_PSEUDO_REGISTER
)
7920 temp
= gen_reg_rtx (mode
);
7921 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
7922 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
7924 start_cleanup_deferral ();
7925 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
7930 op1
= gen_label_rtx ();
7931 jumpifnot (TREE_OPERAND (exp
, 0), op0
);
7933 start_cleanup_deferral ();
7935 /* One branch of the cond can be void, if it never returns. For
7936 example A ? throw : E */
7938 && TREE_TYPE (TREE_OPERAND (exp
, 1)) != void_type_node
)
7939 store_expr (TREE_OPERAND (exp
, 1), temp
, 0);
7941 expand_expr (TREE_OPERAND (exp
, 1),
7942 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
7943 end_cleanup_deferral ();
7945 emit_jump_insn (gen_jump (op1
));
7948 start_cleanup_deferral ();
7950 && TREE_TYPE (TREE_OPERAND (exp
, 2)) != void_type_node
)
7951 store_expr (TREE_OPERAND (exp
, 2), temp
, 0);
7953 expand_expr (TREE_OPERAND (exp
, 2),
7954 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
, 0);
7957 end_cleanup_deferral ();
7968 /* Something needs to be initialized, but we didn't know
7969 where that thing was when building the tree. For example,
7970 it could be the return value of a function, or a parameter
7971 to a function which lays down in the stack, or a temporary
7972 variable which must be passed by reference.
7974 We guarantee that the expression will either be constructed
7975 or copied into our original target. */
7977 tree slot
= TREE_OPERAND (exp
, 0);
7978 tree cleanups
= NULL_TREE
;
7981 if (TREE_CODE (slot
) != VAR_DECL
)
7985 target
= original_target
;
7987 /* Set this here so that if we get a target that refers to a
7988 register variable that's already been used, put_reg_into_stack
7989 knows that it should fix up those uses. */
7990 TREE_USED (slot
) = 1;
7994 if (DECL_RTL (slot
) != 0)
7996 target
= DECL_RTL (slot
);
7997 /* If we have already expanded the slot, so don't do
7999 if (TREE_OPERAND (exp
, 1) == NULL_TREE
)
8004 target
= assign_temp (type
, 2, 0, 1);
8005 /* All temp slots at this level must not conflict. */
8006 preserve_temp_slots (target
);
8007 DECL_RTL (slot
) = target
;
8008 if (TREE_ADDRESSABLE (slot
))
8010 TREE_ADDRESSABLE (slot
) = 0;
8011 mark_addressable (slot
);
8014 /* Since SLOT is not known to the called function
8015 to belong to its stack frame, we must build an explicit
8016 cleanup. This case occurs when we must build up a reference
8017 to pass the reference as an argument. In this case,
8018 it is very likely that such a reference need not be
8021 if (TREE_OPERAND (exp
, 2) == 0)
8022 TREE_OPERAND (exp
, 2) = maybe_build_cleanup (slot
);
8023 cleanups
= TREE_OPERAND (exp
, 2);
8028 /* This case does occur, when expanding a parameter which
8029 needs to be constructed on the stack. The target
8030 is the actual stack address that we want to initialize.
8031 The function we call will perform the cleanup in this case. */
8033 /* If we have already assigned it space, use that space,
8034 not target that we were passed in, as our target
8035 parameter is only a hint. */
8036 if (DECL_RTL (slot
) != 0)
8038 target
= DECL_RTL (slot
);
8039 /* If we have already expanded the slot, so don't do
8041 if (TREE_OPERAND (exp
, 1) == NULL_TREE
)
8046 DECL_RTL (slot
) = target
;
8047 /* If we must have an addressable slot, then make sure that
8048 the RTL that we just stored in slot is OK. */
8049 if (TREE_ADDRESSABLE (slot
))
8051 TREE_ADDRESSABLE (slot
) = 0;
8052 mark_addressable (slot
);
8057 exp1
= TREE_OPERAND (exp
, 3) = TREE_OPERAND (exp
, 1);
8058 /* Mark it as expanded. */
8059 TREE_OPERAND (exp
, 1) = NULL_TREE
;
8061 store_expr (exp1
, target
, 0);
8063 expand_decl_cleanup (NULL_TREE
, cleanups
);
8070 tree lhs
= TREE_OPERAND (exp
, 0);
8071 tree rhs
= TREE_OPERAND (exp
, 1);
8072 tree noncopied_parts
= 0;
8073 tree lhs_type
= TREE_TYPE (lhs
);
8075 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
8076 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0 && !fixed_type_p (rhs
))
8077 noncopied_parts
= init_noncopied_parts (stabilize_reference (lhs
),
8078 TYPE_NONCOPIED_PARTS (lhs_type
));
8079 while (noncopied_parts
!= 0)
8081 expand_assignment (TREE_VALUE (noncopied_parts
),
8082 TREE_PURPOSE (noncopied_parts
), 0, 0);
8083 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
8090 /* If lhs is complex, expand calls in rhs before computing it.
8091 That's so we don't compute a pointer and save it over a call.
8092 If lhs is simple, compute it first so we can give it as a
8093 target if the rhs is just a call. This avoids an extra temp and copy
8094 and that prevents a partial-subsumption which makes bad code.
8095 Actually we could treat component_ref's of vars like vars. */
8097 tree lhs
= TREE_OPERAND (exp
, 0);
8098 tree rhs
= TREE_OPERAND (exp
, 1);
8099 tree noncopied_parts
= 0;
8100 tree lhs_type
= TREE_TYPE (lhs
);
8104 if (TREE_CODE (lhs
) != VAR_DECL
8105 && TREE_CODE (lhs
) != RESULT_DECL
8106 && TREE_CODE (lhs
) != PARM_DECL
8107 && ! (TREE_CODE (lhs
) == INDIRECT_REF
8108 && TYPE_READONLY (TREE_TYPE (TREE_OPERAND (lhs
, 0)))))
8109 preexpand_calls (exp
);
8111 /* Check for |= or &= of a bitfield of size one into another bitfield
8112 of size 1. In this case, (unless we need the result of the
8113 assignment) we can do this more efficiently with a
8114 test followed by an assignment, if necessary.
8116 ??? At this point, we can't get a BIT_FIELD_REF here. But if
8117 things change so we do, this code should be enhanced to
8120 && TREE_CODE (lhs
) == COMPONENT_REF
8121 && (TREE_CODE (rhs
) == BIT_IOR_EXPR
8122 || TREE_CODE (rhs
) == BIT_AND_EXPR
)
8123 && TREE_OPERAND (rhs
, 0) == lhs
8124 && TREE_CODE (TREE_OPERAND (rhs
, 1)) == COMPONENT_REF
8125 && integer_onep (DECL_SIZE (TREE_OPERAND (lhs
, 1)))
8126 && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs
, 1), 1))))
8128 rtx label
= gen_label_rtx ();
8130 do_jump (TREE_OPERAND (rhs
, 1),
8131 TREE_CODE (rhs
) == BIT_IOR_EXPR
? label
: 0,
8132 TREE_CODE (rhs
) == BIT_AND_EXPR
? label
: 0);
8133 expand_assignment (lhs
, convert (TREE_TYPE (rhs
),
8134 (TREE_CODE (rhs
) == BIT_IOR_EXPR
8136 : integer_zero_node
)),
8138 do_pending_stack_adjust ();
8143 if (TYPE_NONCOPIED_PARTS (lhs_type
) != 0
8144 && ! (fixed_type_p (lhs
) && fixed_type_p (rhs
)))
8145 noncopied_parts
= save_noncopied_parts (stabilize_reference (lhs
),
8146 TYPE_NONCOPIED_PARTS (lhs_type
));
8148 temp
= expand_assignment (lhs
, rhs
, ! ignore
, original_target
!= 0);
8149 while (noncopied_parts
!= 0)
8151 expand_assignment (TREE_PURPOSE (noncopied_parts
),
8152 TREE_VALUE (noncopied_parts
), 0, 0);
8153 noncopied_parts
= TREE_CHAIN (noncopied_parts
);
8159 if (!TREE_OPERAND (exp
, 0))
8160 expand_null_return ();
8162 expand_return (TREE_OPERAND (exp
, 0));
8165 case PREINCREMENT_EXPR
:
8166 case PREDECREMENT_EXPR
:
8167 return expand_increment (exp
, 0, ignore
);
8169 case POSTINCREMENT_EXPR
:
8170 case POSTDECREMENT_EXPR
:
8171 /* Faster to treat as pre-increment if result is not used. */
8172 return expand_increment (exp
, ! ignore
, ignore
);
8175 /* If nonzero, TEMP will be set to the address of something that might
8176 be a MEM corresponding to a stack slot. */
8179 /* Are we taking the address of a nested function? */
8180 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == FUNCTION_DECL
8181 && decl_function_context (TREE_OPERAND (exp
, 0)) != 0
8182 && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp
, 0))
8183 && ! TREE_STATIC (exp
))
8185 op0
= trampoline_address (TREE_OPERAND (exp
, 0));
8186 op0
= force_operand (op0
, target
);
8188 /* If we are taking the address of something erroneous, just
8190 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ERROR_MARK
)
8194 /* We make sure to pass const0_rtx down if we came in with
8195 ignore set, to avoid doing the cleanups twice for something. */
8196 op0
= expand_expr (TREE_OPERAND (exp
, 0),
8197 ignore
? const0_rtx
: NULL_RTX
, VOIDmode
,
8198 (modifier
== EXPAND_INITIALIZER
8199 ? modifier
: EXPAND_CONST_ADDRESS
));
8201 /* If we are going to ignore the result, OP0 will have been set
8202 to const0_rtx, so just return it. Don't get confused and
8203 think we are taking the address of the constant. */
8207 op0
= protect_from_queue (op0
, 0);
8209 /* We would like the object in memory. If it is a constant, we can
8210 have it be statically allocated into memory. For a non-constant,
8211 we need to allocate some memory and store the value into it. */
8213 if (CONSTANT_P (op0
))
8214 op0
= force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))),
8216 else if (GET_CODE (op0
) == MEM
)
8218 mark_temp_addr_taken (op0
);
8219 temp
= XEXP (op0
, 0);
8222 else if (GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
8223 || GET_CODE (op0
) == CONCAT
|| GET_CODE (op0
) == ADDRESSOF
)
8225 /* If this object is in a register, it must be not
8227 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
8228 rtx memloc
= assign_temp (inner_type
, 1, 1, 1);
8230 mark_temp_addr_taken (memloc
);
8231 emit_move_insn (memloc
, op0
);
8235 if (GET_CODE (op0
) != MEM
)
8238 if (modifier
== EXPAND_SUM
|| modifier
== EXPAND_INITIALIZER
)
8240 temp
= XEXP (op0
, 0);
8241 #ifdef POINTERS_EXTEND_UNSIGNED
8242 if (GET_MODE (temp
) == Pmode
&& GET_MODE (temp
) != mode
8243 && mode
== ptr_mode
)
8244 temp
= convert_memory_address (ptr_mode
, temp
);
8249 op0
= force_operand (XEXP (op0
, 0), target
);
8252 if (flag_force_addr
&& GET_CODE (op0
) != REG
)
8253 op0
= force_reg (Pmode
, op0
);
8255 if (GET_CODE (op0
) == REG
8256 && ! REG_USERVAR_P (op0
))
8257 mark_reg_pointer (op0
, TYPE_ALIGN (TREE_TYPE (type
)) / BITS_PER_UNIT
);
8259 /* If we might have had a temp slot, add an equivalent address
8262 update_temp_slot_address (temp
, op0
);
8264 #ifdef POINTERS_EXTEND_UNSIGNED
8265 if (GET_MODE (op0
) == Pmode
&& GET_MODE (op0
) != mode
8266 && mode
== ptr_mode
)
8267 op0
= convert_memory_address (ptr_mode
, op0
);
8272 case ENTRY_VALUE_EXPR
:
8275 /* COMPLEX type for Extended Pascal & Fortran */
8278 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
8281 /* Get the rtx code of the operands. */
8282 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8283 op1
= expand_expr (TREE_OPERAND (exp
, 1), 0, VOIDmode
, 0);
8286 target
= gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp
)));
8290 /* Move the real (op0) and imaginary (op1) parts to their location. */
8291 emit_move_insn (gen_realpart (mode
, target
), op0
);
8292 emit_move_insn (gen_imagpart (mode
, target
), op1
);
8294 insns
= get_insns ();
8297 /* Complex construction should appear as a single unit. */
8298 /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8299 each with a separate pseudo as destination.
8300 It's not correct for flow to treat them as a unit. */
8301 if (GET_CODE (target
) != CONCAT
)
8302 emit_no_conflict_block (insns
, target
, op0
, op1
, NULL_RTX
);
8310 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8311 return gen_realpart (mode
, op0
);
8314 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8315 return gen_imagpart (mode
, op0
);
8319 enum machine_mode partmode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
8323 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8326 target
= gen_reg_rtx (mode
);
8330 /* Store the realpart and the negated imagpart to target. */
8331 emit_move_insn (gen_realpart (partmode
, target
),
8332 gen_realpart (partmode
, op0
));
8334 imag_t
= gen_imagpart (partmode
, target
);
8335 temp
= expand_unop (partmode
, neg_optab
,
8336 gen_imagpart (partmode
, op0
), imag_t
, 0);
8338 emit_move_insn (imag_t
, temp
);
8340 insns
= get_insns ();
8343 /* Conjugate should appear as a single unit
8344 If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8345 each with a separate pseudo as destination.
8346 It's not correct for flow to treat them as a unit. */
8347 if (GET_CODE (target
) != CONCAT
)
8348 emit_no_conflict_block (insns
, target
, op0
, NULL_RTX
, NULL_RTX
);
8355 case TRY_CATCH_EXPR
:
8357 tree handler
= TREE_OPERAND (exp
, 1);
8359 expand_eh_region_start ();
8361 op0
= expand_expr (TREE_OPERAND (exp
, 0), 0, VOIDmode
, 0);
8363 expand_eh_region_end (handler
);
8368 case TRY_FINALLY_EXPR
:
8370 tree try_block
= TREE_OPERAND (exp
, 0);
8371 tree finally_block
= TREE_OPERAND (exp
, 1);
8372 rtx finally_label
= gen_label_rtx ();
8373 rtx done_label
= gen_label_rtx ();
8374 rtx return_link
= gen_reg_rtx (Pmode
);
8375 tree cleanup
= build (GOTO_SUBROUTINE_EXPR
, void_type_node
,
8376 (tree
) finally_label
, (tree
) return_link
);
8377 TREE_SIDE_EFFECTS (cleanup
) = 1;
8379 /* Start a new binding layer that will keep track of all cleanup
8380 actions to be performed. */
8381 expand_start_bindings (2);
8383 target_temp_slot_level
= temp_slot_level
;
8385 expand_decl_cleanup (NULL_TREE
, cleanup
);
8386 op0
= expand_expr (try_block
, target
, tmode
, modifier
);
8388 preserve_temp_slots (op0
);
8389 expand_end_bindings (NULL_TREE
, 0, 0);
8390 emit_jump (done_label
);
8391 emit_label (finally_label
);
8392 expand_expr (finally_block
, const0_rtx
, VOIDmode
, 0);
8393 emit_indirect_jump (return_link
);
8394 emit_label (done_label
);
8398 case GOTO_SUBROUTINE_EXPR
:
8400 rtx subr
= (rtx
) TREE_OPERAND (exp
, 0);
8401 rtx return_link
= *(rtx
*) &TREE_OPERAND (exp
, 1);
8402 rtx return_address
= gen_label_rtx ();
8403 emit_move_insn (return_link
, gen_rtx_LABEL_REF (Pmode
, return_address
));
8405 emit_label (return_address
);
8411 rtx dcc
= get_dynamic_cleanup_chain ();
8412 emit_move_insn (dcc
, validize_mem (gen_rtx_MEM (Pmode
, dcc
)));
8418 rtx dhc
= get_dynamic_handler_chain ();
8419 emit_move_insn (dhc
, validize_mem (gen_rtx_MEM (Pmode
, dhc
)));
8424 return expand_builtin_va_arg (TREE_OPERAND (exp
, 0), type
);
8427 return (*lang_expand_expr
) (exp
, original_target
, tmode
, modifier
);
8430 /* Here to do an ordinary binary operator, generating an instruction
8431 from the optab already placed in `this_optab'. */
8433 preexpand_calls (exp
);
8434 if (! safe_from_p (subtarget
, TREE_OPERAND (exp
, 1), 1))
8436 op0
= expand_expr (TREE_OPERAND (exp
, 0), subtarget
, VOIDmode
, 0);
8437 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
8439 temp
= expand_binop (mode
, this_optab
, op0
, op1
, target
,
8440 unsignedp
, OPTAB_LIB_WIDEN
);
8446 /* Similar to expand_expr, except that we don't specify a target, target
8447 mode, or modifier and we return the alignment of the inner type. This is
8448 used in cases where it is not necessary to align the result to the
8449 alignment of its type as long as we know the alignment of the result, for
8450 example for comparisons of BLKmode values. */
8453 expand_expr_unaligned (exp
, palign
)
8455 unsigned int *palign
;
8458 tree type
= TREE_TYPE (exp
);
8459 register enum machine_mode mode
= TYPE_MODE (type
);
8461 /* Default the alignment we return to that of the type. */
8462 *palign
= TYPE_ALIGN (type
);
8464 /* The only cases in which we do anything special is if the resulting mode
8466 if (mode
!= BLKmode
)
8467 return expand_expr (exp
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
8469 switch (TREE_CODE (exp
))
8473 case NON_LVALUE_EXPR
:
8474 /* Conversions between BLKmode values don't change the underlying
8475 alignment or value. */
8476 if (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == BLKmode
)
8477 return expand_expr_unaligned (TREE_OPERAND (exp
, 0), palign
);
8481 /* Much of the code for this case is copied directly from expand_expr.
8482 We need to duplicate it here because we will do something different
8483 in the fall-through case, so we need to handle the same exceptions
8486 tree array
= TREE_OPERAND (exp
, 0);
8487 tree domain
= TYPE_DOMAIN (TREE_TYPE (array
));
8488 tree low_bound
= domain
? TYPE_MIN_VALUE (domain
) : integer_zero_node
;
8489 tree index
= convert (sizetype
, TREE_OPERAND (exp
, 1));
8492 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) != ARRAY_TYPE
)
8495 /* Optimize the special-case of a zero lower bound.
8497 We convert the low_bound to sizetype to avoid some problems
8498 with constant folding. (E.g. suppose the lower bound is 1,
8499 and its mode is QI. Without the conversion, (ARRAY
8500 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8501 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
8503 if (! integer_zerop (low_bound
))
8504 index
= size_diffop (index
, convert (sizetype
, low_bound
));
8506 /* If this is a constant index into a constant array,
8507 just get the value from the array. Handle both the cases when
8508 we have an explicit constructor and when our operand is a variable
8509 that was declared const. */
8511 if (TREE_CODE (array
) == CONSTRUCTOR
&& ! TREE_SIDE_EFFECTS (array
)
8512 && 0 > compare_tree_int (index
,
8513 list_length (CONSTRUCTOR_ELTS
8514 (TREE_OPERAND (exp
, 0)))))
8518 for (elem
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)),
8519 i
= TREE_INT_CST_LOW (index
);
8520 elem
!= 0 && i
!= 0; i
--, elem
= TREE_CHAIN (elem
))
8524 return expand_expr_unaligned (fold (TREE_VALUE (elem
)), palign
);
8527 else if (optimize
>= 1
8528 && TREE_READONLY (array
) && ! TREE_SIDE_EFFECTS (array
)
8529 && TREE_CODE (array
) == VAR_DECL
&& DECL_INITIAL (array
)
8530 && TREE_CODE (DECL_INITIAL (array
)) != ERROR_MARK
)
8532 if (TREE_CODE (index
) == INTEGER_CST
)
8534 tree init
= DECL_INITIAL (array
);
8536 if (TREE_CODE (init
) == CONSTRUCTOR
)
8540 for (elem
= CONSTRUCTOR_ELTS (init
);
8541 ! tree_int_cst_equal (TREE_PURPOSE (elem
), index
);
8542 elem
= TREE_CHAIN (elem
))
8546 return expand_expr_unaligned (fold (TREE_VALUE (elem
)),
8553 /* ... fall through ... */
8557 /* If the operand is a CONSTRUCTOR, we can just extract the
8558 appropriate field if it is present. Don't do this if we have
8559 already written the data since we want to refer to that copy
8560 and varasm.c assumes that's what we'll do. */
8561 if (TREE_CODE (exp
) != ARRAY_REF
8562 && TREE_CODE (TREE_OPERAND (exp
, 0)) == CONSTRUCTOR
8563 && TREE_CST_RTL (TREE_OPERAND (exp
, 0)) == 0)
8567 for (elt
= CONSTRUCTOR_ELTS (TREE_OPERAND (exp
, 0)); elt
;
8568 elt
= TREE_CHAIN (elt
))
8569 if (TREE_PURPOSE (elt
) == TREE_OPERAND (exp
, 1))
8570 /* Note that unlike the case in expand_expr, we know this is
8571 BLKmode and hence not an integer. */
8572 return expand_expr_unaligned (TREE_VALUE (elt
), palign
);
8576 enum machine_mode mode1
;
8577 HOST_WIDE_INT bitsize
, bitpos
;
8580 unsigned int alignment
;
8582 tree tem
= get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
8583 &mode1
, &unsignedp
, &volatilep
,
8586 /* If we got back the original object, something is wrong. Perhaps
8587 we are evaluating an expression too early. In any event, don't
8588 infinitely recurse. */
8592 op0
= expand_expr (tem
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
8594 /* If this is a constant, put it into a register if it is a
8595 legitimate constant and OFFSET is 0 and memory if it isn't. */
8596 if (CONSTANT_P (op0
))
8598 enum machine_mode inner_mode
= TYPE_MODE (TREE_TYPE (tem
));
8600 if (inner_mode
!= BLKmode
&& LEGITIMATE_CONSTANT_P (op0
)
8602 op0
= force_reg (inner_mode
, op0
);
8604 op0
= validize_mem (force_const_mem (inner_mode
, op0
));
8609 rtx offset_rtx
= expand_expr (offset
, NULL_RTX
, VOIDmode
, 0);
8611 /* If this object is in a register, put it into memory.
8612 This case can't occur in C, but can in Ada if we have
8613 unchecked conversion of an expression from a scalar type to
8614 an array or record type. */
8615 if (GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
8616 || GET_CODE (op0
) == CONCAT
|| GET_CODE (op0
) == ADDRESSOF
)
8618 rtx memloc
= assign_temp (TREE_TYPE (tem
), 1, 1, 1);
8620 mark_temp_addr_taken (memloc
);
8621 emit_move_insn (memloc
, op0
);
8625 if (GET_CODE (op0
) != MEM
)
8628 if (GET_MODE (offset_rtx
) != ptr_mode
)
8630 #ifdef POINTERS_EXTEND_UNSIGNED
8631 offset_rtx
= convert_memory_address (ptr_mode
, offset_rtx
);
8633 offset_rtx
= convert_to_mode (ptr_mode
, offset_rtx
, 0);
8637 op0
= change_address (op0
, VOIDmode
,
8638 gen_rtx_PLUS (ptr_mode
, XEXP (op0
, 0),
8639 force_reg (ptr_mode
,
8643 /* Don't forget about volatility even if this is a bitfield. */
8644 if (GET_CODE (op0
) == MEM
&& volatilep
&& ! MEM_VOLATILE_P (op0
))
8646 op0
= copy_rtx (op0
);
8647 MEM_VOLATILE_P (op0
) = 1;
8650 /* Check the access. */
8651 if (current_function_check_memory_usage
&& GET_CODE (op0
) == MEM
)
8656 to
= plus_constant (XEXP (op0
, 0), (bitpos
/ BITS_PER_UNIT
));
8657 size
= (bitpos
% BITS_PER_UNIT
) + bitsize
+ BITS_PER_UNIT
- 1;
8659 /* Check the access right of the pointer. */
8660 if (size
> BITS_PER_UNIT
)
8661 emit_library_call (chkr_check_addr_libfunc
, 1, VOIDmode
, 3,
8662 to
, ptr_mode
, GEN_INT (size
/ BITS_PER_UNIT
),
8663 TYPE_MODE (sizetype
),
8664 GEN_INT (MEMORY_USE_RO
),
8665 TYPE_MODE (integer_type_node
));
8668 /* In cases where an aligned union has an unaligned object
8669 as a field, we might be extracting a BLKmode value from
8670 an integer-mode (e.g., SImode) object. Handle this case
8671 by doing the extract into an object as wide as the field
8672 (which we know to be the width of a basic mode), then
8673 storing into memory, and changing the mode to BLKmode.
8674 If we ultimately want the address (EXPAND_CONST_ADDRESS or
8675 EXPAND_INITIALIZER), then we must not copy to a temporary. */
8676 if (mode1
== VOIDmode
8677 || GET_CODE (op0
) == REG
|| GET_CODE (op0
) == SUBREG
8678 || (SLOW_UNALIGNED_ACCESS (mode1
, alignment
)
8679 && (TYPE_ALIGN (type
) > alignment
* BITS_PER_UNIT
8680 || bitpos
% TYPE_ALIGN (type
) != 0)))
8682 enum machine_mode ext_mode
= mode_for_size (bitsize
, MODE_INT
, 1);
8684 if (ext_mode
== BLKmode
)
8686 /* In this case, BITPOS must start at a byte boundary. */
8687 if (GET_CODE (op0
) != MEM
8688 || bitpos
% BITS_PER_UNIT
!= 0)
8691 op0
= change_address (op0
, VOIDmode
,
8692 plus_constant (XEXP (op0
, 0),
8693 bitpos
/ BITS_PER_UNIT
));
8697 rtx
new = assign_stack_temp (ext_mode
,
8698 bitsize
/ BITS_PER_UNIT
, 0);
8700 op0
= extract_bit_field (validize_mem (op0
), bitsize
, bitpos
,
8701 unsignedp
, NULL_RTX
, ext_mode
,
8702 ext_mode
, alignment
,
8703 int_size_in_bytes (TREE_TYPE (tem
)));
8705 /* If the result is a record type and BITSIZE is narrower than
8706 the mode of OP0, an integral mode, and this is a big endian
8707 machine, we must put the field into the high-order bits. */
8708 if (TREE_CODE (type
) == RECORD_TYPE
&& BYTES_BIG_ENDIAN
8709 && GET_MODE_CLASS (GET_MODE (op0
)) == MODE_INT
8710 && bitsize
< GET_MODE_BITSIZE (GET_MODE (op0
)))
8711 op0
= expand_shift (LSHIFT_EXPR
, GET_MODE (op0
), op0
,
8712 size_int (GET_MODE_BITSIZE
8718 emit_move_insn (new, op0
);
8719 op0
= copy_rtx (new);
8720 PUT_MODE (op0
, BLKmode
);
8724 /* Get a reference to just this component. */
8725 op0
= change_address (op0
, mode1
,
8726 plus_constant (XEXP (op0
, 0),
8727 (bitpos
/ BITS_PER_UNIT
)));
8729 MEM_ALIAS_SET (op0
) = get_alias_set (exp
);
8731 /* Adjust the alignment in case the bit position is not
8732 a multiple of the alignment of the inner object. */
8733 while (bitpos
% alignment
!= 0)
8736 if (GET_CODE (XEXP (op0
, 0)) == REG
)
8737 mark_reg_pointer (XEXP (op0
, 0), alignment
);
8739 MEM_IN_STRUCT_P (op0
) = 1;
8740 MEM_VOLATILE_P (op0
) |= volatilep
;
8742 *palign
= alignment
;
8751 return expand_expr (exp
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
8754 /* Return the tree node if a ARG corresponds to a string constant or zero
8755 if it doesn't. If we return non-zero, set *PTR_OFFSET to the offset
8756 in bytes within the string that ARG is accessing. The type of the
8757 offset will be `sizetype'. */
8760 string_constant (arg
, ptr_offset
)
8766 if (TREE_CODE (arg
) == ADDR_EXPR
8767 && TREE_CODE (TREE_OPERAND (arg
, 0)) == STRING_CST
)
8769 *ptr_offset
= size_zero_node
;
8770 return TREE_OPERAND (arg
, 0);
8772 else if (TREE_CODE (arg
) == PLUS_EXPR
)
8774 tree arg0
= TREE_OPERAND (arg
, 0);
8775 tree arg1
= TREE_OPERAND (arg
, 1);
8780 if (TREE_CODE (arg0
) == ADDR_EXPR
8781 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == STRING_CST
)
8783 *ptr_offset
= convert (sizetype
, arg1
);
8784 return TREE_OPERAND (arg0
, 0);
8786 else if (TREE_CODE (arg1
) == ADDR_EXPR
8787 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == STRING_CST
)
8789 *ptr_offset
= convert (sizetype
, arg0
);
8790 return TREE_OPERAND (arg1
, 0);
8797 /* Expand code for a post- or pre- increment or decrement
8798 and return the RTX for the result.
8799 POST is 1 for postinc/decrements and 0 for preinc/decrements. */
8802 expand_increment (exp
, post
, ignore
)
8806 register rtx op0
, op1
;
8807 register rtx temp
, value
;
8808 register tree incremented
= TREE_OPERAND (exp
, 0);
8809 optab this_optab
= add_optab
;
8811 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
8812 int op0_is_copy
= 0;
8813 int single_insn
= 0;
8814 /* 1 means we can't store into OP0 directly,
8815 because it is a subreg narrower than a word,
8816 and we don't dare clobber the rest of the word. */
8819 /* Stabilize any component ref that might need to be
8820 evaluated more than once below. */
8822 || TREE_CODE (incremented
) == BIT_FIELD_REF
8823 || (TREE_CODE (incremented
) == COMPONENT_REF
8824 && (TREE_CODE (TREE_OPERAND (incremented
, 0)) != INDIRECT_REF
8825 || DECL_BIT_FIELD (TREE_OPERAND (incremented
, 1)))))
8826 incremented
= stabilize_reference (incremented
);
8827 /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
8828 ones into save exprs so that they don't accidentally get evaluated
8829 more than once by the code below. */
8830 if (TREE_CODE (incremented
) == PREINCREMENT_EXPR
8831 || TREE_CODE (incremented
) == PREDECREMENT_EXPR
)
8832 incremented
= save_expr (incremented
);
8834 /* Compute the operands as RTX.
8835 Note whether OP0 is the actual lvalue or a copy of it:
8836 I believe it is a copy iff it is a register or subreg
8837 and insns were generated in computing it. */
8839 temp
= get_last_insn ();
8840 op0
= expand_expr (incremented
, NULL_RTX
, VOIDmode
, EXPAND_MEMORY_USE_RW
);
8842 /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
8843 in place but instead must do sign- or zero-extension during assignment,
8844 so we copy it into a new register and let the code below use it as
8847 Note that we can safely modify this SUBREG since it is know not to be
8848 shared (it was made by the expand_expr call above). */
8850 if (GET_CODE (op0
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (op0
))
8853 SUBREG_REG (op0
) = copy_to_reg (SUBREG_REG (op0
));
8857 else if (GET_CODE (op0
) == SUBREG
8858 && GET_MODE_BITSIZE (GET_MODE (op0
)) < BITS_PER_WORD
)
8860 /* We cannot increment this SUBREG in place. If we are
8861 post-incrementing, get a copy of the old value. Otherwise,
8862 just mark that we cannot increment in place. */
8864 op0
= copy_to_reg (op0
);
8869 op0_is_copy
= ((GET_CODE (op0
) == SUBREG
|| GET_CODE (op0
) == REG
)
8870 && temp
!= get_last_insn ());
8871 op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
,
8872 EXPAND_MEMORY_USE_BAD
);
8874 /* Decide whether incrementing or decrementing. */
8875 if (TREE_CODE (exp
) == POSTDECREMENT_EXPR
8876 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
8877 this_optab
= sub_optab
;
8879 /* Convert decrement by a constant into a negative increment. */
8880 if (this_optab
== sub_optab
8881 && GET_CODE (op1
) == CONST_INT
)
8883 op1
= GEN_INT (- INTVAL (op1
));
8884 this_optab
= add_optab
;
8887 /* For a preincrement, see if we can do this with a single instruction. */
8890 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
8891 if (icode
!= (int) CODE_FOR_nothing
8892 /* Make sure that OP0 is valid for operands 0 and 1
8893 of the insn we want to queue. */
8894 && (*insn_data
[icode
].operand
[0].predicate
) (op0
, mode
)
8895 && (*insn_data
[icode
].operand
[1].predicate
) (op0
, mode
)
8896 && (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
8900 /* If OP0 is not the actual lvalue, but rather a copy in a register,
8901 then we cannot just increment OP0. We must therefore contrive to
8902 increment the original value. Then, for postincrement, we can return
8903 OP0 since it is a copy of the old value. For preincrement, expand here
8904 unless we can do it with a single insn.
8906 Likewise if storing directly into OP0 would clobber high bits
8907 we need to preserve (bad_subreg). */
8908 if (op0_is_copy
|| (!post
&& !single_insn
) || bad_subreg
)
8910 /* This is the easiest way to increment the value wherever it is.
8911 Problems with multiple evaluation of INCREMENTED are prevented
8912 because either (1) it is a component_ref or preincrement,
8913 in which case it was stabilized above, or (2) it is an array_ref
8914 with constant index in an array in a register, which is
8915 safe to reevaluate. */
8916 tree newexp
= build (((TREE_CODE (exp
) == POSTDECREMENT_EXPR
8917 || TREE_CODE (exp
) == PREDECREMENT_EXPR
)
8918 ? MINUS_EXPR
: PLUS_EXPR
),
8921 TREE_OPERAND (exp
, 1));
8923 while (TREE_CODE (incremented
) == NOP_EXPR
8924 || TREE_CODE (incremented
) == CONVERT_EXPR
)
8926 newexp
= convert (TREE_TYPE (incremented
), newexp
);
8927 incremented
= TREE_OPERAND (incremented
, 0);
8930 temp
= expand_assignment (incremented
, newexp
, ! post
&& ! ignore
, 0);
8931 return post
? op0
: temp
;
8936 /* We have a true reference to the value in OP0.
8937 If there is an insn to add or subtract in this mode, queue it.
8938 Queueing the increment insn avoids the register shuffling
8939 that often results if we must increment now and first save
8940 the old value for subsequent use. */
8942 #if 0 /* Turned off to avoid making extra insn for indexed memref. */
8943 op0
= stabilize (op0
);
8946 icode
= (int) this_optab
->handlers
[(int) mode
].insn_code
;
8947 if (icode
!= (int) CODE_FOR_nothing
8948 /* Make sure that OP0 is valid for operands 0 and 1
8949 of the insn we want to queue. */
8950 && (*insn_data
[icode
].operand
[0].predicate
) (op0
, mode
)
8951 && (*insn_data
[icode
].operand
[1].predicate
) (op0
, mode
))
8953 if (! (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
8954 op1
= force_reg (mode
, op1
);
8956 return enqueue_insn (op0
, GEN_FCN (icode
) (op0
, op0
, op1
));
8958 if (icode
!= (int) CODE_FOR_nothing
&& GET_CODE (op0
) == MEM
)
8960 rtx addr
= (general_operand (XEXP (op0
, 0), mode
)
8961 ? force_reg (Pmode
, XEXP (op0
, 0))
8962 : copy_to_reg (XEXP (op0
, 0)));
8965 op0
= change_address (op0
, VOIDmode
, addr
);
8966 temp
= force_reg (GET_MODE (op0
), op0
);
8967 if (! (*insn_data
[icode
].operand
[2].predicate
) (op1
, mode
))
8968 op1
= force_reg (mode
, op1
);
8970 /* The increment queue is LIFO, thus we have to `queue'
8971 the instructions in reverse order. */
8972 enqueue_insn (op0
, gen_move_insn (op0
, temp
));
8973 result
= enqueue_insn (temp
, GEN_FCN (icode
) (temp
, temp
, op1
));
8978 /* Preincrement, or we can't increment with one simple insn. */
8980 /* Save a copy of the value before inc or dec, to return it later. */
8981 temp
= value
= copy_to_reg (op0
);
8983 /* Arrange to return the incremented value. */
8984 /* Copy the rtx because expand_binop will protect from the queue,
8985 and the results of that would be invalid for us to return
8986 if our caller does emit_queue before using our result. */
8987 temp
= copy_rtx (value
= op0
);
8989 /* Increment however we can. */
8990 op1
= expand_binop (mode
, this_optab
, value
, op1
,
8991 current_function_check_memory_usage
? NULL_RTX
: op0
,
8992 TREE_UNSIGNED (TREE_TYPE (exp
)), OPTAB_LIB_WIDEN
);
8993 /* Make sure the value is stored into OP0. */
8995 emit_move_insn (op0
, op1
);
9000 /* Expand all function calls contained within EXP, innermost ones first.
9001 But don't look within expressions that have sequence points.
9002 For each CALL_EXPR, record the rtx for its value
9003 in the CALL_EXPR_RTL field. */
9006 preexpand_calls (exp
)
9009 register int nops
, i
;
9010 int type
= TREE_CODE_CLASS (TREE_CODE (exp
));
9012 if (! do_preexpand_calls
)
9015 /* Only expressions and references can contain calls. */
9017 if (type
!= 'e' && type
!= '<' && type
!= '1' && type
!= '2' && type
!= 'r')
9020 switch (TREE_CODE (exp
))
9023 /* Do nothing if already expanded. */
9024 if (CALL_EXPR_RTL (exp
) != 0
9025 /* Do nothing if the call returns a variable-sized object. */
9026 || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp
))) != INTEGER_CST
9027 /* Do nothing to built-in functions. */
9028 || (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
9029 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
9031 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))))
9034 CALL_EXPR_RTL (exp
) = expand_call (exp
, NULL_RTX
, 0);
9039 case TRUTH_ANDIF_EXPR
:
9040 case TRUTH_ORIF_EXPR
:
9041 /* If we find one of these, then we can be sure
9042 the adjust will be done for it (since it makes jumps).
9043 Do it now, so that if this is inside an argument
9044 of a function, we don't get the stack adjustment
9045 after some other args have already been pushed. */
9046 do_pending_stack_adjust ();
9051 case WITH_CLEANUP_EXPR
:
9052 case CLEANUP_POINT_EXPR
:
9053 case TRY_CATCH_EXPR
:
9057 if (SAVE_EXPR_RTL (exp
) != 0)
9064 nops
= tree_code_length
[(int) TREE_CODE (exp
)];
9065 for (i
= 0; i
< nops
; i
++)
9066 if (TREE_OPERAND (exp
, i
) != 0)
9068 if (TREE_CODE (exp
) == TARGET_EXPR
&& i
== 2)
9069 /* We don't need to preexpand the cleanup for a TARGET_EXPR.
9070 It doesn't happen before the call is made. */
9074 type
= TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, i
)));
9075 if (type
== 'e' || type
== '<' || type
== '1' || type
== '2'
9077 preexpand_calls (TREE_OPERAND (exp
, i
));
9082 /* At the start of a function, record that we have no previously-pushed
9083 arguments waiting to be popped. */
9086 init_pending_stack_adjust ()
9088 pending_stack_adjust
= 0;
9091 /* When exiting from function, if safe, clear out any pending stack adjust
9092 so the adjustment won't get done.
9094 Note, if the current function calls alloca, then it must have a
9095 frame pointer regardless of the value of flag_omit_frame_pointer. */
9098 clear_pending_stack_adjust ()
9100 #ifdef EXIT_IGNORE_STACK
9102 && (! flag_omit_frame_pointer
|| current_function_calls_alloca
)
9103 && EXIT_IGNORE_STACK
9104 && ! (DECL_INLINE (current_function_decl
) && ! flag_no_inline
)
9105 && ! flag_inline_functions
)
9106 pending_stack_adjust
= 0;
9110 /* Pop any previously-pushed arguments that have not been popped yet. */
9113 do_pending_stack_adjust ()
9115 if (inhibit_defer_pop
== 0)
9117 if (pending_stack_adjust
!= 0)
9118 adjust_stack (GEN_INT (pending_stack_adjust
));
9119 pending_stack_adjust
= 0;
9123 /* Expand conditional expressions. */
9125 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9126 LABEL is an rtx of code CODE_LABEL, in this function and all the
9130 jumpifnot (exp
, label
)
9134 do_jump (exp
, label
, NULL_RTX
);
9137 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
9144 do_jump (exp
, NULL_RTX
, label
);
9147 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9148 the result is zero, or IF_TRUE_LABEL if the result is one.
9149 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9150 meaning fall through in that case.
9152 do_jump always does any pending stack adjust except when it does not
9153 actually perform a jump. An example where there is no jump
9154 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9156 This function is responsible for optimizing cases such as
9157 &&, || and comparison operators in EXP. */
9160 do_jump (exp
, if_false_label
, if_true_label
)
9162 rtx if_false_label
, if_true_label
;
9164 register enum tree_code code
= TREE_CODE (exp
);
9165 /* Some cases need to create a label to jump to
9166 in order to properly fall through.
9167 These cases set DROP_THROUGH_LABEL nonzero. */
9168 rtx drop_through_label
= 0;
9172 enum machine_mode mode
;
9174 #ifdef MAX_INTEGER_COMPUTATION_MODE
9175 check_max_integer_computation_mode (exp
);
9186 temp
= integer_zerop (exp
) ? if_false_label
: if_true_label
;
9192 /* This is not true with #pragma weak */
9194 /* The address of something can never be zero. */
9196 emit_jump (if_true_label
);
9201 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == COMPONENT_REF
9202 || TREE_CODE (TREE_OPERAND (exp
, 0)) == BIT_FIELD_REF
9203 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_REF
)
9206 /* If we are narrowing the operand, we have to do the compare in the
9208 if ((TYPE_PRECISION (TREE_TYPE (exp
))
9209 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
9211 case NON_LVALUE_EXPR
:
9212 case REFERENCE_EXPR
:
9217 /* These cannot change zero->non-zero or vice versa. */
9218 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
9221 case WITH_RECORD_EXPR
:
9222 /* Put the object on the placeholder list, recurse through our first
9223 operand, and pop the list. */
9224 placeholder_list
= tree_cons (TREE_OPERAND (exp
, 1), NULL_TREE
,
9226 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
9227 placeholder_list
= TREE_CHAIN (placeholder_list
);
9231 /* This is never less insns than evaluating the PLUS_EXPR followed by
9232 a test and can be longer if the test is eliminated. */
9234 /* Reduce to minus. */
9235 exp
= build (MINUS_EXPR
, TREE_TYPE (exp
),
9236 TREE_OPERAND (exp
, 0),
9237 fold (build1 (NEGATE_EXPR
, TREE_TYPE (TREE_OPERAND (exp
, 1)),
9238 TREE_OPERAND (exp
, 1))));
9239 /* Process as MINUS. */
9243 /* Non-zero iff operands of minus differ. */
9244 do_compare_and_jump (build (NE_EXPR
, TREE_TYPE (exp
),
9245 TREE_OPERAND (exp
, 0),
9246 TREE_OPERAND (exp
, 1)),
9247 NE
, NE
, if_false_label
, if_true_label
);
9251 /* If we are AND'ing with a small constant, do this comparison in the
9252 smallest type that fits. If the machine doesn't have comparisons
9253 that small, it will be converted back to the wider comparison.
9254 This helps if we are testing the sign bit of a narrower object.
9255 combine can't do this for us because it can't know whether a
9256 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
9258 if (! SLOW_BYTE_ACCESS
9259 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
9260 && TYPE_PRECISION (TREE_TYPE (exp
)) <= HOST_BITS_PER_WIDE_INT
9261 && (i
= tree_floor_log2 (TREE_OPERAND (exp
, 1))) >= 0
9262 && (mode
= mode_for_size (i
+ 1, MODE_INT
, 0)) != BLKmode
9263 && (type
= type_for_mode (mode
, 1)) != 0
9264 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
))
9265 && (cmp_optab
->handlers
[(int) TYPE_MODE (type
)].insn_code
9266 != CODE_FOR_nothing
))
9268 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
9273 case TRUTH_NOT_EXPR
:
9274 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
9277 case TRUTH_ANDIF_EXPR
:
9278 if (if_false_label
== 0)
9279 if_false_label
= drop_through_label
= gen_label_rtx ();
9280 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, NULL_RTX
);
9281 start_cleanup_deferral ();
9282 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
9283 end_cleanup_deferral ();
9286 case TRUTH_ORIF_EXPR
:
9287 if (if_true_label
== 0)
9288 if_true_label
= drop_through_label
= gen_label_rtx ();
9289 do_jump (TREE_OPERAND (exp
, 0), NULL_RTX
, if_true_label
);
9290 start_cleanup_deferral ();
9291 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
9292 end_cleanup_deferral ();
9297 expand_expr (TREE_OPERAND (exp
, 0), const0_rtx
, VOIDmode
, 0);
9298 preserve_temp_slots (NULL_RTX
);
9302 do_pending_stack_adjust ();
9303 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
9310 HOST_WIDE_INT bitsize
, bitpos
;
9312 enum machine_mode mode
;
9316 unsigned int alignment
;
9318 /* Get description of this reference. We don't actually care
9319 about the underlying object here. */
9320 get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
,
9321 &mode
, &unsignedp
, &volatilep
,
9324 type
= type_for_size (bitsize
, unsignedp
);
9325 if (! SLOW_BYTE_ACCESS
9326 && type
!= 0 && bitsize
>= 0
9327 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
))
9328 && (cmp_optab
->handlers
[(int) TYPE_MODE (type
)].insn_code
9329 != CODE_FOR_nothing
))
9331 do_jump (convert (type
, exp
), if_false_label
, if_true_label
);
9338 /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
9339 if (integer_onep (TREE_OPERAND (exp
, 1))
9340 && integer_zerop (TREE_OPERAND (exp
, 2)))
9341 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
9343 else if (integer_zerop (TREE_OPERAND (exp
, 1))
9344 && integer_onep (TREE_OPERAND (exp
, 2)))
9345 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
9349 register rtx label1
= gen_label_rtx ();
9350 drop_through_label
= gen_label_rtx ();
9352 do_jump (TREE_OPERAND (exp
, 0), label1
, NULL_RTX
);
9354 start_cleanup_deferral ();
9355 /* Now the THEN-expression. */
9356 do_jump (TREE_OPERAND (exp
, 1),
9357 if_false_label
? if_false_label
: drop_through_label
,
9358 if_true_label
? if_true_label
: drop_through_label
);
9359 /* In case the do_jump just above never jumps. */
9360 do_pending_stack_adjust ();
9361 emit_label (label1
);
9363 /* Now the ELSE-expression. */
9364 do_jump (TREE_OPERAND (exp
, 2),
9365 if_false_label
? if_false_label
: drop_through_label
,
9366 if_true_label
? if_true_label
: drop_through_label
);
9367 end_cleanup_deferral ();
9373 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
9375 if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_COMPLEX_FLOAT
9376 || GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_COMPLEX_INT
)
9378 tree exp0
= save_expr (TREE_OPERAND (exp
, 0));
9379 tree exp1
= save_expr (TREE_OPERAND (exp
, 1));
9382 (build (TRUTH_ANDIF_EXPR
, TREE_TYPE (exp
),
9383 fold (build (EQ_EXPR
, TREE_TYPE (exp
),
9384 fold (build1 (REALPART_EXPR
,
9385 TREE_TYPE (inner_type
),
9387 fold (build1 (REALPART_EXPR
,
9388 TREE_TYPE (inner_type
),
9390 fold (build (EQ_EXPR
, TREE_TYPE (exp
),
9391 fold (build1 (IMAGPART_EXPR
,
9392 TREE_TYPE (inner_type
),
9394 fold (build1 (IMAGPART_EXPR
,
9395 TREE_TYPE (inner_type
),
9397 if_false_label
, if_true_label
);
9400 else if (integer_zerop (TREE_OPERAND (exp
, 1)))
9401 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
9403 else if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_INT
9404 && !can_compare_p (EQ
, TYPE_MODE (inner_type
), ccp_jump
))
9405 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
);
9407 do_compare_and_jump (exp
, EQ
, EQ
, if_false_label
, if_true_label
);
9413 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
9415 if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_COMPLEX_FLOAT
9416 || GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_COMPLEX_INT
)
9418 tree exp0
= save_expr (TREE_OPERAND (exp
, 0));
9419 tree exp1
= save_expr (TREE_OPERAND (exp
, 1));
9422 (build (TRUTH_ORIF_EXPR
, TREE_TYPE (exp
),
9423 fold (build (NE_EXPR
, TREE_TYPE (exp
),
9424 fold (build1 (REALPART_EXPR
,
9425 TREE_TYPE (inner_type
),
9427 fold (build1 (REALPART_EXPR
,
9428 TREE_TYPE (inner_type
),
9430 fold (build (NE_EXPR
, TREE_TYPE (exp
),
9431 fold (build1 (IMAGPART_EXPR
,
9432 TREE_TYPE (inner_type
),
9434 fold (build1 (IMAGPART_EXPR
,
9435 TREE_TYPE (inner_type
),
9437 if_false_label
, if_true_label
);
9440 else if (integer_zerop (TREE_OPERAND (exp
, 1)))
9441 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
9443 else if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_INT
9444 && !can_compare_p (NE
, TYPE_MODE (inner_type
), ccp_jump
))
9445 do_jump_by_parts_equality (exp
, if_true_label
, if_false_label
);
9447 do_compare_and_jump (exp
, NE
, NE
, if_false_label
, if_true_label
);
9452 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9453 if (GET_MODE_CLASS (mode
) == MODE_INT
9454 && ! can_compare_p (LT
, mode
, ccp_jump
))
9455 do_jump_by_parts_greater (exp
, 1, if_false_label
, if_true_label
);
9457 do_compare_and_jump (exp
, LT
, LTU
, if_false_label
, if_true_label
);
9461 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9462 if (GET_MODE_CLASS (mode
) == MODE_INT
9463 && ! can_compare_p (LE
, mode
, ccp_jump
))
9464 do_jump_by_parts_greater (exp
, 0, if_true_label
, if_false_label
);
9466 do_compare_and_jump (exp
, LE
, LEU
, if_false_label
, if_true_label
);
9470 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9471 if (GET_MODE_CLASS (mode
) == MODE_INT
9472 && ! can_compare_p (GT
, mode
, ccp_jump
))
9473 do_jump_by_parts_greater (exp
, 0, if_false_label
, if_true_label
);
9475 do_compare_and_jump (exp
, GT
, GTU
, if_false_label
, if_true_label
);
9479 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9480 if (GET_MODE_CLASS (mode
) == MODE_INT
9481 && ! can_compare_p (GE
, mode
, ccp_jump
))
9482 do_jump_by_parts_greater (exp
, 1, if_true_label
, if_false_label
);
9484 do_compare_and_jump (exp
, GE
, GEU
, if_false_label
, if_true_label
);
9487 case UNORDERED_EXPR
:
9490 enum rtx_code cmp
, rcmp
;
9493 if (code
== UNORDERED_EXPR
)
9494 cmp
= UNORDERED
, rcmp
= ORDERED
;
9496 cmp
= ORDERED
, rcmp
= UNORDERED
;
9497 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9500 if (! can_compare_p (cmp
, mode
, ccp_jump
)
9501 && (can_compare_p (rcmp
, mode
, ccp_jump
)
9502 /* If the target doesn't provide either UNORDERED or ORDERED
9503 comparisons, canonicalize on UNORDERED for the library. */
9504 || rcmp
== UNORDERED
))
9508 do_compare_and_jump (exp
, cmp
, cmp
, if_false_label
, if_true_label
);
9510 do_compare_and_jump (exp
, rcmp
, rcmp
, if_true_label
, if_false_label
);
9515 enum rtx_code rcode1
;
9516 enum tree_code tcode2
;
9540 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9541 if (can_compare_p (rcode1
, mode
, ccp_jump
))
9542 do_compare_and_jump (exp
, rcode1
, rcode1
, if_false_label
,
9546 tree op0
= save_expr (TREE_OPERAND (exp
, 0));
9547 tree op1
= save_expr (TREE_OPERAND (exp
, 1));
9550 /* If the target doesn't support combined unordered
9551 compares, decompose into UNORDERED + comparison. */
9552 cmp0
= fold (build (UNORDERED_EXPR
, TREE_TYPE (exp
), op0
, op1
));
9553 cmp1
= fold (build (tcode2
, TREE_TYPE (exp
), op0
, op1
));
9554 exp
= build (TRUTH_ORIF_EXPR
, TREE_TYPE (exp
), cmp0
, cmp1
);
9555 do_jump (exp
, if_false_label
, if_true_label
);
9562 temp
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
9564 /* This is not needed any more and causes poor code since it causes
9565 comparisons and tests from non-SI objects to have different code
9567 /* Copy to register to avoid generating bad insns by cse
9568 from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
9569 if (!cse_not_expected
&& GET_CODE (temp
) == MEM
)
9570 temp
= copy_to_reg (temp
);
9572 do_pending_stack_adjust ();
9573 /* Do any postincrements in the expression that was tested. */
9576 if (GET_CODE (temp
) == CONST_INT
|| GET_CODE (temp
) == LABEL_REF
)
9578 rtx target
= temp
== const0_rtx
? if_false_label
: if_true_label
;
9582 else if (GET_MODE_CLASS (GET_MODE (temp
)) == MODE_INT
9583 && ! can_compare_p (NE
, GET_MODE (temp
), ccp_jump
))
9584 /* Note swapping the labels gives us not-equal. */
9585 do_jump_by_parts_equality_rtx (temp
, if_true_label
, if_false_label
);
9586 else if (GET_MODE (temp
) != VOIDmode
)
9587 do_compare_rtx_and_jump (temp
, CONST0_RTX (GET_MODE (temp
)),
9588 NE
, TREE_UNSIGNED (TREE_TYPE (exp
)),
9589 GET_MODE (temp
), NULL_RTX
, 0,
9590 if_false_label
, if_true_label
);
9595 if (drop_through_label
)
9597 /* If do_jump produces code that might be jumped around,
9598 do any stack adjusts from that code, before the place
9599 where control merges in. */
9600 do_pending_stack_adjust ();
9601 emit_label (drop_through_label
);
9605 /* Given a comparison expression EXP for values too wide to be compared
9606 with one insn, test the comparison and jump to the appropriate label.
9607 The code of EXP is ignored; we always test GT if SWAP is 0,
9608 and LT if SWAP is 1. */
9611 do_jump_by_parts_greater (exp
, swap
, if_false_label
, if_true_label
)
9614 rtx if_false_label
, if_true_label
;
9616 rtx op0
= expand_expr (TREE_OPERAND (exp
, swap
), NULL_RTX
, VOIDmode
, 0);
9617 rtx op1
= expand_expr (TREE_OPERAND (exp
, !swap
), NULL_RTX
, VOIDmode
, 0);
9618 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9619 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9621 do_jump_by_parts_greater_rtx (mode
, unsignedp
, op0
, op1
, if_false_label
, if_true_label
);
9624 /* Compare OP0 with OP1, word at a time, in mode MODE.
9625 UNSIGNEDP says to do unsigned comparison.
9626 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
9629 do_jump_by_parts_greater_rtx (mode
, unsignedp
, op0
, op1
, if_false_label
, if_true_label
)
9630 enum machine_mode mode
;
9633 rtx if_false_label
, if_true_label
;
9635 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
9636 rtx drop_through_label
= 0;
9639 if (! if_true_label
|| ! if_false_label
)
9640 drop_through_label
= gen_label_rtx ();
9641 if (! if_true_label
)
9642 if_true_label
= drop_through_label
;
9643 if (! if_false_label
)
9644 if_false_label
= drop_through_label
;
9646 /* Compare a word at a time, high order first. */
9647 for (i
= 0; i
< nwords
; i
++)
9649 rtx op0_word
, op1_word
;
9651 if (WORDS_BIG_ENDIAN
)
9653 op0_word
= operand_subword_force (op0
, i
, mode
);
9654 op1_word
= operand_subword_force (op1
, i
, mode
);
9658 op0_word
= operand_subword_force (op0
, nwords
- 1 - i
, mode
);
9659 op1_word
= operand_subword_force (op1
, nwords
- 1 - i
, mode
);
9662 /* All but high-order word must be compared as unsigned. */
9663 do_compare_rtx_and_jump (op0_word
, op1_word
, GT
,
9664 (unsignedp
|| i
> 0), word_mode
, NULL_RTX
, 0,
9665 NULL_RTX
, if_true_label
);
9667 /* Consider lower words only if these are equal. */
9668 do_compare_rtx_and_jump (op0_word
, op1_word
, NE
, unsignedp
, word_mode
,
9669 NULL_RTX
, 0, NULL_RTX
, if_false_label
);
9673 emit_jump (if_false_label
);
9674 if (drop_through_label
)
9675 emit_label (drop_through_label
);
9678 /* Given an EQ_EXPR expression EXP for values too wide to be compared
9679 with one insn, test the comparison and jump to the appropriate label. */
9682 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
)
9684 rtx if_false_label
, if_true_label
;
9686 rtx op0
= expand_expr (TREE_OPERAND (exp
, 0), NULL_RTX
, VOIDmode
, 0);
9687 rtx op1
= expand_expr (TREE_OPERAND (exp
, 1), NULL_RTX
, VOIDmode
, 0);
9688 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
9689 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
9691 rtx drop_through_label
= 0;
9693 if (! if_false_label
)
9694 drop_through_label
= if_false_label
= gen_label_rtx ();
9696 for (i
= 0; i
< nwords
; i
++)
9697 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, mode
),
9698 operand_subword_force (op1
, i
, mode
),
9699 EQ
, TREE_UNSIGNED (TREE_TYPE (exp
)),
9700 word_mode
, NULL_RTX
, 0, if_false_label
,
9704 emit_jump (if_true_label
);
9705 if (drop_through_label
)
9706 emit_label (drop_through_label
);
9709 /* Jump according to whether OP0 is 0.
9710 We assume that OP0 has an integer mode that is too wide
9711 for the available compare insns. */
9714 do_jump_by_parts_equality_rtx (op0
, if_false_label
, if_true_label
)
9716 rtx if_false_label
, if_true_label
;
9718 int nwords
= GET_MODE_SIZE (GET_MODE (op0
)) / UNITS_PER_WORD
;
9721 rtx drop_through_label
= 0;
9723 /* The fastest way of doing this comparison on almost any machine is to
9724 "or" all the words and compare the result. If all have to be loaded
9725 from memory and this is a very wide item, it's possible this may
9726 be slower, but that's highly unlikely. */
9728 part
= gen_reg_rtx (word_mode
);
9729 emit_move_insn (part
, operand_subword_force (op0
, 0, GET_MODE (op0
)));
9730 for (i
= 1; i
< nwords
&& part
!= 0; i
++)
9731 part
= expand_binop (word_mode
, ior_optab
, part
,
9732 operand_subword_force (op0
, i
, GET_MODE (op0
)),
9733 part
, 1, OPTAB_WIDEN
);
9737 do_compare_rtx_and_jump (part
, const0_rtx
, EQ
, 1, word_mode
,
9738 NULL_RTX
, 0, if_false_label
, if_true_label
);
9743 /* If we couldn't do the "or" simply, do this with a series of compares. */
9744 if (! if_false_label
)
9745 drop_through_label
= if_false_label
= gen_label_rtx ();
9747 for (i
= 0; i
< nwords
; i
++)
9748 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, GET_MODE (op0
)),
9749 const0_rtx
, EQ
, 1, word_mode
, NULL_RTX
, 0,
9750 if_false_label
, NULL_RTX
);
9753 emit_jump (if_true_label
);
9755 if (drop_through_label
)
9756 emit_label (drop_through_label
);
9759 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
9760 (including code to compute the values to be compared)
9761 and set (CC0) according to the result.
9762 The decision as to signed or unsigned comparison must be made by the caller.
9764 We force a stack adjustment unless there are currently
9765 things pushed on the stack that aren't yet used.
9767 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9770 If ALIGN is non-zero, it is the alignment of this type; if zero, the
9771 size of MODE should be used. */
9774 compare_from_rtx (op0
, op1
, code
, unsignedp
, mode
, size
, align
)
9775 register rtx op0
, op1
;
9778 enum machine_mode mode
;
9784 /* If one operand is constant, make it the second one. Only do this
9785 if the other operand is not constant as well. */
9787 if ((CONSTANT_P (op0
) && ! CONSTANT_P (op1
))
9788 || (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) != CONST_INT
))
9793 code
= swap_condition (code
);
9798 op0
= force_not_mem (op0
);
9799 op1
= force_not_mem (op1
);
9802 do_pending_stack_adjust ();
9804 if (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) == CONST_INT
9805 && (tem
= simplify_relational_operation (code
, mode
, op0
, op1
)) != 0)
9809 /* There's no need to do this now that combine.c can eliminate lots of
9810 sign extensions. This can be less efficient in certain cases on other
9813 /* If this is a signed equality comparison, we can do it as an
9814 unsigned comparison since zero-extension is cheaper than sign
9815 extension and comparisons with zero are done as unsigned. This is
9816 the case even on machines that can do fast sign extension, since
9817 zero-extension is easier to combine with other operations than
9818 sign-extension is. If we are comparing against a constant, we must
9819 convert it to what it would look like unsigned. */
9820 if ((code
== EQ
|| code
== NE
) && ! unsignedp
9821 && GET_MODE_BITSIZE (GET_MODE (op0
)) <= HOST_BITS_PER_WIDE_INT
)
9823 if (GET_CODE (op1
) == CONST_INT
9824 && (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
))) != INTVAL (op1
))
9825 op1
= GEN_INT (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
)));
9830 emit_cmp_insn (op0
, op1
, code
, size
, mode
, unsignedp
, align
);
9832 return gen_rtx_fmt_ee (code
, VOIDmode
, cc0_rtx
, const0_rtx
);
9835 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
9836 The decision as to signed or unsigned comparison must be made by the caller.
9838 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9841 If ALIGN is non-zero, it is the alignment of this type; if zero, the
9842 size of MODE should be used. */
9845 do_compare_rtx_and_jump (op0
, op1
, code
, unsignedp
, mode
, size
, align
,
9846 if_false_label
, if_true_label
)
9847 register rtx op0
, op1
;
9850 enum machine_mode mode
;
9853 rtx if_false_label
, if_true_label
;
9856 int dummy_true_label
= 0;
9858 /* Reverse the comparison if that is safe and we want to jump if it is
9860 if (! if_true_label
&& ! FLOAT_MODE_P (mode
))
9862 if_true_label
= if_false_label
;
9864 code
= reverse_condition (code
);
9867 /* If one operand is constant, make it the second one. Only do this
9868 if the other operand is not constant as well. */
9870 if ((CONSTANT_P (op0
) && ! CONSTANT_P (op1
))
9871 || (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) != CONST_INT
))
9876 code
= swap_condition (code
);
9881 op0
= force_not_mem (op0
);
9882 op1
= force_not_mem (op1
);
9885 do_pending_stack_adjust ();
9887 if (GET_CODE (op0
) == CONST_INT
&& GET_CODE (op1
) == CONST_INT
9888 && (tem
= simplify_relational_operation (code
, mode
, op0
, op1
)) != 0)
9890 if (tem
== const_true_rtx
)
9893 emit_jump (if_true_label
);
9898 emit_jump (if_false_label
);
9904 /* There's no need to do this now that combine.c can eliminate lots of
9905 sign extensions. This can be less efficient in certain cases on other
9908 /* If this is a signed equality comparison, we can do it as an
9909 unsigned comparison since zero-extension is cheaper than sign
9910 extension and comparisons with zero are done as unsigned. This is
9911 the case even on machines that can do fast sign extension, since
9912 zero-extension is easier to combine with other operations than
9913 sign-extension is. If we are comparing against a constant, we must
9914 convert it to what it would look like unsigned. */
9915 if ((code
== EQ
|| code
== NE
) && ! unsignedp
9916 && GET_MODE_BITSIZE (GET_MODE (op0
)) <= HOST_BITS_PER_WIDE_INT
)
9918 if (GET_CODE (op1
) == CONST_INT
9919 && (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
))) != INTVAL (op1
))
9920 op1
= GEN_INT (INTVAL (op1
) & GET_MODE_MASK (GET_MODE (op0
)));
9925 if (! if_true_label
)
9927 dummy_true_label
= 1;
9928 if_true_label
= gen_label_rtx ();
9931 emit_cmp_and_jump_insns (op0
, op1
, code
, size
, mode
, unsignedp
, align
,
9935 emit_jump (if_false_label
);
9936 if (dummy_true_label
)
9937 emit_label (if_true_label
);
9940 /* Generate code for a comparison expression EXP (including code to compute
9941 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
9942 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
9943 generated code will drop through.
9944 SIGNED_CODE should be the rtx operation for this comparison for
9945 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
9947 We force a stack adjustment unless there are currently
9948 things pushed on the stack that aren't yet used. */
9951 do_compare_and_jump (exp
, signed_code
, unsigned_code
, if_false_label
,
9954 enum rtx_code signed_code
, unsigned_code
;
9955 rtx if_false_label
, if_true_label
;
9957 unsigned int align0
, align1
;
9958 register rtx op0
, op1
;
9960 register enum machine_mode mode
;
9964 /* Don't crash if the comparison was erroneous. */
9965 op0
= expand_expr_unaligned (TREE_OPERAND (exp
, 0), &align0
);
9966 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ERROR_MARK
)
9969 op1
= expand_expr_unaligned (TREE_OPERAND (exp
, 1), &align1
);
9970 type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
9971 mode
= TYPE_MODE (type
);
9972 unsignedp
= TREE_UNSIGNED (type
);
9973 code
= unsignedp
? unsigned_code
: signed_code
;
9975 #ifdef HAVE_canonicalize_funcptr_for_compare
9976 /* If function pointers need to be "canonicalized" before they can
9977 be reliably compared, then canonicalize them. */
9978 if (HAVE_canonicalize_funcptr_for_compare
9979 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
9980 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
9983 rtx new_op0
= gen_reg_rtx (mode
);
9985 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0
, op0
));
9989 if (HAVE_canonicalize_funcptr_for_compare
9990 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 1))) == POINTER_TYPE
9991 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
9994 rtx new_op1
= gen_reg_rtx (mode
);
9996 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1
, op1
));
10001 /* Do any postincrements in the expression that was tested. */
10004 do_compare_rtx_and_jump (op0
, op1
, code
, unsignedp
, mode
,
10006 ? expr_size (TREE_OPERAND (exp
, 0)) : NULL_RTX
),
10007 MIN (align0
, align1
) / BITS_PER_UNIT
,
10008 if_false_label
, if_true_label
);
10011 /* Generate code to calculate EXP using a store-flag instruction
10012 and return an rtx for the result. EXP is either a comparison
10013 or a TRUTH_NOT_EXPR whose operand is a comparison.
10015 If TARGET is nonzero, store the result there if convenient.
10017 If ONLY_CHEAP is non-zero, only do this if it is likely to be very
10020 Return zero if there is no suitable set-flag instruction
10021 available on this machine.
10023 Once expand_expr has been called on the arguments of the comparison,
10024 we are committed to doing the store flag, since it is not safe to
10025 re-evaluate the expression. We emit the store-flag insn by calling
10026 emit_store_flag, but only expand the arguments if we have a reason
10027 to believe that emit_store_flag will be successful. If we think that
10028 it will, but it isn't, we have to simulate the store-flag with a
10029 set/jump/set sequence. */
10032 do_store_flag (exp
, target
, mode
, only_cheap
)
10035 enum machine_mode mode
;
10038 enum rtx_code code
;
10039 tree arg0
, arg1
, type
;
10041 enum machine_mode operand_mode
;
10045 enum insn_code icode
;
10046 rtx subtarget
= target
;
10049 /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10050 result at the end. We can't simply invert the test since it would
10051 have already been inverted if it were valid. This case occurs for
10052 some floating-point comparisons. */
10054 if (TREE_CODE (exp
) == TRUTH_NOT_EXPR
)
10055 invert
= 1, exp
= TREE_OPERAND (exp
, 0);
10057 arg0
= TREE_OPERAND (exp
, 0);
10058 arg1
= TREE_OPERAND (exp
, 1);
10059 type
= TREE_TYPE (arg0
);
10060 operand_mode
= TYPE_MODE (type
);
10061 unsignedp
= TREE_UNSIGNED (type
);
10063 /* We won't bother with BLKmode store-flag operations because it would mean
10064 passing a lot of information to emit_store_flag. */
10065 if (operand_mode
== BLKmode
)
10068 /* We won't bother with store-flag operations involving function pointers
10069 when function pointers must be canonicalized before comparisons. */
10070 #ifdef HAVE_canonicalize_funcptr_for_compare
10071 if (HAVE_canonicalize_funcptr_for_compare
10072 && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
10073 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
10075 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 1))) == POINTER_TYPE
10076 && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
10077 == FUNCTION_TYPE
))))
10084 /* Get the rtx comparison code to use. We know that EXP is a comparison
10085 operation of some type. Some comparisons against 1 and -1 can be
10086 converted to comparisons with zero. Do so here so that the tests
10087 below will be aware that we have a comparison with zero. These
10088 tests will not catch constants in the first operand, but constants
10089 are rarely passed as the first operand. */
10091 switch (TREE_CODE (exp
))
10100 if (integer_onep (arg1
))
10101 arg1
= integer_zero_node
, code
= unsignedp
? LEU
: LE
;
10103 code
= unsignedp
? LTU
: LT
;
10106 if (! unsignedp
&& integer_all_onesp (arg1
))
10107 arg1
= integer_zero_node
, code
= LT
;
10109 code
= unsignedp
? LEU
: LE
;
10112 if (! unsignedp
&& integer_all_onesp (arg1
))
10113 arg1
= integer_zero_node
, code
= GE
;
10115 code
= unsignedp
? GTU
: GT
;
10118 if (integer_onep (arg1
))
10119 arg1
= integer_zero_node
, code
= unsignedp
? GTU
: GT
;
10121 code
= unsignedp
? GEU
: GE
;
10124 case UNORDERED_EXPR
:
10150 /* Put a constant second. */
10151 if (TREE_CODE (arg0
) == REAL_CST
|| TREE_CODE (arg0
) == INTEGER_CST
)
10153 tem
= arg0
; arg0
= arg1
; arg1
= tem
;
10154 code
= swap_condition (code
);
10157 /* If this is an equality or inequality test of a single bit, we can
10158 do this by shifting the bit being tested to the low-order bit and
10159 masking the result with the constant 1. If the condition was EQ,
10160 we xor it with 1. This does not require an scc insn and is faster
10161 than an scc insn even if we have it. */
10163 if ((code
== NE
|| code
== EQ
)
10164 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
10165 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10167 tree inner
= TREE_OPERAND (arg0
, 0);
10168 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
10171 /* If INNER is a right shift of a constant and it plus BITNUM does
10172 not overflow, adjust BITNUM and INNER. */
10174 if (TREE_CODE (inner
) == RSHIFT_EXPR
10175 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
10176 && TREE_INT_CST_HIGH (TREE_OPERAND (inner
, 1)) == 0
10177 && bitnum
< TYPE_PRECISION (type
)
10178 && 0 > compare_tree_int (TREE_OPERAND (inner
, 1),
10179 bitnum
- TYPE_PRECISION (type
)))
10181 bitnum
+= TREE_INT_CST_LOW (TREE_OPERAND (inner
, 1));
10182 inner
= TREE_OPERAND (inner
, 0);
10185 /* If we are going to be able to omit the AND below, we must do our
10186 operations as unsigned. If we must use the AND, we have a choice.
10187 Normally unsigned is faster, but for some machines signed is. */
10188 ops_unsignedp
= (bitnum
== TYPE_PRECISION (type
) - 1 ? 1
10189 #ifdef LOAD_EXTEND_OP
10190 : (LOAD_EXTEND_OP (operand_mode
) == SIGN_EXTEND
? 0 : 1)
10196 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
10197 || GET_MODE (subtarget
) != operand_mode
10198 || ! safe_from_p (subtarget
, inner
, 1))
10201 op0
= expand_expr (inner
, subtarget
, VOIDmode
, 0);
10204 op0
= expand_shift (RSHIFT_EXPR
, GET_MODE (op0
), op0
,
10205 size_int (bitnum
), subtarget
, ops_unsignedp
);
10207 if (GET_MODE (op0
) != mode
)
10208 op0
= convert_to_mode (mode
, op0
, ops_unsignedp
);
10210 if ((code
== EQ
&& ! invert
) || (code
== NE
&& invert
))
10211 op0
= expand_binop (mode
, xor_optab
, op0
, const1_rtx
, subtarget
,
10212 ops_unsignedp
, OPTAB_LIB_WIDEN
);
10214 /* Put the AND last so it can combine with more things. */
10215 if (bitnum
!= TYPE_PRECISION (type
) - 1)
10216 op0
= expand_and (op0
, const1_rtx
, subtarget
);
10221 /* Now see if we are likely to be able to do this. Return if not. */
10222 if (! can_compare_p (code
, operand_mode
, ccp_store_flag
))
10225 icode
= setcc_gen_code
[(int) code
];
10226 if (icode
== CODE_FOR_nothing
10227 || (only_cheap
&& insn_data
[(int) icode
].operand
[0].mode
!= mode
))
10229 /* We can only do this if it is one of the special cases that
10230 can be handled without an scc insn. */
10231 if ((code
== LT
&& integer_zerop (arg1
))
10232 || (! only_cheap
&& code
== GE
&& integer_zerop (arg1
)))
10234 else if (BRANCH_COST
>= 0
10235 && ! only_cheap
&& (code
== NE
|| code
== EQ
)
10236 && TREE_CODE (type
) != REAL_TYPE
10237 && ((abs_optab
->handlers
[(int) operand_mode
].insn_code
10238 != CODE_FOR_nothing
)
10239 || (ffs_optab
->handlers
[(int) operand_mode
].insn_code
10240 != CODE_FOR_nothing
)))
10246 preexpand_calls (exp
);
10247 if (subtarget
== 0 || GET_CODE (subtarget
) != REG
10248 || GET_MODE (subtarget
) != operand_mode
10249 || ! safe_from_p (subtarget
, arg1
, 1))
10252 op0
= expand_expr (arg0
, subtarget
, VOIDmode
, 0);
10253 op1
= expand_expr (arg1
, NULL_RTX
, VOIDmode
, 0);
10256 target
= gen_reg_rtx (mode
);
10258 /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
10259 because, if the emit_store_flag does anything it will succeed and
10260 OP0 and OP1 will not be used subsequently. */
10262 result
= emit_store_flag (target
, code
,
10263 queued_subexp_p (op0
) ? copy_rtx (op0
) : op0
,
10264 queued_subexp_p (op1
) ? copy_rtx (op1
) : op1
,
10265 operand_mode
, unsignedp
, 1);
10270 result
= expand_binop (mode
, xor_optab
, result
, const1_rtx
,
10271 result
, 0, OPTAB_LIB_WIDEN
);
10275 /* If this failed, we have to do this with set/compare/jump/set code. */
10276 if (GET_CODE (target
) != REG
10277 || reg_mentioned_p (target
, op0
) || reg_mentioned_p (target
, op1
))
10278 target
= gen_reg_rtx (GET_MODE (target
));
10280 emit_move_insn (target
, invert
? const0_rtx
: const1_rtx
);
10281 result
= compare_from_rtx (op0
, op1
, code
, unsignedp
,
10282 operand_mode
, NULL_RTX
, 0);
10283 if (GET_CODE (result
) == CONST_INT
)
10284 return (((result
== const0_rtx
&& ! invert
)
10285 || (result
!= const0_rtx
&& invert
))
10286 ? const0_rtx
: const1_rtx
);
10288 label
= gen_label_rtx ();
10289 if (bcc_gen_fctn
[(int) code
] == 0)
10292 emit_jump_insn ((*bcc_gen_fctn
[(int) code
]) (label
));
10293 emit_move_insn (target
, invert
? const1_rtx
: const0_rtx
);
10294 emit_label (label
);
10299 /* Generate a tablejump instruction (used for switch statements). */
10301 #ifdef HAVE_tablejump
10303 /* INDEX is the value being switched on, with the lowest value
10304 in the table already subtracted.
10305 MODE is its expected mode (needed if INDEX is constant).
10306 RANGE is the length of the jump table.
10307 TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10309 DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10310 index value is out of range. */
10313 do_tablejump (index
, mode
, range
, table_label
, default_label
)
10314 rtx index
, range
, table_label
, default_label
;
10315 enum machine_mode mode
;
10317 register rtx temp
, vector
;
10319 /* Do an unsigned comparison (in the proper mode) between the index
10320 expression and the value which represents the length of the range.
10321 Since we just finished subtracting the lower bound of the range
10322 from the index expression, this comparison allows us to simultaneously
10323 check that the original index expression value is both greater than
10324 or equal to the minimum value of the range and less than or equal to
10325 the maximum value of the range. */
10327 emit_cmp_and_jump_insns (index
, range
, GTU
, NULL_RTX
, mode
, 1,
10330 /* If index is in range, it must fit in Pmode.
10331 Convert to Pmode so we can index with it. */
10333 index
= convert_to_mode (Pmode
, index
, 1);
10335 /* Don't let a MEM slip thru, because then INDEX that comes
10336 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10337 and break_out_memory_refs will go to work on it and mess it up. */
10338 #ifdef PIC_CASE_VECTOR_ADDRESS
10339 if (flag_pic
&& GET_CODE (index
) != REG
)
10340 index
= copy_to_mode_reg (Pmode
, index
);
10343 /* If flag_force_addr were to affect this address
10344 it could interfere with the tricky assumptions made
10345 about addresses that contain label-refs,
10346 which may be valid only very near the tablejump itself. */
10347 /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10348 GET_MODE_SIZE, because this indicates how large insns are. The other
10349 uses should all be Pmode, because they are addresses. This code
10350 could fail if addresses and insns are not the same size. */
10351 index
= gen_rtx_PLUS (Pmode
,
10352 gen_rtx_MULT (Pmode
, index
,
10353 GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE
))),
10354 gen_rtx_LABEL_REF (Pmode
, table_label
));
10355 #ifdef PIC_CASE_VECTOR_ADDRESS
10357 index
= PIC_CASE_VECTOR_ADDRESS (index
);
10360 index
= memory_address_noforce (CASE_VECTOR_MODE
, index
);
10361 temp
= gen_reg_rtx (CASE_VECTOR_MODE
);
10362 vector
= gen_rtx_MEM (CASE_VECTOR_MODE
, index
);
10363 RTX_UNCHANGING_P (vector
) = 1;
10364 convert_move (temp
, vector
, 0);
10366 emit_jump_insn (gen_tablejump (temp
, table_label
));
10368 /* If we are generating PIC code or if the table is PC-relative, the
10369 table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10370 if (! CASE_VECTOR_PC_RELATIVE
&& ! flag_pic
)
10374 #endif /* HAVE_tablejump */