![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to expr.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Convert tree expression to rtl instructions, for GNU compiler.
1.1.1.8 root 2: Copyright (C) 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
1.1 root 3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
1.1.1.8 root 18: the Free Software Foundation, 59 Temple Place - Suite 330,
19: Boston, MA 02111-1307, USA. */
1.1 root 20:
21:
22: #include "config.h"
1.1.1.6 root 23: #include "machmode.h"
1.1 root 24: #include "rtl.h"
25: #include "tree.h"
1.1.1.6 root 26: #include "obstack.h"
1.1 root 27: #include "flags.h"
1.1.1.7 root 28: #include "regs.h"
1.1 root 29: #include "function.h"
30: #include "insn-flags.h"
31: #include "insn-codes.h"
32: #include "expr.h"
33: #include "insn-config.h"
34: #include "recog.h"
35: #include "output.h"
36: #include "typeclass.h"
37:
1.1.1.6 root 38: #include "bytecode.h"
39: #include "bc-opcode.h"
40: #include "bc-typecd.h"
41: #include "bc-optab.h"
42: #include "bc-emit.h"
43:
44:
1.1 root 45: #define CEIL(x,y) (((x) + (y) - 1) / (y))
46:
47: /* Decide whether a function's arguments should be processed
1.1.1.5 root 48: from first to last or from last to first.
49:
50: They should if the stack and args grow in opposite directions, but
51: only if we have push insns. */
1.1 root 52:
53: #ifdef PUSH_ROUNDING
1.1.1.5 root 54:
1.1.1.6 root 55: #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
1.1 root 56: #define PUSH_ARGS_REVERSED /* If it's last to first */
57: #endif
1.1.1.5 root 58:
1.1 root 59: #endif
60:
61: #ifndef STACK_PUSH_CODE
62: #ifdef STACK_GROWS_DOWNWARD
63: #define STACK_PUSH_CODE PRE_DEC
64: #else
65: #define STACK_PUSH_CODE PRE_INC
66: #endif
67: #endif
68:
69: /* Like STACK_BOUNDARY but in units of bytes, not bits. */
70: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
71:
72: /* If this is nonzero, we do not bother generating VOLATILE
73: around volatile memory references, and we are willing to
74: output indirect addresses. If cse is to follow, we reject
75: indirect addresses so a useful potential cse is generated;
76: if it is used only once, instruction combination will produce
77: the same indirect address eventually. */
78: int cse_not_expected;
79:
80: /* Nonzero to generate code for all the subroutines within an
81: expression before generating the upper levels of the expression.
82: Nowadays this is never zero. */
83: int do_preexpand_calls = 1;
84:
85: /* Number of units that we should eventually pop off the stack.
86: These are the arguments to function calls that have already returned. */
87: int pending_stack_adjust;
88:
89: /* Nonzero means stack pops must not be deferred, and deferred stack
90: pops must not be output. It is nonzero inside a function call,
91: inside a conditional expression, inside a statement expression,
92: and in other cases as well. */
93: int inhibit_defer_pop;
94:
95: /* A list of all cleanups which belong to the arguments of
96: function calls being expanded by expand_call. */
97: tree cleanups_this_call;
98:
1.1.1.7 root 99: /* When temporaries are created by TARGET_EXPRs, they are created at
100: this level of temp_slot_level, so that they can remain allocated
101: until no longer needed. CLEANUP_POINT_EXPRs define the lifetime
102: of TARGET_EXPRs. */
103: int target_temp_slot_level;
104:
1.1 root 105: /* Nonzero means __builtin_saveregs has already been done in this function.
106: The value is the pseudoreg containing the value __builtin_saveregs
107: returned. */
108: static rtx saveregs_value;
109:
1.1.1.5 root 110: /* Similarly for __builtin_apply_args. */
111: static rtx apply_args_value;
112:
113: /* This structure is used by move_by_pieces to describe the move to
114: be performed. */
115:
116: struct move_by_pieces
117: {
118: rtx to;
119: rtx to_addr;
120: int autinc_to;
121: int explicit_inc_to;
1.1.1.8 root 122: int to_struct;
1.1.1.5 root 123: rtx from;
124: rtx from_addr;
125: int autinc_from;
126: int explicit_inc_from;
1.1.1.8 root 127: int from_struct;
1.1.1.5 root 128: int len;
129: int offset;
130: int reverse;
131: };
132:
1.1.1.6 root 133: /* Used to generate bytecodes: keep track of size of local variables,
134: as well as depth of arithmetic stack. (Notice that variables are
135: stored on the machine's stack, not the arithmetic stack.) */
136:
1.1.1.7 root 137: extern int local_vars_size;
1.1.1.6 root 138: extern int stack_depth;
139: extern int max_stack_depth;
140: extern struct obstack permanent_obstack;
141:
142:
1.1.1.5 root 143: static rtx enqueue_insn PROTO((rtx, rtx));
144: static int queued_subexp_p PROTO((rtx));
145: static void init_queue PROTO((void));
146: static void move_by_pieces PROTO((rtx, rtx, int, int));
147: static int move_by_pieces_ninsns PROTO((unsigned int, int));
148: static void move_by_pieces_1 PROTO((rtx (*) (), enum machine_mode,
149: struct move_by_pieces *));
150: static void store_constructor PROTO((tree, rtx));
151: static rtx store_field PROTO((rtx, int, int, enum machine_mode, tree,
152: enum machine_mode, int, int, int));
1.1.1.7 root 153: static int get_inner_unaligned_p PROTO((tree));
1.1.1.5 root 154: static tree save_noncopied_parts PROTO((tree, tree));
155: static tree init_noncopied_parts PROTO((tree, tree));
156: static int safe_from_p PROTO((rtx, tree));
157: static int fixed_type_p PROTO((tree));
158: static int get_pointer_alignment PROTO((tree, unsigned));
159: static tree string_constant PROTO((tree, tree *));
160: static tree c_strlen PROTO((tree));
1.1.1.7 root 161: static rtx expand_builtin PROTO((tree, rtx, rtx,
162: enum machine_mode, int));
1.1.1.5 root 163: static int apply_args_size PROTO((void));
164: static int apply_result_size PROTO((void));
165: static rtx result_vector PROTO((int, rtx));
166: static rtx expand_builtin_apply_args PROTO((void));
167: static rtx expand_builtin_apply PROTO((rtx, rtx, rtx));
168: static void expand_builtin_return PROTO((rtx));
169: static rtx expand_increment PROTO((tree, int));
1.1.1.6 root 170: rtx bc_expand_increment PROTO((struct increment_operator *, tree));
171: tree bc_runtime_type_code PROTO((tree));
172: rtx bc_allocate_local PROTO((int, int));
173: void bc_store_memory PROTO((tree, tree));
174: tree bc_expand_component_address PROTO((tree));
175: tree bc_expand_address PROTO((tree));
176: void bc_expand_constructor PROTO((tree));
177: void bc_adjust_stack PROTO((int));
178: tree bc_canonicalize_array_ref PROTO((tree));
179: void bc_load_memory PROTO((tree, tree));
180: void bc_load_externaddr PROTO((rtx));
181: void bc_load_externaddr_id PROTO((tree, int));
182: void bc_load_localaddr PROTO((rtx));
183: void bc_load_parmaddr PROTO((rtx));
1.1.1.5 root 184: static void preexpand_calls PROTO((tree));
185: static void do_jump_by_parts_greater PROTO((tree, int, rtx, rtx));
1.1.1.7 root 186: void do_jump_by_parts_greater_rtx PROTO((enum machine_mode, int, rtx, rtx, rtx, rtx));
1.1.1.5 root 187: static void do_jump_by_parts_equality PROTO((tree, rtx, rtx));
188: static void do_jump_by_parts_equality_rtx PROTO((rtx, rtx, rtx));
189: static void do_jump_for_compare PROTO((rtx, rtx, rtx));
190: static rtx compare PROTO((tree, enum rtx_code, enum rtx_code));
191: static rtx do_store_flag PROTO((tree, rtx, enum machine_mode, int));
1.1.1.7 root 192: static tree defer_cleanups_to PROTO((tree));
193: extern void (*interim_eh_hook) PROTO((tree));
1.1.1.8 root 194: extern tree truthvalue_conversion PROTO((tree));
1.1 root 195:
1.1.1.4 root 196: /* Record for each mode whether we can move a register directly to or
197: from an object of that mode in memory. If we can't, we won't try
198: to use that mode directly when accessing a field of that mode. */
199:
200: static char direct_load[NUM_MACHINE_MODES];
201: static char direct_store[NUM_MACHINE_MODES];
202:
1.1 root 203: /* MOVE_RATIO is the number of move instructions that is better than
204: a block move. */
205:
206: #ifndef MOVE_RATIO
1.1.1.4 root 207: #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
1.1 root 208: #define MOVE_RATIO 2
209: #else
210: /* A value of around 6 would minimize code size; infinity would minimize
211: execution time. */
212: #define MOVE_RATIO 15
213: #endif
214: #endif
1.1.1.2 root 215:
1.1.1.4 root 216: /* This array records the insn_code of insns to perform block moves. */
1.1.1.5 root 217: enum insn_code movstr_optab[NUM_MACHINE_MODES];
1.1.1.4 root 218:
1.1.1.2 root 219: /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow. */
220:
221: #ifndef SLOW_UNALIGNED_ACCESS
1.1.1.8 root 222: #define SLOW_UNALIGNED_ACCESS STRICT_ALIGNMENT
1.1.1.2 root 223: #endif
1.1.1.5 root 224:
225: /* Register mappings for target machines without register windows. */
226: #ifndef INCOMING_REGNO
227: #define INCOMING_REGNO(OUT) (OUT)
228: #endif
229: #ifndef OUTGOING_REGNO
230: #define OUTGOING_REGNO(IN) (IN)
231: #endif
1.1 root 232:
1.1.1.6 root 233: /* Maps used to convert modes to const, load, and store bytecodes. */
234: enum bytecode_opcode mode_to_const_map[MAX_MACHINE_MODE];
235: enum bytecode_opcode mode_to_load_map[MAX_MACHINE_MODE];
236: enum bytecode_opcode mode_to_store_map[MAX_MACHINE_MODE];
237:
238: /* Initialize maps used to convert modes to const, load, and store
239: bytecodes. */
240: void
241: bc_init_mode_to_opcode_maps ()
242: {
243: int mode;
244:
245: for (mode = 0; mode < (int) MAX_MACHINE_MODE; mode++)
246: mode_to_const_map[mode] =
247: mode_to_load_map[mode] =
248: mode_to_store_map[mode] = neverneverland;
249:
250: #define DEF_MODEMAP(SYM, CODE, UCODE, CONST, LOAD, STORE) \
251: mode_to_const_map[(int) SYM] = CONST; \
252: mode_to_load_map[(int) SYM] = LOAD; \
253: mode_to_store_map[(int) SYM] = STORE;
254:
255: #include "modemap.def"
256: #undef DEF_MODEMAP
257: }
258:
1.1.1.4 root 259: /* This is run once per compilation to set up which modes can be used
260: directly in memory and to initialize the block move optab. */
261:
262: void
263: init_expr_once ()
264: {
265: rtx insn, pat;
266: enum machine_mode mode;
267: /* Try indexing by frame ptr and try by stack ptr.
268: It is known that on the Convex the stack ptr isn't a valid index.
269: With luck, one or the other is valid on any machine. */
270: rtx mem = gen_rtx (MEM, VOIDmode, stack_pointer_rtx);
271: rtx mem1 = gen_rtx (MEM, VOIDmode, frame_pointer_rtx);
272:
273: start_sequence ();
274: insn = emit_insn (gen_rtx (SET, 0, 0));
275: pat = PATTERN (insn);
276:
277: for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
278: mode = (enum machine_mode) ((int) mode + 1))
279: {
280: int regno;
281: rtx reg;
282: int num_clobbers;
283:
284: direct_load[(int) mode] = direct_store[(int) mode] = 0;
285: PUT_MODE (mem, mode);
286: PUT_MODE (mem1, mode);
287:
288: /* See if there is some register that can be used in this mode and
289: directly loaded or stored from memory. */
290:
291: if (mode != VOIDmode && mode != BLKmode)
292: for (regno = 0; regno < FIRST_PSEUDO_REGISTER
293: && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
294: regno++)
295: {
296: if (! HARD_REGNO_MODE_OK (regno, mode))
297: continue;
298:
299: reg = gen_rtx (REG, mode, regno);
300:
301: SET_SRC (pat) = mem;
302: SET_DEST (pat) = reg;
303: if (recog (pat, insn, &num_clobbers) >= 0)
304: direct_load[(int) mode] = 1;
305:
306: SET_SRC (pat) = mem1;
307: SET_DEST (pat) = reg;
308: if (recog (pat, insn, &num_clobbers) >= 0)
309: direct_load[(int) mode] = 1;
310:
311: SET_SRC (pat) = reg;
312: SET_DEST (pat) = mem;
313: if (recog (pat, insn, &num_clobbers) >= 0)
314: direct_store[(int) mode] = 1;
315:
316: SET_SRC (pat) = reg;
317: SET_DEST (pat) = mem1;
318: if (recog (pat, insn, &num_clobbers) >= 0)
319: direct_store[(int) mode] = 1;
320: }
321: }
322:
323: end_sequence ();
324: }
325:
1.1 root 326: /* This is run at the start of compiling a function. */
327:
328: void
329: init_expr ()
330: {
331: init_queue ();
332:
333: pending_stack_adjust = 0;
334: inhibit_defer_pop = 0;
335: cleanups_this_call = 0;
336: saveregs_value = 0;
1.1.1.5 root 337: apply_args_value = 0;
1.1.1.2 root 338: forced_labels = 0;
1.1 root 339: }
340:
341: /* Save all variables describing the current status into the structure *P.
342: This is used before starting a nested function. */
343:
344: void
345: save_expr_status (p)
346: struct function *p;
347: {
348: /* Instead of saving the postincrement queue, empty it. */
349: emit_queue ();
350:
351: p->pending_stack_adjust = pending_stack_adjust;
352: p->inhibit_defer_pop = inhibit_defer_pop;
353: p->cleanups_this_call = cleanups_this_call;
354: p->saveregs_value = saveregs_value;
1.1.1.5 root 355: p->apply_args_value = apply_args_value;
1.1.1.2 root 356: p->forced_labels = forced_labels;
1.1 root 357:
358: pending_stack_adjust = 0;
359: inhibit_defer_pop = 0;
360: cleanups_this_call = 0;
361: saveregs_value = 0;
1.1.1.5 root 362: apply_args_value = 0;
1.1.1.2 root 363: forced_labels = 0;
1.1 root 364: }
365:
366: /* Restore all variables describing the current status from the structure *P.
367: This is used after a nested function. */
368:
369: void
370: restore_expr_status (p)
371: struct function *p;
372: {
373: pending_stack_adjust = p->pending_stack_adjust;
374: inhibit_defer_pop = p->inhibit_defer_pop;
375: cleanups_this_call = p->cleanups_this_call;
376: saveregs_value = p->saveregs_value;
1.1.1.5 root 377: apply_args_value = p->apply_args_value;
1.1.1.2 root 378: forced_labels = p->forced_labels;
1.1 root 379: }
380:
381: /* Manage the queue of increment instructions to be output
382: for POSTINCREMENT_EXPR expressions, etc. */
383:
384: static rtx pending_chain;
385:
386: /* Queue up to increment (or change) VAR later. BODY says how:
387: BODY should be the same thing you would pass to emit_insn
388: to increment right away. It will go to emit_insn later on.
389:
390: The value is a QUEUED expression to be used in place of VAR
391: where you want to guarantee the pre-incrementation value of VAR. */
392:
393: static rtx
394: enqueue_insn (var, body)
395: rtx var, body;
396: {
397: pending_chain = gen_rtx (QUEUED, GET_MODE (var),
1.1.1.4 root 398: var, NULL_RTX, NULL_RTX, body, pending_chain);
1.1 root 399: return pending_chain;
400: }
401:
402: /* Use protect_from_queue to convert a QUEUED expression
403: into something that you can put immediately into an instruction.
404: If the queued incrementation has not happened yet,
405: protect_from_queue returns the variable itself.
406: If the incrementation has happened, protect_from_queue returns a temp
407: that contains a copy of the old value of the variable.
408:
409: Any time an rtx which might possibly be a QUEUED is to be put
410: into an instruction, it must be passed through protect_from_queue first.
411: QUEUED expressions are not meaningful in instructions.
412:
413: Do not pass a value through protect_from_queue and then hold
414: on to it for a while before putting it in an instruction!
415: If the queue is flushed in between, incorrect code will result. */
416:
417: rtx
418: protect_from_queue (x, modify)
419: register rtx x;
420: int modify;
421: {
422: register RTX_CODE code = GET_CODE (x);
423:
424: #if 0 /* A QUEUED can hang around after the queue is forced out. */
425: /* Shortcut for most common case. */
426: if (pending_chain == 0)
427: return x;
428: #endif
429:
430: if (code != QUEUED)
431: {
1.1.1.6 root 432: /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
433: use of autoincrement. Make a copy of the contents of the memory
434: location rather than a copy of the address, but not if the value is
435: of mode BLKmode. Don't modify X in place since it might be
436: shared. */
1.1 root 437: if (code == MEM && GET_MODE (x) != BLKmode
438: && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
439: {
440: register rtx y = XEXP (x, 0);
1.1.1.6 root 441: register rtx new = gen_rtx (MEM, GET_MODE (x), QUEUED_VAR (y));
442:
443: MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (x);
444: RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x);
445: MEM_VOLATILE_P (new) = MEM_VOLATILE_P (x);
446:
1.1 root 447: if (QUEUED_INSN (y))
448: {
1.1.1.6 root 449: register rtx temp = gen_reg_rtx (GET_MODE (new));
450: emit_insn_before (gen_move_insn (temp, new),
1.1 root 451: QUEUED_INSN (y));
452: return temp;
453: }
1.1.1.6 root 454: return new;
1.1 root 455: }
456: /* Otherwise, recursively protect the subexpressions of all
457: the kinds of rtx's that can contain a QUEUED. */
458: if (code == MEM)
1.1.1.6 root 459: {
460: rtx tem = protect_from_queue (XEXP (x, 0), 0);
461: if (tem != XEXP (x, 0))
462: {
463: x = copy_rtx (x);
464: XEXP (x, 0) = tem;
465: }
466: }
1.1 root 467: else if (code == PLUS || code == MULT)
468: {
1.1.1.6 root 469: rtx new0 = protect_from_queue (XEXP (x, 0), 0);
470: rtx new1 = protect_from_queue (XEXP (x, 1), 0);
471: if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
472: {
473: x = copy_rtx (x);
474: XEXP (x, 0) = new0;
475: XEXP (x, 1) = new1;
476: }
1.1 root 477: }
478: return x;
479: }
480: /* If the increment has not happened, use the variable itself. */
481: if (QUEUED_INSN (x) == 0)
482: return QUEUED_VAR (x);
483: /* If the increment has happened and a pre-increment copy exists,
484: use that copy. */
485: if (QUEUED_COPY (x) != 0)
486: return QUEUED_COPY (x);
487: /* The increment has happened but we haven't set up a pre-increment copy.
488: Set one up now, and use it. */
489: QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
490: emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
491: QUEUED_INSN (x));
492: return QUEUED_COPY (x);
493: }
494:
495: /* Return nonzero if X contains a QUEUED expression:
496: if it contains anything that will be altered by a queued increment.
497: We handle only combinations of MEM, PLUS, MINUS and MULT operators
498: since memory addresses generally contain only those. */
499:
500: static int
501: queued_subexp_p (x)
502: rtx x;
503: {
504: register enum rtx_code code = GET_CODE (x);
505: switch (code)
506: {
507: case QUEUED:
508: return 1;
509: case MEM:
510: return queued_subexp_p (XEXP (x, 0));
511: case MULT:
512: case PLUS:
513: case MINUS:
514: return queued_subexp_p (XEXP (x, 0))
515: || queued_subexp_p (XEXP (x, 1));
516: }
517: return 0;
518: }
519:
520: /* Perform all the pending incrementations. */
521:
522: void
523: emit_queue ()
524: {
525: register rtx p;
526: while (p = pending_chain)
527: {
528: QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
529: pending_chain = QUEUED_NEXT (p);
530: }
531: }
532:
533: static void
534: init_queue ()
535: {
536: if (pending_chain)
537: abort ();
538: }
539:
540: /* Copy data from FROM to TO, where the machine modes are not the same.
541: Both modes may be integer, or both may be floating.
542: UNSIGNEDP should be nonzero if FROM is an unsigned type.
543: This causes zero-extension instead of sign-extension. */
544:
545: void
546: convert_move (to, from, unsignedp)
547: register rtx to, from;
548: int unsignedp;
549: {
550: enum machine_mode to_mode = GET_MODE (to);
551: enum machine_mode from_mode = GET_MODE (from);
552: int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
553: int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
554: enum insn_code code;
555: rtx libcall;
556:
557: /* rtx code for making an equivalent value. */
558: enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
559:
560: to = protect_from_queue (to, 1);
561: from = protect_from_queue (from, 0);
562:
563: if (to_real != from_real)
564: abort ();
565:
1.1.1.4 root 566: /* If FROM is a SUBREG that indicates that we have already done at least
567: the required extension, strip it. We don't handle such SUBREGs as
568: TO here. */
569:
570: if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
571: && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
572: >= GET_MODE_SIZE (to_mode))
573: && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
574: from = gen_lowpart (to_mode, from), from_mode = to_mode;
575:
576: if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
577: abort ();
578:
1.1 root 579: if (to_mode == from_mode
580: || (from_mode == VOIDmode && CONSTANT_P (from)))
581: {
582: emit_move_insn (to, from);
583: return;
584: }
585:
586: if (to_real)
587: {
1.1.1.6 root 588: rtx value;
589:
1.1.1.5 root 590: #ifdef HAVE_extendqfhf2
591: if (HAVE_extendqfsf2 && from_mode == QFmode && to_mode == HFmode)
592: {
593: emit_unop_insn (CODE_FOR_extendqfsf2, to, from, UNKNOWN);
594: return;
595: }
596: #endif
597: #ifdef HAVE_extendqfsf2
598: if (HAVE_extendqfsf2 && from_mode == QFmode && to_mode == SFmode)
599: {
600: emit_unop_insn (CODE_FOR_extendqfsf2, to, from, UNKNOWN);
601: return;
602: }
603: #endif
604: #ifdef HAVE_extendqfdf2
605: if (HAVE_extendqfdf2 && from_mode == QFmode && to_mode == DFmode)
606: {
607: emit_unop_insn (CODE_FOR_extendqfdf2, to, from, UNKNOWN);
608: return;
609: }
610: #endif
611: #ifdef HAVE_extendqfxf2
612: if (HAVE_extendqfxf2 && from_mode == QFmode && to_mode == XFmode)
613: {
614: emit_unop_insn (CODE_FOR_extendqfxf2, to, from, UNKNOWN);
615: return;
616: }
617: #endif
618: #ifdef HAVE_extendqftf2
619: if (HAVE_extendqftf2 && from_mode == QFmode && to_mode == TFmode)
620: {
621: emit_unop_insn (CODE_FOR_extendqftf2, to, from, UNKNOWN);
622: return;
623: }
624: #endif
625:
1.1.1.7 root 626: #ifdef HAVE_extendhftqf2
627: if (HAVE_extendhftqf2 && from_mode == HFmode && to_mode == TQFmode)
628: {
629: emit_unop_insn (CODE_FOR_extendhftqf2, to, from, UNKNOWN);
630: return;
631: }
632: #endif
633:
1.1.1.5 root 634: #ifdef HAVE_extendhfsf2
635: if (HAVE_extendhfsf2 && from_mode == HFmode && to_mode == SFmode)
636: {
637: emit_unop_insn (CODE_FOR_extendhfsf2, to, from, UNKNOWN);
638: return;
639: }
640: #endif
641: #ifdef HAVE_extendhfdf2
642: if (HAVE_extendhfdf2 && from_mode == HFmode && to_mode == DFmode)
643: {
644: emit_unop_insn (CODE_FOR_extendhfdf2, to, from, UNKNOWN);
645: return;
646: }
647: #endif
648: #ifdef HAVE_extendhfxf2
649: if (HAVE_extendhfxf2 && from_mode == HFmode && to_mode == XFmode)
650: {
651: emit_unop_insn (CODE_FOR_extendhfxf2, to, from, UNKNOWN);
652: return;
653: }
654: #endif
655: #ifdef HAVE_extendhftf2
656: if (HAVE_extendhftf2 && from_mode == HFmode && to_mode == TFmode)
657: {
658: emit_unop_insn (CODE_FOR_extendhftf2, to, from, UNKNOWN);
659: return;
660: }
661: #endif
662:
1.1 root 663: #ifdef HAVE_extendsfdf2
664: if (HAVE_extendsfdf2 && from_mode == SFmode && to_mode == DFmode)
665: {
666: emit_unop_insn (CODE_FOR_extendsfdf2, to, from, UNKNOWN);
667: return;
668: }
669: #endif
1.1.1.4 root 670: #ifdef HAVE_extendsfxf2
671: if (HAVE_extendsfxf2 && from_mode == SFmode && to_mode == XFmode)
672: {
673: emit_unop_insn (CODE_FOR_extendsfxf2, to, from, UNKNOWN);
674: return;
675: }
676: #endif
1.1 root 677: #ifdef HAVE_extendsftf2
678: if (HAVE_extendsftf2 && from_mode == SFmode && to_mode == TFmode)
679: {
680: emit_unop_insn (CODE_FOR_extendsftf2, to, from, UNKNOWN);
681: return;
682: }
683: #endif
1.1.1.4 root 684: #ifdef HAVE_extenddfxf2
685: if (HAVE_extenddfxf2 && from_mode == DFmode && to_mode == XFmode)
686: {
687: emit_unop_insn (CODE_FOR_extenddfxf2, to, from, UNKNOWN);
688: return;
689: }
690: #endif
1.1 root 691: #ifdef HAVE_extenddftf2
692: if (HAVE_extenddftf2 && from_mode == DFmode && to_mode == TFmode)
693: {
694: emit_unop_insn (CODE_FOR_extenddftf2, to, from, UNKNOWN);
695: return;
696: }
697: #endif
1.1.1.5 root 698:
699: #ifdef HAVE_trunchfqf2
700: if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
701: {
702: emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
703: return;
704: }
705: #endif
706: #ifdef HAVE_truncsfqf2
707: if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
708: {
709: emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
710: return;
711: }
712: #endif
713: #ifdef HAVE_truncdfqf2
714: if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
715: {
716: emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
717: return;
718: }
719: #endif
720: #ifdef HAVE_truncxfqf2
721: if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
722: {
723: emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
724: return;
725: }
726: #endif
727: #ifdef HAVE_trunctfqf2
728: if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
729: {
730: emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
731: return;
732: }
733: #endif
1.1.1.7 root 734:
735: #ifdef HAVE_trunctqfhf2
736: if (HAVE_trunctqfhf2 && from_mode == TQFmode && to_mode == HFmode)
737: {
738: emit_unop_insn (CODE_FOR_trunctqfhf2, to, from, UNKNOWN);
739: return;
740: }
741: #endif
1.1.1.5 root 742: #ifdef HAVE_truncsfhf2
743: if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
744: {
745: emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
746: return;
747: }
748: #endif
749: #ifdef HAVE_truncdfhf2
750: if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
751: {
752: emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
753: return;
754: }
755: #endif
756: #ifdef HAVE_truncxfhf2
757: if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
758: {
759: emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
760: return;
761: }
762: #endif
763: #ifdef HAVE_trunctfhf2
764: if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
765: {
766: emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
767: return;
768: }
769: #endif
1.1 root 770: #ifdef HAVE_truncdfsf2
771: if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
772: {
773: emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
774: return;
775: }
776: #endif
1.1.1.4 root 777: #ifdef HAVE_truncxfsf2
778: if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
779: {
780: emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
781: return;
782: }
783: #endif
1.1 root 784: #ifdef HAVE_trunctfsf2
785: if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
786: {
787: emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
788: return;
789: }
790: #endif
1.1.1.4 root 791: #ifdef HAVE_truncxfdf2
792: if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
793: {
794: emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
795: return;
796: }
797: #endif
1.1 root 798: #ifdef HAVE_trunctfdf2
799: if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
800: {
801: emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
802: return;
803: }
804: #endif
805:
1.1.1.4 root 806: libcall = (rtx) 0;
807: switch (from_mode)
808: {
809: case SFmode:
810: switch (to_mode)
811: {
812: case DFmode:
813: libcall = extendsfdf2_libfunc;
814: break;
815:
816: case XFmode:
817: libcall = extendsfxf2_libfunc;
818: break;
819:
820: case TFmode:
821: libcall = extendsftf2_libfunc;
822: break;
823: }
824: break;
825:
826: case DFmode:
827: switch (to_mode)
828: {
829: case SFmode:
830: libcall = truncdfsf2_libfunc;
831: break;
832:
833: case XFmode:
834: libcall = extenddfxf2_libfunc;
835: break;
836:
837: case TFmode:
838: libcall = extenddftf2_libfunc;
839: break;
840: }
841: break;
842:
843: case XFmode:
844: switch (to_mode)
845: {
846: case SFmode:
847: libcall = truncxfsf2_libfunc;
848: break;
849:
850: case DFmode:
851: libcall = truncxfdf2_libfunc;
852: break;
853: }
854: break;
855:
856: case TFmode:
857: switch (to_mode)
858: {
859: case SFmode:
860: libcall = trunctfsf2_libfunc;
861: break;
862:
863: case DFmode:
864: libcall = trunctfdf2_libfunc;
865: break;
866: }
867: break;
868: }
869:
870: if (libcall == (rtx) 0)
871: /* This conversion is not implemented yet. */
1.1 root 872: abort ();
873:
1.1.1.6 root 874: value = emit_library_call_value (libcall, NULL_RTX, 1, to_mode,
875: 1, from, from_mode);
876: emit_move_insn (to, value);
1.1 root 877: return;
878: }
879:
880: /* Now both modes are integers. */
881:
882: /* Handle expanding beyond a word. */
883: if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
884: && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
885: {
886: rtx insns;
887: rtx lowpart;
888: rtx fill_value;
889: rtx lowfrom;
890: int i;
891: enum machine_mode lowpart_mode;
892: int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
893:
894: /* Try converting directly if the insn is supported. */
895: if ((code = can_extend_p (to_mode, from_mode, unsignedp))
896: != CODE_FOR_nothing)
897: {
1.1.1.4 root 898: /* If FROM is a SUBREG, put it into a register. Do this
899: so that we always generate the same set of insns for
900: better cse'ing; if an intermediate assignment occurred,
901: we won't be doing the operation directly on the SUBREG. */
902: if (optimize > 0 && GET_CODE (from) == SUBREG)
903: from = force_reg (from_mode, from);
1.1 root 904: emit_unop_insn (code, to, from, equiv_code);
905: return;
906: }
907: /* Next, try converting via full word. */
908: else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
909: && ((code = can_extend_p (to_mode, word_mode, unsignedp))
910: != CODE_FOR_nothing))
911: {
1.1.1.6 root 912: if (GET_CODE (to) == REG)
913: emit_insn (gen_rtx (CLOBBER, VOIDmode, to));
1.1 root 914: convert_move (gen_lowpart (word_mode, to), from, unsignedp);
915: emit_unop_insn (code, to,
916: gen_lowpart (word_mode, to), equiv_code);
917: return;
918: }
919:
920: /* No special multiword conversion insn; do it by hand. */
921: start_sequence ();
922:
1.1.1.7 root 923: /* Since we will turn this into a no conflict block, we must ensure
924: that the source does not overlap the target. */
925:
926: if (reg_overlap_mentioned_p (to, from))
927: from = force_reg (from_mode, from);
928:
1.1 root 929: /* Get a copy of FROM widened to a word, if necessary. */
930: if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
931: lowpart_mode = word_mode;
932: else
933: lowpart_mode = from_mode;
934:
935: lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
936:
937: lowpart = gen_lowpart (lowpart_mode, to);
938: emit_move_insn (lowpart, lowfrom);
939:
940: /* Compute the value to put in each remaining word. */
941: if (unsignedp)
942: fill_value = const0_rtx;
943: else
944: {
945: #ifdef HAVE_slt
946: if (HAVE_slt
947: && insn_operand_mode[(int) CODE_FOR_slt][0] == word_mode
948: && STORE_FLAG_VALUE == -1)
949: {
1.1.1.4 root 950: emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
951: lowpart_mode, 0, 0);
1.1 root 952: fill_value = gen_reg_rtx (word_mode);
953: emit_insn (gen_slt (fill_value));
954: }
955: else
956: #endif
957: {
958: fill_value
959: = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
960: size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
1.1.1.4 root 961: NULL_RTX, 0);
1.1 root 962: fill_value = convert_to_mode (word_mode, fill_value, 1);
963: }
964: }
965:
966: /* Fill the remaining words. */
967: for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
968: {
969: int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
970: rtx subword = operand_subword (to, index, 1, to_mode);
971:
972: if (subword == 0)
973: abort ();
974:
975: if (fill_value != subword)
976: emit_move_insn (subword, fill_value);
977: }
978:
979: insns = get_insns ();
980: end_sequence ();
981:
1.1.1.4 root 982: emit_no_conflict_block (insns, to, from, NULL_RTX,
1.1.1.5 root 983: gen_rtx (equiv_code, to_mode, copy_rtx (from)));
1.1 root 984: return;
985: }
986:
1.1.1.5 root 987: /* Truncating multi-word to a word or less. */
988: if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
989: && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
1.1 root 990: {
1.1.1.6 root 991: if (!((GET_CODE (from) == MEM
992: && ! MEM_VOLATILE_P (from)
993: && direct_load[(int) to_mode]
994: && ! mode_dependent_address_p (XEXP (from, 0)))
995: || GET_CODE (from) == REG
996: || GET_CODE (from) == SUBREG))
997: from = force_reg (from_mode, from);
1.1 root 998: convert_move (to, gen_lowpart (word_mode, from), 0);
999: return;
1000: }
1001:
1002: /* Handle pointer conversion */ /* SPEE 900220 */
1003: if (to_mode == PSImode)
1004: {
1005: if (from_mode != SImode)
1006: from = convert_to_mode (SImode, from, unsignedp);
1007:
1.1.1.7 root 1008: #ifdef HAVE_truncsipsi2
1009: if (HAVE_truncsipsi2)
1.1 root 1010: {
1.1.1.7 root 1011: emit_unop_insn (CODE_FOR_truncsipsi2, to, from, UNKNOWN);
1.1 root 1012: return;
1013: }
1.1.1.7 root 1014: #endif /* HAVE_truncsipsi2 */
1.1 root 1015: abort ();
1016: }
1017:
1018: if (from_mode == PSImode)
1019: {
1020: if (to_mode != SImode)
1021: {
1022: from = convert_to_mode (SImode, from, unsignedp);
1023: from_mode = SImode;
1024: }
1025: else
1026: {
1.1.1.7 root 1027: #ifdef HAVE_extendpsisi2
1028: if (HAVE_extendpsisi2)
1.1 root 1029: {
1.1.1.7 root 1030: emit_unop_insn (CODE_FOR_extendpsisi2, to, from, UNKNOWN);
1.1 root 1031: return;
1032: }
1.1.1.7 root 1033: #endif /* HAVE_extendpsisi2 */
1034: abort ();
1035: }
1036: }
1037:
1038: if (to_mode == PDImode)
1039: {
1040: if (from_mode != DImode)
1041: from = convert_to_mode (DImode, from, unsignedp);
1042:
1043: #ifdef HAVE_truncdipdi2
1044: if (HAVE_truncdipdi2)
1045: {
1046: emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN);
1047: return;
1048: }
1049: #endif /* HAVE_truncdipdi2 */
1050: abort ();
1051: }
1052:
1053: if (from_mode == PDImode)
1054: {
1055: if (to_mode != DImode)
1056: {
1057: from = convert_to_mode (DImode, from, unsignedp);
1058: from_mode = DImode;
1059: }
1060: else
1061: {
1062: #ifdef HAVE_extendpdidi2
1063: if (HAVE_extendpdidi2)
1064: {
1065: emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN);
1066: return;
1067: }
1068: #endif /* HAVE_extendpdidi2 */
1.1 root 1069: abort ();
1070: }
1071: }
1072:
1073: /* Now follow all the conversions between integers
1074: no more than a word long. */
1075:
1076: /* For truncation, usually we can just refer to FROM in a narrower mode. */
1077: if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
1078: && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1.1.1.5 root 1079: GET_MODE_BITSIZE (from_mode)))
1.1 root 1080: {
1.1.1.5 root 1081: if (!((GET_CODE (from) == MEM
1082: && ! MEM_VOLATILE_P (from)
1083: && direct_load[(int) to_mode]
1084: && ! mode_dependent_address_p (XEXP (from, 0)))
1085: || GET_CODE (from) == REG
1086: || GET_CODE (from) == SUBREG))
1087: from = force_reg (from_mode, from);
1.1.1.8 root 1088: if (GET_CODE (from) == REG && REGNO (from) < FIRST_PSEUDO_REGISTER
1089: && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
1090: from = copy_to_reg (from);
1.1 root 1091: emit_move_insn (to, gen_lowpart (to_mode, from));
1092: return;
1093: }
1094:
1.1.1.5 root 1095: /* Handle extension. */
1.1 root 1096: if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
1097: {
1098: /* Convert directly if that works. */
1099: if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1100: != CODE_FOR_nothing)
1101: {
1102: emit_unop_insn (code, to, from, equiv_code);
1103: return;
1104: }
1105: else
1106: {
1107: enum machine_mode intermediate;
1108:
1109: /* Search for a mode to convert via. */
1110: for (intermediate = from_mode; intermediate != VOIDmode;
1111: intermediate = GET_MODE_WIDER_MODE (intermediate))
1.1.1.7 root 1112: if (((can_extend_p (to_mode, intermediate, unsignedp)
1113: != CODE_FOR_nothing)
1114: || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
1115: && TRULY_NOOP_TRUNCATION (to_mode, intermediate)))
1.1 root 1116: && (can_extend_p (intermediate, from_mode, unsignedp)
1117: != CODE_FOR_nothing))
1118: {
1119: convert_move (to, convert_to_mode (intermediate, from,
1120: unsignedp), unsignedp);
1121: return;
1122: }
1123:
1124: /* No suitable intermediate mode. */
1125: abort ();
1126: }
1127: }
1128:
1129: /* Support special truncate insns for certain modes. */
1130:
1131: if (from_mode == DImode && to_mode == SImode)
1132: {
1133: #ifdef HAVE_truncdisi2
1134: if (HAVE_truncdisi2)
1135: {
1136: emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
1137: return;
1138: }
1139: #endif
1140: convert_move (to, force_reg (from_mode, from), unsignedp);
1141: return;
1142: }
1143:
1144: if (from_mode == DImode && to_mode == HImode)
1145: {
1146: #ifdef HAVE_truncdihi2
1147: if (HAVE_truncdihi2)
1148: {
1149: emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
1150: return;
1151: }
1152: #endif
1153: convert_move (to, force_reg (from_mode, from), unsignedp);
1154: return;
1155: }
1156:
1157: if (from_mode == DImode && to_mode == QImode)
1158: {
1159: #ifdef HAVE_truncdiqi2
1160: if (HAVE_truncdiqi2)
1161: {
1162: emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
1163: return;
1164: }
1165: #endif
1166: convert_move (to, force_reg (from_mode, from), unsignedp);
1167: return;
1168: }
1169:
1170: if (from_mode == SImode && to_mode == HImode)
1171: {
1172: #ifdef HAVE_truncsihi2
1173: if (HAVE_truncsihi2)
1174: {
1175: emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
1176: return;
1177: }
1178: #endif
1179: convert_move (to, force_reg (from_mode, from), unsignedp);
1180: return;
1181: }
1182:
1183: if (from_mode == SImode && to_mode == QImode)
1184: {
1185: #ifdef HAVE_truncsiqi2
1186: if (HAVE_truncsiqi2)
1187: {
1188: emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
1189: return;
1190: }
1191: #endif
1192: convert_move (to, force_reg (from_mode, from), unsignedp);
1193: return;
1194: }
1195:
1196: if (from_mode == HImode && to_mode == QImode)
1197: {
1198: #ifdef HAVE_trunchiqi2
1199: if (HAVE_trunchiqi2)
1200: {
1201: emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
1202: return;
1203: }
1204: #endif
1205: convert_move (to, force_reg (from_mode, from), unsignedp);
1206: return;
1207: }
1208:
1.1.1.7 root 1209: if (from_mode == TImode && to_mode == DImode)
1210: {
1211: #ifdef HAVE_trunctidi2
1212: if (HAVE_trunctidi2)
1213: {
1214: emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN);
1215: return;
1216: }
1217: #endif
1218: convert_move (to, force_reg (from_mode, from), unsignedp);
1219: return;
1220: }
1221:
1222: if (from_mode == TImode && to_mode == SImode)
1223: {
1224: #ifdef HAVE_trunctisi2
1225: if (HAVE_trunctisi2)
1226: {
1227: emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN);
1228: return;
1229: }
1230: #endif
1231: convert_move (to, force_reg (from_mode, from), unsignedp);
1232: return;
1233: }
1234:
1235: if (from_mode == TImode && to_mode == HImode)
1236: {
1237: #ifdef HAVE_trunctihi2
1238: if (HAVE_trunctihi2)
1239: {
1240: emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN);
1241: return;
1242: }
1243: #endif
1244: convert_move (to, force_reg (from_mode, from), unsignedp);
1245: return;
1246: }
1247:
1248: if (from_mode == TImode && to_mode == QImode)
1249: {
1250: #ifdef HAVE_trunctiqi2
1251: if (HAVE_trunctiqi2)
1252: {
1253: emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN);
1254: return;
1255: }
1256: #endif
1257: convert_move (to, force_reg (from_mode, from), unsignedp);
1258: return;
1259: }
1260:
1.1 root 1261: /* Handle truncation of volatile memrefs, and so on;
1262: the things that couldn't be truncated directly,
1263: and for which there was no special instruction. */
1264: if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
1265: {
1266: rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
1267: emit_move_insn (to, temp);
1268: return;
1269: }
1270:
1271: /* Mode combination is not recognized. */
1272: abort ();
1273: }
1274:
1275: /* Return an rtx for a value that would result
1276: from converting X to mode MODE.
1277: Both X and MODE may be floating, or both integer.
1278: UNSIGNEDP is nonzero if X is an unsigned value.
1279: This can be done by referring to a part of X in place
1.1.1.4 root 1280: or by copying to a new temporary with conversion.
1281:
1282: This function *must not* call protect_from_queue
1283: except when putting X into an insn (in which case convert_move does it). */
1.1 root 1284:
1285: rtx
1286: convert_to_mode (mode, x, unsignedp)
1287: enum machine_mode mode;
1288: rtx x;
1289: int unsignedp;
1290: {
1.1.1.6 root 1291: return convert_modes (mode, VOIDmode, x, unsignedp);
1292: }
1293:
1294: /* Return an rtx for a value that would result
1295: from converting X from mode OLDMODE to mode MODE.
1296: Both modes may be floating, or both integer.
1297: UNSIGNEDP is nonzero if X is an unsigned value.
1298:
1299: This can be done by referring to a part of X in place
1300: or by copying to a new temporary with conversion.
1301:
1302: You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1303:
1304: This function *must not* call protect_from_queue
1305: except when putting X into an insn (in which case convert_move does it). */
1306:
1307: rtx
1308: convert_modes (mode, oldmode, x, unsignedp)
1309: enum machine_mode mode, oldmode;
1310: rtx x;
1311: int unsignedp;
1312: {
1.1 root 1313: register rtx temp;
1.1.1.6 root 1314:
1.1.1.4 root 1315: /* If FROM is a SUBREG that indicates that we have already done at least
1316: the required extension, strip it. */
1.1 root 1317:
1.1.1.4 root 1318: if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
1319: && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
1320: && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
1321: x = gen_lowpart (mode, x);
1.1 root 1322:
1.1.1.6 root 1323: if (GET_MODE (x) != VOIDmode)
1324: oldmode = GET_MODE (x);
1325:
1326: if (mode == oldmode)
1.1 root 1327: return x;
1328:
1329: /* There is one case that we must handle specially: If we are converting
1.1.1.4 root 1330: a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1.1 root 1331: we are to interpret the constant as unsigned, gen_lowpart will do
1332: the wrong if the constant appears negative. What we want to do is
1333: make the high-order word of the constant zero, not all ones. */
1334:
1335: if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
1.1.1.4 root 1336: && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
1.1 root 1337: && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
1.1.1.4 root 1338: return immed_double_const (INTVAL (x), (HOST_WIDE_INT) 0, mode);
1.1 root 1339:
1340: /* We can do this with a gen_lowpart if both desired and current modes
1341: are integer, and this is either a constant integer, a register, or a
1.1.1.6 root 1342: non-volatile MEM. Except for the constant case where MODE is no
1343: wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */
1.1 root 1344:
1.1.1.6 root 1345: if ((GET_CODE (x) == CONST_INT
1346: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1.1 root 1347: || (GET_MODE_CLASS (mode) == MODE_INT
1.1.1.6 root 1348: && GET_MODE_CLASS (oldmode) == MODE_INT
1.1 root 1349: && (GET_CODE (x) == CONST_DOUBLE
1.1.1.6 root 1350: || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
1351: && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
1352: && direct_load[(int) mode])
1.1.1.7 root 1353: || (GET_CODE (x) == REG
1354: && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1355: GET_MODE_BITSIZE (GET_MODE (x)))))))))
1.1.1.6 root 1356: {
1357: /* ?? If we don't know OLDMODE, we have to assume here that
1358: X does not need sign- or zero-extension. This may not be
1359: the case, but it's the best we can do. */
1360: if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
1361: && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
1362: {
1363: HOST_WIDE_INT val = INTVAL (x);
1364: int width = GET_MODE_BITSIZE (oldmode);
1365:
1366: /* We must sign or zero-extend in this case. Start by
1367: zero-extending, then sign extend if we need to. */
1368: val &= ((HOST_WIDE_INT) 1 << width) - 1;
1369: if (! unsignedp
1370: && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1371: val |= (HOST_WIDE_INT) (-1) << width;
1372:
1373: return GEN_INT (val);
1374: }
1375:
1376: return gen_lowpart (mode, x);
1377: }
1.1 root 1378:
1379: temp = gen_reg_rtx (mode);
1380: convert_move (temp, x, unsignedp);
1381: return temp;
1382: }
1383:
1384: /* Generate several move instructions to copy LEN bytes
1385: from block FROM to block TO. (These are MEM rtx's with BLKmode).
1386: The caller must pass FROM and TO
1387: through protect_from_queue before calling.
1388: ALIGN (in bytes) is maximum alignment we can assume. */
1389:
1390: static void
1391: move_by_pieces (to, from, len, align)
1392: rtx to, from;
1393: int len, align;
1394: {
1395: struct move_by_pieces data;
1396: rtx to_addr = XEXP (to, 0), from_addr = XEXP (from, 0);
1.1.1.2 root 1397: int max_size = MOVE_MAX + 1;
1.1 root 1398:
1399: data.offset = 0;
1400: data.to_addr = to_addr;
1401: data.from_addr = from_addr;
1402: data.to = to;
1403: data.from = from;
1404: data.autinc_to
1405: = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1406: || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1407: data.autinc_from
1408: = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1409: || GET_CODE (from_addr) == POST_INC
1410: || GET_CODE (from_addr) == POST_DEC);
1411:
1412: data.explicit_inc_from = 0;
1413: data.explicit_inc_to = 0;
1414: data.reverse
1415: = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1416: if (data.reverse) data.offset = len;
1417: data.len = len;
1418:
1.1.1.8 root 1419: data.to_struct = MEM_IN_STRUCT_P (to);
1420: data.from_struct = MEM_IN_STRUCT_P (from);
1421:
1.1 root 1422: /* If copying requires more than two move insns,
1423: copy addresses to registers (to make displacements shorter)
1424: and use post-increment if available. */
1425: if (!(data.autinc_from && data.autinc_to)
1426: && move_by_pieces_ninsns (len, align) > 2)
1427: {
1428: #ifdef HAVE_PRE_DECREMENT
1429: if (data.reverse && ! data.autinc_from)
1430: {
1431: data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1432: data.autinc_from = 1;
1433: data.explicit_inc_from = -1;
1434: }
1435: #endif
1436: #ifdef HAVE_POST_INCREMENT
1437: if (! data.autinc_from)
1438: {
1439: data.from_addr = copy_addr_to_reg (from_addr);
1440: data.autinc_from = 1;
1441: data.explicit_inc_from = 1;
1442: }
1443: #endif
1444: if (!data.autinc_from && CONSTANT_P (from_addr))
1445: data.from_addr = copy_addr_to_reg (from_addr);
1446: #ifdef HAVE_PRE_DECREMENT
1447: if (data.reverse && ! data.autinc_to)
1448: {
1449: data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1450: data.autinc_to = 1;
1451: data.explicit_inc_to = -1;
1452: }
1453: #endif
1454: #ifdef HAVE_POST_INCREMENT
1455: if (! data.reverse && ! data.autinc_to)
1456: {
1457: data.to_addr = copy_addr_to_reg (to_addr);
1458: data.autinc_to = 1;
1459: data.explicit_inc_to = 1;
1460: }
1461: #endif
1462: if (!data.autinc_to && CONSTANT_P (to_addr))
1463: data.to_addr = copy_addr_to_reg (to_addr);
1464: }
1465:
1.1.1.8 root 1466: if (! SLOW_UNALIGNED_ACCESS
1.1.1.2 root 1467: || align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1.1 root 1468: align = MOVE_MAX;
1469:
1470: /* First move what we can in the largest integer mode, then go to
1471: successively smaller modes. */
1472:
1473: while (max_size > 1)
1474: {
1475: enum machine_mode mode = VOIDmode, tmode;
1476: enum insn_code icode;
1477:
1.1.1.3 root 1478: for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1479: tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1480: if (GET_MODE_SIZE (tmode) < max_size)
1.1 root 1481: mode = tmode;
1482:
1483: if (mode == VOIDmode)
1484: break;
1485:
1486: icode = mov_optab->handlers[(int) mode].insn_code;
1487: if (icode != CODE_FOR_nothing
1488: && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
1489: GET_MODE_SIZE (mode)))
1490: move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1491:
1492: max_size = GET_MODE_SIZE (mode);
1493: }
1494:
1495: /* The code above should have handled everything. */
1496: if (data.len != 0)
1497: abort ();
1498: }
1499:
1500: /* Return number of insns required to move L bytes by pieces.
1501: ALIGN (in bytes) is maximum alignment we can assume. */
1502:
1503: static int
1504: move_by_pieces_ninsns (l, align)
1505: unsigned int l;
1506: int align;
1507: {
1508: register int n_insns = 0;
1.1.1.2 root 1509: int max_size = MOVE_MAX + 1;
1.1 root 1510:
1.1.1.8 root 1511: if (! SLOW_UNALIGNED_ACCESS
1.1.1.2 root 1512: || align > MOVE_MAX || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1.1 root 1513: align = MOVE_MAX;
1514:
1515: while (max_size > 1)
1516: {
1517: enum machine_mode mode = VOIDmode, tmode;
1518: enum insn_code icode;
1519:
1.1.1.3 root 1520: for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1521: tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1522: if (GET_MODE_SIZE (tmode) < max_size)
1.1 root 1523: mode = tmode;
1524:
1525: if (mode == VOIDmode)
1526: break;
1527:
1528: icode = mov_optab->handlers[(int) mode].insn_code;
1529: if (icode != CODE_FOR_nothing
1530: && align >= MIN (BIGGEST_ALIGNMENT / BITS_PER_UNIT,
1531: GET_MODE_SIZE (mode)))
1532: n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1533:
1534: max_size = GET_MODE_SIZE (mode);
1535: }
1536:
1537: return n_insns;
1538: }
1539:
1540: /* Subroutine of move_by_pieces. Move as many bytes as appropriate
1541: with move instructions for mode MODE. GENFUN is the gen_... function
1542: to make a move insn for that mode. DATA has all the other info. */
1543:
1544: static void
1545: move_by_pieces_1 (genfun, mode, data)
1546: rtx (*genfun) ();
1547: enum machine_mode mode;
1548: struct move_by_pieces *data;
1549: {
1550: register int size = GET_MODE_SIZE (mode);
1551: register rtx to1, from1;
1552:
1553: while (data->len >= size)
1554: {
1555: if (data->reverse) data->offset -= size;
1556:
1557: to1 = (data->autinc_to
1558: ? gen_rtx (MEM, mode, data->to_addr)
1559: : change_address (data->to, mode,
1560: plus_constant (data->to_addr, data->offset)));
1.1.1.8 root 1561: MEM_IN_STRUCT_P (to1) = data->to_struct;
1.1 root 1562: from1 =
1563: (data->autinc_from
1564: ? gen_rtx (MEM, mode, data->from_addr)
1565: : change_address (data->from, mode,
1566: plus_constant (data->from_addr, data->offset)));
1.1.1.8 root 1567: MEM_IN_STRUCT_P (from1) = data->from_struct;
1.1 root 1568:
1569: #ifdef HAVE_PRE_DECREMENT
1570: if (data->explicit_inc_to < 0)
1.1.1.4 root 1571: emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
1.1 root 1572: if (data->explicit_inc_from < 0)
1.1.1.4 root 1573: emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
1.1 root 1574: #endif
1575:
1576: emit_insn ((*genfun) (to1, from1));
1577: #ifdef HAVE_POST_INCREMENT
1578: if (data->explicit_inc_to > 0)
1.1.1.4 root 1579: emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1.1 root 1580: if (data->explicit_inc_from > 0)
1.1.1.4 root 1581: emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1.1 root 1582: #endif
1583:
1584: if (! data->reverse) data->offset += size;
1585:
1586: data->len -= size;
1587: }
1588: }
1589:
1590: /* Emit code to move a block Y to a block X.
1591: This may be done with string-move instructions,
1592: with multiple scalar move instructions, or with a library call.
1593:
1594: Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1595: with mode BLKmode.
1596: SIZE is an rtx that says how long they are.
1597: ALIGN is the maximum alignment we can assume they have,
1598: measured in bytes. */
1599:
1600: void
1601: emit_block_move (x, y, size, align)
1602: rtx x, y;
1603: rtx size;
1604: int align;
1605: {
1606: if (GET_MODE (x) != BLKmode)
1607: abort ();
1608:
1609: if (GET_MODE (y) != BLKmode)
1610: abort ();
1611:
1612: x = protect_from_queue (x, 1);
1613: y = protect_from_queue (y, 0);
1.1.1.4 root 1614: size = protect_from_queue (size, 0);
1.1 root 1615:
1616: if (GET_CODE (x) != MEM)
1617: abort ();
1618: if (GET_CODE (y) != MEM)
1619: abort ();
1620: if (size == 0)
1621: abort ();
1622:
1623: if (GET_CODE (size) == CONST_INT
1.1.1.4 root 1624: && (move_by_pieces_ninsns (INTVAL (size), align) < MOVE_RATIO))
1.1 root 1625: move_by_pieces (x, y, INTVAL (size), align);
1626: else
1627: {
1628: /* Try the most limited insn first, because there's no point
1629: including more than one in the machine description unless
1630: the more limited one has some advantage. */
1.1.1.4 root 1631:
1632: rtx opalign = GEN_INT (align);
1633: enum machine_mode mode;
1634:
1635: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1636: mode = GET_MODE_WIDER_MODE (mode))
1.1 root 1637: {
1.1.1.4 root 1638: enum insn_code code = movstr_optab[(int) mode];
1639:
1640: if (code != CODE_FOR_nothing
1641: /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1642: here because if SIZE is less than the mode mask, as it is
1.1.1.5 root 1643: returned by the macro, it will definitely be less than the
1.1.1.4 root 1644: actual mode mask. */
1.1.1.7 root 1645: && ((GET_CODE (size) == CONST_INT
1646: && ((unsigned HOST_WIDE_INT) INTVAL (size)
1647: <= GET_MODE_MASK (mode)))
1648: || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1.1.1.4 root 1649: && (insn_operand_predicate[(int) code][0] == 0
1650: || (*insn_operand_predicate[(int) code][0]) (x, BLKmode))
1651: && (insn_operand_predicate[(int) code][1] == 0
1652: || (*insn_operand_predicate[(int) code][1]) (y, BLKmode))
1653: && (insn_operand_predicate[(int) code][3] == 0
1654: || (*insn_operand_predicate[(int) code][3]) (opalign,
1655: VOIDmode)))
1.1 root 1656: {
1.1.1.4 root 1657: rtx op2;
1658: rtx last = get_last_insn ();
1659: rtx pat;
1660:
1661: op2 = convert_to_mode (mode, size, 1);
1662: if (insn_operand_predicate[(int) code][2] != 0
1663: && ! (*insn_operand_predicate[(int) code][2]) (op2, mode))
1664: op2 = copy_to_mode_reg (mode, op2);
1665:
1666: pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1667: if (pat)
1668: {
1669: emit_insn (pat);
1670: return;
1671: }
1672: else
1673: delete_insns_since (last);
1.1 root 1674: }
1675: }
1676:
1677: #ifdef TARGET_MEM_FUNCTIONS
1.1.1.4 root 1678: emit_library_call (memcpy_libfunc, 0,
1.1 root 1679: VOIDmode, 3, XEXP (x, 0), Pmode,
1680: XEXP (y, 0), Pmode,
1.1.1.5 root 1681: convert_to_mode (TYPE_MODE (sizetype), size,
1682: TREE_UNSIGNED (sizetype)),
1683: TYPE_MODE (sizetype));
1.1 root 1684: #else
1.1.1.4 root 1685: emit_library_call (bcopy_libfunc, 0,
1.1 root 1686: VOIDmode, 3, XEXP (y, 0), Pmode,
1687: XEXP (x, 0), Pmode,
1.1.1.5 root 1688: convert_to_mode (TYPE_MODE (sizetype), size,
1689: TREE_UNSIGNED (sizetype)),
1690: TYPE_MODE (sizetype));
1.1 root 1691: #endif
1692: }
1693: }
1694:
1695: /* Copy all or part of a value X into registers starting at REGNO.
1696: The number of registers to be filled is NREGS. */
1697:
1698: void
1699: move_block_to_reg (regno, x, nregs, mode)
1700: int regno;
1701: rtx x;
1702: int nregs;
1703: enum machine_mode mode;
1704: {
1705: int i;
1706: rtx pat, last;
1707:
1.1.1.7 root 1708: if (nregs == 0)
1709: return;
1710:
1.1 root 1711: if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1712: x = validize_mem (force_const_mem (mode, x));
1713:
1714: /* See if the machine can do this with a load multiple insn. */
1715: #ifdef HAVE_load_multiple
1.1.1.6 root 1716: if (HAVE_load_multiple)
1.1 root 1717: {
1.1.1.6 root 1718: last = get_last_insn ();
1719: pat = gen_load_multiple (gen_rtx (REG, word_mode, regno), x,
1720: GEN_INT (nregs));
1721: if (pat)
1722: {
1723: emit_insn (pat);
1724: return;
1725: }
1726: else
1727: delete_insns_since (last);
1.1 root 1728: }
1729: #endif
1730:
1731: for (i = 0; i < nregs; i++)
1732: emit_move_insn (gen_rtx (REG, word_mode, regno + i),
1733: operand_subword_force (x, i, mode));
1734: }
1735:
1736: /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1.1.1.6 root 1737: The number of registers to be filled is NREGS. SIZE indicates the number
1738: of bytes in the object X. */
1739:
1.1 root 1740:
1741: void
1.1.1.6 root 1742: move_block_from_reg (regno, x, nregs, size)
1.1 root 1743: int regno;
1744: rtx x;
1745: int nregs;
1.1.1.6 root 1746: int size;
1.1 root 1747: {
1748: int i;
1749: rtx pat, last;
1750:
1.1.1.6 root 1751: /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1752: to the left before storing to memory. */
1753: if (size < UNITS_PER_WORD && BYTES_BIG_ENDIAN)
1754: {
1755: rtx tem = operand_subword (x, 0, 1, BLKmode);
1756: rtx shift;
1757:
1758: if (tem == 0)
1759: abort ();
1760:
1761: shift = expand_shift (LSHIFT_EXPR, word_mode,
1762: gen_rtx (REG, word_mode, regno),
1763: build_int_2 ((UNITS_PER_WORD - size)
1764: * BITS_PER_UNIT, 0), NULL_RTX, 0);
1765: emit_move_insn (tem, shift);
1766: return;
1767: }
1768:
1.1 root 1769: /* See if the machine can do this with a store multiple insn. */
1770: #ifdef HAVE_store_multiple
1.1.1.6 root 1771: if (HAVE_store_multiple)
1.1 root 1772: {
1.1.1.6 root 1773: last = get_last_insn ();
1774: pat = gen_store_multiple (x, gen_rtx (REG, word_mode, regno),
1775: GEN_INT (nregs));
1776: if (pat)
1777: {
1778: emit_insn (pat);
1779: return;
1780: }
1781: else
1782: delete_insns_since (last);
1.1 root 1783: }
1784: #endif
1785:
1786: for (i = 0; i < nregs; i++)
1787: {
1788: rtx tem = operand_subword (x, i, 1, BLKmode);
1789:
1790: if (tem == 0)
1791: abort ();
1792:
1793: emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i));
1794: }
1795: }
1796:
1.1.1.7 root 1797: /* Add a USE expression for REG to the (possibly empty) list pointed
1798: to by CALL_FUSAGE. REG must denote a hard register. */
1.1 root 1799:
1800: void
1.1.1.7 root 1801: use_reg (call_fusage, reg)
1802: rtx *call_fusage, reg;
1.1 root 1803: {
1.1.1.7 root 1804: if (GET_CODE (reg) != REG
1805: || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
1806: abort();
1.1 root 1807:
1.1.1.7 root 1808: *call_fusage
1809: = gen_rtx (EXPR_LIST, VOIDmode,
1810: gen_rtx (USE, VOIDmode, reg), *call_fusage);
1.1 root 1811: }
1.1.1.4 root 1812:
1.1.1.7 root 1813: /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
1814: starting at REGNO. All of these registers must be hard registers. */
1.1.1.4 root 1815:
1.1.1.7 root 1816: void
1817: use_regs (call_fusage, regno, nregs)
1818: rtx *call_fusage;
1819: int regno;
1820: int nregs;
1.1.1.4 root 1821: {
1.1.1.7 root 1822: int i;
1.1.1.4 root 1823:
1.1.1.7 root 1824: if (regno + nregs > FIRST_PSEUDO_REGISTER)
1825: abort ();
1.1.1.4 root 1826:
1.1.1.7 root 1827: for (i = 0; i < nregs; i++)
1828: use_reg (call_fusage, gen_rtx (REG, reg_raw_mode[regno + i], regno + i));
1.1.1.4 root 1829: }
1.1 root 1830:
1831: /* Write zeros through the storage of OBJECT.
1832: If OBJECT has BLKmode, SIZE is its length in bytes. */
1833:
1834: void
1835: clear_storage (object, size)
1836: rtx object;
1.1.1.8 root 1837: rtx size;
1.1 root 1838: {
1839: if (GET_MODE (object) == BLKmode)
1840: {
1841: #ifdef TARGET_MEM_FUNCTIONS
1.1.1.4 root 1842: emit_library_call (memset_libfunc, 0,
1.1 root 1843: VOIDmode, 3,
1.1.1.8 root 1844: XEXP (object, 0), Pmode, const0_rtx, ptr_mode,
1845: convert_to_mode (TYPE_MODE (sizetype),
1846: size, TREE_UNSIGNED (sizetype)),
1847: TYPE_MODE (sizetype));
1.1 root 1848: #else
1.1.1.4 root 1849: emit_library_call (bzero_libfunc, 0,
1.1 root 1850: VOIDmode, 2,
1.1.1.8 root 1851: XEXP (object, 0), Pmode,
1852: convert_to_mode (TYPE_MODE (sizetype),
1853: size, TREE_UNSIGNED (sizetype)),
1854: TYPE_MODE (sizetype));
1.1 root 1855: #endif
1856: }
1857: else
1858: emit_move_insn (object, const0_rtx);
1859: }
1860:
1861: /* Generate code to copy Y into X.
1862: Both Y and X must have the same mode, except that
1863: Y can be a constant with VOIDmode.
1864: This mode cannot be BLKmode; use emit_block_move for that.
1865:
1866: Return the last instruction emitted. */
1867:
1868: rtx
1869: emit_move_insn (x, y)
1870: rtx x, y;
1871: {
1872: enum machine_mode mode = GET_MODE (x);
1873:
1874: x = protect_from_queue (x, 1);
1875: y = protect_from_queue (y, 0);
1876:
1877: if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
1878: abort ();
1879:
1880: if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
1881: y = force_const_mem (mode, y);
1882:
1883: /* If X or Y are memory references, verify that their addresses are valid
1884: for the machine. */
1885: if (GET_CODE (x) == MEM
1886: && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
1887: && ! push_operand (x, GET_MODE (x)))
1888: || (flag_force_addr
1889: && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
1890: x = change_address (x, VOIDmode, XEXP (x, 0));
1891:
1892: if (GET_CODE (y) == MEM
1893: && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
1894: || (flag_force_addr
1895: && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
1896: y = change_address (y, VOIDmode, XEXP (y, 0));
1897:
1898: if (mode == BLKmode)
1899: abort ();
1900:
1.1.1.5 root 1901: return emit_move_insn_1 (x, y);
1902: }
1903:
1904: /* Low level part of emit_move_insn.
1905: Called just like emit_move_insn, but assumes X and Y
1906: are basically valid. */
1907:
1908: rtx
1909: emit_move_insn_1 (x, y)
1910: rtx x, y;
1911: {
1912: enum machine_mode mode = GET_MODE (x);
1913: enum machine_mode submode;
1914: enum mode_class class = GET_MODE_CLASS (mode);
1915: int i;
1916:
1.1 root 1917: if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
1918: return
1919: emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
1920:
1.1.1.5 root 1921: /* Expand complex moves by moving real part and imag part, if possible. */
1.1.1.4 root 1922: else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
1.1.1.7 root 1923: && BLKmode != (submode = mode_for_size ((GET_MODE_UNIT_SIZE (mode)
1924: * BITS_PER_UNIT),
1925: (class == MODE_COMPLEX_INT
1926: ? MODE_INT : MODE_FLOAT),
1927: 0))
1.1.1.4 root 1928: && (mov_optab->handlers[(int) submode].insn_code
1929: != CODE_FOR_nothing))
1930: {
1931: /* Don't split destination if it is a stack push. */
1932: int stack = push_operand (x, GET_MODE (x));
1.1.1.7 root 1933: rtx insns;
1.1.1.4 root 1934:
1935: /* If this is a stack, push the highpart first, so it
1936: will be in the argument order.
1937:
1938: In that case, change_address is used only to convert
1939: the mode, not to change the address. */
1.1.1.6 root 1940: if (stack)
1941: {
1942: /* Note that the real part always precedes the imag part in memory
1943: regardless of machine's endianness. */
1944: #ifdef STACK_GROWS_DOWNWARD
1945: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1946: (gen_rtx (MEM, submode, (XEXP (x, 0))),
1947: gen_imagpart (submode, y)));
1948: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1949: (gen_rtx (MEM, submode, (XEXP (x, 0))),
1950: gen_realpart (submode, y)));
1951: #else
1952: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1953: (gen_rtx (MEM, submode, (XEXP (x, 0))),
1954: gen_realpart (submode, y)));
1955: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1956: (gen_rtx (MEM, submode, (XEXP (x, 0))),
1957: gen_imagpart (submode, y)));
1958: #endif
1959: }
1960: else
1961: {
1962: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1.1.1.7 root 1963: (gen_realpart (submode, x), gen_realpart (submode, y)));
1.1.1.6 root 1964: emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
1.1.1.7 root 1965: (gen_imagpart (submode, x), gen_imagpart (submode, y)));
1.1.1.6 root 1966: }
1.1.1.4 root 1967:
1968: return get_last_insn ();
1969: }
1970:
1.1 root 1971: /* This will handle any multi-word mode that lacks a move_insn pattern.
1972: However, you will get better code if you define such patterns,
1973: even if they must turn into multiple assembler instructions. */
1.1.1.4 root 1974: else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
1.1 root 1975: {
1976: rtx last_insn = 0;
1.1.1.7 root 1977: rtx insns;
1978:
1979: #ifdef PUSH_ROUNDING
1.1 root 1980:
1.1.1.7 root 1981: /* If X is a push on the stack, do the push now and replace
1982: X with a reference to the stack pointer. */
1983: if (push_operand (x, GET_MODE (x)))
1984: {
1985: anti_adjust_stack (GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
1986: x = change_address (x, VOIDmode, stack_pointer_rtx);
1987: }
1988: #endif
1989:
1.1.1.8 root 1990: /* Show the output dies here. */
1991: emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
1992:
1.1 root 1993: for (i = 0;
1994: i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
1995: i++)
1996: {
1997: rtx xpart = operand_subword (x, i, 1, mode);
1998: rtx ypart = operand_subword (y, i, 1, mode);
1999:
2000: /* If we can't get a part of Y, put Y into memory if it is a
2001: constant. Otherwise, force it into a register. If we still
2002: can't get a part of Y, abort. */
2003: if (ypart == 0 && CONSTANT_P (y))
2004: {
2005: y = force_const_mem (mode, y);
2006: ypart = operand_subword (y, i, 1, mode);
2007: }
2008: else if (ypart == 0)
2009: ypart = operand_subword_force (y, i, mode);
2010:
2011: if (xpart == 0 || ypart == 0)
2012: abort ();
2013:
2014: last_insn = emit_move_insn (xpart, ypart);
2015: }
1.1.1.4 root 2016:
1.1 root 2017: return last_insn;
2018: }
2019: else
2020: abort ();
2021: }
2022:
2023: /* Pushing data onto the stack. */
2024:
2025: /* Push a block of length SIZE (perhaps variable)
2026: and return an rtx to address the beginning of the block.
2027: Note that it is not possible for the value returned to be a QUEUED.
2028: The value may be virtual_outgoing_args_rtx.
2029:
2030: EXTRA is the number of bytes of padding to push in addition to SIZE.
2031: BELOW nonzero means this padding comes at low addresses;
2032: otherwise, the padding comes at high addresses. */
2033:
2034: rtx
2035: push_block (size, extra, below)
2036: rtx size;
2037: int extra, below;
2038: {
2039: register rtx temp;
1.1.1.8 root 2040:
2041: size = convert_modes (Pmode, ptr_mode, size, 1);
1.1 root 2042: if (CONSTANT_P (size))
2043: anti_adjust_stack (plus_constant (size, extra));
2044: else if (GET_CODE (size) == REG && extra == 0)
2045: anti_adjust_stack (size);
2046: else
2047: {
2048: rtx temp = copy_to_mode_reg (Pmode, size);
2049: if (extra != 0)
1.1.1.4 root 2050: temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
1.1 root 2051: temp, 0, OPTAB_LIB_WIDEN);
2052: anti_adjust_stack (temp);
2053: }
2054:
2055: #ifdef STACK_GROWS_DOWNWARD
2056: temp = virtual_outgoing_args_rtx;
2057: if (extra != 0 && below)
2058: temp = plus_constant (temp, extra);
2059: #else
2060: if (GET_CODE (size) == CONST_INT)
2061: temp = plus_constant (virtual_outgoing_args_rtx,
2062: - INTVAL (size) - (below ? 0 : extra));
2063: else if (extra != 0 && !below)
2064: temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
2065: negate_rtx (Pmode, plus_constant (size, extra)));
2066: else
2067: temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
2068: negate_rtx (Pmode, size));
2069: #endif
2070:
2071: return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
2072: }
2073:
1.1.1.4 root 2074: rtx
1.1 root 2075: gen_push_operand ()
2076: {
2077: return gen_rtx (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
2078: }
2079:
2080: /* Generate code to push X onto the stack, assuming it has mode MODE and
2081: type TYPE.
2082: MODE is redundant except when X is a CONST_INT (since they don't
2083: carry mode info).
2084: SIZE is an rtx for the size of data to be copied (in bytes),
2085: needed only if X is BLKmode.
2086:
2087: ALIGN (in bytes) is maximum alignment we can assume.
2088:
1.1.1.5 root 2089: If PARTIAL and REG are both nonzero, then copy that many of the first
2090: words of X into registers starting with REG, and push the rest of X.
1.1 root 2091: The amount of space pushed is decreased by PARTIAL words,
2092: rounded *down* to a multiple of PARM_BOUNDARY.
2093: REG must be a hard register in this case.
1.1.1.5 root 2094: If REG is zero but PARTIAL is not, take any all others actions for an
2095: argument partially in registers, but do not actually load any
2096: registers.
1.1 root 2097:
2098: EXTRA is the amount in bytes of extra space to leave next to this arg.
1.1.1.3 root 2099: This is ignored if an argument block has already been allocated.
1.1 root 2100:
2101: On a machine that lacks real push insns, ARGS_ADDR is the address of
2102: the bottom of the argument block for this call. We use indexing off there
2103: to store the arg. On machines with push insns, ARGS_ADDR is 0 when a
2104: argument block has not been preallocated.
2105:
2106: ARGS_SO_FAR is the size of args previously pushed for this call. */
2107:
2108: void
2109: emit_push_insn (x, mode, type, size, align, partial, reg, extra,
2110: args_addr, args_so_far)
2111: register rtx x;
2112: enum machine_mode mode;
2113: tree type;
2114: rtx size;
2115: int align;
2116: int partial;
2117: rtx reg;
2118: int extra;
2119: rtx args_addr;
2120: rtx args_so_far;
2121: {
2122: rtx xinner;
2123: enum direction stack_direction
2124: #ifdef STACK_GROWS_DOWNWARD
2125: = downward;
2126: #else
2127: = upward;
2128: #endif
2129:
2130: /* Decide where to pad the argument: `downward' for below,
2131: `upward' for above, or `none' for don't pad it.
2132: Default is below for small data on big-endian machines; else above. */
2133: enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
2134:
2135: /* Invert direction if stack is post-update. */
2136: if (STACK_PUSH_CODE == POST_INC || STACK_PUSH_CODE == POST_DEC)
2137: if (where_pad != none)
2138: where_pad = (where_pad == downward ? upward : downward);
2139:
2140: xinner = x = protect_from_queue (x, 0);
2141:
2142: if (mode == BLKmode)
2143: {
2144: /* Copy a block into the stack, entirely or partially. */
2145:
2146: register rtx temp;
2147: int used = partial * UNITS_PER_WORD;
2148: int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
2149: int skip;
2150:
2151: if (size == 0)
2152: abort ();
2153:
2154: used -= offset;
2155:
2156: /* USED is now the # of bytes we need not copy to the stack
2157: because registers will take care of them. */
2158:
2159: if (partial != 0)
2160: xinner = change_address (xinner, BLKmode,
2161: plus_constant (XEXP (xinner, 0), used));
2162:
2163: /* If the partial register-part of the arg counts in its stack size,
2164: skip the part of stack space corresponding to the registers.
2165: Otherwise, start copying to the beginning of the stack space,
2166: by setting SKIP to 0. */
2167: #ifndef REG_PARM_STACK_SPACE
2168: skip = 0;
2169: #else
2170: skip = used;
2171: #endif
2172:
2173: #ifdef PUSH_ROUNDING
2174: /* Do it with several push insns if that doesn't take lots of insns
2175: and if there is no difficulty with push insns that skip bytes
2176: on the stack for alignment purposes. */
2177: if (args_addr == 0
2178: && GET_CODE (size) == CONST_INT
2179: && skip == 0
2180: && (move_by_pieces_ninsns ((unsigned) INTVAL (size) - used, align)
2181: < MOVE_RATIO)
2182: /* Here we avoid the case of a structure whose weak alignment
2183: forces many pushes of a small amount of data,
2184: and such small pushes do rounding that causes trouble. */
1.1.1.8 root 2185: && ((! SLOW_UNALIGNED_ACCESS)
1.1.1.2 root 2186: || align >= BIGGEST_ALIGNMENT / BITS_PER_UNIT
1.1 root 2187: || PUSH_ROUNDING (align) == align)
2188: && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
2189: {
2190: /* Push padding now if padding above and stack grows down,
2191: or if padding below and stack grows up.
2192: But if space already allocated, this has already been done. */
2193: if (extra && args_addr == 0
2194: && where_pad != none && where_pad != stack_direction)
1.1.1.4 root 2195: anti_adjust_stack (GEN_INT (extra));
1.1 root 2196:
2197: move_by_pieces (gen_rtx (MEM, BLKmode, gen_push_operand ()), xinner,
2198: INTVAL (size) - used, align);
2199: }
2200: else
2201: #endif /* PUSH_ROUNDING */
2202: {
2203: /* Otherwise make space on the stack and copy the data
2204: to the address of that space. */
2205:
2206: /* Deduct words put into registers from the size we must copy. */
2207: if (partial != 0)
2208: {
2209: if (GET_CODE (size) == CONST_INT)
1.1.1.4 root 2210: size = GEN_INT (INTVAL (size) - used);
1.1 root 2211: else
2212: size = expand_binop (GET_MODE (size), sub_optab, size,
1.1.1.4 root 2213: GEN_INT (used), NULL_RTX, 0,
2214: OPTAB_LIB_WIDEN);
1.1 root 2215: }
2216:
2217: /* Get the address of the stack space.
2218: In this case, we do not deal with EXTRA separately.
2219: A single stack adjust will do. */
2220: if (! args_addr)
2221: {
2222: temp = push_block (size, extra, where_pad == downward);
2223: extra = 0;
2224: }
2225: else if (GET_CODE (args_so_far) == CONST_INT)
2226: temp = memory_address (BLKmode,
2227: plus_constant (args_addr,
2228: skip + INTVAL (args_so_far)));
2229: else
2230: temp = memory_address (BLKmode,
2231: plus_constant (gen_rtx (PLUS, Pmode,
2232: args_addr, args_so_far),
2233: skip));
2234:
2235: /* TEMP is the address of the block. Copy the data there. */
2236: if (GET_CODE (size) == CONST_INT
2237: && (move_by_pieces_ninsns ((unsigned) INTVAL (size), align)
2238: < MOVE_RATIO))
2239: {
2240: move_by_pieces (gen_rtx (MEM, BLKmode, temp), xinner,
2241: INTVAL (size), align);
2242: goto ret;
2243: }
2244: /* Try the most limited insn first, because there's no point
2245: including more than one in the machine description unless
2246: the more limited one has some advantage. */
2247: #ifdef HAVE_movstrqi
2248: if (HAVE_movstrqi
2249: && GET_CODE (size) == CONST_INT
2250: && ((unsigned) INTVAL (size)
2251: < (1 << (GET_MODE_BITSIZE (QImode) - 1))))
2252: {
1.1.1.5 root 2253: rtx pat = gen_movstrqi (gen_rtx (MEM, BLKmode, temp),
2254: xinner, size, GEN_INT (align));
2255: if (pat != 0)
2256: {
2257: emit_insn (pat);
2258: goto ret;
2259: }
1.1 root 2260: }
2261: #endif
2262: #ifdef HAVE_movstrhi
2263: if (HAVE_movstrhi
2264: && GET_CODE (size) == CONST_INT
2265: && ((unsigned) INTVAL (size)
2266: < (1 << (GET_MODE_BITSIZE (HImode) - 1))))
2267: {
1.1.1.5 root 2268: rtx pat = gen_movstrhi (gen_rtx (MEM, BLKmode, temp),
2269: xinner, size, GEN_INT (align));
2270: if (pat != 0)
2271: {
2272: emit_insn (pat);
2273: goto ret;
2274: }
1.1 root 2275: }
2276: #endif
2277: #ifdef HAVE_movstrsi
2278: if (HAVE_movstrsi)
2279: {
1.1.1.5 root 2280: rtx pat = gen_movstrsi (gen_rtx (MEM, BLKmode, temp),
2281: xinner, size, GEN_INT (align));
2282: if (pat != 0)
2283: {
2284: emit_insn (pat);
2285: goto ret;
2286: }
1.1 root 2287: }
2288: #endif
2289: #ifdef HAVE_movstrdi
2290: if (HAVE_movstrdi)
2291: {
1.1.1.5 root 2292: rtx pat = gen_movstrdi (gen_rtx (MEM, BLKmode, temp),
2293: xinner, size, GEN_INT (align));
2294: if (pat != 0)
2295: {
2296: emit_insn (pat);
2297: goto ret;
2298: }
1.1 root 2299: }
2300: #endif
2301:
2302: #ifndef ACCUMULATE_OUTGOING_ARGS
2303: /* If the source is referenced relative to the stack pointer,
2304: copy it to another register to stabilize it. We do not need
2305: to do this if we know that we won't be changing sp. */
2306:
2307: if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
2308: || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
2309: temp = copy_to_reg (temp);
2310: #endif
2311:
2312: /* Make inhibit_defer_pop nonzero around the library call
2313: to force it to pop the bcopy-arguments right away. */
2314: NO_DEFER_POP;
2315: #ifdef TARGET_MEM_FUNCTIONS
1.1.1.4 root 2316: emit_library_call (memcpy_libfunc, 0,
1.1 root 2317: VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
1.1.1.5 root 2318: convert_to_mode (TYPE_MODE (sizetype),
2319: size, TREE_UNSIGNED (sizetype)),
2320: TYPE_MODE (sizetype));
1.1 root 2321: #else
1.1.1.4 root 2322: emit_library_call (bcopy_libfunc, 0,
1.1 root 2323: VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
1.1.1.5 root 2324: convert_to_mode (TYPE_MODE (sizetype),
2325: size, TREE_UNSIGNED (sizetype)),
2326: TYPE_MODE (sizetype));
1.1 root 2327: #endif
2328: OK_DEFER_POP;
2329: }
2330: }
2331: else if (partial > 0)
2332: {
2333: /* Scalar partly in registers. */
2334:
2335: int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
2336: int i;
2337: int not_stack;
2338: /* # words of start of argument
2339: that we must make space for but need not store. */
2340: int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
2341: int args_offset = INTVAL (args_so_far);
2342: int skip;
2343:
2344: /* Push padding now if padding above and stack grows down,
2345: or if padding below and stack grows up.
2346: But if space already allocated, this has already been done. */
2347: if (extra && args_addr == 0
2348: && where_pad != none && where_pad != stack_direction)
1.1.1.4 root 2349: anti_adjust_stack (GEN_INT (extra));
1.1 root 2350:
2351: /* If we make space by pushing it, we might as well push
2352: the real data. Otherwise, we can leave OFFSET nonzero
2353: and leave the space uninitialized. */
2354: if (args_addr == 0)
2355: offset = 0;
2356:
2357: /* Now NOT_STACK gets the number of words that we don't need to
2358: allocate on the stack. */
2359: not_stack = partial - offset;
2360:
2361: /* If the partial register-part of the arg counts in its stack size,
2362: skip the part of stack space corresponding to the registers.
2363: Otherwise, start copying to the beginning of the stack space,
2364: by setting SKIP to 0. */
2365: #ifndef REG_PARM_STACK_SPACE
2366: skip = 0;
2367: #else
2368: skip = not_stack;
2369: #endif
2370:
2371: if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
2372: x = validize_mem (force_const_mem (mode, x));
2373:
2374: /* If X is a hard register in a non-integer mode, copy it into a pseudo;
2375: SUBREGs of such registers are not allowed. */
2376: if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
2377: && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
2378: x = copy_to_reg (x);
2379:
2380: /* Loop over all the words allocated on the stack for this arg. */
2381: /* We can do it by words, because any scalar bigger than a word
2382: has a size a multiple of a word. */
2383: #ifndef PUSH_ARGS_REVERSED
2384: for (i = not_stack; i < size; i++)
2385: #else
2386: for (i = size - 1; i >= not_stack; i--)
2387: #endif
2388: if (i >= not_stack + offset)
2389: emit_push_insn (operand_subword_force (x, i, mode),
1.1.1.4 root 2390: word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
2391: 0, args_addr,
2392: GEN_INT (args_offset + ((i - not_stack + skip)
1.1 root 2393: * UNITS_PER_WORD)));
2394: }
2395: else
2396: {
2397: rtx addr;
2398:
2399: /* Push padding now if padding above and stack grows down,
2400: or if padding below and stack grows up.
2401: But if space already allocated, this has already been done. */
2402: if (extra && args_addr == 0
2403: && where_pad != none && where_pad != stack_direction)
1.1.1.4 root 2404: anti_adjust_stack (GEN_INT (extra));
1.1 root 2405:
2406: #ifdef PUSH_ROUNDING
2407: if (args_addr == 0)
2408: addr = gen_push_operand ();
2409: else
2410: #endif
2411: if (GET_CODE (args_so_far) == CONST_INT)
2412: addr
2413: = memory_address (mode,
2414: plus_constant (args_addr, INTVAL (args_so_far)));
2415: else
2416: addr = memory_address (mode, gen_rtx (PLUS, Pmode, args_addr,
2417: args_so_far));
2418:
2419: emit_move_insn (gen_rtx (MEM, mode, addr), x);
2420: }
2421:
2422: ret:
2423: /* If part should go in registers, copy that part
2424: into the appropriate registers. Do this now, at the end,
2425: since mem-to-mem copies above may do function calls. */
1.1.1.5 root 2426: if (partial > 0 && reg != 0)
1.1 root 2427: move_block_to_reg (REGNO (reg), x, partial, mode);
2428:
2429: if (extra && args_addr == 0 && where_pad == stack_direction)
1.1.1.4 root 2430: anti_adjust_stack (GEN_INT (extra));
1.1 root 2431: }
2432:
2433: /* Expand an assignment that stores the value of FROM into TO.
2434: If WANT_VALUE is nonzero, return an rtx for the value of TO.
1.1.1.6 root 2435: (This may contain a QUEUED rtx;
2436: if the value is constant, this rtx is a constant.)
2437: Otherwise, the returned value is NULL_RTX.
1.1 root 2438:
2439: SUGGEST_REG is no longer actually used.
2440: It used to mean, copy the value through a register
2441: and return that register, if that is possible.
1.1.1.6 root 2442: We now use WANT_VALUE to decide whether to do this. */
1.1 root 2443:
2444: rtx
2445: expand_assignment (to, from, want_value, suggest_reg)
2446: tree to, from;
2447: int want_value;
2448: int suggest_reg;
2449: {
2450: register rtx to_rtx = 0;
2451: rtx result;
2452:
2453: /* Don't crash if the lhs of the assignment was erroneous. */
2454:
2455: if (TREE_CODE (to) == ERROR_MARK)
1.1.1.6 root 2456: {
2457: result = expand_expr (from, NULL_RTX, VOIDmode, 0);
2458: return want_value ? result : NULL_RTX;
2459: }
2460:
2461: if (output_bytecode)
2462: {
2463: tree dest_innermost;
2464:
2465: bc_expand_expr (from);
2466: bc_emit_instruction (duplicate);
2467:
2468: dest_innermost = bc_expand_address (to);
2469:
2470: /* Can't deduce from TYPE that we're dealing with a bitfield, so
2471: take care of it here. */
2472:
2473: bc_store_memory (TREE_TYPE (to), dest_innermost);
2474: return NULL;
2475: }
1.1 root 2476:
2477: /* Assignment of a structure component needs special treatment
2478: if the structure component's rtx is not simply a MEM.
1.1.1.7 root 2479: Assignment of an array element at a constant index, and assignment of
2480: an array element in an unaligned packed structure field, has the same
2481: problem. */
1.1 root 2482:
2483: if (TREE_CODE (to) == COMPONENT_REF
2484: || TREE_CODE (to) == BIT_FIELD_REF
2485: || (TREE_CODE (to) == ARRAY_REF
1.1.1.7 root 2486: && ((TREE_CODE (TREE_OPERAND (to, 1)) == INTEGER_CST
2487: && TREE_CODE (TYPE_SIZE (TREE_TYPE (to))) == INTEGER_CST)
1.1.1.8 root 2488: || (SLOW_UNALIGNED_ACCESS && get_inner_unaligned_p (to)))))
1.1 root 2489: {
2490: enum machine_mode mode1;
2491: int bitsize;
2492: int bitpos;
1.1.1.3 root 2493: tree offset;
1.1 root 2494: int unsignedp;
2495: int volatilep = 0;
1.1.1.6 root 2496: tree tem;
2497: int alignment;
2498:
2499: push_temp_slots ();
2500: tem = get_inner_reference (to, &bitsize, &bitpos, &offset,
1.1 root 2501: &mode1, &unsignedp, &volatilep);
2502:
2503: /* If we are going to use store_bit_field and extract_bit_field,
2504: make sure to_rtx will be safe for multiple use. */
2505:
2506: if (mode1 == VOIDmode && want_value)
2507: tem = stabilize_reference (tem);
2508:
1.1.1.6 root 2509: alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
1.1.1.4 root 2510: to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
1.1.1.3 root 2511: if (offset != 0)
2512: {
1.1.1.4 root 2513: rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
1.1.1.3 root 2514:
2515: if (GET_CODE (to_rtx) != MEM)
2516: abort ();
2517: to_rtx = change_address (to_rtx, VOIDmode,
1.1.1.8 root 2518: gen_rtx (PLUS, ptr_mode, XEXP (to_rtx, 0),
2519: force_reg (ptr_mode, offset_rtx)));
1.1.1.6 root 2520: /* If we have a variable offset, the known alignment
2521: is only that of the innermost structure containing the field.
2522: (Actually, we could sometimes do better by using the
2523: align of an element of the innermost array, but no need.) */
2524: if (TREE_CODE (to) == COMPONENT_REF
2525: || TREE_CODE (to) == BIT_FIELD_REF)
2526: alignment
2527: = TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (to, 0))) / BITS_PER_UNIT;
1.1.1.3 root 2528: }
1.1 root 2529: if (volatilep)
2530: {
2531: if (GET_CODE (to_rtx) == MEM)
1.1.1.8 root 2532: {
2533: /* When the offset is zero, to_rtx is the address of the
2534: structure we are storing into, and hence may be shared.
2535: We must make a new MEM before setting the volatile bit. */
2536: if (offset == 0)
2537: to_rtx = change_address (to_rtx, VOIDmode, XEXP (to_rtx, 0));
2538: MEM_VOLATILE_P (to_rtx) = 1;
2539: }
1.1 root 2540: #if 0 /* This was turned off because, when a field is volatile
2541: in an object which is not volatile, the object may be in a register,
2542: and then we would abort over here. */
2543: else
2544: abort ();
2545: #endif
2546: }
2547:
2548: result = store_field (to_rtx, bitsize, bitpos, mode1, from,
2549: (want_value
2550: /* Spurious cast makes HPUX compiler happy. */
2551: ? (enum machine_mode) TYPE_MODE (TREE_TYPE (to))
2552: : VOIDmode),
2553: unsignedp,
2554: /* Required alignment of containing datum. */
1.1.1.6 root 2555: alignment,
1.1 root 2556: int_size_in_bytes (TREE_TYPE (tem)));
2557: preserve_temp_slots (result);
2558: free_temp_slots ();
1.1.1.6 root 2559: pop_temp_slots ();
1.1 root 2560:
1.1.1.6 root 2561: /* If the value is meaningful, convert RESULT to the proper mode.
2562: Otherwise, return nothing. */
2563: return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
2564: TYPE_MODE (TREE_TYPE (from)),
2565: result,
2566: TREE_UNSIGNED (TREE_TYPE (to)))
2567: : NULL_RTX);
2568: }
2569:
2570: /* If the rhs is a function call and its value is not an aggregate,
2571: call the function before we start to compute the lhs.
2572: This is needed for correct code for cases such as
2573: val = setjmp (buf) on machines where reference to val
2574: requires loading up part of an address in a separate insn.
2575:
2576: Don't do this if TO is a VAR_DECL whose DECL_RTL is REG since it might be
2577: a promoted variable where the zero- or sign- extension needs to be done.
2578: Handling this in the normal way is safe because no computation is done
2579: before the call. */
2580: if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
2581: && ! (TREE_CODE (to) == VAR_DECL && GET_CODE (DECL_RTL (to)) == REG))
2582: {
2583: rtx value;
2584:
2585: push_temp_slots ();
2586: value = expand_expr (from, NULL_RTX, VOIDmode, 0);
2587: if (to_rtx == 0)
2588: to_rtx = expand_expr (to, NULL_RTX, VOIDmode, 0);
1.1.1.8 root 2589:
2590: if (GET_MODE (to_rtx) == BLKmode)
2591: {
2592: int align = MIN (TYPE_ALIGN (TREE_TYPE (from)), BITS_PER_WORD);
2593: emit_block_move (to_rtx, value, expr_size (from), align);
2594: }
2595: else
2596: emit_move_insn (to_rtx, value);
1.1.1.6 root 2597: preserve_temp_slots (to_rtx);
2598: free_temp_slots ();
2599: pop_temp_slots ();
2600: return want_value ? to_rtx : NULL_RTX;
1.1 root 2601: }
2602:
2603: /* Ordinary treatment. Expand TO to get a REG or MEM rtx.
2604: Don't re-expand if it was expanded already (in COMPONENT_REF case). */
2605:
2606: if (to_rtx == 0)
1.1.1.4 root 2607: to_rtx = expand_expr (to, NULL_RTX, VOIDmode, 0);
1.1 root 2608:
1.1.1.5 root 2609: /* Don't move directly into a return register. */
2610: if (TREE_CODE (to) == RESULT_DECL && GET_CODE (to_rtx) == REG)
2611: {
1.1.1.6 root 2612: rtx temp;
2613:
2614: push_temp_slots ();
2615: temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
1.1.1.5 root 2616: emit_move_insn (to_rtx, temp);
2617: preserve_temp_slots (to_rtx);
2618: free_temp_slots ();
1.1.1.6 root 2619: pop_temp_slots ();
2620: return want_value ? to_rtx : NULL_RTX;
1.1.1.5 root 2621: }
2622:
1.1 root 2623: /* In case we are returning the contents of an object which overlaps
2624: the place the value is being stored, use a safe function when copying
2625: a value through a pointer into a structure value return block. */
2626: if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
2627: && current_function_returns_struct
2628: && !current_function_returns_pcc_struct)
2629: {
1.1.1.6 root 2630: rtx from_rtx, size;
2631:
2632: push_temp_slots ();
2633: size = expr_size (from);
2634: from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
1.1 root 2635:
2636: #ifdef TARGET_MEM_FUNCTIONS
1.1.1.4 root 2637: emit_library_call (memcpy_libfunc, 0,
1.1 root 2638: VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
2639: XEXP (from_rtx, 0), Pmode,
1.1.1.5 root 2640: convert_to_mode (TYPE_MODE (sizetype),
2641: size, TREE_UNSIGNED (sizetype)),
2642: TYPE_MODE (sizetype));
1.1 root 2643: #else
1.1.1.4 root 2644: emit_library_call (bcopy_libfunc, 0,
1.1 root 2645: VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
2646: XEXP (to_rtx, 0), Pmode,
1.1.1.5 root 2647: convert_to_mode (TYPE_MODE (sizetype),
2648: size, TREE_UNSIGNED (sizetype)),
2649: TYPE_MODE (sizetype));
1.1 root 2650: #endif
2651:
2652: preserve_temp_slots (to_rtx);
2653: free_temp_slots ();
1.1.1.6 root 2654: pop_temp_slots ();
2655: return want_value ? to_rtx : NULL_RTX;
1.1 root 2656: }
2657:
2658: /* Compute FROM and store the value in the rtx we got. */
2659:
1.1.1.6 root 2660: push_temp_slots ();
1.1 root 2661: result = store_expr (from, to_rtx, want_value);
2662: preserve_temp_slots (result);
2663: free_temp_slots ();
1.1.1.6 root 2664: pop_temp_slots ();
2665: return want_value ? result : NULL_RTX;
1.1 root 2666: }
2667:
2668: /* Generate code for computing expression EXP,
2669: and storing the value into TARGET.
2670: TARGET may contain a QUEUED rtx.
2671:
1.1.1.6 root 2672: If WANT_VALUE is nonzero, return a copy of the value
2673: not in TARGET, so that we can be sure to use the proper
2674: value in a containing expression even if TARGET has something
2675: else stored in it. If possible, we copy the value through a pseudo
2676: and return that pseudo. Or, if the value is constant, we try to
2677: return the constant. In some cases, we return a pseudo
2678: copied *from* TARGET.
2679:
2680: If the mode is BLKmode then we may return TARGET itself.
2681: It turns out that in BLKmode it doesn't cause a problem.
2682: because C has no operators that could combine two different
2683: assignments into the same BLKmode object with different values
2684: with no sequence point. Will other languages need this to
2685: be more thorough?
2686:
2687: If WANT_VALUE is 0, we return NULL, to make sure
2688: to catch quickly any cases where the caller uses the value
2689: and fails to set WANT_VALUE. */
1.1 root 2690:
2691: rtx
1.1.1.6 root 2692: store_expr (exp, target, want_value)
1.1 root 2693: register tree exp;
2694: register rtx target;
1.1.1.6 root 2695: int want_value;
1.1 root 2696: {
2697: register rtx temp;
2698: int dont_return_target = 0;
2699:
2700: if (TREE_CODE (exp) == COMPOUND_EXPR)
2701: {
2702: /* Perform first part of compound expression, then assign from second
2703: part. */
2704: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
2705: emit_queue ();
1.1.1.6 root 2706: return store_expr (TREE_OPERAND (exp, 1), target, want_value);
1.1 root 2707: }
2708: else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
2709: {
2710: /* For conditional expression, get safe form of the target. Then
2711: test the condition, doing the appropriate assignment on either
2712: side. This avoids the creation of unnecessary temporaries.
2713: For non-BLKmode, it is more efficient not to do this. */
2714:
2715: rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
2716:
2717: emit_queue ();
2718: target = protect_from_queue (target, 1);
2719:
1.1.1.8 root 2720: do_pending_stack_adjust ();
1.1 root 2721: NO_DEFER_POP;
2722: jumpifnot (TREE_OPERAND (exp, 0), lab1);
1.1.1.6 root 2723: store_expr (TREE_OPERAND (exp, 1), target, 0);
1.1 root 2724: emit_queue ();
2725: emit_jump_insn (gen_jump (lab2));
2726: emit_barrier ();
2727: emit_label (lab1);
1.1.1.6 root 2728: store_expr (TREE_OPERAND (exp, 2), target, 0);
1.1 root 2729: emit_queue ();
2730: emit_label (lab2);
2731: OK_DEFER_POP;
1.1.1.6 root 2732: return want_value ? target : NULL_RTX;
1.1 root 2733: }
1.1.1.6 root 2734: else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
1.1 root 2735: && GET_MODE (target) != BLKmode)
2736: /* If target is in memory and caller wants value in a register instead,
2737: arrange that. Pass TARGET as target for expand_expr so that,
1.1.1.6 root 2738: if EXP is another assignment, WANT_VALUE will be nonzero for it.
2739: We know expand_expr will not use the target in that case.
2740: Don't do this if TARGET is volatile because we are supposed
2741: to write it and then read it. */
1.1 root 2742: {
1.1.1.4 root 2743: temp = expand_expr (exp, cse_not_expected ? NULL_RTX : target,
1.1 root 2744: GET_MODE (target), 0);
2745: if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
2746: temp = copy_to_reg (temp);
2747: dont_return_target = 1;
2748: }
2749: else if (queued_subexp_p (target))
1.1.1.6 root 2750: /* If target contains a postincrement, let's not risk
2751: using it as the place to generate the rhs. */
1.1 root 2752: {
2753: if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
2754: {
2755: /* Expand EXP into a new pseudo. */
2756: temp = gen_reg_rtx (GET_MODE (target));
2757: temp = expand_expr (exp, temp, GET_MODE (target), 0);
2758: }
2759: else
1.1.1.4 root 2760: temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
1.1.1.6 root 2761:
2762: /* If target is volatile, ANSI requires accessing the value
2763: *from* the target, if it is accessed. So make that happen.
2764: In no case return the target itself. */
2765: if (! MEM_VOLATILE_P (target) && want_value)
2766: dont_return_target = 1;
1.1 root 2767: }
1.1.1.4 root 2768: else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
2769: /* If this is an scalar in a register that is stored in a wider mode
2770: than the declared mode, compute the result into its declared mode
2771: and then convert to the wider mode. Our value is the computed
2772: expression. */
2773: {
1.1.1.8 root 2774: /* If we don't want a value, we can do the conversion inside EXP,
2775: which will often result in some optimizations. Do the conversion
2776: in two steps: first change the signedness, if needed, then
2777: the extend. */
2778: if (! want_value)
2779: {
2780: if (TREE_UNSIGNED (TREE_TYPE (exp))
2781: != SUBREG_PROMOTED_UNSIGNED_P (target))
2782: exp
2783: = convert
2784: (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
2785: TREE_TYPE (exp)),
2786: exp);
2787:
2788: exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
2789: SUBREG_PROMOTED_UNSIGNED_P (target)),
2790: exp);
2791: }
2792:
1.1.1.4 root 2793: temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
1.1.1.6 root 2794:
1.1.1.7 root 2795: /* If TEMP is a volatile MEM and we want a result value, make
1.1.1.8 root 2796: the access now so it gets done only once. Likewise if
2797: it contains TARGET. */
2798: if (GET_CODE (temp) == MEM && want_value
2799: && (MEM_VOLATILE_P (temp)
2800: || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
1.1.1.7 root 2801: temp = copy_to_reg (temp);
2802:
1.1.1.6 root 2803: /* If TEMP is a VOIDmode constant, use convert_modes to make
2804: sure that we properly convert it. */
2805: if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
2806: temp = convert_modes (GET_MODE (SUBREG_REG (target)),
2807: TYPE_MODE (TREE_TYPE (exp)), temp,
2808: SUBREG_PROMOTED_UNSIGNED_P (target));
2809:
1.1.1.4 root 2810: convert_move (SUBREG_REG (target), temp,
2811: SUBREG_PROMOTED_UNSIGNED_P (target));
1.1.1.6 root 2812: return want_value ? temp : NULL_RTX;
1.1.1.4 root 2813: }
1.1 root 2814: else
2815: {
2816: temp = expand_expr (exp, target, GET_MODE (target), 0);
1.1.1.7 root 2817: /* Return TARGET if it's a specified hardware register.
1.1.1.6 root 2818: If TARGET is a volatile mem ref, either return TARGET
2819: or return a reg copied *from* TARGET; ANSI requires this.
2820:
2821: Otherwise, if TEMP is not TARGET, return TEMP
2822: if it is constant (for efficiency),
2823: or if we really want the correct value. */
1.1 root 2824: if (!(target && GET_CODE (target) == REG
2825: && REGNO (target) < FIRST_PSEUDO_REGISTER)
1.1.1.6 root 2826: && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
2827: && temp != target
2828: && (CONSTANT_P (temp) || want_value))
1.1 root 2829: dont_return_target = 1;
2830: }
2831:
1.1.1.6 root 2832: /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
2833: the same as that of TARGET, adjust the constant. This is needed, for
2834: example, in case it is a CONST_DOUBLE and we want only a word-sized
2835: value. */
2836: if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
1.1.1.7 root 2837: && TREE_CODE (exp) != ERROR_MARK
1.1.1.6 root 2838: && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2839: temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
2840: temp, TREE_UNSIGNED (TREE_TYPE (exp)));
2841:
1.1 root 2842: /* If value was not generated in the target, store it there.
2843: Convert the value to TARGET's type first if nec. */
2844:
2845: if (temp != target && TREE_CODE (exp) != ERROR_MARK)
2846: {
2847: target = protect_from_queue (target, 1);
2848: if (GET_MODE (temp) != GET_MODE (target)
2849: && GET_MODE (temp) != VOIDmode)
2850: {
2851: int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
2852: if (dont_return_target)
2853: {
2854: /* In this case, we will return TEMP,
2855: so make sure it has the proper mode.
2856: But don't forget to store the value into TARGET. */
2857: temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
2858: emit_move_insn (target, temp);
2859: }
2860: else
2861: convert_move (target, temp, unsignedp);
2862: }
2863:
2864: else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
2865: {
2866: /* Handle copying a string constant into an array.
2867: The string constant may be shorter than the array.
2868: So copy just the string's actual length, and clear the rest. */
2869: rtx size;
1.1.1.7 root 2870: rtx addr;
1.1 root 2871:
1.1.1.2 root 2872: /* Get the size of the data type of the string,
2873: which is actually the size of the target. */
2874: size = expr_size (exp);
2875: if (GET_CODE (size) == CONST_INT
2876: && INTVAL (size) < TREE_STRING_LENGTH (exp))
2877: emit_block_move (target, temp, size,
2878: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
2879: else
1.1 root 2880: {
1.1.1.2 root 2881: /* Compute the size of the data to copy from the string. */
2882: tree copy_size
1.1.1.5 root 2883: = size_binop (MIN_EXPR,
1.1.1.6 root 2884: make_tree (sizetype, size),
1.1.1.5 root 2885: convert (sizetype,
2886: build_int_2 (TREE_STRING_LENGTH (exp), 0)));
1.1.1.4 root 2887: rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
2888: VOIDmode, 0);
1.1.1.2 root 2889: rtx label = 0;
2890:
2891: /* Copy that much. */
2892: emit_block_move (target, temp, copy_size_rtx,
2893: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
2894:
1.1.1.8 root 2895: /* Figure out how much is left in TARGET that we have to clear.
2896: Do all calculations in ptr_mode. */
2897:
2898: addr = XEXP (target, 0);
2899: addr = convert_modes (ptr_mode, Pmode, addr, 1);
2900:
1.1.1.2 root 2901: if (GET_CODE (copy_size_rtx) == CONST_INT)
2902: {
1.1.1.8 root 2903: addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
1.1.1.7 root 2904: size = plus_constant (size, - TREE_STRING_LENGTH (exp));
1.1.1.2 root 2905: }
2906: else
2907: {
1.1.1.8 root 2908: addr = force_reg (ptr_mode, addr);
2909: addr = expand_binop (ptr_mode, add_optab, addr,
1.1.1.4 root 2910: copy_size_rtx, NULL_RTX, 0,
2911: OPTAB_LIB_WIDEN);
1.1.1.2 root 2912:
1.1.1.8 root 2913: size = expand_binop (ptr_mode, sub_optab, size,
1.1.1.4 root 2914: copy_size_rtx, NULL_RTX, 0,
2915: OPTAB_LIB_WIDEN);
1.1.1.2 root 2916:
1.1.1.4 root 2917: emit_cmp_insn (size, const0_rtx, LT, NULL_RTX,
1.1.1.2 root 2918: GET_MODE (size), 0, 0);
2919: label = gen_label_rtx ();
2920: emit_jump_insn (gen_blt (label));
2921: }
2922:
2923: if (size != const0_rtx)
2924: {
1.1 root 2925: #ifdef TARGET_MEM_FUNCTIONS
1.1.1.7 root 2926: emit_library_call (memset_libfunc, 0, VOIDmode, 3, addr,
1.1.1.8 root 2927: Pmode, const0_rtx, Pmode, size, ptr_mode);
1.1 root 2928: #else
1.1.1.4 root 2929: emit_library_call (bzero_libfunc, 0, VOIDmode, 2,
1.1.1.8 root 2930: addr, Pmode, size, ptr_mode);
1.1 root 2931: #endif
1.1.1.2 root 2932: }
1.1.1.7 root 2933:
1.1.1.2 root 2934: if (label)
2935: emit_label (label);
1.1 root 2936: }
2937: }
2938: else if (GET_MODE (temp) == BLKmode)
2939: emit_block_move (target, temp, expr_size (exp),
2940: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
2941: else
2942: emit_move_insn (target, temp);
2943: }
1.1.1.6 root 2944:
1.1.1.7 root 2945: /* If we don't want a value, return NULL_RTX. */
2946: if (! want_value)
2947: return NULL_RTX;
2948:
2949: /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
2950: ??? The latter test doesn't seem to make sense. */
2951: else if (dont_return_target && GET_CODE (temp) != MEM)
1.1 root 2952: return temp;
1.1.1.7 root 2953:
2954: /* Return TARGET itself if it is a hard register. */
2955: else if (want_value && GET_MODE (target) != BLKmode
2956: && ! (GET_CODE (target) == REG
2957: && REGNO (target) < FIRST_PSEUDO_REGISTER))
1.1.1.6 root 2958: return copy_to_reg (target);
1.1.1.7 root 2959:
2960: else
1.1.1.6 root 2961: return target;
1.1 root 2962: }
2963:
2964: /* Store the value of constructor EXP into the rtx TARGET.
2965: TARGET is either a REG or a MEM. */
2966:
2967: static void
2968: store_constructor (exp, target)
2969: tree exp;
2970: rtx target;
2971: {
1.1.1.3 root 2972: tree type = TREE_TYPE (exp);
2973:
1.1 root 2974: /* We know our target cannot conflict, since safe_from_p has been called. */
2975: #if 0
2976: /* Don't try copying piece by piece into a hard register
2977: since that is vulnerable to being clobbered by EXP.
2978: Instead, construct in a pseudo register and then copy it all. */
2979: if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
2980: {
2981: rtx temp = gen_reg_rtx (GET_MODE (target));
2982: store_constructor (exp, temp);
2983: emit_move_insn (target, temp);
2984: return;
2985: }
2986: #endif
2987:
1.1.1.6 root 2988: if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
2989: || TREE_CODE (type) == QUAL_UNION_TYPE)
1.1 root 2990: {
2991: register tree elt;
2992:
1.1.1.3 root 2993: /* Inform later passes that the whole union value is dead. */
1.1.1.6 root 2994: if (TREE_CODE (type) == UNION_TYPE
2995: || TREE_CODE (type) == QUAL_UNION_TYPE)
1.1 root 2996: emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
1.1.1.3 root 2997:
2998: /* If we are building a static constructor into a register,
2999: set the initial value as zero so we can fold the value into
1.1.1.8 root 3000: a constant. But if more than one register is involved,
3001: this probably loses. */
3002: else if (GET_CODE (target) == REG && TREE_STATIC (exp)
3003: && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
1.1.1.3 root 3004: emit_move_insn (target, const0_rtx);
3005:
1.1 root 3006: /* If the constructor has fewer fields than the structure,
3007: clear the whole structure first. */
3008: else if (list_length (CONSTRUCTOR_ELTS (exp))
1.1.1.3 root 3009: != list_length (TYPE_FIELDS (type)))
1.1.1.8 root 3010: clear_storage (target, expr_size (exp));
1.1 root 3011: else
3012: /* Inform later passes that the old value is dead. */
3013: emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
3014:
3015: /* Store each element of the constructor into
3016: the corresponding field of TARGET. */
3017:
3018: for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
3019: {
3020: register tree field = TREE_PURPOSE (elt);
3021: register enum machine_mode mode;
3022: int bitsize;
1.1.1.6 root 3023: int bitpos = 0;
1.1 root 3024: int unsignedp;
1.1.1.6 root 3025: tree pos, constant = 0, offset = 0;
3026: rtx to_rtx = target;
1.1 root 3027:
1.1.1.4 root 3028: /* Just ignore missing fields.
3029: We cleared the whole structure, above,
3030: if any fields are missing. */
3031: if (field == 0)
3032: continue;
3033:
1.1 root 3034: bitsize = TREE_INT_CST_LOW (DECL_SIZE (field));
3035: unsignedp = TREE_UNSIGNED (field);
3036: mode = DECL_MODE (field);
3037: if (DECL_BIT_FIELD (field))
3038: mode = VOIDmode;
3039:
1.1.1.6 root 3040: pos = DECL_FIELD_BITPOS (field);
3041: if (TREE_CODE (pos) == INTEGER_CST)
3042: constant = pos;
3043: else if (TREE_CODE (pos) == PLUS_EXPR
3044: && TREE_CODE (TREE_OPERAND (pos, 1)) == INTEGER_CST)
3045: constant = TREE_OPERAND (pos, 1), offset = TREE_OPERAND (pos, 0);
3046: else
3047: offset = pos;
1.1 root 3048:
1.1.1.6 root 3049: if (constant)
1.1.1.8 root 3050: bitpos = TREE_INT_CST_LOW (constant);
1.1.1.6 root 3051:
3052: if (offset)
3053: {
3054: rtx offset_rtx;
1.1 root 3055:
1.1.1.6 root 3056: if (contains_placeholder_p (offset))
3057: offset = build (WITH_RECORD_EXPR, sizetype,
3058: offset, exp);
3059:
3060: offset = size_binop (FLOOR_DIV_EXPR, offset,
3061: size_int (BITS_PER_UNIT));
3062:
3063: offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3064: if (GET_CODE (to_rtx) != MEM)
3065: abort ();
3066:
3067: to_rtx
3068: = change_address (to_rtx, VOIDmode,
1.1.1.8 root 3069: gen_rtx (PLUS, ptr_mode, XEXP (to_rtx, 0),
3070: force_reg (ptr_mode, offset_rtx)));
1.1.1.6 root 3071: }
3072:
3073: store_field (to_rtx, bitsize, bitpos, mode, TREE_VALUE (elt),
1.1 root 3074: /* The alignment of TARGET is
3075: at least what its type requires. */
3076: VOIDmode, 0,
1.1.1.3 root 3077: TYPE_ALIGN (type) / BITS_PER_UNIT,
3078: int_size_in_bytes (type));
1.1 root 3079: }
3080: }
1.1.1.3 root 3081: else if (TREE_CODE (type) == ARRAY_TYPE)
1.1 root 3082: {
3083: register tree elt;
3084: register int i;
1.1.1.3 root 3085: tree domain = TYPE_DOMAIN (type);
1.1.1.4 root 3086: HOST_WIDE_INT minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
3087: HOST_WIDE_INT maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
1.1.1.3 root 3088: tree elttype = TREE_TYPE (type);
1.1 root 3089:
3090: /* If the constructor has fewer fields than the structure,
1.1.1.3 root 3091: clear the whole structure first. Similarly if this this is
3092: static constructor of a non-BLKmode object. */
1.1 root 3093:
1.1.1.3 root 3094: if (list_length (CONSTRUCTOR_ELTS (exp)) < maxelt - minelt + 1
3095: || (GET_CODE (target) == REG && TREE_STATIC (exp)))
1.1.1.8 root 3096: clear_storage (target, expr_size (exp));
1.1 root 3097: else
3098: /* Inform later passes that the old value is dead. */
3099: emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
3100:
3101: /* Store each element of the constructor into
3102: the corresponding element of TARGET, determined
3103: by counting the elements. */
3104: for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
3105: elt;
3106: elt = TREE_CHAIN (elt), i++)
3107: {
3108: register enum machine_mode mode;
3109: int bitsize;
3110: int bitpos;
3111: int unsignedp;
1.1.1.6 root 3112: tree index = TREE_PURPOSE (elt);
3113: rtx xtarget = target;
1.1 root 3114:
3115: mode = TYPE_MODE (elttype);
3116: bitsize = GET_MODE_BITSIZE (mode);
3117: unsignedp = TREE_UNSIGNED (elttype);
3118:
1.1.1.8 root 3119: if ((index != 0 && TREE_CODE (index) != INTEGER_CST)
3120: || TREE_CODE (TYPE_SIZE (elttype)) != INTEGER_CST)
1.1.1.6 root 3121: {
3122: rtx pos_rtx, addr, xtarget;
3123: tree position;
3124:
1.1.1.8 root 3125: if (index == 0)
3126: index = size_int (i);
3127:
3128: position = size_binop (EXACT_DIV_EXPR, TYPE_SIZE (elttype),
3129: size_int (BITS_PER_UNIT));
3130: position = size_binop (MULT_EXPR, index, position);
1.1.1.6 root 3131: pos_rtx = expand_expr (position, 0, VOIDmode, 0);
3132: addr = gen_rtx (PLUS, Pmode, XEXP (target, 0), pos_rtx);
3133: xtarget = change_address (target, mode, addr);
3134: store_expr (TREE_VALUE (elt), xtarget, 0);
3135: }
3136: else
3137: {
3138: if (index != 0)
3139: bitpos = ((TREE_INT_CST_LOW (index) - minelt)
3140: * TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
3141: else
3142: bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
1.1 root 3143:
1.1.1.6 root 3144: store_field (xtarget, bitsize, bitpos, mode, TREE_VALUE (elt),
3145: /* The alignment of TARGET is
3146: at least what its type requires. */
3147: VOIDmode, 0,
3148: TYPE_ALIGN (type) / BITS_PER_UNIT,
3149: int_size_in_bytes (type));
3150: }
1.1 root 3151: }
3152: }
1.1.1.8 root 3153: /* set constructor assignments */
3154: else if (TREE_CODE (type) == SET_TYPE)
3155: {
3156: tree elt;
3157: rtx xtarget = XEXP (target, 0);
3158: int set_word_size = TYPE_ALIGN (type);
3159: int nbytes = int_size_in_bytes (type);
3160: tree non_const_elements;
3161: int need_to_clear_first;
3162: tree domain = TYPE_DOMAIN (type);
3163: tree domain_min, domain_max, bitlength;
3164:
3165: /* The default implementation strategy is to extract the constant
3166: parts of the constructor, use that to initialize the target,
3167: and then "or" in whatever non-constant ranges we need in addition.
3168:
3169: If a large set is all zero or all ones, it is
3170: probably better to set it using memset (if available) or bzero.
3171: Also, if a large set has just a single range, it may also be
3172: better to first clear all the first clear the set (using
3173: bzero/memset), and set the bits we want. */
3174:
3175: /* Check for all zeros. */
3176: if (CONSTRUCTOR_ELTS (exp) == NULL_TREE)
3177: {
3178: clear_storage (target, expr_size (exp));
3179: return;
3180: }
3181:
3182: if (nbytes < 0)
3183: abort ();
3184:
3185: domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
3186: domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
3187: bitlength = size_binop (PLUS_EXPR,
3188: size_binop (MINUS_EXPR, domain_max, domain_min),
3189: size_one_node);
3190:
3191: /* Check for range all ones, or at most a single range.
3192: (This optimization is only a win for big sets.) */
3193: if (GET_MODE (target) == BLKmode && nbytes > 16
3194: && TREE_CHAIN (CONSTRUCTOR_ELTS (exp)) == NULL_TREE)
3195: {
3196: need_to_clear_first = 1;
3197: non_const_elements = CONSTRUCTOR_ELTS (exp);
3198: }
3199: else
3200: {
3201: int nbits = nbytes * BITS_PER_UNIT;
3202: int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
3203: enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
3204: char *bit_buffer = (char*) alloca (nbits);
3205: HOST_WIDE_INT word = 0;
3206: int bit_pos = 0;
3207: int ibit = 0;
3208: int offset = 0; /* In bytes from beginning of set. */
3209: non_const_elements = get_set_constructor_bits (exp,
3210: bit_buffer, nbits);
3211: for (;;)
3212: {
3213: if (bit_buffer[ibit])
3214: {
3215: if (BYTES_BIG_ENDIAN)
3216: word |= (1 << (set_word_size - 1 - bit_pos));
3217: else
3218: word |= 1 << bit_pos;
3219: }
3220: bit_pos++; ibit++;
3221: if (bit_pos >= set_word_size || ibit == nbits)
3222: {
3223: rtx datum = GEN_INT (word);
3224: rtx to_rtx;
3225: /* The assumption here is that it is safe to use XEXP if
3226: the set is multi-word, but not if it's single-word. */
3227: if (GET_CODE (target) == MEM)
3228: to_rtx = change_address (target, mode,
3229: plus_constant (XEXP (target, 0),
3230: offset));
3231: else if (offset == 0)
3232: to_rtx = target;
3233: else
3234: abort ();
3235: emit_move_insn (to_rtx, datum);
3236: if (ibit == nbits)
3237: break;
3238: word = 0;
3239: bit_pos = 0;
3240: offset += set_word_size / BITS_PER_UNIT;
3241: }
3242: }
3243: need_to_clear_first = 0;
3244: }
3245:
3246: for (elt = non_const_elements; elt != NULL_TREE; elt = TREE_CHAIN (elt))
3247: {
3248: /* start of range of element or NULL */
3249: tree startbit = TREE_PURPOSE (elt);
3250: /* end of range of element, or element value */
3251: tree endbit = TREE_VALUE (elt);
3252: HOST_WIDE_INT startb, endb;
3253: rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
3254:
3255: bitlength_rtx = expand_expr (bitlength,
3256: NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
3257:
3258: /* handle non-range tuple element like [ expr ] */
3259: if (startbit == NULL_TREE)
3260: {
3261: startbit = save_expr (endbit);
3262: endbit = startbit;
3263: }
3264: startbit = convert (sizetype, startbit);
3265: endbit = convert (sizetype, endbit);
3266: if (! integer_zerop (domain_min))
3267: {
3268: startbit = size_binop (MINUS_EXPR, startbit, domain_min);
3269: endbit = size_binop (MINUS_EXPR, endbit, domain_min);
3270: }
3271: startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
3272: EXPAND_CONST_ADDRESS);
3273: endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
3274: EXPAND_CONST_ADDRESS);
3275:
3276: if (REG_P (target))
3277: {
3278: targetx = assign_stack_temp (GET_MODE (target),
3279: GET_MODE_SIZE (GET_MODE (target)),
3280: 0);
3281: emit_move_insn (targetx, target);
3282: }
3283: else if (GET_CODE (target) == MEM)
3284: targetx = target;
3285: else
3286: abort ();
3287:
3288: #ifdef TARGET_MEM_FUNCTIONS
3289: /* Optimization: If startbit and endbit are
3290: constants divisible by BITS_PER_UNIT,
3291: call memset instead. */
3292: if (TREE_CODE (startbit) == INTEGER_CST
3293: && TREE_CODE (endbit) == INTEGER_CST
3294: && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
3295: && (endb = TREE_INT_CST_LOW (endbit)) % BITS_PER_UNIT == 0)
3296: {
3297:
3298: if (need_to_clear_first
3299: && endb - startb != nbytes * BITS_PER_UNIT)
3300: clear_storage (target, expr_size (exp));
3301: need_to_clear_first = 0;
3302: emit_library_call (memset_libfunc, 0,
3303: VOIDmode, 3,
3304: plus_constant (XEXP (targetx, 0), startb),
3305: Pmode,
3306: constm1_rtx, Pmode,
3307: GEN_INT ((endb - startb) / BITS_PER_UNIT),
3308: Pmode);
3309: }
3310: else
3311: #endif
3312: {
3313: if (need_to_clear_first)
3314: {
3315: clear_storage (target, expr_size (exp));
3316: need_to_clear_first = 0;
3317: }
3318: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__setbits"),
3319: 0, VOIDmode, 4, XEXP (targetx, 0), Pmode,
3320: bitlength_rtx, TYPE_MODE (sizetype),
3321: startbit_rtx, TYPE_MODE (sizetype),
3322: endbit_rtx, TYPE_MODE (sizetype));
3323: }
3324: if (REG_P (target))
3325: emit_move_insn (target, targetx);
3326: }
3327: }
1.1 root 3328:
3329: else
3330: abort ();
3331: }
3332:
3333: /* Store the value of EXP (an expression tree)
3334: into a subfield of TARGET which has mode MODE and occupies
3335: BITSIZE bits, starting BITPOS bits from the start of TARGET.
3336: If MODE is VOIDmode, it means that we are storing into a bit-field.
3337:
3338: If VALUE_MODE is VOIDmode, return nothing in particular.
3339: UNSIGNEDP is not used in this case.
3340:
3341: Otherwise, return an rtx for the value stored. This rtx
3342: has mode VALUE_MODE if that is convenient to do.
3343: In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
3344:
3345: ALIGN is the alignment that TARGET is known to have, measured in bytes.
3346: TOTAL_SIZE is the size in bytes of the structure, or -1 if varying. */
3347:
3348: static rtx
3349: store_field (target, bitsize, bitpos, mode, exp, value_mode,
3350: unsignedp, align, total_size)
3351: rtx target;
3352: int bitsize, bitpos;
3353: enum machine_mode mode;
3354: tree exp;
3355: enum machine_mode value_mode;
3356: int unsignedp;
3357: int align;
3358: int total_size;
3359: {
1.1.1.4 root 3360: HOST_WIDE_INT width_mask = 0;
1.1 root 3361:
1.1.1.4 root 3362: if (bitsize < HOST_BITS_PER_WIDE_INT)
3363: width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
1.1 root 3364:
3365: /* If we are storing into an unaligned field of an aligned union that is
3366: in a register, we may have the mode of TARGET being an integer mode but
3367: MODE == BLKmode. In that case, get an aligned object whose size and
3368: alignment are the same as TARGET and store TARGET into it (we can avoid
3369: the store if the field being stored is the entire width of TARGET). Then
3370: call ourselves recursively to store the field into a BLKmode version of
3371: that object. Finally, load from the object into TARGET. This is not
3372: very efficient in general, but should only be slightly more expensive
3373: than the otherwise-required unaligned accesses. Perhaps this can be
3374: cleaned up later. */
3375:
3376: if (mode == BLKmode
3377: && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
3378: {
3379: rtx object = assign_stack_temp (GET_MODE (target),
3380: GET_MODE_SIZE (GET_MODE (target)), 0);
3381: rtx blk_object = copy_rtx (object);
3382:
1.1.1.7 root 3383: MEM_IN_STRUCT_P (object) = 1;
3384: MEM_IN_STRUCT_P (blk_object) = 1;
1.1 root 3385: PUT_MODE (blk_object, BLKmode);
3386:
3387: if (bitsize != GET_MODE_BITSIZE (GET_MODE (target)))
3388: emit_move_insn (object, target);
3389:
3390: store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
3391: align, total_size);
3392:
1.1.1.6 root 3393: /* Even though we aren't returning target, we need to
3394: give it the updated value. */
1.1 root 3395: emit_move_insn (target, object);
3396:
1.1.1.6 root 3397: return blk_object;
1.1 root 3398: }
3399:
3400: /* If the structure is in a register or if the component
3401: is a bit field, we cannot use addressing to access it.
3402: Use bit-field techniques or SUBREG to store in it. */
3403:
1.1.1.4 root 3404: if (mode == VOIDmode
3405: || (mode != BLKmode && ! direct_store[(int) mode])
3406: || GET_CODE (target) == REG
1.1.1.6 root 3407: || GET_CODE (target) == SUBREG
3408: /* If the field isn't aligned enough to store as an ordinary memref,
3409: store it as a bit field. */
1.1.1.8 root 3410: || (SLOW_UNALIGNED_ACCESS
1.1.1.6 root 3411: && align * BITS_PER_UNIT < GET_MODE_ALIGNMENT (mode))
1.1.1.8 root 3412: || (SLOW_UNALIGNED_ACCESS && bitpos % GET_MODE_ALIGNMENT (mode) != 0))
1.1 root 3413: {
1.1.1.4 root 3414: rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
1.1.1.6 root 3415:
3416: /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
3417: MODE. */
3418: if (mode != VOIDmode && mode != BLKmode
3419: && mode != TYPE_MODE (TREE_TYPE (exp)))
3420: temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
3421:
1.1 root 3422: /* Store the value in the bitfield. */
3423: store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
3424: if (value_mode != VOIDmode)
3425: {
3426: /* The caller wants an rtx for the value. */
3427: /* If possible, avoid refetching from the bitfield itself. */
3428: if (width_mask != 0
3429: && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
1.1.1.4 root 3430: {
3431: tree count;
3432: enum machine_mode tmode;
3433:
3434: if (unsignedp)
3435: return expand_and (temp, GEN_INT (width_mask), NULL_RTX);
3436: tmode = GET_MODE (temp);
3437: if (tmode == VOIDmode)
3438: tmode = value_mode;
3439: count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
3440: temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
3441: return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
3442: }
1.1 root 3443: return extract_bit_field (target, bitsize, bitpos, unsignedp,
1.1.1.4 root 3444: NULL_RTX, value_mode, 0, align,
3445: total_size);
1.1 root 3446: }
3447: return const0_rtx;
3448: }
3449: else
3450: {
3451: rtx addr = XEXP (target, 0);
3452: rtx to_rtx;
3453:
3454: /* If a value is wanted, it must be the lhs;
3455: so make the address stable for multiple use. */
3456:
3457: if (value_mode != VOIDmode && GET_CODE (addr) != REG
3458: && ! CONSTANT_ADDRESS_P (addr)
3459: /* A frame-pointer reference is already stable. */
3460: && ! (GET_CODE (addr) == PLUS
3461: && GET_CODE (XEXP (addr, 1)) == CONST_INT
3462: && (XEXP (addr, 0) == virtual_incoming_args_rtx
3463: || XEXP (addr, 0) == virtual_stack_vars_rtx)))
3464: addr = copy_to_reg (addr);
3465:
3466: /* Now build a reference to just the desired component. */
3467:
3468: to_rtx = change_address (target, mode,
3469: plus_constant (addr, (bitpos / BITS_PER_UNIT)));
3470: MEM_IN_STRUCT_P (to_rtx) = 1;
3471:
3472: return store_expr (exp, to_rtx, value_mode != VOIDmode);
3473: }
3474: }
3475:
1.1.1.7 root 3476: /* Return true if any object containing the innermost array is an unaligned
3477: packed structure field. */
3478:
3479: static int
3480: get_inner_unaligned_p (exp)
3481: tree exp;
3482: {
3483: int needed_alignment = TYPE_ALIGN (TREE_TYPE (exp));
3484:
3485: while (1)
3486: {
3487: if (TREE_CODE (exp) == COMPONENT_REF || TREE_CODE (exp) == BIT_FIELD_REF)
3488: {
3489: if (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
3490: < needed_alignment)
3491: return 1;
3492: }
3493: else if (TREE_CODE (exp) != ARRAY_REF
3494: && TREE_CODE (exp) != NON_LVALUE_EXPR
3495: && ! ((TREE_CODE (exp) == NOP_EXPR
3496: || TREE_CODE (exp) == CONVERT_EXPR)
3497: && (TYPE_MODE (TREE_TYPE (exp))
3498: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
3499: break;
3500:
3501: exp = TREE_OPERAND (exp, 0);
3502: }
3503:
3504: return 0;
3505: }
3506:
1.1 root 3507: /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
3508: or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
1.1.1.5 root 3509: ARRAY_REFs and find the ultimate containing object, which we return.
1.1 root 3510:
3511: We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
3512: bit position, and *PUNSIGNEDP to the signedness of the field.
1.1.1.3 root 3513: If the position of the field is variable, we store a tree
3514: giving the variable offset (in units) in *POFFSET.
3515: This offset is in addition to the bit position.
3516: If the position is not variable, we store 0 in *POFFSET.
1.1 root 3517:
3518: If any of the extraction expressions is volatile,
3519: we store 1 in *PVOLATILEP. Otherwise we don't change that.
3520:
3521: If the field is a bit-field, *PMODE is set to VOIDmode. Otherwise, it
3522: is a mode that can be used to access the field. In that case, *PBITSIZE
1.1.1.3 root 3523: is redundant.
3524:
3525: If the field describes a variable-sized object, *PMODE is set to
3526: VOIDmode and *PBITSIZE is set to -1. An access cannot be made in
3527: this case, but the address of the object can be found. */
1.1 root 3528:
3529: tree
1.1.1.5 root 3530: get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
3531: punsignedp, pvolatilep)
1.1 root 3532: tree exp;
3533: int *pbitsize;
3534: int *pbitpos;
1.1.1.3 root 3535: tree *poffset;
1.1 root 3536: enum machine_mode *pmode;
3537: int *punsignedp;
3538: int *pvolatilep;
3539: {
1.1.1.6 root 3540: tree orig_exp = exp;
1.1 root 3541: tree size_tree = 0;
3542: enum machine_mode mode = VOIDmode;
1.1.1.5 root 3543: tree offset = integer_zero_node;
1.1 root 3544:
3545: if (TREE_CODE (exp) == COMPONENT_REF)
3546: {
3547: size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
3548: if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
3549: mode = DECL_MODE (TREE_OPERAND (exp, 1));
3550: *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
3551: }
3552: else if (TREE_CODE (exp) == BIT_FIELD_REF)
3553: {
3554: size_tree = TREE_OPERAND (exp, 1);
3555: *punsignedp = TREE_UNSIGNED (exp);
3556: }
3557: else
3558: {
3559: mode = TYPE_MODE (TREE_TYPE (exp));
3560: *pbitsize = GET_MODE_BITSIZE (mode);
3561: *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
3562: }
3563:
3564: if (size_tree)
3565: {
3566: if (TREE_CODE (size_tree) != INTEGER_CST)
1.1.1.3 root 3567: mode = BLKmode, *pbitsize = -1;
3568: else
3569: *pbitsize = TREE_INT_CST_LOW (size_tree);
1.1 root 3570: }
3571:
3572: /* Compute cumulative bit-offset for nested component-refs and array-refs,
3573: and find the ultimate containing object. */
3574:
3575: *pbitpos = 0;
3576:
3577: while (1)
3578: {
1.1.1.3 root 3579: if (TREE_CODE (exp) == COMPONENT_REF || TREE_CODE (exp) == BIT_FIELD_REF)
1.1 root 3580: {
1.1.1.3 root 3581: tree pos = (TREE_CODE (exp) == COMPONENT_REF
3582: ? DECL_FIELD_BITPOS (TREE_OPERAND (exp, 1))
3583: : TREE_OPERAND (exp, 2));
1.1.1.8 root 3584: tree constant = integer_zero_node, var = pos;
1.1 root 3585:
1.1.1.5 root 3586: /* If this field hasn't been filled in yet, don't go
3587: past it. This should only happen when folding expressions
3588: made during type construction. */
3589: if (pos == 0)
3590: break;
3591:
1.1.1.8 root 3592: /* Assume here that the offset is a multiple of a unit.
3593: If not, there should be an explicitly added constant. */
3594: if (TREE_CODE (pos) == PLUS_EXPR
3595: && TREE_CODE (TREE_OPERAND (pos, 1)) == INTEGER_CST)
3596: constant = TREE_OPERAND (pos, 1), var = TREE_OPERAND (pos, 0);
1.1.1.3 root 3597: else if (TREE_CODE (pos) == INTEGER_CST)
1.1.1.8 root 3598: constant = pos, var = integer_zero_node;
3599:
3600: *pbitpos += TREE_INT_CST_LOW (constant);
3601:
3602: if (var)
3603: offset = size_binop (PLUS_EXPR, offset,
3604: size_binop (EXACT_DIV_EXPR, var,
3605: size_int (BITS_PER_UNIT)));
1.1 root 3606: }
3607:
1.1.1.5 root 3608: else if (TREE_CODE (exp) == ARRAY_REF)
1.1 root 3609: {
1.1.1.5 root 3610: /* This code is based on the code in case ARRAY_REF in expand_expr
3611: below. We assume here that the size of an array element is
3612: always an integral multiple of BITS_PER_UNIT. */
3613:
3614: tree index = TREE_OPERAND (exp, 1);
3615: tree domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0)));
3616: tree low_bound
3617: = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
3618: tree index_type = TREE_TYPE (index);
3619:
3620: if (! integer_zerop (low_bound))
3621: index = fold (build (MINUS_EXPR, index_type, index, low_bound));
3622:
1.1.1.8 root 3623: if (TYPE_PRECISION (index_type) != TYPE_PRECISION (sizetype))
1.1.1.5 root 3624: {
1.1.1.8 root 3625: index = convert (type_for_size (TYPE_PRECISION (sizetype), 0),
3626: index);
1.1.1.5 root 3627: index_type = TREE_TYPE (index);
3628: }
3629:
3630: index = fold (build (MULT_EXPR, index_type, index,
3631: TYPE_SIZE (TREE_TYPE (exp))));
3632:
3633: if (TREE_CODE (index) == INTEGER_CST
3634: && TREE_INT_CST_HIGH (index) == 0)
3635: *pbitpos += TREE_INT_CST_LOW (index);
3636: else
3637: offset = size_binop (PLUS_EXPR, offset,
3638: size_binop (FLOOR_DIV_EXPR, index,
3639: size_int (BITS_PER_UNIT)));
1.1 root 3640: }
3641: else if (TREE_CODE (exp) != NON_LVALUE_EXPR
3642: && ! ((TREE_CODE (exp) == NOP_EXPR
3643: || TREE_CODE (exp) == CONVERT_EXPR)
1.1.1.8 root 3644: && ! (TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE
3645: && (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0)))
3646: != UNION_TYPE))
1.1 root 3647: && (TYPE_MODE (TREE_TYPE (exp))
3648: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
3649: break;
1.1.1.3 root 3650:
3651: /* If any reference in the chain is volatile, the effect is volatile. */
3652: if (TREE_THIS_VOLATILE (exp))
3653: *pvolatilep = 1;
1.1 root 3654: exp = TREE_OPERAND (exp, 0);
3655: }
3656:
3657: /* If this was a bit-field, see if there is a mode that allows direct
3658: access in case EXP is in memory. */
1.1.1.5 root 3659: if (mode == VOIDmode && *pbitsize != 0 && *pbitpos % *pbitsize == 0)
1.1 root 3660: {
3661: mode = mode_for_size (*pbitsize, MODE_INT, 0);
3662: if (mode == BLKmode)
3663: mode = VOIDmode;
3664: }
3665:
1.1.1.5 root 3666: if (integer_zerop (offset))
3667: offset = 0;
3668:
1.1.1.6 root 3669: if (offset != 0 && contains_placeholder_p (offset))
3670: offset = build (WITH_RECORD_EXPR, sizetype, offset, orig_exp);
3671:
1.1 root 3672: *pmode = mode;
1.1.1.3 root 3673: *poffset = offset;
1.1 root 3674: return exp;
3675: }
3676:
3677: /* Given an rtx VALUE that may contain additions and multiplications,
3678: return an equivalent value that just refers to a register or memory.
3679: This is done by generating instructions to perform the arithmetic
1.1.1.4 root 3680: and returning a pseudo-register containing the value.
3681:
3682: The returned value may be a REG, SUBREG, MEM or constant. */
1.1 root 3683:
3684: rtx
3685: force_operand (value, target)
3686: rtx value, target;
3687: {
3688: register optab binoptab = 0;
3689: /* Use a temporary to force order of execution of calls to
3690: `force_operand'. */
3691: rtx tmp;
3692: register rtx op2;
3693: /* Use subtarget as the target for operand 0 of a binary operation. */
3694: register rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
3695:
3696: if (GET_CODE (value) == PLUS)
3697: binoptab = add_optab;
3698: else if (GET_CODE (value) == MINUS)
3699: binoptab = sub_optab;
3700: else if (GET_CODE (value) == MULT)
3701: {
3702: op2 = XEXP (value, 1);
3703: if (!CONSTANT_P (op2)
3704: && !(GET_CODE (op2) == REG && op2 != subtarget))
3705: subtarget = 0;
3706: tmp = force_operand (XEXP (value, 0), subtarget);
3707: return expand_mult (GET_MODE (value), tmp,
1.1.1.4 root 3708: force_operand (op2, NULL_RTX),
1.1 root 3709: target, 0);
3710: }
3711:
3712: if (binoptab)
3713: {
3714: op2 = XEXP (value, 1);
3715: if (!CONSTANT_P (op2)
3716: && !(GET_CODE (op2) == REG && op2 != subtarget))
3717: subtarget = 0;
3718: if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
3719: {
3720: binoptab = add_optab;
3721: op2 = negate_rtx (GET_MODE (value), op2);
3722: }
3723:
3724: /* Check for an addition with OP2 a constant integer and our first
3725: operand a PLUS of a virtual register and something else. In that
3726: case, we want to emit the sum of the virtual register and the
3727: constant first and then add the other value. This allows virtual
3728: register instantiation to simply modify the constant rather than
3729: creating another one around this addition. */
3730: if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
3731: && GET_CODE (XEXP (value, 0)) == PLUS
3732: && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
3733: && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
3734: && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
3735: {
3736: rtx temp = expand_binop (GET_MODE (value), binoptab,
3737: XEXP (XEXP (value, 0), 0), op2,
3738: subtarget, 0, OPTAB_LIB_WIDEN);
3739: return expand_binop (GET_MODE (value), binoptab, temp,
3740: force_operand (XEXP (XEXP (value, 0), 1), 0),
3741: target, 0, OPTAB_LIB_WIDEN);
3742: }
3743:
3744: tmp = force_operand (XEXP (value, 0), subtarget);
3745: return expand_binop (GET_MODE (value), binoptab, tmp,
1.1.1.4 root 3746: force_operand (op2, NULL_RTX),
1.1 root 3747: target, 0, OPTAB_LIB_WIDEN);
1.1.1.5 root 3748: /* We give UNSIGNEDP = 0 to expand_binop
1.1 root 3749: because the only operations we are expanding here are signed ones. */
3750: }
3751: return value;
3752: }
3753:
3754: /* Subroutine of expand_expr:
3755: save the non-copied parts (LIST) of an expr (LHS), and return a list
3756: which can restore these values to their previous values,
3757: should something modify their storage. */
3758:
3759: static tree
3760: save_noncopied_parts (lhs, list)
3761: tree lhs;
3762: tree list;
3763: {
3764: tree tail;
3765: tree parts = 0;
3766:
3767: for (tail = list; tail; tail = TREE_CHAIN (tail))
3768: if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
3769: parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
3770: else
3771: {
3772: tree part = TREE_VALUE (tail);
3773: tree part_type = TREE_TYPE (part);
1.1.1.4 root 3774: tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
1.1 root 3775: rtx target = assign_stack_temp (TYPE_MODE (part_type),
3776: int_size_in_bytes (part_type), 0);
1.1.1.8 root 3777: MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (part_type);
1.1 root 3778: if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
1.1.1.4 root 3779: target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
1.1 root 3780: parts = tree_cons (to_be_saved,
1.1.1.4 root 3781: build (RTL_EXPR, part_type, NULL_TREE,
3782: (tree) target),
1.1 root 3783: parts);
3784: store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
3785: }
3786: return parts;
3787: }
3788:
3789: /* Subroutine of expand_expr:
3790: record the non-copied parts (LIST) of an expr (LHS), and return a list
3791: which specifies the initial values of these parts. */
3792:
3793: static tree
3794: init_noncopied_parts (lhs, list)
3795: tree lhs;
3796: tree list;
3797: {
3798: tree tail;
3799: tree parts = 0;
3800:
3801: for (tail = list; tail; tail = TREE_CHAIN (tail))
3802: if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
3803: parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
3804: else
3805: {
3806: tree part = TREE_VALUE (tail);
3807: tree part_type = TREE_TYPE (part);
1.1.1.4 root 3808: tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
1.1 root 3809: parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
3810: }
3811: return parts;
3812: }
3813:
3814: /* Subroutine of expand_expr: return nonzero iff there is no way that
3815: EXP can reference X, which is being modified. */
3816:
3817: static int
3818: safe_from_p (x, exp)
3819: rtx x;
3820: tree exp;
3821: {
3822: rtx exp_rtl = 0;
3823: int i, nops;
3824:
1.1.1.7 root 3825: if (x == 0
3826: /* If EXP has varying size, we MUST use a target since we currently
3827: have no way of allocating temporaries of variable size. So we
3828: assume here that something at a higher level has prevented a
1.1.1.8 root 3829: clash. This is somewhat bogus, but the best we can do. Only
3830: do this when X is BLKmode. */
1.1.1.7 root 3831: || (TREE_TYPE (exp) != 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0
1.1.1.8 root 3832: && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
3833: && GET_MODE (x) == BLKmode))
1.1 root 3834: return 1;
3835:
3836: /* If this is a subreg of a hard register, declare it unsafe, otherwise,
3837: find the underlying pseudo. */
3838: if (GET_CODE (x) == SUBREG)
3839: {
3840: x = SUBREG_REG (x);
3841: if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
3842: return 0;
3843: }
3844:
3845: /* If X is a location in the outgoing argument area, it is always safe. */
3846: if (GET_CODE (x) == MEM
3847: && (XEXP (x, 0) == virtual_outgoing_args_rtx
3848: || (GET_CODE (XEXP (x, 0)) == PLUS
3849: && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx)))
3850: return 1;
3851:
3852: switch (TREE_CODE_CLASS (TREE_CODE (exp)))
3853: {
3854: case 'd':
3855: exp_rtl = DECL_RTL (exp);
3856: break;
3857:
3858: case 'c':
3859: return 1;
3860:
3861: case 'x':
3862: if (TREE_CODE (exp) == TREE_LIST)
1.1.1.4 root 3863: return ((TREE_VALUE (exp) == 0
3864: || safe_from_p (x, TREE_VALUE (exp)))
1.1 root 3865: && (TREE_CHAIN (exp) == 0
3866: || safe_from_p (x, TREE_CHAIN (exp))));
3867: else
3868: return 0;
3869:
3870: case '1':
3871: return safe_from_p (x, TREE_OPERAND (exp, 0));
3872:
3873: case '2':
3874: case '<':
3875: return (safe_from_p (x, TREE_OPERAND (exp, 0))
3876: && safe_from_p (x, TREE_OPERAND (exp, 1)));
3877:
3878: case 'e':
3879: case 'r':
3880: /* Now do code-specific tests. EXP_RTL is set to any rtx we find in
3881: the expression. If it is set, we conflict iff we are that rtx or
3882: both are in memory. Otherwise, we check all operands of the
3883: expression recursively. */
3884:
3885: switch (TREE_CODE (exp))
3886: {
3887: case ADDR_EXPR:
1.1.1.6 root 3888: return (staticp (TREE_OPERAND (exp, 0))
3889: || safe_from_p (x, TREE_OPERAND (exp, 0)));
1.1 root 3890:
3891: case INDIRECT_REF:
3892: if (GET_CODE (x) == MEM)
3893: return 0;
3894: break;
3895:
3896: case CALL_EXPR:
3897: exp_rtl = CALL_EXPR_RTL (exp);
3898: if (exp_rtl == 0)
3899: {
3900: /* Assume that the call will clobber all hard registers and
3901: all of memory. */
3902: if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
3903: || GET_CODE (x) == MEM)
3904: return 0;
3905: }
3906:
3907: break;
3908:
3909: case RTL_EXPR:
1.1.1.8 root 3910: /* If a sequence exists, we would have to scan every instruction
3911: in the sequence to see if it was safe. This is probably not
3912: worthwhile. */
3913: if (RTL_EXPR_SEQUENCE (exp))
1.1 root 3914: return 0;
3915:
1.1.1.8 root 3916: exp_rtl = RTL_EXPR_RTL (exp);
1.1 root 3917: break;
3918:
3919: case WITH_CLEANUP_EXPR:
3920: exp_rtl = RTL_EXPR_RTL (exp);
3921: break;
3922:
1.1.1.7 root 3923: case CLEANUP_POINT_EXPR:
3924: return safe_from_p (x, TREE_OPERAND (exp, 0));
3925:
1.1 root 3926: case SAVE_EXPR:
3927: exp_rtl = SAVE_EXPR_RTL (exp);
3928: break;
3929:
1.1.1.3 root 3930: case BIND_EXPR:
3931: /* The only operand we look at is operand 1. The rest aren't
3932: part of the expression. */
3933: return safe_from_p (x, TREE_OPERAND (exp, 1));
3934:
1.1 root 3935: case METHOD_CALL_EXPR:
3936: /* This takes a rtx argument, but shouldn't appear here. */
3937: abort ();
3938: }
3939:
3940: /* If we have an rtx, we do not need to scan our operands. */
3941: if (exp_rtl)
3942: break;
3943:
3944: nops = tree_code_length[(int) TREE_CODE (exp)];
3945: for (i = 0; i < nops; i++)
3946: if (TREE_OPERAND (exp, i) != 0
3947: && ! safe_from_p (x, TREE_OPERAND (exp, i)))
3948: return 0;
3949: }
3950:
3951: /* If we have an rtl, find any enclosed object. Then see if we conflict
3952: with it. */
3953: if (exp_rtl)
3954: {
3955: if (GET_CODE (exp_rtl) == SUBREG)
3956: {
3957: exp_rtl = SUBREG_REG (exp_rtl);
3958: if (GET_CODE (exp_rtl) == REG
3959: && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
3960: return 0;
3961: }
3962:
3963: /* If the rtl is X, then it is not safe. Otherwise, it is unless both
3964: are memory and EXP is not readonly. */
3965: return ! (rtx_equal_p (x, exp_rtl)
3966: || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
3967: && ! TREE_READONLY (exp)));
3968: }
3969:
3970: /* If we reach here, it is safe. */
3971: return 1;
3972: }
3973:
3974: /* Subroutine of expand_expr: return nonzero iff EXP is an
3975: expression whose type is statically determinable. */
3976:
3977: static int
3978: fixed_type_p (exp)
3979: tree exp;
3980: {
3981: if (TREE_CODE (exp) == PARM_DECL
3982: || TREE_CODE (exp) == VAR_DECL
3983: || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
3984: || TREE_CODE (exp) == COMPONENT_REF
3985: || TREE_CODE (exp) == ARRAY_REF)
3986: return 1;
3987: return 0;
3988: }
3989:
3990: /* expand_expr: generate code for computing expression EXP.
3991: An rtx for the computed value is returned. The value is never null.
3992: In the case of a void EXP, const0_rtx is returned.
3993:
3994: The value may be stored in TARGET if TARGET is nonzero.
3995: TARGET is just a suggestion; callers must assume that
3996: the rtx returned may not be the same as TARGET.
3997:
3998: If TARGET is CONST0_RTX, it means that the value will be ignored.
3999:
4000: If TMODE is not VOIDmode, it suggests generating the
4001: result in mode TMODE. But this is done only when convenient.
4002: Otherwise, TMODE is ignored and the value generated in its natural mode.
4003: TMODE is just a suggestion; callers must assume that
4004: the rtx returned may not have mode TMODE.
4005:
1.1.1.7 root 4006: Note that TARGET may have neither TMODE nor MODE. In that case, it
4007: probably will not be used.
1.1 root 4008:
4009: If MODIFIER is EXPAND_SUM then when EXP is an addition
4010: we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
4011: or a nest of (PLUS ...) and (MINUS ...) where the terms are
4012: products as above, or REG or MEM, or constant.
4013: Ordinarily in such cases we would output mul or add instructions
4014: and then return a pseudo reg containing the sum.
4015:
4016: EXPAND_INITIALIZER is much like EXPAND_SUM except that
4017: it also marks a label as absolutely required (it can't be dead).
1.1.1.4 root 4018: It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
1.1.1.7 root 4019: This is used for outputting expressions used in initializers.
4020:
4021: EXPAND_CONST_ADDRESS says that it is okay to return a MEM
4022: with a constant address even if that address is not normally legitimate.
4023: EXPAND_INITIALIZER and EXPAND_SUM also have this effect. */
1.1 root 4024:
4025: rtx
4026: expand_expr (exp, target, tmode, modifier)
4027: register tree exp;
4028: rtx target;
4029: enum machine_mode tmode;
4030: enum expand_modifier modifier;
4031: {
1.1.1.6 root 4032: /* Chain of pending expressions for PLACEHOLDER_EXPR to replace.
4033: This is static so it will be accessible to our recursive callees. */
4034: static tree placeholder_list = 0;
1.1 root 4035: register rtx op0, op1, temp;
4036: tree type = TREE_TYPE (exp);
4037: int unsignedp = TREE_UNSIGNED (type);
4038: register enum machine_mode mode = TYPE_MODE (type);
4039: register enum tree_code code = TREE_CODE (exp);
4040: optab this_optab;
4041: /* Use subtarget as the target for operand 0 of a binary operation. */
4042: rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
4043: rtx original_target = target;
1.1.1.6 root 4044: /* Maybe defer this until sure not doing bytecode? */
4045: int ignore = (target == const0_rtx
4046: || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4047: || code == CONVERT_EXPR || code == REFERENCE_EXPR
4048: || code == COND_EXPR)
4049: && TREE_CODE (type) == VOID_TYPE));
1.1 root 4050: tree context;
4051:
1.1.1.6 root 4052:
1.1.1.7 root 4053: if (output_bytecode && modifier != EXPAND_INITIALIZER)
1.1.1.6 root 4054: {
4055: bc_expand_expr (exp);
4056: return NULL;
4057: }
4058:
1.1 root 4059: /* Don't use hard regs as subtargets, because the combiner
4060: can only handle pseudo regs. */
4061: if (subtarget && REGNO (subtarget) < FIRST_PSEUDO_REGISTER)
4062: subtarget = 0;
4063: /* Avoid subtargets inside loops,
4064: since they hide some invariant expressions. */
4065: if (preserve_subexpressions_p ())
4066: subtarget = 0;
4067:
1.1.1.6 root 4068: /* If we are going to ignore this result, we need only do something
4069: if there is a side-effect somewhere in the expression. If there
4070: is, short-circuit the most common cases here. Note that we must
4071: not call expand_expr with anything but const0_rtx in case this
4072: is an initial expansion of a size that contains a PLACEHOLDER_EXPR. */
4073:
4074: if (ignore)
4075: {
4076: if (! TREE_SIDE_EFFECTS (exp))
4077: return const0_rtx;
4078:
4079: /* Ensure we reference a volatile object even if value is ignored. */
4080: if (TREE_THIS_VOLATILE (exp)
4081: && TREE_CODE (exp) != FUNCTION_DECL
4082: && mode != VOIDmode && mode != BLKmode)
4083: {
4084: temp = expand_expr (exp, NULL_RTX, VOIDmode, modifier);
4085: if (GET_CODE (temp) == MEM)
4086: temp = copy_to_reg (temp);
4087: return const0_rtx;
4088: }
4089:
4090: if (TREE_CODE_CLASS (code) == '1')
4091: return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
4092: VOIDmode, modifier);
4093: else if (TREE_CODE_CLASS (code) == '2'
4094: || TREE_CODE_CLASS (code) == '<')
4095: {
4096: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
4097: expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
4098: return const0_rtx;
4099: }
4100: else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
4101: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
4102: /* If the second operand has no side effects, just evaluate
4103: the first. */
4104: return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
4105: VOIDmode, modifier);
4106:
4107: target = 0;
4108: }
1.1 root 4109:
4110: /* If will do cse, generate all results into pseudo registers
4111: since 1) that allows cse to find more things
4112: and 2) otherwise cse could produce an insn the machine
4113: cannot support. */
4114:
4115: if (! cse_not_expected && mode != BLKmode && target
4116: && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
4117: target = subtarget;
4118:
4119: switch (code)
4120: {
4121: case LABEL_DECL:
1.1.1.3 root 4122: {
4123: tree function = decl_function_context (exp);
4124: /* Handle using a label in a containing function. */
4125: if (function != current_function_decl && function != 0)
4126: {
4127: struct function *p = find_function_data (function);
4128: /* Allocate in the memory associated with the function
4129: that the label is in. */
4130: push_obstacks (p->function_obstack,
4131: p->function_maybepermanent_obstack);
4132:
4133: p->forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
4134: label_rtx (exp), p->forced_labels);
4135: pop_obstacks ();
4136: }
4137: else if (modifier == EXPAND_INITIALIZER)
4138: forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
4139: label_rtx (exp), forced_labels);
1.1.1.4 root 4140: temp = gen_rtx (MEM, FUNCTION_MODE,
1.1.1.3 root 4141: gen_rtx (LABEL_REF, Pmode, label_rtx (exp)));
1.1.1.4 root 4142: if (function != current_function_decl && function != 0)
4143: LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
4144: return temp;
1.1.1.3 root 4145: }
1.1 root 4146:
4147: case PARM_DECL:
4148: if (DECL_RTL (exp) == 0)
4149: {
4150: error_with_decl (exp, "prior parameter's size depends on `%s'");
1.1.1.3 root 4151: return CONST0_RTX (mode);
1.1 root 4152: }
4153:
1.1.1.7 root 4154: /* ... fall through ... */
4155:
1.1 root 4156: case VAR_DECL:
1.1.1.6 root 4157: /* If a static var's type was incomplete when the decl was written,
4158: but the type is complete now, lay out the decl now. */
4159: if (DECL_SIZE (exp) == 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0
4160: && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
4161: {
4162: push_obstacks_nochange ();
4163: end_temporary_allocation ();
4164: layout_decl (exp, 0);
4165: PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
4166: pop_obstacks ();
4167: }
1.1.1.7 root 4168:
4169: /* ... fall through ... */
4170:
1.1.1.6 root 4171: case FUNCTION_DECL:
1.1 root 4172: case RESULT_DECL:
4173: if (DECL_RTL (exp) == 0)
4174: abort ();
1.1.1.7 root 4175:
1.1.1.6 root 4176: /* Ensure variable marked as used even if it doesn't go through
4177: a parser. If it hasn't be used yet, write out an external
4178: definition. */
4179: if (! TREE_USED (exp))
4180: {
4181: assemble_external (exp);
4182: TREE_USED (exp) = 1;
4183: }
4184:
1.1 root 4185: /* Handle variables inherited from containing functions. */
4186: context = decl_function_context (exp);
4187:
4188: /* We treat inline_function_decl as an alias for the current function
4189: because that is the inline function whose vars, types, etc.
4190: are being merged into the current function.
4191: See expand_inline_function. */
1.1.1.7 root 4192:
1.1 root 4193: if (context != 0 && context != current_function_decl
4194: && context != inline_function_decl
4195: /* If var is static, we don't need a static chain to access it. */
4196: && ! (GET_CODE (DECL_RTL (exp)) == MEM
4197: && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
4198: {
4199: rtx addr;
4200:
4201: /* Mark as non-local and addressable. */
1.1.1.4 root 4202: DECL_NONLOCAL (exp) = 1;
1.1 root 4203: mark_addressable (exp);
4204: if (GET_CODE (DECL_RTL (exp)) != MEM)
4205: abort ();
4206: addr = XEXP (DECL_RTL (exp), 0);
4207: if (GET_CODE (addr) == MEM)
1.1.1.7 root 4208: addr = gen_rtx (MEM, Pmode,
4209: fix_lexical_addr (XEXP (addr, 0), exp));
1.1 root 4210: else
4211: addr = fix_lexical_addr (addr, exp);
4212: return change_address (DECL_RTL (exp), mode, addr);
4213: }
1.1.1.3 root 4214:
1.1 root 4215: /* This is the case of an array whose size is to be determined
4216: from its initializer, while the initializer is still being parsed.
4217: See expand_decl. */
1.1.1.7 root 4218:
1.1 root 4219: if (GET_CODE (DECL_RTL (exp)) == MEM
4220: && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
4221: return change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
4222: XEXP (DECL_RTL (exp), 0));
1.1.1.7 root 4223:
4224: /* If DECL_RTL is memory, we are in the normal case and either
4225: the address is not valid or it is not a register and -fforce-addr
4226: is specified, get the address into a register. */
4227:
1.1 root 4228: if (GET_CODE (DECL_RTL (exp)) == MEM
4229: && modifier != EXPAND_CONST_ADDRESS
4230: && modifier != EXPAND_SUM
1.1.1.7 root 4231: && modifier != EXPAND_INITIALIZER
4232: && (! memory_address_p (DECL_MODE (exp), XEXP (DECL_RTL (exp), 0))
1.1 root 4233: || (flag_force_addr
1.1.1.7 root 4234: && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
4235: return change_address (DECL_RTL (exp), VOIDmode,
4236: copy_rtx (XEXP (DECL_RTL (exp), 0)));
1.1.1.4 root 4237:
4238: /* If the mode of DECL_RTL does not match that of the decl, it
4239: must be a promoted value. We return a SUBREG of the wanted mode,
4240: but mark it so that we know that it was already extended. */
4241:
4242: if (GET_CODE (DECL_RTL (exp)) == REG
4243: && GET_MODE (DECL_RTL (exp)) != mode)
4244: {
4245: /* Get the signedness used for this variable. Ensure we get the
4246: same mode we got when the variable was declared. */
1.1.1.7 root 4247: if (GET_MODE (DECL_RTL (exp))
4248: != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
1.1.1.4 root 4249: abort ();
4250:
4251: temp = gen_rtx (SUBREG, mode, DECL_RTL (exp), 0);
4252: SUBREG_PROMOTED_VAR_P (temp) = 1;
4253: SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
4254: return temp;
4255: }
4256:
1.1 root 4257: return DECL_RTL (exp);
4258:
4259: case INTEGER_CST:
4260: return immed_double_const (TREE_INT_CST_LOW (exp),
4261: TREE_INT_CST_HIGH (exp),
4262: mode);
4263:
4264: case CONST_DECL:
4265: return expand_expr (DECL_INITIAL (exp), target, VOIDmode, 0);
4266:
4267: case REAL_CST:
4268: /* If optimized, generate immediate CONST_DOUBLE
4269: which will be turned into memory by reload if necessary.
4270:
4271: We used to force a register so that loop.c could see it. But
4272: this does not allow gen_* patterns to perform optimizations with
4273: the constants. It also produces two insns in cases like "x = 1.0;".
4274: On most machines, floating-point constants are not permitted in
4275: many insns, so we'd end up copying it to a register in any case.
4276:
4277: Now, we do the copying in expand_binop, if appropriate. */
4278: return immed_real_const (exp);
4279:
4280: case COMPLEX_CST:
4281: case STRING_CST:
4282: if (! TREE_CST_RTL (exp))
4283: output_constant_def (exp);
4284:
4285: /* TREE_CST_RTL probably contains a constant address.
4286: On RISC machines where a constant address isn't valid,
4287: make some insns to get that address into a register. */
4288: if (GET_CODE (TREE_CST_RTL (exp)) == MEM
4289: && modifier != EXPAND_CONST_ADDRESS
4290: && modifier != EXPAND_INITIALIZER
4291: && modifier != EXPAND_SUM
1.1.1.7 root 4292: && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
4293: || (flag_force_addr
4294: && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
1.1 root 4295: return change_address (TREE_CST_RTL (exp), VOIDmode,
4296: copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
4297: return TREE_CST_RTL (exp);
4298:
4299: case SAVE_EXPR:
4300: context = decl_function_context (exp);
1.1.1.7 root 4301:
1.1 root 4302: /* We treat inline_function_decl as an alias for the current function
4303: because that is the inline function whose vars, types, etc.
4304: are being merged into the current function.
4305: See expand_inline_function. */
4306: if (context == current_function_decl || context == inline_function_decl)
4307: context = 0;
4308:
4309: /* If this is non-local, handle it. */
4310: if (context)
4311: {
4312: temp = SAVE_EXPR_RTL (exp);
4313: if (temp && GET_CODE (temp) == REG)
4314: {
4315: put_var_into_stack (exp);
4316: temp = SAVE_EXPR_RTL (exp);
4317: }
4318: if (temp == 0 || GET_CODE (temp) != MEM)
4319: abort ();
4320: return change_address (temp, mode,
4321: fix_lexical_addr (XEXP (temp, 0), exp));
4322: }
4323: if (SAVE_EXPR_RTL (exp) == 0)
4324: {
4325: if (mode == BLKmode)
1.1.1.6 root 4326: {
4327: temp
4328: = assign_stack_temp (mode, int_size_in_bytes (type), 0);
1.1.1.7 root 4329: MEM_IN_STRUCT_P (temp) = AGGREGATE_TYPE_P (type);
1.1.1.6 root 4330: }
1.1.1.8 root 4331: else if (mode == VOIDmode)
4332: temp = const0_rtx;
1.1 root 4333: else
1.1.1.7 root 4334: temp = gen_reg_rtx (promote_mode (type, mode, &unsignedp, 0));
1.1.1.4 root 4335:
1.1 root 4336: SAVE_EXPR_RTL (exp) = temp;
4337: if (!optimize && GET_CODE (temp) == REG)
4338: save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, temp,
4339: save_expr_regs);
1.1.1.5 root 4340:
4341: /* If the mode of TEMP does not match that of the expression, it
4342: must be a promoted value. We pass store_expr a SUBREG of the
4343: wanted mode but mark it so that we know that it was already
4344: extended. Note that `unsignedp' was modified above in
4345: this case. */
4346:
4347: if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
4348: {
4349: temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
4350: SUBREG_PROMOTED_VAR_P (temp) = 1;
4351: SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
4352: }
4353:
1.1.1.8 root 4354: if (temp == const0_rtx)
4355: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
4356: else
4357: store_expr (TREE_OPERAND (exp, 0), temp, 0);
1.1 root 4358: }
1.1.1.4 root 4359:
4360: /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
4361: must be a promoted value. We return a SUBREG of the wanted mode,
1.1.1.6 root 4362: but mark it so that we know that it was already extended. */
1.1.1.4 root 4363:
4364: if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
4365: && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
4366: {
1.1.1.7 root 4367: /* Compute the signedness and make the proper SUBREG. */
4368: promote_mode (type, mode, &unsignedp, 0);
1.1.1.4 root 4369: temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
4370: SUBREG_PROMOTED_VAR_P (temp) = 1;
4371: SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
4372: return temp;
4373: }
4374:
1.1 root 4375: return SAVE_EXPR_RTL (exp);
4376:
1.1.1.6 root 4377: case PLACEHOLDER_EXPR:
4378: /* If there is an object on the head of the placeholder list,
4379: see if some object in it's references is of type TYPE. For
4380: further information, see tree.def. */
4381: if (placeholder_list)
4382: {
4383: tree object;
4384: tree old_list = placeholder_list;
4385:
4386: for (object = TREE_PURPOSE (placeholder_list);
1.1.1.8 root 4387: (TYPE_MAIN_VARIANT (TREE_TYPE (object))
4388: != TYPE_MAIN_VARIANT (type))
1.1.1.6 root 4389: && (TREE_CODE_CLASS (TREE_CODE (object)) == 'r'
4390: || TREE_CODE_CLASS (TREE_CODE (object)) == '1'
4391: || TREE_CODE_CLASS (TREE_CODE (object)) == '2'
4392: || TREE_CODE_CLASS (TREE_CODE (object)) == 'e');
4393: object = TREE_OPERAND (object, 0))
4394: ;
4395:
1.1.1.8 root 4396: if (object != 0
4397: && (TYPE_MAIN_VARIANT (TREE_TYPE (object))
4398: == TYPE_MAIN_VARIANT (type)))
1.1.1.6 root 4399: {
4400: /* Expand this object skipping the list entries before
4401: it was found in case it is also a PLACEHOLDER_EXPR.
4402: In that case, we want to translate it using subsequent
4403: entries. */
4404: placeholder_list = TREE_CHAIN (placeholder_list);
4405: temp = expand_expr (object, original_target, tmode, modifier);
4406: placeholder_list = old_list;
4407: return temp;
4408: }
4409: }
4410:
4411: /* We can't find the object or there was a missing WITH_RECORD_EXPR. */
4412: abort ();
4413:
4414: case WITH_RECORD_EXPR:
4415: /* Put the object on the placeholder list, expand our first operand,
4416: and pop the list. */
4417: placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
4418: placeholder_list);
4419: target = expand_expr (TREE_OPERAND (exp, 0), original_target,
4420: tmode, modifier);
4421: placeholder_list = TREE_CHAIN (placeholder_list);
4422: return target;
4423:
1.1 root 4424: case EXIT_EXPR:
1.1.1.6 root 4425: expand_exit_loop_if_false (NULL_PTR,
4426: invert_truthvalue (TREE_OPERAND (exp, 0)));
1.1 root 4427: return const0_rtx;
4428:
4429: case LOOP_EXPR:
1.1.1.6 root 4430: push_temp_slots ();
1.1 root 4431: expand_start_loop (1);
4432: expand_expr_stmt (TREE_OPERAND (exp, 0));
4433: expand_end_loop ();
1.1.1.6 root 4434: pop_temp_slots ();
1.1 root 4435:
4436: return const0_rtx;
4437:
4438: case BIND_EXPR:
4439: {
4440: tree vars = TREE_OPERAND (exp, 0);
4441: int vars_need_expansion = 0;
4442:
4443: /* Need to open a binding contour here because
4444: if there are any cleanups they most be contained here. */
4445: expand_start_bindings (0);
4446:
1.1.1.4 root 4447: /* Mark the corresponding BLOCK for output in its proper place. */
4448: if (TREE_OPERAND (exp, 2) != 0
4449: && ! TREE_USED (TREE_OPERAND (exp, 2)))
4450: insert_block (TREE_OPERAND (exp, 2));
1.1 root 4451:
4452: /* If VARS have not yet been expanded, expand them now. */
4453: while (vars)
4454: {
4455: if (DECL_RTL (vars) == 0)
4456: {
4457: vars_need_expansion = 1;
4458: expand_decl (vars);
4459: }
4460: expand_decl_init (vars);
4461: vars = TREE_CHAIN (vars);
4462: }
4463:
4464: temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, modifier);
4465:
4466: expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
4467:
4468: return temp;
4469: }
4470:
4471: case RTL_EXPR:
4472: if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
4473: abort ();
4474: emit_insns (RTL_EXPR_SEQUENCE (exp));
4475: RTL_EXPR_SEQUENCE (exp) = const0_rtx;
1.1.1.6 root 4476: preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
4477: free_temps_for_rtl_expr (exp);
1.1 root 4478: return RTL_EXPR_RTL (exp);
4479:
4480: case CONSTRUCTOR:
1.1.1.6 root 4481: /* If we don't need the result, just ensure we evaluate any
4482: subexpressions. */
4483: if (ignore)
4484: {
4485: tree elt;
4486: for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4487: expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode, 0);
4488: return const0_rtx;
4489: }
1.1.1.7 root 4490:
1.1.1.3 root 4491: /* All elts simple constants => refer to a constant in memory. But
4492: if this is a non-BLKmode mode, let it store a field at a time
4493: since that should make a CONST_INT or CONST_DOUBLE when we
1.1.1.7 root 4494: fold. Likewise, if we have a target we can use, it is best to
4495: store directly into the target unless the type is large enough
4496: that memcpy will be used. If we are making an initializer and
4497: all operands are constant, put it in memory as well. */
1.1.1.6 root 4498: else if ((TREE_STATIC (exp)
1.1.1.7 root 4499: && ((mode == BLKmode
4500: && ! (target != 0 && safe_from_p (target, exp)))
4501: || TREE_ADDRESSABLE (exp)
4502: || (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4503: && (move_by_pieces_ninsns
1.1.1.8 root 4504: (TREE_INT_CST_LOW (TYPE_SIZE (type))/BITS_PER_UNIT,
4505: TYPE_ALIGN (type) / BITS_PER_UNIT)
1.1.1.7 root 4506: > MOVE_RATIO))))
1.1.1.6 root 4507: || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
1.1 root 4508: {
4509: rtx constructor = output_constant_def (exp);
1.1.1.3 root 4510: if (modifier != EXPAND_CONST_ADDRESS
4511: && modifier != EXPAND_INITIALIZER
4512: && modifier != EXPAND_SUM
1.1.1.7 root 4513: && (! memory_address_p (GET_MODE (constructor),
4514: XEXP (constructor, 0))
4515: || (flag_force_addr
4516: && GET_CODE (XEXP (constructor, 0)) != REG)))
1.1 root 4517: constructor = change_address (constructor, VOIDmode,
4518: XEXP (constructor, 0));
4519: return constructor;
4520: }
4521:
4522: else
4523: {
4524: if (target == 0 || ! safe_from_p (target, exp))
4525: {
4526: if (mode != BLKmode && ! TREE_ADDRESSABLE (exp))
1.1.1.7 root 4527: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
1.1 root 4528: else
4529: {
1.1.1.5 root 4530: target
4531: = assign_stack_temp (mode, int_size_in_bytes (type), 0);
1.1.1.7 root 4532: if (AGGREGATE_TYPE_P (type))
1.1.1.5 root 4533: MEM_IN_STRUCT_P (target) = 1;
1.1 root 4534: }
4535: }
4536: store_constructor (exp, target);
4537: return target;
4538: }
4539:
4540: case INDIRECT_REF:
4541: {
4542: tree exp1 = TREE_OPERAND (exp, 0);
4543: tree exp2;
4544:
4545: /* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated
4546: for *PTR += ANYTHING where PTR is put inside the SAVE_EXPR.
4547: This code has the same general effect as simply doing
4548: expand_expr on the save expr, except that the expression PTR
4549: is computed for use as a memory address. This means different
4550: code, suitable for indexing, may be generated. */
4551: if (TREE_CODE (exp1) == SAVE_EXPR
4552: && SAVE_EXPR_RTL (exp1) == 0
1.1.1.8 root 4553: && TYPE_MODE (TREE_TYPE (exp1)) == ptr_mode)
1.1 root 4554: {
1.1.1.4 root 4555: temp = expand_expr (TREE_OPERAND (exp1, 0), NULL_RTX,
4556: VOIDmode, EXPAND_SUM);
1.1 root 4557: op0 = memory_address (mode, temp);
4558: op0 = copy_all_regs (op0);
4559: SAVE_EXPR_RTL (exp1) = op0;
4560: }
4561: else
4562: {
1.1.1.4 root 4563: op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
1.1 root 4564: op0 = memory_address (mode, op0);
4565: }
1.1.1.3 root 4566:
4567: temp = gen_rtx (MEM, mode, op0);
4568: /* If address was computed by addition,
4569: mark this as an element of an aggregate. */
4570: if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
4571: || (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR
4572: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == PLUS_EXPR)
1.1.1.7 root 4573: || AGGREGATE_TYPE_P (TREE_TYPE (exp))
1.1.1.3 root 4574: || (TREE_CODE (exp1) == ADDR_EXPR
4575: && (exp2 = TREE_OPERAND (exp1, 0))
1.1.1.7 root 4576: && AGGREGATE_TYPE_P (TREE_TYPE (exp2))))
1.1.1.3 root 4577: MEM_IN_STRUCT_P (temp) = 1;
1.1.1.6 root 4578: MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) | flag_volatile;
1.1.1.8 root 4579:
4580: /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
4581: here, because, in C and C++, the fact that a location is accessed
4582: through a pointer to const does not mean that the value there can
4583: never change. Languages where it can never change should
4584: also set TREE_STATIC. */
1.1.1.9 ! root 4585: RTX_UNCHANGING_P (temp) = TREE_READONLY (exp) & TREE_STATIC (exp);
1.1.1.3 root 4586: return temp;
4587: }
1.1 root 4588:
4589: case ARRAY_REF:
1.1.1.5 root 4590: if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
4591: abort ();
1.1 root 4592:
4593: {
1.1.1.5 root 4594: tree array = TREE_OPERAND (exp, 0);
4595: tree domain = TYPE_DOMAIN (TREE_TYPE (array));
4596: tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
4597: tree index = TREE_OPERAND (exp, 1);
4598: tree index_type = TREE_TYPE (index);
1.1 root 4599: int i;
4600:
1.1.1.6 root 4601: if (TREE_CODE (low_bound) != INTEGER_CST
4602: && contains_placeholder_p (low_bound))
4603: low_bound = build (WITH_RECORD_EXPR, sizetype, low_bound, exp);
4604:
4605: /* Optimize the special-case of a zero lower bound.
4606:
4607: We convert the low_bound to sizetype to avoid some problems
4608: with constant folding. (E.g. suppose the lower bound is 1,
4609: and its mode is QI. Without the conversion, (ARRAY
4610: +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
4611: +INDEX), which becomes (ARRAY+255+INDEX). Oops!)
4612:
4613: But sizetype isn't quite right either (especially if
4614: the lowbound is negative). FIXME */
4615:
1.1.1.5 root 4616: if (! integer_zerop (low_bound))
1.1.1.6 root 4617: index = fold (build (MINUS_EXPR, index_type, index,
4618: convert (sizetype, low_bound)));
1.1.1.5 root 4619:
1.1.1.7 root 4620: if ((TREE_CODE (index) != INTEGER_CST
4621: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1.1.1.8 root 4622: && (! SLOW_UNALIGNED_ACCESS || ! get_inner_unaligned_p (exp)))
1.1.1.5 root 4623: {
1.1.1.7 root 4624: /* Nonconstant array index or nonconstant element size, and
4625: not an array in an unaligned (packed) structure field.
1.1.1.5 root 4626: Generate the tree for *(&array+index) and expand that,
4627: except do it in a language-independent way
4628: and don't complain about non-lvalue arrays.
4629: `mark_addressable' should already have been called
4630: for any array for which this case will be reached. */
4631:
4632: /* Don't forget the const or volatile flag from the array
4633: element. */
4634: tree variant_type = build_type_variant (type,
4635: TREE_READONLY (exp),
4636: TREE_THIS_VOLATILE (exp));
4637: tree array_adr = build1 (ADDR_EXPR,
4638: build_pointer_type (variant_type), array);
4639: tree elt;
1.1.1.6 root 4640: tree size = size_in_bytes (type);
1.1.1.5 root 4641:
1.1.1.8 root 4642: /* Convert the integer argument to a type the same size as sizetype
4643: so the multiply won't overflow spuriously. */
4644: if (TYPE_PRECISION (index_type) != TYPE_PRECISION (sizetype))
4645: index = convert (type_for_size (TYPE_PRECISION (sizetype), 0),
4646: index);
1.1.1.5 root 4647:
1.1.1.6 root 4648: if (TREE_CODE (size) != INTEGER_CST
4649: && contains_placeholder_p (size))
4650: size = build (WITH_RECORD_EXPR, sizetype, size, exp);
4651:
1.1.1.5 root 4652: /* Don't think the address has side effects
4653: just because the array does.
4654: (In some cases the address might have side effects,
4655: and we fail to record that fact here. However, it should not
4656: matter, since expand_expr should not care.) */
4657: TREE_SIDE_EFFECTS (array_adr) = 0;
4658:
1.1.1.8 root 4659: elt
4660: = build1
4661: (INDIRECT_REF, type,
4662: fold (build (PLUS_EXPR,
4663: TYPE_POINTER_TO (variant_type),
4664: array_adr,
4665: fold
4666: (build1
4667: (NOP_EXPR,
4668: TYPE_POINTER_TO (variant_type),
4669: fold (build (MULT_EXPR, TREE_TYPE (index),
4670: index,
4671: convert (TREE_TYPE (index),
4672: size))))))));;
1.1.1.5 root 4673:
4674: /* Volatility, etc., of new expression is same as old
4675: expression. */
4676: TREE_SIDE_EFFECTS (elt) = TREE_SIDE_EFFECTS (exp);
4677: TREE_THIS_VOLATILE (elt) = TREE_THIS_VOLATILE (exp);
4678: TREE_READONLY (elt) = TREE_READONLY (exp);
4679:
4680: return expand_expr (elt, target, tmode, modifier);
4681: }
4682:
4683: /* Fold an expression like: "foo"[2].
1.1.1.7 root 4684: This is not done in fold so it won't happen inside &.
4685: Don't fold if this is for wide characters since it's too
4686: difficult to do correctly and this is a very rare case. */
1.1.1.5 root 4687:
4688: if (TREE_CODE (array) == STRING_CST
4689: && TREE_CODE (index) == INTEGER_CST
4690: && !TREE_INT_CST_HIGH (index)
1.1.1.7 root 4691: && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (array)
4692: && GET_MODE_CLASS (mode) == MODE_INT
4693: && GET_MODE_SIZE (mode) == 1)
4694: return GEN_INT (TREE_STRING_POINTER (array)[i]);
1.1 root 4695:
1.1.1.5 root 4696: /* If this is a constant index into a constant array,
4697: just get the value from the array. Handle both the cases when
4698: we have an explicit constructor and when our operand is a variable
4699: that was declared const. */
1.1.1.3 root 4700:
1.1.1.5 root 4701: if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array))
4702: {
4703: if (TREE_CODE (index) == INTEGER_CST
4704: && TREE_INT_CST_HIGH (index) == 0)
4705: {
4706: tree elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
1.1 root 4707:
1.1.1.5 root 4708: i = TREE_INT_CST_LOW (index);
4709: while (elem && i--)
4710: elem = TREE_CHAIN (elem);
4711: if (elem)
4712: return expand_expr (fold (TREE_VALUE (elem)), target,
4713: tmode, modifier);
4714: }
4715: }
1.1.1.3 root 4716:
1.1.1.5 root 4717: else if (optimize >= 1
4718: && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
4719: && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
4720: && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
4721: {
4722: if (TREE_CODE (index) == INTEGER_CST
4723: && TREE_INT_CST_HIGH (index) == 0)
4724: {
4725: tree init = DECL_INITIAL (array);
1.1.1.3 root 4726:
1.1.1.5 root 4727: i = TREE_INT_CST_LOW (index);
4728: if (TREE_CODE (init) == CONSTRUCTOR)
4729: {
4730: tree elem = CONSTRUCTOR_ELTS (init);
4731:
1.1.1.6 root 4732: while (elem
4733: && !tree_int_cst_equal (TREE_PURPOSE (elem), index))
1.1.1.5 root 4734: elem = TREE_CHAIN (elem);
4735: if (elem)
4736: return expand_expr (fold (TREE_VALUE (elem)), target,
4737: tmode, modifier);
4738: }
4739: else if (TREE_CODE (init) == STRING_CST
4740: && i < TREE_STRING_LENGTH (init))
1.1.1.7 root 4741: return GEN_INT (TREE_STRING_POINTER (init)[i]);
1.1.1.5 root 4742: }
4743: }
4744: }
1.1.1.3 root 4745:
1.1 root 4746: /* Treat array-ref with constant index as a component-ref. */
4747:
4748: case COMPONENT_REF:
4749: case BIT_FIELD_REF:
1.1.1.3 root 4750: /* If the operand is a CONSTRUCTOR, we can just extract the
1.1.1.7 root 4751: appropriate field if it is present. Don't do this if we have
4752: already written the data since we want to refer to that copy
4753: and varasm.c assumes that's what we'll do. */
1.1.1.3 root 4754: if (code != ARRAY_REF
1.1.1.7 root 4755: && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
4756: && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
1.1.1.3 root 4757: {
4758: tree elt;
4759:
4760: for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
4761: elt = TREE_CHAIN (elt))
4762: if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
4763: return expand_expr (TREE_VALUE (elt), target, tmode, modifier);
4764: }
4765:
1.1 root 4766: {
4767: enum machine_mode mode1;
4768: int bitsize;
4769: int bitpos;
1.1.1.3 root 4770: tree offset;
1.1 root 4771: int volatilep = 0;
1.1.1.3 root 4772: tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
1.1 root 4773: &mode1, &unsignedp, &volatilep);
1.1.1.6 root 4774: int alignment;
1.1 root 4775:
1.1.1.5 root 4776: /* If we got back the original object, something is wrong. Perhaps
4777: we are evaluating an expression too early. In any event, don't
4778: infinitely recurse. */
4779: if (tem == exp)
4780: abort ();
4781:
1.1 root 4782: /* In some cases, we will be offsetting OP0's address by a constant.
4783: So get it as a sum, if possible. If we will be using it
1.1.1.8 root 4784: directly in an insn, we validate it.
4785:
4786: If TEM's type is a union of variable size, pass TARGET to the inner
4787: computation, since it will need a temporary and TARGET is known
4788: to have to do. This occurs in unchecked conversion in Ada. */
4789:
4790: op0 = expand_expr (tem,
4791: (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
4792: && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
4793: != INTEGER_CST)
4794: ? target : NULL_RTX),
4795: VOIDmode, EXPAND_SUM);
1.1 root 4796:
1.1.1.3 root 4797: /* If this is a constant, put it into a register if it is a
1.1.1.5 root 4798: legitimate constant and memory if it isn't. */
1.1.1.3 root 4799: if (CONSTANT_P (op0))
4800: {
4801: enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
1.1.1.5 root 4802: if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0))
1.1.1.3 root 4803: op0 = force_reg (mode, op0);
4804: else
4805: op0 = validize_mem (force_const_mem (mode, op0));
4806: }
4807:
1.1.1.6 root 4808: alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
1.1.1.3 root 4809: if (offset != 0)
4810: {
1.1.1.4 root 4811: rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
1.1.1.3 root 4812:
4813: if (GET_CODE (op0) != MEM)
4814: abort ();
4815: op0 = change_address (op0, VOIDmode,
1.1.1.8 root 4816: gen_rtx (PLUS, ptr_mode, XEXP (op0, 0),
4817: force_reg (ptr_mode, offset_rtx)));
1.1.1.6 root 4818: /* If we have a variable offset, the known alignment
4819: is only that of the innermost structure containing the field.
4820: (Actually, we could sometimes do better by using the
4821: size of an element of the innermost array, but no need.) */
4822: if (TREE_CODE (exp) == COMPONENT_REF
4823: || TREE_CODE (exp) == BIT_FIELD_REF)
4824: alignment = (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
4825: / BITS_PER_UNIT);
1.1.1.3 root 4826: }
4827:
1.1 root 4828: /* Don't forget about volatility even if this is a bitfield. */
4829: if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
4830: {
4831: op0 = copy_rtx (op0);
4832: MEM_VOLATILE_P (op0) = 1;
4833: }
4834:
1.1.1.6 root 4835: /* In cases where an aligned union has an unaligned object
4836: as a field, we might be extracting a BLKmode value from
4837: an integer-mode (e.g., SImode) object. Handle this case
4838: by doing the extract into an object as wide as the field
4839: (which we know to be the width of a basic mode), then
4840: storing into memory, and changing the mode to BLKmode. */
1.1 root 4841: if (mode1 == VOIDmode
1.1.1.6 root 4842: || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
1.1.1.8 root 4843: || (modifier != EXPAND_CONST_ADDRESS
4844: && modifier != EXPAND_SUM
4845: && modifier != EXPAND_INITIALIZER
4846: && ((mode1 != BLKmode && ! direct_load[(int) mode1])
4847: /* If the field isn't aligned enough to fetch as a memref,
4848: fetch it as a bit field. */
4849: || (SLOW_UNALIGNED_ACCESS
4850: && ((TYPE_ALIGN (TREE_TYPE (tem)) < GET_MODE_ALIGNMENT (mode))
4851: || (bitpos % GET_MODE_ALIGNMENT (mode) != 0))))))
1.1 root 4852: {
4853: enum machine_mode ext_mode = mode;
4854:
4855: if (ext_mode == BLKmode)
4856: ext_mode = mode_for_size (bitsize, MODE_INT, 1);
4857:
4858: if (ext_mode == BLKmode)
4859: abort ();
4860:
4861: op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
4862: unsignedp, target, ext_mode, ext_mode,
1.1.1.6 root 4863: alignment,
1.1 root 4864: int_size_in_bytes (TREE_TYPE (tem)));
4865: if (mode == BLKmode)
4866: {
4867: rtx new = assign_stack_temp (ext_mode,
4868: bitsize / BITS_PER_UNIT, 0);
4869:
4870: emit_move_insn (new, op0);
4871: op0 = copy_rtx (new);
4872: PUT_MODE (op0, BLKmode);
1.1.1.6 root 4873: MEM_IN_STRUCT_P (op0) = 1;
1.1 root 4874: }
4875:
4876: return op0;
4877: }
4878:
4879: /* Get a reference to just this component. */
4880: if (modifier == EXPAND_CONST_ADDRESS
4881: || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
4882: op0 = gen_rtx (MEM, mode1, plus_constant (XEXP (op0, 0),
4883: (bitpos / BITS_PER_UNIT)));
4884: else
4885: op0 = change_address (op0, mode1,
4886: plus_constant (XEXP (op0, 0),
4887: (bitpos / BITS_PER_UNIT)));
4888: MEM_IN_STRUCT_P (op0) = 1;
4889: MEM_VOLATILE_P (op0) |= volatilep;
4890: if (mode == mode1 || mode1 == BLKmode || mode1 == tmode)
4891: return op0;
4892: if (target == 0)
4893: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
4894: convert_move (target, op0, unsignedp);
4895: return target;
4896: }
4897:
4898: case OFFSET_REF:
4899: {
1.1.1.5 root 4900: tree base = build1 (ADDR_EXPR, type, TREE_OPERAND (exp, 0));
1.1 root 4901: tree addr = build (PLUS_EXPR, type, base, TREE_OPERAND (exp, 1));
1.1.1.4 root 4902: op0 = expand_expr (addr, NULL_RTX, VOIDmode, EXPAND_SUM);
1.1 root 4903: temp = gen_rtx (MEM, mode, memory_address (mode, op0));
4904: MEM_IN_STRUCT_P (temp) = 1;
1.1.1.5 root 4905: MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp);
4906: #if 0 /* It is incorrect to set RTX_UNCHANGING_P here, because the fact that
1.1 root 4907: a location is accessed through a pointer to const does not mean
4908: that the value there can never change. */
4909: RTX_UNCHANGING_P (temp) = TREE_READONLY (exp);
4910: #endif
4911: return temp;
4912: }
4913:
4914: /* Intended for a reference to a buffer of a file-object in Pascal.
4915: But it's not certain that a special tree code will really be
4916: necessary for these. INDIRECT_REF might work for them. */
4917: case BUFFER_REF:
4918: abort ();
4919:
1.1.1.4 root 4920: case IN_EXPR:
4921: {
1.1.1.7 root 4922: /* Pascal set IN expression.
4923:
4924: Algorithm:
4925: rlo = set_low - (set_low%bits_per_word);
4926: the_word = set [ (index - rlo)/bits_per_word ];
4927: bit_index = index % bits_per_word;
4928: bitmask = 1 << bit_index;
4929: return !!(the_word & bitmask); */
4930:
1.1.1.4 root 4931: tree set = TREE_OPERAND (exp, 0);
4932: tree index = TREE_OPERAND (exp, 1);
1.1.1.7 root 4933: int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
1.1.1.4 root 4934: tree set_type = TREE_TYPE (set);
4935: tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
4936: tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
1.1.1.7 root 4937: rtx index_val = expand_expr (index, 0, VOIDmode, 0);
4938: rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
4939: rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
4940: rtx setval = expand_expr (set, 0, VOIDmode, 0);
4941: rtx setaddr = XEXP (setval, 0);
4942: enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
1.1.1.4 root 4943: rtx rlow;
4944: rtx diff, quo, rem, addr, bit, result;
4945:
1.1.1.7 root 4946: preexpand_calls (exp);
1.1.1.4 root 4947:
1.1.1.7 root 4948: /* If domain is empty, answer is no. Likewise if index is constant
4949: and out of bounds. */
4950: if ((TREE_CODE (set_high_bound) == INTEGER_CST
4951: && TREE_CODE (set_low_bound) == INTEGER_CST
4952: && tree_int_cst_lt (set_high_bound, set_low_bound)
4953: || (TREE_CODE (index) == INTEGER_CST
4954: && TREE_CODE (set_low_bound) == INTEGER_CST
4955: && tree_int_cst_lt (index, set_low_bound))
4956: || (TREE_CODE (set_high_bound) == INTEGER_CST
4957: && TREE_CODE (index) == INTEGER_CST
4958: && tree_int_cst_lt (set_high_bound, index))))
1.1.1.4 root 4959: return const0_rtx;
4960:
1.1.1.7 root 4961: if (target == 0)
4962: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
1.1.1.4 root 4963:
4964: /* If we get here, we have to generate the code for both cases
4965: (in range and out of range). */
4966:
4967: op0 = gen_label_rtx ();
4968: op1 = gen_label_rtx ();
4969:
4970: if (! (GET_CODE (index_val) == CONST_INT
4971: && GET_CODE (lo_r) == CONST_INT))
4972: {
1.1.1.5 root 4973: emit_cmp_insn (index_val, lo_r, LT, NULL_RTX,
1.1.1.7 root 4974: GET_MODE (index_val), iunsignedp, 0);
1.1.1.4 root 4975: emit_jump_insn (gen_blt (op1));
4976: }
4977:
4978: if (! (GET_CODE (index_val) == CONST_INT
4979: && GET_CODE (hi_r) == CONST_INT))
4980: {
1.1.1.5 root 4981: emit_cmp_insn (index_val, hi_r, GT, NULL_RTX,
1.1.1.7 root 4982: GET_MODE (index_val), iunsignedp, 0);
1.1.1.4 root 4983: emit_jump_insn (gen_bgt (op1));
4984: }
4985:
4986: /* Calculate the element number of bit zero in the first word
4987: of the set. */
4988: if (GET_CODE (lo_r) == CONST_INT)
1.1.1.5 root 4989: rlow = GEN_INT (INTVAL (lo_r)
4990: & ~ ((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
1.1.1.4 root 4991: else
1.1.1.5 root 4992: rlow = expand_binop (index_mode, and_optab, lo_r,
4993: GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
1.1.1.7 root 4994: NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
1.1.1.4 root 4995:
1.1.1.7 root 4996: diff = expand_binop (index_mode, sub_optab, index_val, rlow,
4997: NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
1.1.1.4 root 4998:
4999: quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
1.1.1.7 root 5000: GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
1.1.1.4 root 5001: rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
1.1.1.7 root 5002: GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
5003:
1.1.1.4 root 5004: addr = memory_address (byte_mode,
1.1.1.7 root 5005: expand_binop (index_mode, add_optab, diff,
5006: setaddr, NULL_RTX, iunsignedp,
1.1.1.5 root 5007: OPTAB_LIB_WIDEN));
1.1.1.7 root 5008:
1.1.1.4 root 5009: /* Extract the bit we want to examine */
5010: bit = expand_shift (RSHIFT_EXPR, byte_mode,
1.1.1.5 root 5011: gen_rtx (MEM, byte_mode, addr),
5012: make_tree (TREE_TYPE (index), rem),
5013: NULL_RTX, 1);
5014: result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
5015: GET_MODE (target) == byte_mode ? target : 0,
1.1.1.4 root 5016: 1, OPTAB_LIB_WIDEN);
1.1.1.5 root 5017:
5018: if (result != target)
5019: convert_move (target, result, 1);
1.1.1.4 root 5020:
5021: /* Output the code to handle the out-of-range case. */
5022: emit_jump (op0);
5023: emit_label (op1);
5024: emit_move_insn (target, const0_rtx);
5025: emit_label (op0);
5026: return target;
5027: }
5028:
1.1 root 5029: case WITH_CLEANUP_EXPR:
5030: if (RTL_EXPR_RTL (exp) == 0)
5031: {
5032: RTL_EXPR_RTL (exp)
1.1.1.7 root 5033: = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
1.1.1.4 root 5034: cleanups_this_call
5035: = tree_cons (NULL_TREE, TREE_OPERAND (exp, 2), cleanups_this_call);
1.1 root 5036: /* That's it for this cleanup. */
5037: TREE_OPERAND (exp, 2) = 0;
1.1.1.7 root 5038: (*interim_eh_hook) (NULL_TREE);
1.1 root 5039: }
5040: return RTL_EXPR_RTL (exp);
5041:
1.1.1.7 root 5042: case CLEANUP_POINT_EXPR:
5043: {
5044: extern int temp_slot_level;
5045: tree old_cleanups = cleanups_this_call;
5046: int old_temp_level = target_temp_slot_level;
5047: push_temp_slots ();
5048: target_temp_slot_level = temp_slot_level;
1.1.1.8 root 5049: op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
5050: /* If we're going to use this value, load it up now. */
5051: if (! ignore)
5052: op0 = force_not_mem (op0);
1.1.1.7 root 5053: expand_cleanups_to (old_cleanups);
5054: preserve_temp_slots (op0);
5055: free_temp_slots ();
5056: pop_temp_slots ();
5057: target_temp_slot_level = old_temp_level;
5058: }
5059: return op0;
5060:
1.1 root 5061: case CALL_EXPR:
5062: /* Check for a built-in function. */
5063: if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1.1.1.7 root 5064: && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5065: == FUNCTION_DECL)
1.1 root 5066: && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
5067: return expand_builtin (exp, target, subtarget, tmode, ignore);
1.1.1.7 root 5068:
1.1 root 5069: /* If this call was expanded already by preexpand_calls,
5070: just return the result we got. */
5071: if (CALL_EXPR_RTL (exp) != 0)
5072: return CALL_EXPR_RTL (exp);
1.1.1.7 root 5073:
1.1.1.3 root 5074: return expand_call (exp, target, ignore);
1.1 root 5075:
5076: case NON_LVALUE_EXPR:
5077: case NOP_EXPR:
5078: case CONVERT_EXPR:
5079: case REFERENCE_EXPR:
5080: if (TREE_CODE (type) == UNION_TYPE)
5081: {
5082: tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
5083: if (target == 0)
5084: {
5085: if (mode == BLKmode)
5086: {
5087: if (TYPE_SIZE (type) == 0
5088: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5089: abort ();
5090: target = assign_stack_temp (BLKmode,
5091: (TREE_INT_CST_LOW (TYPE_SIZE (type))
5092: + BITS_PER_UNIT - 1)
5093: / BITS_PER_UNIT, 0);
1.1.1.8 root 5094: MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (type);
1.1 root 5095: }
5096: else
1.1.1.7 root 5097: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
1.1 root 5098: }
1.1.1.7 root 5099:
1.1 root 5100: if (GET_CODE (target) == MEM)
5101: /* Store data into beginning of memory target. */
5102: store_expr (TREE_OPERAND (exp, 0),
5103: change_address (target, TYPE_MODE (valtype), 0), 0);
1.1.1.4 root 5104:
1.1 root 5105: else if (GET_CODE (target) == REG)
5106: /* Store this field into a union of the proper type. */
5107: store_field (target, GET_MODE_BITSIZE (TYPE_MODE (valtype)), 0,
5108: TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
5109: VOIDmode, 0, 1,
5110: int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0))));
5111: else
5112: abort ();
5113:
5114: /* Return the entire union. */
5115: return target;
5116: }
1.1.1.7 root 5117:
1.1.1.8 root 5118: if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
5119: {
5120: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
5121: modifier);
5122:
5123: /* If the signedness of the conversion differs and OP0 is
5124: a promoted SUBREG, clear that indication since we now
5125: have to do the proper extension. */
5126: if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
5127: && GET_CODE (op0) == SUBREG)
5128: SUBREG_PROMOTED_VAR_P (op0) = 0;
5129:
5130: return op0;
5131: }
5132:
1.1.1.4 root 5133: op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
1.1.1.5 root 5134: if (GET_MODE (op0) == mode)
5135: return op0;
5136:
1.1.1.7 root 5137: /* If OP0 is a constant, just convert it into the proper mode. */
5138: if (CONSTANT_P (op0))
5139: return
5140: convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
5141: op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
5142:
1.1.1.4 root 5143: if (modifier == EXPAND_INITIALIZER)
5144: return gen_rtx (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
1.1.1.7 root 5145:
1.1 root 5146: if (flag_force_mem && GET_CODE (op0) == MEM)
5147: op0 = copy_to_reg (op0);
5148:
5149: if (target == 0)
1.1.1.7 root 5150: return
5151: convert_to_mode (mode, op0,
5152: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
1.1 root 5153: else
1.1.1.7 root 5154: convert_move (target, op0,
5155: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
1.1 root 5156: return target;
5157:
5158: case PLUS_EXPR:
5159: /* We come here from MINUS_EXPR when the second operand is a constant. */
5160: plus_expr:
5161: this_optab = add_optab;
5162:
5163: /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
5164: something else, make sure we add the register to the constant and
5165: then to the other thing. This case can occur during strength
5166: reduction and doing it this way will produce better code if the
5167: frame pointer or argument pointer is eliminated.
5168:
5169: fold-const.c will ensure that the constant is always in the inner
5170: PLUS_EXPR, so the only case we need to do anything about is if
5171: sp, ap, or fp is our second argument, in which case we must swap
5172: the innermost first argument and our second argument. */
5173:
5174: if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
5175: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
5176: && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
5177: && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
5178: || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
5179: || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
5180: {
5181: tree t = TREE_OPERAND (exp, 1);
5182:
5183: TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
5184: TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
5185: }
5186:
1.1.1.8 root 5187: /* If the result is to be ptr_mode and we are adding an integer to
1.1 root 5188: something, we might be forming a constant. So try to use
5189: plus_constant. If it produces a sum and we can't accept it,
5190: use force_operand. This allows P = &ARR[const] to generate
5191: efficient code on machines where a SYMBOL_REF is not a valid
5192: address.
5193:
5194: If this is an EXPAND_SUM call, always return the sum. */
1.1.1.6 root 5195: if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
1.1.1.8 root 5196: || mode == ptr_mode)
1.1.1.6 root 5197: {
5198: if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
5199: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5200: && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
5201: {
5202: op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
5203: EXPAND_SUM);
5204: op1 = plus_constant (op1, TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)));
5205: if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
5206: op1 = force_operand (op1, target);
5207: return op1;
5208: }
5209:
5210: else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
5211: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
5212: && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
5213: {
5214: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
5215: EXPAND_SUM);
5216: if (! CONSTANT_P (op0))
5217: {
5218: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
5219: VOIDmode, modifier);
5220: /* Don't go to both_summands if modifier
5221: says it's not right to return a PLUS. */
5222: if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
5223: goto binop2;
5224: goto both_summands;
5225: }
5226: op0 = plus_constant (op0, TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)));
5227: if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
5228: op0 = force_operand (op0, target);
5229: return op0;
5230: }
1.1 root 5231: }
5232:
5233: /* No sense saving up arithmetic to be done
5234: if it's all in the wrong mode to form part of an address.
5235: And force_operand won't know whether to sign-extend or
5236: zero-extend. */
5237: if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
1.1.1.8 root 5238: || mode != ptr_mode)
1.1.1.6 root 5239: goto binop;
1.1 root 5240:
5241: preexpand_calls (exp);
5242: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
5243: subtarget = 0;
5244:
5245: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, modifier);
1.1.1.4 root 5246: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, modifier);
1.1.1.2 root 5247:
1.1.1.6 root 5248: both_summands:
1.1 root 5249: /* Make sure any term that's a sum with a constant comes last. */
5250: if (GET_CODE (op0) == PLUS
5251: && CONSTANT_P (XEXP (op0, 1)))
5252: {
5253: temp = op0;
5254: op0 = op1;
5255: op1 = temp;
5256: }
5257: /* If adding to a sum including a constant,
5258: associate it to put the constant outside. */
5259: if (GET_CODE (op1) == PLUS
5260: && CONSTANT_P (XEXP (op1, 1)))
5261: {
1.1.1.2 root 5262: rtx constant_term = const0_rtx;
5263:
5264: temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
5265: if (temp != 0)
5266: op0 = temp;
1.1.1.3 root 5267: /* Ensure that MULT comes first if there is one. */
5268: else if (GET_CODE (op0) == MULT)
5269: op0 = gen_rtx (PLUS, mode, op0, XEXP (op1, 0));
1.1.1.2 root 5270: else
5271: op0 = gen_rtx (PLUS, mode, XEXP (op1, 0), op0);
1.1 root 5272:
5273: /* Let's also eliminate constants from op0 if possible. */
1.1.1.2 root 5274: op0 = eliminate_constant_term (op0, &constant_term);
5275:
5276: /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
5277: their sum should be a constant. Form it into OP1, since the
5278: result we want will then be OP0 + OP1. */
5279:
5280: temp = simplify_binary_operation (PLUS, mode, constant_term,
5281: XEXP (op1, 1));
5282: if (temp != 0)
5283: op1 = temp;
1.1 root 5284: else
1.1.1.2 root 5285: op1 = gen_rtx (PLUS, mode, constant_term, XEXP (op1, 1));
1.1 root 5286: }
1.1.1.2 root 5287:
5288: /* Put a constant term last and put a multiplication first. */
5289: if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
5290: temp = op1, op1 = op0, op0 = temp;
5291:
5292: temp = simplify_binary_operation (PLUS, mode, op0, op1);
5293: return temp ? temp : gen_rtx (PLUS, mode, op0, op1);
1.1 root 5294:
5295: case MINUS_EXPR:
1.1.1.6 root 5296: /* For initializers, we are allowed to return a MINUS of two
5297: symbolic constants. Here we handle all cases when both operands
5298: are constant. */
1.1 root 5299: /* Handle difference of two symbolic constants,
5300: for the sake of an initializer. */
5301: if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
5302: && really_constant_p (TREE_OPERAND (exp, 0))
5303: && really_constant_p (TREE_OPERAND (exp, 1)))
5304: {
1.1.1.4 root 5305: rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
5306: VOIDmode, modifier);
5307: rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
5308: VOIDmode, modifier);
1.1.1.6 root 5309:
5310: /* If the last operand is a CONST_INT, use plus_constant of
5311: the negated constant. Else make the MINUS. */
5312: if (GET_CODE (op1) == CONST_INT)
5313: return plus_constant (op0, - INTVAL (op1));
5314: else
5315: return gen_rtx (MINUS, mode, op0, op1);
1.1 root 5316: }
5317: /* Convert A - const to A + (-const). */
5318: if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
5319: {
1.1.1.8 root 5320: tree negated = fold (build1 (NEGATE_EXPR, type,
5321: TREE_OPERAND (exp, 1)));
5322:
5323: /* Deal with the case where we can't negate the constant
5324: in TYPE. */
5325: if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
5326: {
5327: tree newtype = signed_type (type);
5328: tree newop0 = convert (newtype, TREE_OPERAND (exp, 0));
5329: tree newop1 = convert (newtype, TREE_OPERAND (exp, 1));
5330: tree newneg = fold (build1 (NEGATE_EXPR, newtype, newop1));
5331:
5332: if (! TREE_OVERFLOW (newneg))
5333: return expand_expr (convert (type,
5334: build (PLUS_EXPR, newtype,
5335: newop0, newneg)),
5336: target, tmode, modifier);
5337: }
5338: else
5339: {
5340: exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
5341: goto plus_expr;
5342: }
1.1 root 5343: }
5344: this_optab = sub_optab;
5345: goto binop;
5346:
5347: case MULT_EXPR:
5348: preexpand_calls (exp);
5349: /* If first operand is constant, swap them.
5350: Thus the following special case checks need only
5351: check the second operand. */
5352: if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
5353: {
5354: register tree t1 = TREE_OPERAND (exp, 0);
5355: TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
5356: TREE_OPERAND (exp, 1) = t1;
5357: }
5358:
5359: /* Attempt to return something suitable for generating an
5360: indexed address, for machines that support that. */
5361:
1.1.1.8 root 5362: if (modifier == EXPAND_SUM && mode == ptr_mode
1.1 root 5363: && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
1.1.1.4 root 5364: && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1.1 root 5365: {
5366: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, EXPAND_SUM);
5367:
5368: /* Apply distributive law if OP0 is x+c. */
5369: if (GET_CODE (op0) == PLUS
5370: && GET_CODE (XEXP (op0, 1)) == CONST_INT)
5371: return gen_rtx (PLUS, mode,
5372: gen_rtx (MULT, mode, XEXP (op0, 0),
1.1.1.4 root 5373: GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
5374: GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
5375: * INTVAL (XEXP (op0, 1))));
1.1 root 5376:
5377: if (GET_CODE (op0) != REG)
1.1.1.4 root 5378: op0 = force_operand (op0, NULL_RTX);
1.1 root 5379: if (GET_CODE (op0) != REG)
5380: op0 = copy_to_mode_reg (mode, op0);
5381:
5382: return gen_rtx (MULT, mode, op0,
1.1.1.4 root 5383: GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
1.1 root 5384: }
5385:
5386: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
5387: subtarget = 0;
5388:
5389: /* Check for multiplying things that have been extended
5390: from a narrower type. If this machine supports multiplying
5391: in that narrower type with a result in the desired type,
5392: do it that way, and avoid the explicit type-conversion. */
5393: if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
5394: && TREE_CODE (type) == INTEGER_TYPE
5395: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
5396: < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
5397: && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
5398: && int_fits_type_p (TREE_OPERAND (exp, 1),
5399: TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
5400: /* Don't use a widening multiply if a shift will do. */
5401: && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
1.1.1.4 root 5402: > HOST_BITS_PER_WIDE_INT)
1.1 root 5403: || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
5404: ||
5405: (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
5406: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
5407: ==
5408: TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
5409: /* If both operands are extended, they must either both
5410: be zero-extended or both be sign-extended. */
5411: && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
5412: ==
5413: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
5414: {
5415: enum machine_mode innermode
5416: = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
5417: this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
5418: ? umul_widen_optab : smul_widen_optab);
5419: if (mode == GET_MODE_WIDER_MODE (innermode)
5420: && this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
5421: {
5422: op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
1.1.1.4 root 5423: NULL_RTX, VOIDmode, 0);
1.1 root 5424: if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
1.1.1.4 root 5425: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
5426: VOIDmode, 0);
1.1 root 5427: else
5428: op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
1.1.1.4 root 5429: NULL_RTX, VOIDmode, 0);
1.1 root 5430: goto binop2;
5431: }
5432: }
5433: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
1.1.1.4 root 5434: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1 root 5435: return expand_mult (mode, op0, op1, target, unsignedp);
5436:
5437: case TRUNC_DIV_EXPR:
5438: case FLOOR_DIV_EXPR:
5439: case CEIL_DIV_EXPR:
5440: case ROUND_DIV_EXPR:
5441: case EXACT_DIV_EXPR:
5442: preexpand_calls (exp);
5443: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
5444: subtarget = 0;
5445: /* Possible optimization: compute the dividend with EXPAND_SUM
5446: then if the divisor is constant can optimize the case
5447: where some terms of the dividend have coeffs divisible by it. */
5448: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
1.1.1.4 root 5449: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1 root 5450: return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
5451:
5452: case RDIV_EXPR:
5453: this_optab = flodiv_optab;
5454: goto binop;
5455:
5456: case TRUNC_MOD_EXPR:
5457: case FLOOR_MOD_EXPR:
5458: case CEIL_MOD_EXPR:
5459: case ROUND_MOD_EXPR:
5460: preexpand_calls (exp);
5461: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
5462: subtarget = 0;
5463: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
1.1.1.4 root 5464: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1 root 5465: return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
5466:
5467: case FIX_ROUND_EXPR:
5468: case FIX_FLOOR_EXPR:
5469: case FIX_CEIL_EXPR:
5470: abort (); /* Not used for C. */
5471:
5472: case FIX_TRUNC_EXPR:
1.1.1.4 root 5473: op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1.1 root 5474: if (target == 0)
5475: target = gen_reg_rtx (mode);
5476: expand_fix (target, op0, unsignedp);
5477: return target;
5478:
5479: case FLOAT_EXPR:
1.1.1.4 root 5480: op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1.1 root 5481: if (target == 0)
5482: target = gen_reg_rtx (mode);
5483: /* expand_float can't figure out what to do if FROM has VOIDmode.
5484: So give it the correct mode. With -O, cse will optimize this. */
5485: if (GET_MODE (op0) == VOIDmode)
5486: op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
5487: op0);
5488: expand_float (target, op0,
5489: TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
5490: return target;
5491:
5492: case NEGATE_EXPR:
1.1.1.7 root 5493: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
1.1 root 5494: temp = expand_unop (mode, neg_optab, op0, target, 0);
5495: if (temp == 0)
5496: abort ();
5497: return temp;
5498:
5499: case ABS_EXPR:
5500: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
5501:
1.1.1.4 root 5502: /* Handle complex values specially. */
1.1.1.7 root 5503: if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
5504: || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
5505: return expand_complex_abs (mode, op0, target, unsignedp);
1.1.1.4 root 5506:
1.1 root 5507: /* Unsigned abs is simply the operand. Testing here means we don't
5508: risk generating incorrect code below. */
5509: if (TREE_UNSIGNED (type))
5510: return op0;
5511:
1.1.1.7 root 5512: return expand_abs (mode, op0, target, unsignedp,
5513: safe_from_p (target, TREE_OPERAND (exp, 0)));
1.1 root 5514:
5515: case MAX_EXPR:
5516: case MIN_EXPR:
5517: target = original_target;
5518: if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1))
1.1.1.6 root 5519: || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
1.1.1.7 root 5520: || GET_MODE (target) != mode
1.1 root 5521: || (GET_CODE (target) == REG
5522: && REGNO (target) < FIRST_PSEUDO_REGISTER))
5523: target = gen_reg_rtx (mode);
1.1.1.4 root 5524: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1 root 5525: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
5526:
5527: /* First try to do it with a special MIN or MAX instruction.
5528: If that does not win, use a conditional jump to select the proper
5529: value. */
5530: this_optab = (TREE_UNSIGNED (type)
5531: ? (code == MIN_EXPR ? umin_optab : umax_optab)
5532: : (code == MIN_EXPR ? smin_optab : smax_optab));
5533:
5534: temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
5535: OPTAB_WIDEN);
5536: if (temp != 0)
5537: return temp;
5538:
1.1.1.8 root 5539: /* At this point, a MEM target is no longer useful; we will get better
5540: code without it. */
5541:
5542: if (GET_CODE (target) == MEM)
5543: target = gen_reg_rtx (mode);
5544:
1.1 root 5545: if (target != op0)
5546: emit_move_insn (target, op0);
1.1.1.7 root 5547:
1.1 root 5548: op0 = gen_label_rtx ();
1.1.1.7 root 5549:
1.1.1.5 root 5550: /* If this mode is an integer too wide to compare properly,
5551: compare word by word. Rely on cse to optimize constant cases. */
1.1.1.7 root 5552: if (GET_MODE_CLASS (mode) == MODE_INT && !can_compare_p (mode))
1.1 root 5553: {
1.1.1.5 root 5554: if (code == MAX_EXPR)
1.1.1.7 root 5555: do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
5556: target, op1, NULL_RTX, op0);
1.1 root 5557: else
1.1.1.7 root 5558: do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
5559: op1, target, NULL_RTX, op0);
1.1 root 5560: emit_move_insn (target, op1);
5561: }
1.1.1.5 root 5562: else
5563: {
5564: if (code == MAX_EXPR)
5565: temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
5566: ? compare_from_rtx (target, op1, GEU, 1, mode, NULL_RTX, 0)
5567: : compare_from_rtx (target, op1, GE, 0, mode, NULL_RTX, 0));
5568: else
5569: temp = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))
5570: ? compare_from_rtx (target, op1, LEU, 1, mode, NULL_RTX, 0)
5571: : compare_from_rtx (target, op1, LE, 0, mode, NULL_RTX, 0));
5572: if (temp == const0_rtx)
5573: emit_move_insn (target, op1);
5574: else if (temp != const_true_rtx)
5575: {
5576: if (bcc_gen_fctn[(int) GET_CODE (temp)] != 0)
5577: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (temp)]) (op0));
5578: else
5579: abort ();
5580: emit_move_insn (target, op1);
5581: }
5582: }
1.1 root 5583: emit_label (op0);
5584: return target;
5585:
5586: case BIT_NOT_EXPR:
5587: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
5588: temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
5589: if (temp == 0)
5590: abort ();
5591: return temp;
5592:
5593: case FFS_EXPR:
5594: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
5595: temp = expand_unop (mode, ffs_optab, op0, target, 1);
5596: if (temp == 0)
5597: abort ();
5598: return temp;
5599:
1.1.1.7 root 5600: /* ??? Can optimize bitwise operations with one arg constant.
5601: Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
5602: and (a bitwise1 b) bitwise2 b (etc)
5603: but that is probably not worth while. */
5604:
5605: /* BIT_AND_EXPR is for bitwise anding. TRUTH_AND_EXPR is for anding two
5606: boolean values when we want in all cases to compute both of them. In
5607: general it is fastest to do TRUTH_AND_EXPR by computing both operands
5608: as actual zero-or-1 values and then bitwise anding. In cases where
5609: there cannot be any side effects, better code would be made by
5610: treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
5611: how to recognize those cases. */
1.1 root 5612:
5613: case TRUTH_AND_EXPR:
5614: case BIT_AND_EXPR:
5615: this_optab = and_optab;
5616: goto binop;
5617:
5618: case TRUTH_OR_EXPR:
5619: case BIT_IOR_EXPR:
5620: this_optab = ior_optab;
5621: goto binop;
5622:
1.1.1.5 root 5623: case TRUTH_XOR_EXPR:
1.1 root 5624: case BIT_XOR_EXPR:
5625: this_optab = xor_optab;
5626: goto binop;
5627:
5628: case LSHIFT_EXPR:
5629: case RSHIFT_EXPR:
5630: case LROTATE_EXPR:
5631: case RROTATE_EXPR:
5632: preexpand_calls (exp);
5633: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
5634: subtarget = 0;
5635: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
5636: return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
5637: unsignedp);
5638:
1.1.1.7 root 5639: /* Could determine the answer when only additive constants differ. Also,
5640: the addition of one can be handled by changing the condition. */
1.1 root 5641: case LT_EXPR:
5642: case LE_EXPR:
5643: case GT_EXPR:
5644: case GE_EXPR:
5645: case EQ_EXPR:
5646: case NE_EXPR:
5647: preexpand_calls (exp);
5648: temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
5649: if (temp != 0)
5650: return temp;
1.1.1.7 root 5651:
1.1 root 5652: /* For foo != 0, load foo, and if it is nonzero load 1 instead. */
5653: if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
5654: && original_target
5655: && GET_CODE (original_target) == REG
5656: && (GET_MODE (original_target)
5657: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
5658: {
1.1.1.7 root 5659: temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
5660: VOIDmode, 0);
5661:
1.1 root 5662: if (temp != original_target)
5663: temp = copy_to_reg (temp);
1.1.1.7 root 5664:
1.1 root 5665: op1 = gen_label_rtx ();
1.1.1.4 root 5666: emit_cmp_insn (temp, const0_rtx, EQ, NULL_RTX,
1.1 root 5667: GET_MODE (temp), unsignedp, 0);
5668: emit_jump_insn (gen_beq (op1));
5669: emit_move_insn (temp, const1_rtx);
5670: emit_label (op1);
5671: return temp;
5672: }
1.1.1.7 root 5673:
1.1 root 5674: /* If no set-flag instruction, must generate a conditional
5675: store into a temporary variable. Drop through
5676: and handle this like && and ||. */
5677:
5678: case TRUTH_ANDIF_EXPR:
5679: case TRUTH_ORIF_EXPR:
1.1.1.6 root 5680: if (! ignore
5681: && (target == 0 || ! safe_from_p (target, exp)
5682: /* Make sure we don't have a hard reg (such as function's return
5683: value) live across basic blocks, if not optimizing. */
5684: || (!optimize && GET_CODE (target) == REG
5685: && REGNO (target) < FIRST_PSEUDO_REGISTER)))
1.1 root 5686: target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
1.1.1.6 root 5687:
5688: if (target)
5689: emit_clr_insn (target);
5690:
1.1 root 5691: op1 = gen_label_rtx ();
5692: jumpifnot (exp, op1);
1.1.1.6 root 5693:
5694: if (target)
5695: emit_0_to_1_insn (target);
5696:
1.1 root 5697: emit_label (op1);
1.1.1.6 root 5698: return ignore ? const0_rtx : target;
1.1 root 5699:
5700: case TRUTH_NOT_EXPR:
5701: op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
5702: /* The parser is careful to generate TRUTH_NOT_EXPR
5703: only with operands that are always zero or one. */
1.1.1.4 root 5704: temp = expand_binop (mode, xor_optab, op0, const1_rtx,
1.1 root 5705: target, 1, OPTAB_LIB_WIDEN);
5706: if (temp == 0)
5707: abort ();
5708: return temp;
5709:
5710: case COMPOUND_EXPR:
5711: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
5712: emit_queue ();
5713: return expand_expr (TREE_OPERAND (exp, 1),
5714: (ignore ? const0_rtx : target),
5715: VOIDmode, 0);
5716:
5717: case COND_EXPR:
5718: {
1.1.1.7 root 5719: rtx flag = NULL_RTX;
5720: tree left_cleanups = NULL_TREE;
5721: tree right_cleanups = NULL_TREE;
5722:
5723: /* Used to save a pointer to the place to put the setting of
5724: the flag that indicates if this side of the conditional was
5725: taken. We backpatch the code, if we find out later that we
5726: have any conditional cleanups that need to be performed. */
5727: rtx dest_right_flag = NULL_RTX;
5728: rtx dest_left_flag = NULL_RTX;
5729:
1.1 root 5730: /* Note that COND_EXPRs whose type is a structure or union
5731: are required to be constructed to contain assignments of
5732: a temporary variable, so that we can evaluate them here
5733: for side effect only. If type is void, we must do likewise. */
5734:
5735: /* If an arm of the branch requires a cleanup,
5736: only that cleanup is performed. */
5737:
5738: tree singleton = 0;
5739: tree binary_op = 0, unary_op = 0;
5740: tree old_cleanups = cleanups_this_call;
5741:
5742: /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
5743: convert it to our mode, if necessary. */
5744: if (integer_onep (TREE_OPERAND (exp, 1))
5745: && integer_zerop (TREE_OPERAND (exp, 2))
5746: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
5747: {
1.1.1.6 root 5748: if (ignore)
5749: {
5750: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
5751: modifier);
5752: return const0_rtx;
5753: }
5754:
1.1 root 5755: op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, modifier);
5756: if (GET_MODE (op0) == mode)
5757: return op0;
1.1.1.7 root 5758:
1.1 root 5759: if (target == 0)
5760: target = gen_reg_rtx (mode);
5761: convert_move (target, op0, unsignedp);
5762: return target;
5763: }
5764:
5765: /* If we are not to produce a result, we have no target. Otherwise,
5766: if a target was specified use it; it will not be used as an
5767: intermediate target unless it is safe. If no target, use a
5768: temporary. */
5769:
1.1.1.6 root 5770: if (ignore)
1.1 root 5771: temp = 0;
5772: else if (original_target
1.1.1.7 root 5773: && safe_from_p (original_target, TREE_OPERAND (exp, 0))
5774: && GET_MODE (original_target) == mode
5775: && ! (GET_CODE (original_target) == MEM
5776: && MEM_VOLATILE_P (original_target)))
1.1 root 5777: temp = original_target;
5778: else if (mode == BLKmode)
5779: {
5780: if (TYPE_SIZE (type) == 0
5781: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5782: abort ();
1.1.1.6 root 5783:
1.1 root 5784: temp = assign_stack_temp (BLKmode,
5785: (TREE_INT_CST_LOW (TYPE_SIZE (type))
5786: + BITS_PER_UNIT - 1)
5787: / BITS_PER_UNIT, 0);
1.1.1.7 root 5788: MEM_IN_STRUCT_P (temp) = AGGREGATE_TYPE_P (type);
1.1 root 5789: }
5790: else
5791: temp = gen_reg_rtx (mode);
5792:
5793: /* Check for X ? A + B : A. If we have this, we can copy
5794: A to the output and conditionally add B. Similarly for unary
5795: operations. Don't do this if X has side-effects because
5796: those side effects might affect A or B and the "?" operation is
5797: a sequence point in ANSI. (We test for side effects later.) */
5798:
5799: if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
5800: && operand_equal_p (TREE_OPERAND (exp, 2),
5801: TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
5802: singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
5803: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
5804: && operand_equal_p (TREE_OPERAND (exp, 1),
5805: TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
5806: singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
5807: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
5808: && operand_equal_p (TREE_OPERAND (exp, 2),
5809: TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
5810: singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
5811: else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
5812: && operand_equal_p (TREE_OPERAND (exp, 1),
5813: TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
5814: singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
5815:
5816: /* If we had X ? A + 1 : A and we can do the test of X as a store-flag
5817: operation, do this as A + (X != 0). Similarly for other simple
5818: binary operators. */
1.1.1.6 root 5819: if (temp && singleton && binary_op
1.1 root 5820: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
5821: && (TREE_CODE (binary_op) == PLUS_EXPR
5822: || TREE_CODE (binary_op) == MINUS_EXPR
5823: || TREE_CODE (binary_op) == BIT_IOR_EXPR
1.1.1.7 root 5824: || TREE_CODE (binary_op) == BIT_XOR_EXPR)
1.1 root 5825: && integer_onep (TREE_OPERAND (binary_op, 1))
5826: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
5827: {
5828: rtx result;
5829: optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR ? add_optab
5830: : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab
5831: : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
1.1.1.7 root 5832: : xor_optab);
1.1 root 5833:
5834: /* If we had X ? A : A + 1, do this as A + (X == 0).
5835:
5836: We have to invert the truth value here and then put it
5837: back later if do_store_flag fails. We cannot simply copy
5838: TREE_OPERAND (exp, 0) to another variable and modify that
5839: because invert_truthvalue can modify the tree pointed to
5840: by its argument. */
5841: if (singleton == TREE_OPERAND (exp, 1))
5842: TREE_OPERAND (exp, 0)
5843: = invert_truthvalue (TREE_OPERAND (exp, 0));
5844:
5845: result = do_store_flag (TREE_OPERAND (exp, 0),
1.1.1.4 root 5846: (safe_from_p (temp, singleton)
5847: ? temp : NULL_RTX),
1.1 root 5848: mode, BRANCH_COST <= 1);
5849:
5850: if (result)
5851: {
1.1.1.4 root 5852: op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
1.1 root 5853: return expand_binop (mode, boptab, op1, result, temp,
5854: unsignedp, OPTAB_LIB_WIDEN);
5855: }
5856: else if (singleton == TREE_OPERAND (exp, 1))
5857: TREE_OPERAND (exp, 0)
5858: = invert_truthvalue (TREE_OPERAND (exp, 0));
5859: }
5860:
1.1.1.8 root 5861: do_pending_stack_adjust ();
1.1 root 5862: NO_DEFER_POP;
5863: op0 = gen_label_rtx ();
5864:
1.1.1.7 root 5865: flag = gen_reg_rtx (word_mode);
1.1 root 5866: if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
5867: {
5868: if (temp != 0)
5869: {
5870: /* If the target conflicts with the other operand of the
5871: binary op, we can't use it. Also, we can't use the target
5872: if it is a hard register, because evaluating the condition
5873: might clobber it. */
5874: if ((binary_op
5875: && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1)))
5876: || (GET_CODE (temp) == REG
5877: && REGNO (temp) < FIRST_PSEUDO_REGISTER))
5878: temp = gen_reg_rtx (mode);
5879: store_expr (singleton, temp, 0);
5880: }
5881: else
1.1.1.4 root 5882: expand_expr (singleton,
1.1.1.5 root 5883: ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
1.1.1.7 root 5884: dest_left_flag = get_last_insn ();
1.1 root 5885: if (singleton == TREE_OPERAND (exp, 1))
5886: jumpif (TREE_OPERAND (exp, 0), op0);
5887: else
5888: jumpifnot (TREE_OPERAND (exp, 0), op0);
5889:
1.1.1.7 root 5890: /* Allows cleanups up to here. */
5891: old_cleanups = cleanups_this_call;
1.1 root 5892: if (binary_op && temp == 0)
5893: /* Just touch the other operand. */
5894: expand_expr (TREE_OPERAND (binary_op, 1),
1.1.1.4 root 5895: ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
1.1 root 5896: else if (binary_op)
5897: store_expr (build (TREE_CODE (binary_op), type,
5898: make_tree (type, temp),
5899: TREE_OPERAND (binary_op, 1)),
5900: temp, 0);
5901: else
5902: store_expr (build1 (TREE_CODE (unary_op), type,
5903: make_tree (type, temp)),
5904: temp, 0);
5905: op1 = op0;
1.1.1.7 root 5906: dest_right_flag = get_last_insn ();
1.1 root 5907: }
5908: #if 0
5909: /* This is now done in jump.c and is better done there because it
5910: produces shorter register lifetimes. */
5911:
5912: /* Check for both possibilities either constants or variables
5913: in registers (but not the same as the target!). If so, can
5914: save branches by assigning one, branching, and assigning the
5915: other. */
5916: else if (temp && GET_MODE (temp) != BLKmode
5917: && (TREE_CONSTANT (TREE_OPERAND (exp, 1))
5918: || ((TREE_CODE (TREE_OPERAND (exp, 1)) == PARM_DECL
5919: || TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL)
5920: && DECL_RTL (TREE_OPERAND (exp, 1))
5921: && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 1))) == REG
5922: && DECL_RTL (TREE_OPERAND (exp, 1)) != temp))
5923: && (TREE_CONSTANT (TREE_OPERAND (exp, 2))
5924: || ((TREE_CODE (TREE_OPERAND (exp, 2)) == PARM_DECL
5925: || TREE_CODE (TREE_OPERAND (exp, 2)) == VAR_DECL)
5926: && DECL_RTL (TREE_OPERAND (exp, 2))
5927: && GET_CODE (DECL_RTL (TREE_OPERAND (exp, 2))) == REG
5928: && DECL_RTL (TREE_OPERAND (exp, 2)) != temp)))
5929: {
5930: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
5931: temp = gen_reg_rtx (mode);
5932: store_expr (TREE_OPERAND (exp, 2), temp, 0);
1.1.1.7 root 5933: dest_left_flag = get_last_insn ();
1.1 root 5934: jumpifnot (TREE_OPERAND (exp, 0), op0);
1.1.1.7 root 5935:
5936: /* Allows cleanups up to here. */
5937: old_cleanups = cleanups_this_call;
1.1 root 5938: store_expr (TREE_OPERAND (exp, 1), temp, 0);
5939: op1 = op0;
1.1.1.7 root 5940: dest_right_flag = get_last_insn ();
1.1 root 5941: }
5942: #endif
5943: /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
5944: comparison operator. If we have one of these cases, set the
5945: output to A, branch on A (cse will merge these two references),
5946: then set the output to FOO. */
5947: else if (temp
5948: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
5949: && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
5950: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
5951: TREE_OPERAND (exp, 1), 0)
5952: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
5953: && safe_from_p (temp, TREE_OPERAND (exp, 2)))
5954: {
5955: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
5956: temp = gen_reg_rtx (mode);
5957: store_expr (TREE_OPERAND (exp, 1), temp, 0);
1.1.1.7 root 5958: dest_left_flag = get_last_insn ();
1.1 root 5959: jumpif (TREE_OPERAND (exp, 0), op0);
1.1.1.7 root 5960:
5961: /* Allows cleanups up to here. */
5962: old_cleanups = cleanups_this_call;
1.1 root 5963: store_expr (TREE_OPERAND (exp, 2), temp, 0);
5964: op1 = op0;
1.1.1.7 root 5965: dest_right_flag = get_last_insn ();
1.1 root 5966: }
5967: else if (temp
5968: && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
5969: && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
5970: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
5971: TREE_OPERAND (exp, 2), 0)
5972: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
5973: && safe_from_p (temp, TREE_OPERAND (exp, 1)))
5974: {
5975: if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
5976: temp = gen_reg_rtx (mode);
5977: store_expr (TREE_OPERAND (exp, 2), temp, 0);
1.1.1.7 root 5978: dest_left_flag = get_last_insn ();
1.1 root 5979: jumpifnot (TREE_OPERAND (exp, 0), op0);
1.1.1.7 root 5980:
5981: /* Allows cleanups up to here. */
5982: old_cleanups = cleanups_this_call;
1.1 root 5983: store_expr (TREE_OPERAND (exp, 1), temp, 0);
5984: op1 = op0;
1.1.1.7 root 5985: dest_right_flag = get_last_insn ();
1.1 root 5986: }
5987: else
5988: {
5989: op1 = gen_label_rtx ();
5990: jumpifnot (TREE_OPERAND (exp, 0), op0);
1.1.1.7 root 5991:
5992: /* Allows cleanups up to here. */
5993: old_cleanups = cleanups_this_call;
1.1 root 5994: if (temp != 0)
5995: store_expr (TREE_OPERAND (exp, 1), temp, 0);
5996: else
1.1.1.4 root 5997: expand_expr (TREE_OPERAND (exp, 1),
5998: ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
1.1.1.7 root 5999: dest_left_flag = get_last_insn ();
6000:
6001: /* Handle conditional cleanups, if any. */
6002: left_cleanups = defer_cleanups_to (old_cleanups);
1.1 root 6003:
6004: emit_queue ();
6005: emit_jump_insn (gen_jump (op1));
6006: emit_barrier ();
6007: emit_label (op0);
6008: if (temp != 0)
6009: store_expr (TREE_OPERAND (exp, 2), temp, 0);
6010: else
1.1.1.4 root 6011: expand_expr (TREE_OPERAND (exp, 2),
6012: ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
1.1.1.7 root 6013: dest_right_flag = get_last_insn ();
1.1 root 6014: }
6015:
1.1.1.7 root 6016: /* Handle conditional cleanups, if any. */
6017: right_cleanups = defer_cleanups_to (old_cleanups);
1.1 root 6018:
6019: emit_queue ();
6020: emit_label (op1);
6021: OK_DEFER_POP;
1.1.1.7 root 6022:
6023: /* Add back in, any conditional cleanups. */
6024: if (left_cleanups || right_cleanups)
6025: {
6026: tree new_cleanups;
6027: tree cond;
6028: rtx last;
6029:
6030: /* Now that we know that a flag is needed, go back and add in the
6031: setting of the flag. */
6032:
6033: /* Do the left side flag. */
6034: last = get_last_insn ();
6035: /* Flag left cleanups as needed. */
6036: emit_move_insn (flag, const1_rtx);
6037: /* ??? deprecated, use sequences instead. */
6038: reorder_insns (NEXT_INSN (last), get_last_insn (), dest_left_flag);
6039:
6040: /* Do the right side flag. */
6041: last = get_last_insn ();
6042: /* Flag left cleanups as needed. */
6043: emit_move_insn (flag, const0_rtx);
6044: /* ??? deprecated, use sequences instead. */
6045: reorder_insns (NEXT_INSN (last), get_last_insn (), dest_right_flag);
6046:
6047: /* convert flag, which is an rtx, into a tree. */
6048: cond = make_node (RTL_EXPR);
6049: TREE_TYPE (cond) = integer_type_node;
6050: RTL_EXPR_RTL (cond) = flag;
6051: RTL_EXPR_SEQUENCE (cond) = NULL_RTX;
1.1.1.8 root 6052: cond = save_expr (cond);
1.1.1.7 root 6053:
6054: if (! left_cleanups)
6055: left_cleanups = integer_zero_node;
6056: if (! right_cleanups)
6057: right_cleanups = integer_zero_node;
6058: new_cleanups = build (COND_EXPR, void_type_node,
6059: truthvalue_conversion (cond),
6060: left_cleanups, right_cleanups);
6061: new_cleanups = fold (new_cleanups);
6062:
6063: /* Now add in the conditionalized cleanups. */
6064: cleanups_this_call
6065: = tree_cons (NULL_TREE, new_cleanups, cleanups_this_call);
6066: (*interim_eh_hook) (NULL_TREE);
6067: }
1.1 root 6068: return temp;
6069: }
6070:
6071: case TARGET_EXPR:
6072: {
1.1.1.7 root 6073: int need_exception_region = 0;
1.1 root 6074: /* Something needs to be initialized, but we didn't know
6075: where that thing was when building the tree. For example,
6076: it could be the return value of a function, or a parameter
6077: to a function which lays down in the stack, or a temporary
6078: variable which must be passed by reference.
6079:
6080: We guarantee that the expression will either be constructed
6081: or copied into our original target. */
6082:
6083: tree slot = TREE_OPERAND (exp, 0);
1.1.1.4 root 6084: tree exp1;
1.1.1.7 root 6085: rtx temp;
1.1 root 6086:
6087: if (TREE_CODE (slot) != VAR_DECL)
6088: abort ();
6089:
1.1.1.8 root 6090: if (! ignore)
6091: target = original_target;
6092:
1.1 root 6093: if (target == 0)
6094: {
6095: if (DECL_RTL (slot) != 0)
1.1.1.4 root 6096: {
6097: target = DECL_RTL (slot);
6098: /* If we have already expanded the slot, so don't do
6099: it again. (mrs) */
6100: if (TREE_OPERAND (exp, 1) == NULL_TREE)
6101: return target;
6102: }
1.1 root 6103: else
6104: {
1.1.1.7 root 6105: target = assign_stack_temp (mode, int_size_in_bytes (type), 2);
1.1.1.8 root 6106: MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (type);
1.1 root 6107: /* All temp slots at this level must not conflict. */
6108: preserve_temp_slots (target);
6109: DECL_RTL (slot) = target;
6110:
1.1.1.6 root 6111: /* Since SLOT is not known to the called function
6112: to belong to its stack frame, we must build an explicit
6113: cleanup. This case occurs when we must build up a reference
6114: to pass the reference as an argument. In this case,
6115: it is very likely that such a reference need not be
6116: built here. */
6117:
6118: if (TREE_OPERAND (exp, 2) == 0)
6119: TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
6120: if (TREE_OPERAND (exp, 2))
1.1.1.7 root 6121: {
6122: cleanups_this_call = tree_cons (NULL_TREE,
6123: TREE_OPERAND (exp, 2),
6124: cleanups_this_call);
6125: need_exception_region = 1;
6126: }
1.1.1.6 root 6127: }
1.1 root 6128: }
6129: else
6130: {
6131: /* This case does occur, when expanding a parameter which
6132: needs to be constructed on the stack. The target
6133: is the actual stack address that we want to initialize.
6134: The function we call will perform the cleanup in this case. */
6135:
1.1.1.5 root 6136: /* If we have already assigned it space, use that space,
6137: not target that we were passed in, as our target
6138: parameter is only a hint. */
6139: if (DECL_RTL (slot) != 0)
6140: {
6141: target = DECL_RTL (slot);
6142: /* If we have already expanded the slot, so don't do
6143: it again. (mrs) */
6144: if (TREE_OPERAND (exp, 1) == NULL_TREE)
6145: return target;
6146: }
6147:
1.1 root 6148: DECL_RTL (slot) = target;
6149: }
6150:
1.1.1.4 root 6151: exp1 = TREE_OPERAND (exp, 1);
6152: /* Mark it as expanded. */
6153: TREE_OPERAND (exp, 1) = NULL_TREE;
6154:
1.1.1.7 root 6155: temp = expand_expr (exp1, target, tmode, modifier);
6156:
6157: if (need_exception_region)
6158: (*interim_eh_hook) (NULL_TREE);
6159:
6160: return temp;
1.1 root 6161: }
6162:
6163: case INIT_EXPR:
6164: {
6165: tree lhs = TREE_OPERAND (exp, 0);
6166: tree rhs = TREE_OPERAND (exp, 1);
6167: tree noncopied_parts = 0;
6168: tree lhs_type = TREE_TYPE (lhs);
6169:
6170: temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
6171: if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
6172: noncopied_parts = init_noncopied_parts (stabilize_reference (lhs),
6173: TYPE_NONCOPIED_PARTS (lhs_type));
6174: while (noncopied_parts != 0)
6175: {
6176: expand_assignment (TREE_VALUE (noncopied_parts),
6177: TREE_PURPOSE (noncopied_parts), 0, 0);
6178: noncopied_parts = TREE_CHAIN (noncopied_parts);
6179: }
6180: return temp;
6181: }
6182:
6183: case MODIFY_EXPR:
6184: {
6185: /* If lhs is complex, expand calls in rhs before computing it.
6186: That's so we don't compute a pointer and save it over a call.
6187: If lhs is simple, compute it first so we can give it as a
6188: target if the rhs is just a call. This avoids an extra temp and copy
6189: and that prevents a partial-subsumption which makes bad code.
6190: Actually we could treat component_ref's of vars like vars. */
6191:
6192: tree lhs = TREE_OPERAND (exp, 0);
6193: tree rhs = TREE_OPERAND (exp, 1);
6194: tree noncopied_parts = 0;
6195: tree lhs_type = TREE_TYPE (lhs);
6196:
6197: temp = 0;
6198:
6199: if (TREE_CODE (lhs) != VAR_DECL
6200: && TREE_CODE (lhs) != RESULT_DECL
6201: && TREE_CODE (lhs) != PARM_DECL)
6202: preexpand_calls (exp);
6203:
6204: /* Check for |= or &= of a bitfield of size one into another bitfield
6205: of size 1. In this case, (unless we need the result of the
6206: assignment) we can do this more efficiently with a
6207: test followed by an assignment, if necessary.
6208:
6209: ??? At this point, we can't get a BIT_FIELD_REF here. But if
6210: things change so we do, this code should be enhanced to
6211: support it. */
6212: if (ignore
6213: && TREE_CODE (lhs) == COMPONENT_REF
6214: && (TREE_CODE (rhs) == BIT_IOR_EXPR
6215: || TREE_CODE (rhs) == BIT_AND_EXPR)
6216: && TREE_OPERAND (rhs, 0) == lhs
6217: && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
6218: && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs, 1))) == 1
6219: && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))) == 1)
6220: {
6221: rtx label = gen_label_rtx ();
6222:
6223: do_jump (TREE_OPERAND (rhs, 1),
6224: TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
6225: TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
6226: expand_assignment (lhs, convert (TREE_TYPE (rhs),
6227: (TREE_CODE (rhs) == BIT_IOR_EXPR
6228: ? integer_one_node
6229: : integer_zero_node)),
6230: 0, 0);
1.1.1.3 root 6231: do_pending_stack_adjust ();
1.1 root 6232: emit_label (label);
6233: return const0_rtx;
6234: }
6235:
6236: if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
6237: && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
6238: noncopied_parts = save_noncopied_parts (stabilize_reference (lhs),
6239: TYPE_NONCOPIED_PARTS (lhs_type));
6240:
6241: temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
6242: while (noncopied_parts != 0)
6243: {
6244: expand_assignment (TREE_PURPOSE (noncopied_parts),
6245: TREE_VALUE (noncopied_parts), 0, 0);
6246: noncopied_parts = TREE_CHAIN (noncopied_parts);
6247: }
6248: return temp;
6249: }
6250:
6251: case PREINCREMENT_EXPR:
6252: case PREDECREMENT_EXPR:
6253: return expand_increment (exp, 0);
6254:
6255: case POSTINCREMENT_EXPR:
6256: case POSTDECREMENT_EXPR:
6257: /* Faster to treat as pre-increment if result is not used. */
6258: return expand_increment (exp, ! ignore);
6259:
6260: case ADDR_EXPR:
1.1.1.7 root 6261: /* If nonzero, TEMP will be set to the address of something that might
6262: be a MEM corresponding to a stack slot. */
6263: temp = 0;
6264:
1.1 root 6265: /* Are we taking the address of a nested function? */
6266: if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
6267: && decl_function_context (TREE_OPERAND (exp, 0)) != 0)
6268: {
6269: op0 = trampoline_address (TREE_OPERAND (exp, 0));
6270: op0 = force_operand (op0, target);
6271: }
1.1.1.7 root 6272: /* If we are taking the address of something erroneous, just
6273: return a zero. */
6274: else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
6275: return const0_rtx;
1.1 root 6276: else
6277: {
1.1.1.6 root 6278: /* We make sure to pass const0_rtx down if we came in with
6279: ignore set, to avoid doing the cleanups twice for something. */
6280: op0 = expand_expr (TREE_OPERAND (exp, 0),
6281: ignore ? const0_rtx : NULL_RTX, VOIDmode,
1.1 root 6282: (modifier == EXPAND_INITIALIZER
6283: ? modifier : EXPAND_CONST_ADDRESS));
1.1.1.5 root 6284:
1.1.1.7 root 6285: /* If we are going to ignore the result, OP0 will have been set
6286: to const0_rtx, so just return it. Don't get confused and
6287: think we are taking the address of the constant. */
6288: if (ignore)
6289: return op0;
6290:
1.1.1.5 root 6291: /* We would like the object in memory. If it is a constant,
6292: we can have it be statically allocated into memory. For
1.1.1.7 root 6293: a non-constant (REG, SUBREG or CONCAT), we need to allocate some
1.1.1.5 root 6294: memory and store the value into it. */
6295:
6296: if (CONSTANT_P (op0))
6297: op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
6298: op0);
1.1.1.7 root 6299: else if (GET_CODE (op0) == MEM)
6300: {
6301: mark_temp_addr_taken (op0);
6302: temp = XEXP (op0, 0);
6303: }
1.1.1.5 root 6304:
1.1.1.7 root 6305: else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6306: || GET_CODE (op0) == CONCAT)
1.1.1.5 root 6307: {
6308: /* If this object is in a register, it must be not
6309: be BLKmode. */
6310: tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
6311: enum machine_mode inner_mode = TYPE_MODE (inner_type);
6312: rtx memloc
6313: = assign_stack_temp (inner_mode,
6314: int_size_in_bytes (inner_type), 1);
1.1.1.8 root 6315: MEM_IN_STRUCT_P (memloc) = AGGREGATE_TYPE_P (inner_type);
1.1.1.5 root 6316:
1.1.1.7 root 6317: mark_temp_addr_taken (memloc);
1.1.1.5 root 6318: emit_move_insn (memloc, op0);
6319: op0 = memloc;
6320: }
6321:
1.1 root 6322: if (GET_CODE (op0) != MEM)
6323: abort ();
6324:
6325: if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
1.1.1.8 root 6326: {
6327: temp = XEXP (op0, 0);
6328: #ifdef POINTERS_EXTEND_UNSIGNED
6329: if (GET_MODE (temp) == Pmode && GET_MODE (temp) != mode
6330: && mode == ptr_mode)
6331: temp = convert_memory_address (ptr_mode, temp);
6332: #endif
6333: return temp;
6334: }
1.1.1.7 root 6335:
1.1 root 6336: op0 = force_operand (XEXP (op0, 0), target);
6337: }
1.1.1.7 root 6338:
1.1 root 6339: if (flag_force_addr && GET_CODE (op0) != REG)
1.1.1.7 root 6340: op0 = force_reg (Pmode, op0);
6341:
6342: if (GET_CODE (op0) == REG)
6343: mark_reg_pointer (op0);
6344:
6345: /* If we might have had a temp slot, add an equivalent address
6346: for it. */
6347: if (temp != 0)
6348: update_temp_slot_address (temp, op0);
6349:
1.1.1.8 root 6350: #ifdef POINTERS_EXTEND_UNSIGNED
6351: if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
6352: && mode == ptr_mode)
6353: op0 = convert_memory_address (ptr_mode, op0);
6354: #endif
6355:
1.1 root 6356: return op0;
6357:
6358: case ENTRY_VALUE_EXPR:
6359: abort ();
6360:
1.1.1.4 root 6361: /* COMPLEX type for Extended Pascal & Fortran */
6362: case COMPLEX_EXPR:
6363: {
6364: enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
1.1.1.7 root 6365: rtx insns;
1.1.1.4 root 6366:
6367: /* Get the rtx code of the operands. */
6368: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
6369: op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
6370:
6371: if (! target)
6372: target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
6373:
1.1.1.7 root 6374: start_sequence ();
1.1.1.4 root 6375:
6376: /* Move the real (op0) and imaginary (op1) parts to their location. */
6377: emit_move_insn (gen_realpart (mode, target), op0);
6378: emit_move_insn (gen_imagpart (mode, target), op1);
6379:
1.1.1.7 root 6380: insns = get_insns ();
6381: end_sequence ();
6382:
1.1.1.4 root 6383: /* Complex construction should appear as a single unit. */
1.1.1.7 root 6384: /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
6385: each with a separate pseudo as destination.
6386: It's not correct for flow to treat them as a unit. */
1.1.1.6 root 6387: if (GET_CODE (target) != CONCAT)
1.1.1.7 root 6388: emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
6389: else
6390: emit_insns (insns);
1.1.1.4 root 6391:
6392: return target;
6393: }
6394:
6395: case REALPART_EXPR:
6396: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
6397: return gen_realpart (mode, op0);
6398:
6399: case IMAGPART_EXPR:
6400: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
6401: return gen_imagpart (mode, op0);
6402:
6403: case CONJ_EXPR:
6404: {
1.1.1.7 root 6405: enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
1.1.1.4 root 6406: rtx imag_t;
1.1.1.7 root 6407: rtx insns;
1.1.1.4 root 6408:
6409: op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
6410:
6411: if (! target)
1.1.1.7 root 6412: target = gen_reg_rtx (mode);
1.1.1.4 root 6413:
1.1.1.7 root 6414: start_sequence ();
1.1.1.4 root 6415:
6416: /* Store the realpart and the negated imagpart to target. */
1.1.1.7 root 6417: emit_move_insn (gen_realpart (partmode, target),
6418: gen_realpart (partmode, op0));
1.1.1.4 root 6419:
1.1.1.7 root 6420: imag_t = gen_imagpart (partmode, target);
6421: temp = expand_unop (partmode, neg_optab,
6422: gen_imagpart (partmode, op0), imag_t, 0);
1.1.1.4 root 6423: if (temp != imag_t)
6424: emit_move_insn (imag_t, temp);
6425:
1.1.1.7 root 6426: insns = get_insns ();
6427: end_sequence ();
6428:
6429: /* Conjugate should appear as a single unit
6430: If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
6431: each with a separate pseudo as destination.
6432: It's not correct for flow to treat them as a unit. */
1.1.1.6 root 6433: if (GET_CODE (target) != CONCAT)
1.1.1.7 root 6434: emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
6435: else
6436: emit_insns (insns);
1.1.1.4 root 6437:
6438: return target;
6439: }
6440:
1.1 root 6441: case ERROR_MARK:
1.1.1.5 root 6442: op0 = CONST0_RTX (tmode);
6443: if (op0 != 0)
6444: return op0;
1.1 root 6445: return const0_rtx;
6446:
6447: default:
1.1.1.6 root 6448: return (*lang_expand_expr) (exp, original_target, tmode, modifier);
1.1 root 6449: }
6450:
6451: /* Here to do an ordinary binary operator, generating an instruction
6452: from the optab already placed in `this_optab'. */
6453: binop:
6454: preexpand_calls (exp);
6455: if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
6456: subtarget = 0;
6457: op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
1.1.1.4 root 6458: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1 root 6459: binop2:
6460: temp = expand_binop (mode, this_optab, op0, op1, target,
6461: unsignedp, OPTAB_LIB_WIDEN);
6462: if (temp == 0)
6463: abort ();
6464: return temp;
6465: }
6466:
6467:
1.1.1.6 root 6468: /* Emit bytecode to evaluate the given expression EXP to the stack. */
6469: void
6470: bc_expand_expr (exp)
6471: tree exp;
1.1 root 6472: {
1.1.1.6 root 6473: enum tree_code code;
6474: tree type, arg0;
6475: rtx r;
6476: struct binary_operator *binoptab;
6477: struct unary_operator *unoptab;
6478: struct increment_operator *incroptab;
6479: struct bc_label *lab, *lab1;
6480: enum bytecode_opcode opcode;
6481:
6482:
6483: code = TREE_CODE (exp);
6484:
6485: switch (code)
6486: {
6487: case PARM_DECL:
6488:
6489: if (DECL_RTL (exp) == 0)
6490: {
6491: error_with_decl (exp, "prior parameter's size depends on `%s'");
6492: return;
6493: }
6494:
6495: bc_load_parmaddr (DECL_RTL (exp));
6496: bc_load_memory (TREE_TYPE (exp), exp);
6497:
6498: return;
6499:
6500: case VAR_DECL:
6501:
6502: if (DECL_RTL (exp) == 0)
6503: abort ();
6504:
6505: #if 0
6506: if (BYTECODE_LABEL (DECL_RTL (exp)))
6507: bc_load_externaddr (DECL_RTL (exp));
6508: else
6509: bc_load_localaddr (DECL_RTL (exp));
6510: #endif
6511: if (TREE_PUBLIC (exp))
6512: bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
6513: BYTECODE_BC_LABEL (DECL_RTL (exp))->offset);
6514: else
6515: bc_load_localaddr (DECL_RTL (exp));
6516:
6517: bc_load_memory (TREE_TYPE (exp), exp);
6518: return;
6519:
6520: case INTEGER_CST:
6521:
6522: #ifdef DEBUG_PRINT_CODE
6523: fprintf (stderr, " [%x]\n", TREE_INT_CST_LOW (exp));
6524: #endif
6525: bc_emit_instruction (mode_to_const_map[(int) (DECL_BIT_FIELD (exp)
6526: ? SImode
6527: : TYPE_MODE (TREE_TYPE (exp)))],
6528: (HOST_WIDE_INT) TREE_INT_CST_LOW (exp));
6529: return;
6530:
6531: case REAL_CST:
6532:
6533: #if 0
6534: #ifdef DEBUG_PRINT_CODE
6535: fprintf (stderr, " [%g]\n", (double) TREE_INT_CST_LOW (exp));
6536: #endif
6537: /* FIX THIS: find a better way to pass real_cst's. -bson */
6538: bc_emit_instruction (mode_to_const_map[TYPE_MODE (TREE_TYPE (exp))],
6539: (double) TREE_REAL_CST (exp));
6540: #else
6541: abort ();
6542: #endif
6543:
6544: return;
6545:
6546: case CALL_EXPR:
6547:
6548: /* We build a call description vector describing the type of
6549: the return value and of the arguments; this call vector,
6550: together with a pointer to a location for the return value
6551: and the base of the argument list, is passed to the low
6552: level machine dependent call subroutine, which is responsible
6553: for putting the arguments wherever real functions expect
6554: them, as well as getting the return value back. */
6555: {
6556: tree calldesc = 0, arg;
6557: int nargs = 0, i;
6558: rtx retval;
6559:
6560: /* Push the evaluated args on the evaluation stack in reverse
6561: order. Also make an entry for each arg in the calldesc
6562: vector while we're at it. */
6563:
6564: TREE_OPERAND (exp, 1) = nreverse (TREE_OPERAND (exp, 1));
6565:
6566: for (arg = TREE_OPERAND (exp, 1); arg; arg = TREE_CHAIN (arg))
6567: {
6568: ++nargs;
6569: bc_expand_expr (TREE_VALUE (arg));
6570:
6571: calldesc = tree_cons ((tree) 0,
6572: size_in_bytes (TREE_TYPE (TREE_VALUE (arg))),
6573: calldesc);
6574: calldesc = tree_cons ((tree) 0,
6575: bc_runtime_type_code (TREE_TYPE (TREE_VALUE (arg))),
6576: calldesc);
6577: }
6578:
6579: TREE_OPERAND (exp, 1) = nreverse (TREE_OPERAND (exp, 1));
6580:
6581: /* Allocate a location for the return value and push its
6582: address on the evaluation stack. Also make an entry
6583: at the front of the calldesc for the return value type. */
6584:
6585: type = TREE_TYPE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))));
6586: retval = bc_allocate_local (int_size_in_bytes (type), TYPE_ALIGN (type));
6587: bc_load_localaddr (retval);
6588:
6589: calldesc = tree_cons ((tree) 0, size_in_bytes (type), calldesc);
6590: calldesc = tree_cons ((tree) 0, bc_runtime_type_code (type), calldesc);
6591:
6592: /* Prepend the argument count. */
6593: calldesc = tree_cons ((tree) 0,
6594: build_int_2 (nargs, 0),
6595: calldesc);
6596:
6597: /* Push the address of the call description vector on the stack. */
6598: calldesc = build_nt (CONSTRUCTOR, (tree) 0, calldesc);
6599: TREE_TYPE (calldesc) = build_array_type (integer_type_node,
6600: build_index_type (build_int_2 (nargs * 2, 0)));
6601: r = output_constant_def (calldesc);
6602: bc_load_externaddr (r);
6603:
6604: /* Push the address of the function to be called. */
6605: bc_expand_expr (TREE_OPERAND (exp, 0));
6606:
6607: /* Call the function, popping its address and the calldesc vector
6608: address off the evaluation stack in the process. */
6609: bc_emit_instruction (call);
6610:
6611: /* Pop the arguments off the stack. */
6612: bc_adjust_stack (nargs);
6613:
6614: /* Load the return value onto the stack. */
6615: bc_load_localaddr (retval);
6616: bc_load_memory (type, TREE_OPERAND (exp, 0));
6617: }
6618: return;
6619:
6620: case SAVE_EXPR:
6621:
6622: if (!SAVE_EXPR_RTL (exp))
6623: {
6624: /* First time around: copy to local variable */
6625: SAVE_EXPR_RTL (exp) = bc_allocate_local (int_size_in_bytes (TREE_TYPE (exp)),
6626: TYPE_ALIGN (TREE_TYPE(exp)));
6627: bc_expand_expr (TREE_OPERAND (exp, 0));
6628: bc_emit_instruction (duplicate);
6629:
6630: bc_load_localaddr (SAVE_EXPR_RTL (exp));
6631: bc_store_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
6632: }
6633: else
6634: {
6635: /* Consecutive reference: use saved copy */
6636: bc_load_localaddr (SAVE_EXPR_RTL (exp));
6637: bc_load_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
6638: }
6639: return;
6640:
6641: #if 0
6642: /* FIXME: the XXXX_STMT codes have been removed in GCC2, but
6643: how are they handled instead? */
6644: case LET_STMT:
6645:
6646: TREE_USED (exp) = 1;
6647: bc_expand_expr (STMT_BODY (exp));
6648: return;
6649: #endif
6650:
6651: case NOP_EXPR:
6652: case CONVERT_EXPR:
6653:
6654: bc_expand_expr (TREE_OPERAND (exp, 0));
6655: bc_expand_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)), TREE_TYPE (exp));
6656: return;
6657:
6658: case MODIFY_EXPR:
6659:
6660: expand_assignment (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1), 0, 0);
6661: return;
6662:
6663: case ADDR_EXPR:
6664:
6665: bc_expand_address (TREE_OPERAND (exp, 0));
6666: return;
6667:
6668: case INDIRECT_REF:
6669:
6670: bc_expand_expr (TREE_OPERAND (exp, 0));
6671: bc_load_memory (TREE_TYPE (exp), TREE_OPERAND (exp, 0));
6672: return;
6673:
6674: case ARRAY_REF:
6675:
6676: bc_expand_expr (bc_canonicalize_array_ref (exp));
6677: return;
6678:
6679: case COMPONENT_REF:
6680:
6681: bc_expand_component_address (exp);
6682:
6683: /* If we have a bitfield, generate a proper load */
6684: bc_load_memory (TREE_TYPE (TREE_OPERAND (exp, 1)), TREE_OPERAND (exp, 1));
6685: return;
6686:
6687: case COMPOUND_EXPR:
6688:
6689: bc_expand_expr (TREE_OPERAND (exp, 0));
6690: bc_emit_instruction (drop);
6691: bc_expand_expr (TREE_OPERAND (exp, 1));
6692: return;
6693:
6694: case COND_EXPR:
6695:
6696: bc_expand_expr (TREE_OPERAND (exp, 0));
6697: bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)));
6698: lab = bc_get_bytecode_label ();
6699: bc_emit_bytecode (xjumpifnot);
6700: bc_emit_bytecode_labelref (lab);
6701:
6702: #ifdef DEBUG_PRINT_CODE
6703: fputc ('\n', stderr);
6704: #endif
6705: bc_expand_expr (TREE_OPERAND (exp, 1));
6706: lab1 = bc_get_bytecode_label ();
6707: bc_emit_bytecode (jump);
6708: bc_emit_bytecode_labelref (lab1);
6709:
6710: #ifdef DEBUG_PRINT_CODE
6711: fputc ('\n', stderr);
6712: #endif
6713:
6714: bc_emit_bytecode_labeldef (lab);
6715: bc_expand_expr (TREE_OPERAND (exp, 2));
6716: bc_emit_bytecode_labeldef (lab1);
6717: return;
6718:
6719: case TRUTH_ANDIF_EXPR:
6720:
6721: opcode = xjumpifnot;
6722: goto andorif;
6723:
6724: case TRUTH_ORIF_EXPR:
6725:
6726: opcode = xjumpif;
6727: goto andorif;
6728:
6729: case PLUS_EXPR:
6730:
6731: binoptab = optab_plus_expr;
6732: goto binop;
6733:
6734: case MINUS_EXPR:
6735:
6736: binoptab = optab_minus_expr;
6737: goto binop;
6738:
6739: case MULT_EXPR:
6740:
6741: binoptab = optab_mult_expr;
6742: goto binop;
6743:
6744: case TRUNC_DIV_EXPR:
6745: case FLOOR_DIV_EXPR:
6746: case CEIL_DIV_EXPR:
6747: case ROUND_DIV_EXPR:
6748: case EXACT_DIV_EXPR:
6749:
6750: binoptab = optab_trunc_div_expr;
6751: goto binop;
6752:
6753: case TRUNC_MOD_EXPR:
6754: case FLOOR_MOD_EXPR:
6755: case CEIL_MOD_EXPR:
6756: case ROUND_MOD_EXPR:
6757:
6758: binoptab = optab_trunc_mod_expr;
6759: goto binop;
6760:
6761: case FIX_ROUND_EXPR:
6762: case FIX_FLOOR_EXPR:
6763: case FIX_CEIL_EXPR:
6764: abort (); /* Not used for C. */
6765:
6766: case FIX_TRUNC_EXPR:
6767: case FLOAT_EXPR:
6768: case MAX_EXPR:
6769: case MIN_EXPR:
6770: case FFS_EXPR:
6771: case LROTATE_EXPR:
6772: case RROTATE_EXPR:
6773: abort (); /* FIXME */
6774:
6775: case RDIV_EXPR:
6776:
6777: binoptab = optab_rdiv_expr;
6778: goto binop;
6779:
6780: case BIT_AND_EXPR:
6781:
6782: binoptab = optab_bit_and_expr;
6783: goto binop;
6784:
6785: case BIT_IOR_EXPR:
6786:
6787: binoptab = optab_bit_ior_expr;
6788: goto binop;
6789:
6790: case BIT_XOR_EXPR:
6791:
6792: binoptab = optab_bit_xor_expr;
6793: goto binop;
6794:
6795: case LSHIFT_EXPR:
6796:
6797: binoptab = optab_lshift_expr;
6798: goto binop;
6799:
6800: case RSHIFT_EXPR:
6801:
6802: binoptab = optab_rshift_expr;
6803: goto binop;
6804:
6805: case TRUTH_AND_EXPR:
6806:
6807: binoptab = optab_truth_and_expr;
6808: goto binop;
6809:
6810: case TRUTH_OR_EXPR:
6811:
6812: binoptab = optab_truth_or_expr;
6813: goto binop;
6814:
6815: case LT_EXPR:
6816:
6817: binoptab = optab_lt_expr;
6818: goto binop;
6819:
6820: case LE_EXPR:
6821:
6822: binoptab = optab_le_expr;
6823: goto binop;
6824:
6825: case GE_EXPR:
6826:
6827: binoptab = optab_ge_expr;
6828: goto binop;
6829:
6830: case GT_EXPR:
6831:
6832: binoptab = optab_gt_expr;
6833: goto binop;
6834:
6835: case EQ_EXPR:
6836:
6837: binoptab = optab_eq_expr;
6838: goto binop;
6839:
6840: case NE_EXPR:
6841:
6842: binoptab = optab_ne_expr;
6843: goto binop;
6844:
6845: case NEGATE_EXPR:
6846:
6847: unoptab = optab_negate_expr;
6848: goto unop;
6849:
6850: case BIT_NOT_EXPR:
6851:
6852: unoptab = optab_bit_not_expr;
6853: goto unop;
6854:
6855: case TRUTH_NOT_EXPR:
6856:
6857: unoptab = optab_truth_not_expr;
6858: goto unop;
6859:
6860: case PREDECREMENT_EXPR:
6861:
6862: incroptab = optab_predecrement_expr;
6863: goto increment;
6864:
6865: case PREINCREMENT_EXPR:
6866:
6867: incroptab = optab_preincrement_expr;
6868: goto increment;
6869:
6870: case POSTDECREMENT_EXPR:
6871:
6872: incroptab = optab_postdecrement_expr;
6873: goto increment;
6874:
6875: case POSTINCREMENT_EXPR:
6876:
6877: incroptab = optab_postincrement_expr;
6878: goto increment;
6879:
6880: case CONSTRUCTOR:
6881:
6882: bc_expand_constructor (exp);
6883: return;
6884:
6885: case ERROR_MARK:
6886: case RTL_EXPR:
6887:
6888: return;
6889:
6890: case BIND_EXPR:
6891: {
6892: tree vars = TREE_OPERAND (exp, 0);
6893: int vars_need_expansion = 0;
6894:
6895: /* Need to open a binding contour here because
6896: if there are any cleanups they most be contained here. */
6897: expand_start_bindings (0);
6898:
6899: /* Mark the corresponding BLOCK for output. */
6900: if (TREE_OPERAND (exp, 2) != 0)
6901: TREE_USED (TREE_OPERAND (exp, 2)) = 1;
6902:
6903: /* If VARS have not yet been expanded, expand them now. */
6904: while (vars)
6905: {
6906: if (DECL_RTL (vars) == 0)
6907: {
6908: vars_need_expansion = 1;
1.1.1.7 root 6909: expand_decl (vars);
1.1.1.6 root 6910: }
1.1.1.7 root 6911: expand_decl_init (vars);
1.1.1.6 root 6912: vars = TREE_CHAIN (vars);
6913: }
6914:
6915: bc_expand_expr (TREE_OPERAND (exp, 1));
6916:
6917: expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6918:
6919: return;
6920: }
6921: }
6922:
6923: abort ();
6924:
6925: binop:
6926:
6927: bc_expand_binary_operation (binoptab, TREE_TYPE (exp),
6928: TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1));
6929: return;
6930:
6931:
6932: unop:
6933:
6934: bc_expand_unary_operation (unoptab, TREE_TYPE (exp), TREE_OPERAND (exp, 0));
6935: return;
6936:
6937:
6938: andorif:
6939:
6940: bc_expand_expr (TREE_OPERAND (exp, 0));
6941: bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 0)));
6942: lab = bc_get_bytecode_label ();
6943:
6944: bc_emit_instruction (duplicate);
6945: bc_emit_bytecode (opcode);
6946: bc_emit_bytecode_labelref (lab);
6947:
6948: #ifdef DEBUG_PRINT_CODE
6949: fputc ('\n', stderr);
6950: #endif
6951:
6952: bc_emit_instruction (drop);
6953:
6954: bc_expand_expr (TREE_OPERAND (exp, 1));
6955: bc_expand_truth_conversion (TREE_TYPE (TREE_OPERAND (exp, 1)));
6956: bc_emit_bytecode_labeldef (lab);
6957: return;
6958:
6959:
6960: increment:
6961:
6962: type = TREE_TYPE (TREE_OPERAND (exp, 0));
6963:
6964: /* Push the quantum. */
6965: bc_expand_expr (TREE_OPERAND (exp, 1));
6966:
6967: /* Convert it to the lvalue's type. */
6968: bc_expand_conversion (TREE_TYPE (TREE_OPERAND (exp, 1)), type);
6969:
6970: /* Push the address of the lvalue */
6971: bc_expand_expr (build1 (ADDR_EXPR, TYPE_POINTER_TO (type), TREE_OPERAND (exp, 0)));
6972:
6973: /* Perform actual increment */
6974: bc_expand_increment (incroptab, type);
6975: return;
6976: }
6977:
6978: /* Return the alignment in bits of EXP, a pointer valued expression.
6979: But don't return more than MAX_ALIGN no matter what.
6980: The alignment returned is, by default, the alignment of the thing that
6981: EXP points to (if it is not a POINTER_TYPE, 0 is returned).
6982:
6983: Otherwise, look at the expression to see if we can do better, i.e., if the
6984: expression is actually pointing at an object whose alignment is tighter. */
6985:
6986: static int
6987: get_pointer_alignment (exp, max_align)
6988: tree exp;
6989: unsigned max_align;
6990: {
6991: unsigned align, inner;
6992:
6993: if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
6994: return 0;
6995:
6996: align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
6997: align = MIN (align, max_align);
6998:
6999: while (1)
7000: {
7001: switch (TREE_CODE (exp))
7002: {
7003: case NOP_EXPR:
7004: case CONVERT_EXPR:
7005: case NON_LVALUE_EXPR:
7006: exp = TREE_OPERAND (exp, 0);
7007: if (TREE_CODE (TREE_TYPE (exp)) != POINTER_TYPE)
7008: return align;
7009: inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
1.1.1.7 root 7010: align = MIN (inner, max_align);
1.1.1.6 root 7011: break;
7012:
7013: case PLUS_EXPR:
7014: /* If sum of pointer + int, restrict our maximum alignment to that
7015: imposed by the integer. If not, we can't do any better than
7016: ALIGN. */
7017: if (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST)
7018: return align;
7019:
7020: while (((TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT)
7021: & (max_align - 1))
7022: != 0)
7023: max_align >>= 1;
7024:
7025: exp = TREE_OPERAND (exp, 0);
7026: break;
7027:
7028: case ADDR_EXPR:
7029: /* See what we are pointing at and look at its alignment. */
7030: exp = TREE_OPERAND (exp, 0);
7031: if (TREE_CODE (exp) == FUNCTION_DECL)
1.1.1.7 root 7032: align = FUNCTION_BOUNDARY;
1.1.1.6 root 7033: else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1.1.1.7 root 7034: align = DECL_ALIGN (exp);
1.1.1.6 root 7035: #ifdef CONSTANT_ALIGNMENT
7036: else if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c')
7037: align = CONSTANT_ALIGNMENT (exp, align);
7038: #endif
7039: return MIN (align, max_align);
7040:
7041: default:
7042: return align;
7043: }
7044: }
7045: }
7046:
7047: /* Return the tree node and offset if a given argument corresponds to
7048: a string constant. */
7049:
7050: static tree
7051: string_constant (arg, ptr_offset)
7052: tree arg;
7053: tree *ptr_offset;
7054: {
7055: STRIP_NOPS (arg);
7056:
7057: if (TREE_CODE (arg) == ADDR_EXPR
7058: && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
7059: {
7060: *ptr_offset = integer_zero_node;
7061: return TREE_OPERAND (arg, 0);
7062: }
7063: else if (TREE_CODE (arg) == PLUS_EXPR)
7064: {
7065: tree arg0 = TREE_OPERAND (arg, 0);
7066: tree arg1 = TREE_OPERAND (arg, 1);
7067:
7068: STRIP_NOPS (arg0);
7069: STRIP_NOPS (arg1);
7070:
7071: if (TREE_CODE (arg0) == ADDR_EXPR
7072: && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
7073: {
7074: *ptr_offset = arg1;
7075: return TREE_OPERAND (arg0, 0);
7076: }
7077: else if (TREE_CODE (arg1) == ADDR_EXPR
7078: && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
7079: {
7080: *ptr_offset = arg0;
7081: return TREE_OPERAND (arg1, 0);
7082: }
7083: }
7084:
7085: return 0;
7086: }
7087:
7088: /* Compute the length of a C string. TREE_STRING_LENGTH is not the right
7089: way, because it could contain a zero byte in the middle.
7090: TREE_STRING_LENGTH is the size of the character array, not the string.
7091:
7092: Unfortunately, string_constant can't access the values of const char
7093: arrays with initializers, so neither can we do so here. */
7094:
7095: static tree
7096: c_strlen (src)
7097: tree src;
7098: {
7099: tree offset_node;
7100: int offset, max;
7101: char *ptr;
7102:
7103: src = string_constant (src, &offset_node);
7104: if (src == 0)
7105: return 0;
7106: max = TREE_STRING_LENGTH (src);
7107: ptr = TREE_STRING_POINTER (src);
7108: if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
7109: {
7110: /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
7111: compute the offset to the following null if we don't know where to
7112: start searching for it. */
7113: int i;
7114: for (i = 0; i < max; i++)
7115: if (ptr[i] == 0)
7116: return 0;
7117: /* We don't know the starting offset, but we do know that the string
7118: has no internal zero bytes. We can assume that the offset falls
7119: within the bounds of the string; otherwise, the programmer deserves
7120: what he gets. Subtract the offset from the length of the string,
7121: and return that. */
7122: /* This would perhaps not be valid if we were dealing with named
7123: arrays in addition to literal string constants. */
7124: return size_binop (MINUS_EXPR, size_int (max), offset_node);
7125: }
7126:
7127: /* We have a known offset into the string. Start searching there for
7128: a null character. */
7129: if (offset_node == 0)
7130: offset = 0;
7131: else
7132: {
7133: /* Did we get a long long offset? If so, punt. */
7134: if (TREE_INT_CST_HIGH (offset_node) != 0)
7135: return 0;
7136: offset = TREE_INT_CST_LOW (offset_node);
7137: }
7138: /* If the offset is known to be out of bounds, warn, and call strlen at
7139: runtime. */
7140: if (offset < 0 || offset > max)
7141: {
7142: warning ("offset outside bounds of constant string");
7143: return 0;
7144: }
7145: /* Use strlen to search for the first zero byte. Since any strings
7146: constructed with build_string will have nulls appended, we win even
7147: if we get handed something like (char[4])"abcd".
7148:
7149: Since OFFSET is our starting index into the string, no further
7150: calculation is needed. */
7151: return size_int (strlen (ptr + offset));
7152: }
1.1.1.8 root 7153:
7154: rtx
7155: expand_builtin_return_addr (fndecl_code, count, tem)
7156: enum built_in_function fndecl_code;
7157: rtx tem;
7158: int count;
7159: {
7160: int i;
7161:
7162: /* Some machines need special handling before we can access
7163: arbitrary frames. For example, on the sparc, we must first flush
7164: all register windows to the stack. */
7165: #ifdef SETUP_FRAME_ADDRESSES
7166: SETUP_FRAME_ADDRESSES ();
7167: #endif
7168:
7169: /* On the sparc, the return address is not in the frame, it is in a
7170: register. There is no way to access it off of the current frame
7171: pointer, but it can be accessed off the previous frame pointer by
7172: reading the value from the register window save area. */
7173: #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
7174: if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
7175: count--;
7176: #endif
7177:
7178: /* Scan back COUNT frames to the specified frame. */
7179: for (i = 0; i < count; i++)
7180: {
7181: /* Assume the dynamic chain pointer is in the word that the
7182: frame address points to, unless otherwise specified. */
7183: #ifdef DYNAMIC_CHAIN_ADDRESS
7184: tem = DYNAMIC_CHAIN_ADDRESS (tem);
7185: #endif
7186: tem = memory_address (Pmode, tem);
7187: tem = copy_to_reg (gen_rtx (MEM, Pmode, tem));
7188: }
7189:
7190: /* For __builtin_frame_address, return what we've got. */
7191: if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
7192: return tem;
7193:
7194: /* For __builtin_return_address, Get the return address from that
7195: frame. */
7196: #ifdef RETURN_ADDR_RTX
7197: tem = RETURN_ADDR_RTX (count, tem);
7198: #else
7199: tem = memory_address (Pmode,
7200: plus_constant (tem, GET_MODE_SIZE (Pmode)));
7201: tem = gen_rtx (MEM, Pmode, tem);
7202: #endif
7203: return tem;
7204: }
1.1.1.6 root 7205:
7206: /* Expand an expression EXP that calls a built-in function,
7207: with result going to TARGET if that's convenient
7208: (and in mode MODE if that's convenient).
7209: SUBTARGET may be used as the target for computing one of EXP's operands.
7210: IGNORE is nonzero if the value is to be ignored. */
7211:
1.1.1.7 root 7212: #define CALLED_AS_BUILT_IN(NODE) \
7213: (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
7214:
1.1.1.6 root 7215: static rtx
7216: expand_builtin (exp, target, subtarget, mode, ignore)
7217: tree exp;
7218: rtx target;
7219: rtx subtarget;
7220: enum machine_mode mode;
7221: int ignore;
7222: {
7223: tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7224: tree arglist = TREE_OPERAND (exp, 1);
7225: rtx op0;
7226: rtx lab1, insns;
7227: enum machine_mode value_mode = TYPE_MODE (TREE_TYPE (exp));
7228: optab builtin_optab;
7229:
7230: switch (DECL_FUNCTION_CODE (fndecl))
7231: {
7232: case BUILT_IN_ABS:
7233: case BUILT_IN_LABS:
7234: case BUILT_IN_FABS:
7235: /* build_function_call changes these into ABS_EXPR. */
7236: abort ();
7237:
7238: case BUILT_IN_SIN:
7239: case BUILT_IN_COS:
1.1.1.7 root 7240: /* Treat these like sqrt, but only if the user asks for them. */
7241: if (! flag_fast_math)
7242: break;
1.1.1.6 root 7243: case BUILT_IN_FSQRT:
7244: /* If not optimizing, call the library function. */
7245: if (! optimize)
7246: break;
7247:
7248: if (arglist == 0
7249: /* Arg could be wrong type if user redeclared this fcn wrong. */
7250: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != REAL_TYPE)
7251: break;
7252:
7253: /* Stabilize and compute the argument. */
7254: if (TREE_CODE (TREE_VALUE (arglist)) != VAR_DECL
7255: && TREE_CODE (TREE_VALUE (arglist)) != PARM_DECL)
7256: {
7257: exp = copy_node (exp);
7258: arglist = copy_node (arglist);
7259: TREE_OPERAND (exp, 1) = arglist;
7260: TREE_VALUE (arglist) = save_expr (TREE_VALUE (arglist));
7261: }
7262: op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
7263:
7264: /* Make a suitable register to place result in. */
7265: target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
7266:
7267: emit_queue ();
7268: start_sequence ();
7269:
7270: switch (DECL_FUNCTION_CODE (fndecl))
7271: {
7272: case BUILT_IN_SIN:
7273: builtin_optab = sin_optab; break;
7274: case BUILT_IN_COS:
7275: builtin_optab = cos_optab; break;
7276: case BUILT_IN_FSQRT:
7277: builtin_optab = sqrt_optab; break;
7278: default:
7279: abort ();
7280: }
7281:
7282: /* Compute into TARGET.
7283: Set TARGET to wherever the result comes back. */
7284: target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
7285: builtin_optab, op0, target, 0);
7286:
7287: /* If we were unable to expand via the builtin, stop the
7288: sequence (without outputting the insns) and break, causing
7289: a call the the library function. */
7290: if (target == 0)
7291: {
7292: end_sequence ();
7293: break;
7294: }
7295:
7296: /* Check the results by default. But if flag_fast_math is turned on,
7297: then assume sqrt will always be called with valid arguments. */
7298:
7299: if (! flag_fast_math)
7300: {
7301: /* Don't define the builtin FP instructions
7302: if your machine is not IEEE. */
7303: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
7304: abort ();
7305:
7306: lab1 = gen_label_rtx ();
7307:
7308: /* Test the result; if it is NaN, set errno=EDOM because
7309: the argument was not in the domain. */
7310: emit_cmp_insn (target, target, EQ, 0, GET_MODE (target), 0, 0);
7311: emit_jump_insn (gen_beq (lab1));
7312:
1.1.1.7 root 7313: #ifdef TARGET_EDOM
1.1.1.6 root 7314: {
7315: #ifdef GEN_ERRNO_RTX
7316: rtx errno_rtx = GEN_ERRNO_RTX;
7317: #else
7318: rtx errno_rtx
1.1.1.7 root 7319: = gen_rtx (MEM, word_mode, gen_rtx (SYMBOL_REF, Pmode, "errno"));
1.1.1.6 root 7320: #endif
7321:
7322: emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
7323: }
7324: #else
7325: /* We can't set errno=EDOM directly; let the library call do it.
7326: Pop the arguments right away in case the call gets deleted. */
7327: NO_DEFER_POP;
7328: expand_call (exp, target, 0);
7329: OK_DEFER_POP;
7330: #endif
7331:
7332: emit_label (lab1);
7333: }
7334:
7335: /* Output the entire sequence. */
7336: insns = get_insns ();
7337: end_sequence ();
7338: emit_insns (insns);
7339:
7340: return target;
7341:
7342: /* __builtin_apply_args returns block of memory allocated on
7343: the stack into which is stored the arg pointer, structure
7344: value address, static chain, and all the registers that might
7345: possibly be used in performing a function call. The code is
7346: moved to the start of the function so the incoming values are
7347: saved. */
7348: case BUILT_IN_APPLY_ARGS:
7349: /* Don't do __builtin_apply_args more than once in a function.
7350: Save the result of the first call and reuse it. */
7351: if (apply_args_value != 0)
7352: return apply_args_value;
7353: {
7354: /* When this function is called, it means that registers must be
7355: saved on entry to this function. So we migrate the
7356: call to the first insn of this function. */
7357: rtx temp;
7358: rtx seq;
7359:
7360: start_sequence ();
7361: temp = expand_builtin_apply_args ();
7362: seq = get_insns ();
7363: end_sequence ();
7364:
7365: apply_args_value = temp;
7366:
7367: /* Put the sequence after the NOTE that starts the function.
7368: If this is inside a SEQUENCE, make the outer-level insn
7369: chain current, so the code is placed at the start of the
7370: function. */
7371: push_topmost_sequence ();
7372: emit_insns_before (seq, NEXT_INSN (get_insns ()));
7373: pop_topmost_sequence ();
7374: return temp;
7375: }
7376:
7377: /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
7378: FUNCTION with a copy of the parameters described by
7379: ARGUMENTS, and ARGSIZE. It returns a block of memory
7380: allocated on the stack into which is stored all the registers
7381: that might possibly be used for returning the result of a
7382: function. ARGUMENTS is the value returned by
7383: __builtin_apply_args. ARGSIZE is the number of bytes of
7384: arguments that must be copied. ??? How should this value be
7385: computed? We'll also need a safe worst case value for varargs
7386: functions. */
7387: case BUILT_IN_APPLY:
7388: if (arglist == 0
7389: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7390: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
7391: || TREE_CHAIN (arglist) == 0
7392: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
7393: || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
7394: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
7395: return const0_rtx;
7396: else
7397: {
7398: int i;
7399: tree t;
7400: rtx ops[3];
7401:
7402: for (t = arglist, i = 0; t; t = TREE_CHAIN (t), i++)
7403: ops[i] = expand_expr (TREE_VALUE (t), NULL_RTX, VOIDmode, 0);
7404:
7405: return expand_builtin_apply (ops[0], ops[1], ops[2]);
7406: }
7407:
7408: /* __builtin_return (RESULT) causes the function to return the
7409: value described by RESULT. RESULT is address of the block of
7410: memory returned by __builtin_apply. */
7411: case BUILT_IN_RETURN:
7412: if (arglist
7413: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7414: && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE)
7415: expand_builtin_return (expand_expr (TREE_VALUE (arglist),
7416: NULL_RTX, VOIDmode, 0));
7417: return const0_rtx;
7418:
7419: case BUILT_IN_SAVEREGS:
7420: /* Don't do __builtin_saveregs more than once in a function.
7421: Save the result of the first call and reuse it. */
7422: if (saveregs_value != 0)
7423: return saveregs_value;
7424: {
7425: /* When this function is called, it means that registers must be
7426: saved on entry to this function. So we migrate the
7427: call to the first insn of this function. */
7428: rtx temp;
7429: rtx seq;
7430:
7431: /* Now really call the function. `expand_call' does not call
7432: expand_builtin, so there is no danger of infinite recursion here. */
7433: start_sequence ();
7434:
7435: #ifdef EXPAND_BUILTIN_SAVEREGS
7436: /* Do whatever the machine needs done in this case. */
7437: temp = EXPAND_BUILTIN_SAVEREGS (arglist);
7438: #else
7439: /* The register where the function returns its value
7440: is likely to have something else in it, such as an argument.
7441: So preserve that register around the call. */
1.1.1.7 root 7442:
1.1.1.6 root 7443: if (value_mode != VOIDmode)
7444: {
1.1.1.7 root 7445: rtx valreg = hard_libcall_value (value_mode);
7446: rtx saved_valreg = gen_reg_rtx (value_mode);
7447:
1.1.1.6 root 7448: emit_move_insn (saved_valreg, valreg);
1.1.1.7 root 7449: temp = expand_call (exp, target, ignore);
7450: emit_move_insn (valreg, saved_valreg);
1.1.1.6 root 7451: }
1.1.1.7 root 7452: else
7453: /* Generate the call, putting the value in a pseudo. */
7454: temp = expand_call (exp, target, ignore);
1.1.1.6 root 7455: #endif
7456:
7457: seq = get_insns ();
7458: end_sequence ();
7459:
7460: saveregs_value = temp;
7461:
7462: /* Put the sequence after the NOTE that starts the function.
7463: If this is inside a SEQUENCE, make the outer-level insn
7464: chain current, so the code is placed at the start of the
7465: function. */
7466: push_topmost_sequence ();
7467: emit_insns_before (seq, NEXT_INSN (get_insns ()));
7468: pop_topmost_sequence ();
7469: return temp;
7470: }
7471:
7472: /* __builtin_args_info (N) returns word N of the arg space info
7473: for the current function. The number and meanings of words
7474: is controlled by the definition of CUMULATIVE_ARGS. */
7475: case BUILT_IN_ARGS_INFO:
7476: {
7477: int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
7478: int i;
7479: int *word_ptr = (int *) ¤t_function_args_info;
7480: tree type, elts, result;
7481:
7482: if (sizeof (CUMULATIVE_ARGS) % sizeof (int) != 0)
7483: fatal ("CUMULATIVE_ARGS type defined badly; see %s, line %d",
7484: __FILE__, __LINE__);
7485:
7486: if (arglist != 0)
7487: {
7488: tree arg = TREE_VALUE (arglist);
7489: if (TREE_CODE (arg) != INTEGER_CST)
7490: error ("argument of `__builtin_args_info' must be constant");
7491: else
7492: {
7493: int wordnum = TREE_INT_CST_LOW (arg);
7494:
7495: if (wordnum < 0 || wordnum >= nwords || TREE_INT_CST_HIGH (arg))
7496: error ("argument of `__builtin_args_info' out of range");
7497: else
7498: return GEN_INT (word_ptr[wordnum]);
7499: }
7500: }
7501: else
7502: error ("missing argument in `__builtin_args_info'");
7503:
7504: return const0_rtx;
7505:
7506: #if 0
7507: for (i = 0; i < nwords; i++)
7508: elts = tree_cons (NULL_TREE, build_int_2 (word_ptr[i], 0));
7509:
7510: type = build_array_type (integer_type_node,
7511: build_index_type (build_int_2 (nwords, 0)));
7512: result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (elts));
7513: TREE_CONSTANT (result) = 1;
7514: TREE_STATIC (result) = 1;
7515: result = build (INDIRECT_REF, build_pointer_type (type), result);
7516: TREE_CONSTANT (result) = 1;
7517: return expand_expr (result, NULL_RTX, VOIDmode, 0);
7518: #endif
7519: }
7520:
7521: /* Return the address of the first anonymous stack arg. */
7522: case BUILT_IN_NEXT_ARG:
7523: {
7524: tree fntype = TREE_TYPE (current_function_decl);
1.1.1.7 root 7525:
7526: if ((TYPE_ARG_TYPES (fntype) == 0
7527: || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
7528: == void_type_node))
7529: && ! current_function_varargs)
1.1.1.6 root 7530: {
7531: error ("`va_start' used in function with fixed args");
7532: return const0_rtx;
7533: }
1.1.1.7 root 7534:
7535: if (arglist)
7536: {
7537: tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
7538: tree arg = TREE_VALUE (arglist);
7539:
7540: /* Strip off all nops for the sake of the comparison. This
7541: is not quite the same as STRIP_NOPS. It does more. */
7542: while (TREE_CODE (arg) == NOP_EXPR
7543: || TREE_CODE (arg) == CONVERT_EXPR
7544: || TREE_CODE (arg) == NON_LVALUE_EXPR)
7545: arg = TREE_OPERAND (arg, 0);
7546: if (arg != last_parm)
7547: warning ("second parameter of `va_start' not last named argument");
7548: }
1.1.1.8 root 7549: else if (! current_function_varargs)
1.1.1.7 root 7550: /* Evidently an out of date version of <stdarg.h>; can't validate
7551: va_start's second argument, but can still work as intended. */
7552: warning ("`__builtin_next_arg' called without an argument");
1.1.1.6 root 7553: }
7554:
7555: return expand_binop (Pmode, add_optab,
7556: current_function_internal_arg_pointer,
7557: current_function_arg_offset_rtx,
7558: NULL_RTX, 0, OPTAB_LIB_WIDEN);
7559:
7560: case BUILT_IN_CLASSIFY_TYPE:
7561: if (arglist != 0)
7562: {
7563: tree type = TREE_TYPE (TREE_VALUE (arglist));
7564: enum tree_code code = TREE_CODE (type);
7565: if (code == VOID_TYPE)
7566: return GEN_INT (void_type_class);
7567: if (code == INTEGER_TYPE)
7568: return GEN_INT (integer_type_class);
7569: if (code == CHAR_TYPE)
7570: return GEN_INT (char_type_class);
7571: if (code == ENUMERAL_TYPE)
7572: return GEN_INT (enumeral_type_class);
7573: if (code == BOOLEAN_TYPE)
7574: return GEN_INT (boolean_type_class);
7575: if (code == POINTER_TYPE)
7576: return GEN_INT (pointer_type_class);
7577: if (code == REFERENCE_TYPE)
7578: return GEN_INT (reference_type_class);
7579: if (code == OFFSET_TYPE)
7580: return GEN_INT (offset_type_class);
7581: if (code == REAL_TYPE)
7582: return GEN_INT (real_type_class);
7583: if (code == COMPLEX_TYPE)
7584: return GEN_INT (complex_type_class);
7585: if (code == FUNCTION_TYPE)
7586: return GEN_INT (function_type_class);
7587: if (code == METHOD_TYPE)
7588: return GEN_INT (method_type_class);
7589: if (code == RECORD_TYPE)
7590: return GEN_INT (record_type_class);
7591: if (code == UNION_TYPE || code == QUAL_UNION_TYPE)
7592: return GEN_INT (union_type_class);
7593: if (code == ARRAY_TYPE)
1.1.1.7 root 7594: {
7595: if (TYPE_STRING_FLAG (type))
7596: return GEN_INT (string_type_class);
7597: else
7598: return GEN_INT (array_type_class);
7599: }
1.1.1.6 root 7600: if (code == SET_TYPE)
7601: return GEN_INT (set_type_class);
7602: if (code == FILE_TYPE)
7603: return GEN_INT (file_type_class);
7604: if (code == LANG_TYPE)
7605: return GEN_INT (lang_type_class);
7606: }
7607: return GEN_INT (no_type_class);
7608:
7609: case BUILT_IN_CONSTANT_P:
7610: if (arglist == 0)
7611: return const0_rtx;
7612: else
1.1.1.8 root 7613: {
7614: tree arg = TREE_VALUE (arglist);
7615:
7616: STRIP_NOPS (arg);
7617: return (TREE_CODE_CLASS (TREE_CODE (arg)) == 'c'
7618: || (TREE_CODE (arg) == ADDR_EXPR
7619: && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
7620: ? const1_rtx : const0_rtx);
7621: }
1.1.1.6 root 7622:
7623: case BUILT_IN_FRAME_ADDRESS:
7624: /* The argument must be a nonnegative integer constant.
7625: It counts the number of frames to scan up the stack.
7626: The value is the address of that frame. */
7627: case BUILT_IN_RETURN_ADDRESS:
7628: /* The argument must be a nonnegative integer constant.
7629: It counts the number of frames to scan up the stack.
7630: The value is the return address saved in that frame. */
7631: if (arglist == 0)
7632: /* Warning about missing arg was already issued. */
7633: return const0_rtx;
7634: else if (TREE_CODE (TREE_VALUE (arglist)) != INTEGER_CST)
7635: {
7636: error ("invalid arg to `__builtin_return_address'");
7637: return const0_rtx;
7638: }
1.1.1.7 root 7639: else if (tree_int_cst_sgn (TREE_VALUE (arglist)) < 0)
1.1.1.6 root 7640: {
7641: error ("invalid arg to `__builtin_return_address'");
7642: return const0_rtx;
7643: }
7644: else
7645: {
1.1.1.8 root 7646: rtx tem = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
7647: TREE_INT_CST_LOW (TREE_VALUE (arglist)),
7648: hard_frame_pointer_rtx);
1.1.1.6 root 7649:
7650: /* For __builtin_frame_address, return what we've got. */
7651: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
7652: return tem;
7653:
1.1.1.8 root 7654: if (GET_CODE (tem) != REG)
7655: tem = copy_to_reg (tem);
7656: return tem;
1.1.1.6 root 7657: }
7658:
7659: case BUILT_IN_ALLOCA:
7660: if (arglist == 0
7661: /* Arg could be non-integer if user redeclared this fcn wrong. */
7662: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
7663: break;
1.1.1.7 root 7664:
1.1.1.6 root 7665: /* Compute the argument. */
7666: op0 = expand_expr (TREE_VALUE (arglist), NULL_RTX, VOIDmode, 0);
1.1 root 7667:
1.1.1.6 root 7668: /* Allocate the desired space. */
1.1.1.7 root 7669: return allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
1.1 root 7670:
1.1.1.6 root 7671: case BUILT_IN_FFS:
7672: /* If not optimizing, call the library function. */
1.1.1.7 root 7673: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.6 root 7674: break;
7675:
7676: if (arglist == 0
7677: /* Arg could be non-integer if user redeclared this fcn wrong. */
7678: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != INTEGER_TYPE)
7679: break;
7680:
7681: /* Compute the argument. */
7682: op0 = expand_expr (TREE_VALUE (arglist), subtarget, VOIDmode, 0);
7683: /* Compute ffs, into TARGET if possible.
7684: Set TARGET to wherever the result comes back. */
7685: target = expand_unop (TYPE_MODE (TREE_TYPE (TREE_VALUE (arglist))),
7686: ffs_optab, op0, target, 1);
7687: if (target == 0)
7688: abort ();
7689: return target;
7690:
7691: case BUILT_IN_STRLEN:
7692: /* If not optimizing, call the library function. */
1.1.1.7 root 7693: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.6 root 7694: break;
7695:
7696: if (arglist == 0
7697: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7698: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
7699: break;
7700: else
1.1 root 7701: {
1.1.1.6 root 7702: tree src = TREE_VALUE (arglist);
7703: tree len = c_strlen (src);
1.1 root 7704:
1.1.1.6 root 7705: int align
7706: = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
1.1 root 7707:
1.1.1.6 root 7708: rtx result, src_rtx, char_rtx;
7709: enum machine_mode insn_mode = value_mode, char_mode;
7710: enum insn_code icode;
1.1 root 7711:
1.1.1.6 root 7712: /* If the length is known, just return it. */
7713: if (len != 0)
7714: return expand_expr (len, target, mode, 0);
1.1 root 7715:
1.1.1.6 root 7716: /* If SRC is not a pointer type, don't do this operation inline. */
7717: if (align == 0)
7718: break;
1.1 root 7719:
1.1.1.6 root 7720: /* Call a function if we can't compute strlen in the right mode. */
1.1 root 7721:
1.1.1.6 root 7722: while (insn_mode != VOIDmode)
7723: {
7724: icode = strlen_optab->handlers[(int) insn_mode].insn_code;
7725: if (icode != CODE_FOR_nothing)
7726: break;
1.1 root 7727:
1.1.1.6 root 7728: insn_mode = GET_MODE_WIDER_MODE (insn_mode);
7729: }
7730: if (insn_mode == VOIDmode)
7731: break;
1.1 root 7732:
1.1.1.6 root 7733: /* Make a place to write the result of the instruction. */
7734: result = target;
7735: if (! (result != 0
7736: && GET_CODE (result) == REG
7737: && GET_MODE (result) == insn_mode
7738: && REGNO (result) >= FIRST_PSEUDO_REGISTER))
7739: result = gen_reg_rtx (insn_mode);
1.1 root 7740:
1.1.1.6 root 7741: /* Make sure the operands are acceptable to the predicates. */
7742:
7743: if (! (*insn_operand_predicate[(int)icode][0]) (result, insn_mode))
7744: result = gen_reg_rtx (insn_mode);
7745:
7746: src_rtx = memory_address (BLKmode,
1.1.1.8 root 7747: expand_expr (src, NULL_RTX, ptr_mode,
1.1.1.6 root 7748: EXPAND_NORMAL));
7749: if (! (*insn_operand_predicate[(int)icode][1]) (src_rtx, Pmode))
7750: src_rtx = copy_to_mode_reg (Pmode, src_rtx);
7751:
7752: char_rtx = const0_rtx;
7753: char_mode = insn_operand_mode[(int)icode][2];
7754: if (! (*insn_operand_predicate[(int)icode][2]) (char_rtx, char_mode))
7755: char_rtx = copy_to_mode_reg (char_mode, char_rtx);
7756:
7757: emit_insn (GEN_FCN (icode) (result,
7758: gen_rtx (MEM, BLKmode, src_rtx),
7759: char_rtx, GEN_INT (align)));
7760:
7761: /* Return the value in the proper mode for this function. */
7762: if (GET_MODE (result) == value_mode)
7763: return result;
7764: else if (target != 0)
7765: {
7766: convert_move (target, result, 0);
7767: return target;
7768: }
7769: else
7770: return convert_to_mode (value_mode, result, 0);
1.1 root 7771: }
1.1.1.6 root 7772:
7773: case BUILT_IN_STRCPY:
7774: /* If not optimizing, call the library function. */
1.1.1.7 root 7775: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.6 root 7776: break;
7777:
7778: if (arglist == 0
7779: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7780: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
7781: || TREE_CHAIN (arglist) == 0
7782: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
7783: break;
7784: else
1.1 root 7785: {
1.1.1.6 root 7786: tree len = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
7787:
7788: if (len == 0)
7789: break;
7790:
7791: len = size_binop (PLUS_EXPR, len, integer_one_node);
7792:
7793: chainon (arglist, build_tree_list (NULL_TREE, len));
1.1 root 7794: }
7795:
1.1.1.6 root 7796: /* Drops in. */
7797: case BUILT_IN_MEMCPY:
7798: /* If not optimizing, call the library function. */
1.1.1.7 root 7799: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.6 root 7800: break;
1.1 root 7801:
1.1.1.6 root 7802: if (arglist == 0
7803: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7804: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
7805: || TREE_CHAIN (arglist) == 0
7806: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
7807: || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
7808: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
7809: break;
7810: else
7811: {
7812: tree dest = TREE_VALUE (arglist);
7813: tree src = TREE_VALUE (TREE_CHAIN (arglist));
7814: tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
1.1.1.8 root 7815: tree type;
1.1 root 7816:
1.1.1.6 root 7817: int src_align
7818: = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
7819: int dest_align
7820: = get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
7821: rtx dest_rtx, dest_mem, src_mem;
1.1 root 7822:
1.1.1.6 root 7823: /* If either SRC or DEST is not a pointer type, don't do
7824: this operation in-line. */
7825: if (src_align == 0 || dest_align == 0)
7826: {
7827: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCPY)
7828: TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
7829: break;
7830: }
7831:
1.1.1.8 root 7832: dest_rtx = expand_expr (dest, NULL_RTX, ptr_mode, EXPAND_SUM);
1.1.1.6 root 7833: dest_mem = gen_rtx (MEM, BLKmode,
7834: memory_address (BLKmode, dest_rtx));
1.1.1.8 root 7835: /* There could be a void* cast on top of the object. */
7836: while (TREE_CODE (dest) == NOP_EXPR)
7837: dest = TREE_OPERAND (dest, 0);
7838: type = TREE_TYPE (TREE_TYPE (dest));
7839: MEM_IN_STRUCT_P (dest_mem) = AGGREGATE_TYPE_P (type);
1.1.1.6 root 7840: src_mem = gen_rtx (MEM, BLKmode,
7841: memory_address (BLKmode,
7842: expand_expr (src, NULL_RTX,
1.1.1.8 root 7843: ptr_mode,
7844: EXPAND_SUM)));
7845: /* There could be a void* cast on top of the object. */
7846: while (TREE_CODE (src) == NOP_EXPR)
7847: src = TREE_OPERAND (src, 0);
7848: type = TREE_TYPE (TREE_TYPE (src));
7849: MEM_IN_STRUCT_P (src_mem) = AGGREGATE_TYPE_P (type);
1.1.1.6 root 7850:
7851: /* Copy word part most expediently. */
7852: emit_block_move (dest_mem, src_mem,
7853: expand_expr (len, NULL_RTX, VOIDmode, 0),
7854: MIN (src_align, dest_align));
1.1.1.8 root 7855: return force_operand (dest_rtx, NULL_RTX);
1.1.1.6 root 7856: }
1.1 root 7857:
1.1.1.6 root 7858: /* These comparison functions need an instruction that returns an actual
7859: index. An ordinary compare that just sets the condition codes
7860: is not enough. */
7861: #ifdef HAVE_cmpstrsi
7862: case BUILT_IN_STRCMP:
7863: /* If not optimizing, call the library function. */
1.1.1.7 root 7864: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.6 root 7865: break;
1.1 root 7866:
1.1.1.6 root 7867: if (arglist == 0
7868: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7869: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
7870: || TREE_CHAIN (arglist) == 0
7871: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE)
7872: break;
7873: else if (!HAVE_cmpstrsi)
7874: break;
7875: {
7876: tree arg1 = TREE_VALUE (arglist);
7877: tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
7878: tree offset;
7879: tree len, len2;
1.1 root 7880:
1.1.1.6 root 7881: len = c_strlen (arg1);
7882: if (len)
7883: len = size_binop (PLUS_EXPR, integer_one_node, len);
7884: len2 = c_strlen (arg2);
7885: if (len2)
7886: len2 = size_binop (PLUS_EXPR, integer_one_node, len2);
1.1 root 7887:
1.1.1.6 root 7888: /* If we don't have a constant length for the first, use the length
7889: of the second, if we know it. We don't require a constant for
7890: this case; some cost analysis could be done if both are available
7891: but neither is constant. For now, assume they're equally cheap.
1.1 root 7892:
1.1.1.6 root 7893: If both strings have constant lengths, use the smaller. This
7894: could arise if optimization results in strcpy being called with
7895: two fixed strings, or if the code was machine-generated. We should
7896: add some code to the `memcmp' handler below to deal with such
7897: situations, someday. */
7898: if (!len || TREE_CODE (len) != INTEGER_CST)
7899: {
7900: if (len2)
7901: len = len2;
7902: else if (len == 0)
7903: break;
7904: }
7905: else if (len2 && TREE_CODE (len2) == INTEGER_CST)
7906: {
7907: if (tree_int_cst_lt (len2, len))
7908: len = len2;
7909: }
1.1 root 7910:
1.1.1.6 root 7911: chainon (arglist, build_tree_list (NULL_TREE, len));
7912: }
7913:
7914: /* Drops in. */
7915: case BUILT_IN_MEMCMP:
1.1.1.2 root 7916: /* If not optimizing, call the library function. */
1.1.1.7 root 7917: if (!optimize && ! CALLED_AS_BUILT_IN (fndecl))
1.1.1.2 root 7918: break;
7919:
7920: if (arglist == 0
1.1.1.6 root 7921: /* Arg could be non-pointer if user redeclared this fcn wrong. */
7922: || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE
7923: || TREE_CHAIN (arglist) == 0
7924: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) != POINTER_TYPE
7925: || TREE_CHAIN (TREE_CHAIN (arglist)) == 0
7926: || TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))))) != INTEGER_TYPE)
7927: break;
7928: else if (!HAVE_cmpstrsi)
7929: break;
7930: {
7931: tree arg1 = TREE_VALUE (arglist);
7932: tree arg2 = TREE_VALUE (TREE_CHAIN (arglist));
7933: tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
7934: rtx result;
1.1.1.2 root 7935:
1.1.1.6 root 7936: int arg1_align
7937: = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
7938: int arg2_align
7939: = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
7940: enum machine_mode insn_mode
7941: = insn_operand_mode[(int) CODE_FOR_cmpstrsi][0];
1.1.1.3 root 7942:
1.1.1.6 root 7943: /* If we don't have POINTER_TYPE, call the function. */
7944: if (arg1_align == 0 || arg2_align == 0)
7945: {
7946: if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRCMP)
7947: TREE_CHAIN (TREE_CHAIN (arglist)) = 0;
7948: break;
7949: }
1.1.1.3 root 7950:
1.1.1.6 root 7951: /* Make a place to write the result of the instruction. */
7952: result = target;
7953: if (! (result != 0
7954: && GET_CODE (result) == REG && GET_MODE (result) == insn_mode
7955: && REGNO (result) >= FIRST_PSEUDO_REGISTER))
7956: result = gen_reg_rtx (insn_mode);
1.1.1.3 root 7957:
1.1.1.6 root 7958: emit_insn (gen_cmpstrsi (result,
7959: gen_rtx (MEM, BLKmode,
1.1.1.8 root 7960: expand_expr (arg1, NULL_RTX,
7961: ptr_mode,
1.1.1.6 root 7962: EXPAND_NORMAL)),
7963: gen_rtx (MEM, BLKmode,
1.1.1.8 root 7964: expand_expr (arg2, NULL_RTX,
7965: ptr_mode,
1.1.1.6 root 7966: EXPAND_NORMAL)),
7967: expand_expr (len, NULL_RTX, VOIDmode, 0),
7968: GEN_INT (MIN (arg1_align, arg2_align))));
1.1.1.3 root 7969:
1.1.1.6 root 7970: /* Return the value in the proper mode for this function. */
7971: mode = TYPE_MODE (TREE_TYPE (exp));
7972: if (GET_MODE (result) == mode)
7973: return result;
7974: else if (target != 0)
7975: {
7976: convert_move (target, result, 0);
7977: return target;
7978: }
7979: else
7980: return convert_to_mode (mode, result, 0);
7981: }
7982: #else
7983: case BUILT_IN_STRCMP:
7984: case BUILT_IN_MEMCMP:
7985: break;
7986: #endif
1.1.1.3 root 7987:
1.1.1.6 root 7988: default: /* just do library call, if unknown builtin */
7989: error ("built-in function `%s' not currently supported",
7990: IDENTIFIER_POINTER (DECL_NAME (fndecl)));
7991: }
1.1.1.2 root 7992:
1.1.1.6 root 7993: /* The switch statement above can drop through to cause the function
7994: to be called normally. */
1.1.1.4 root 7995:
1.1.1.6 root 7996: return expand_call (exp, target, ignore);
7997: }
7998:
7999: /* Built-in functions to perform an untyped call and return. */
8000:
8001: /* For each register that may be used for calling a function, this
8002: gives a mode used to copy the register's value. VOIDmode indicates
8003: the register is not used for calling a function. If the machine
8004: has register windows, this gives only the outbound registers.
8005: INCOMING_REGNO gives the corresponding inbound register. */
8006: static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1.1.1.4 root 8007:
1.1.1.6 root 8008: /* For each register that may be used for returning values, this gives
8009: a mode used to copy the register's value. VOIDmode indicates the
8010: register is not used for returning values. If the machine has
8011: register windows, this gives only the outbound registers.
8012: INCOMING_REGNO gives the corresponding inbound register. */
8013: static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1.1.1.4 root 8014:
1.1.1.6 root 8015: /* For each register that may be used for calling a function, this
8016: gives the offset of that register into the block returned by
1.1.1.8 root 8017: __builtin_apply_args. 0 indicates that the register is not
1.1.1.6 root 8018: used for calling a function. */
8019: static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
8020:
8021: /* Return the offset of register REGNO into the block returned by
8022: __builtin_apply_args. This is not declared static, since it is
8023: needed in objc-act.c. */
1.1.1.4 root 8024:
1.1.1.6 root 8025: int
8026: apply_args_register_offset (regno)
8027: int regno;
8028: {
8029: apply_args_size ();
1.1.1.4 root 8030:
1.1.1.6 root 8031: /* Arguments are always put in outgoing registers (in the argument
8032: block) if such make sense. */
8033: #ifdef OUTGOING_REGNO
8034: regno = OUTGOING_REGNO(regno);
1.1.1.4 root 8035: #endif
1.1.1.6 root 8036: return apply_args_reg_offset[regno];
8037: }
1.1.1.4 root 8038:
1.1.1.6 root 8039: /* Return the size required for the block returned by __builtin_apply_args,
8040: and initialize apply_args_mode. */
1.1.1.2 root 8041:
1.1.1.6 root 8042: static int
8043: apply_args_size ()
8044: {
8045: static int size = -1;
8046: int align, regno;
8047: enum machine_mode mode;
1.1.1.3 root 8048:
1.1.1.6 root 8049: /* The values computed by this function never change. */
8050: if (size < 0)
8051: {
8052: /* The first value is the incoming arg-pointer. */
8053: size = GET_MODE_SIZE (Pmode);
1.1.1.5 root 8054:
1.1.1.6 root 8055: /* The second value is the structure value address unless this is
8056: passed as an "invisible" first argument. */
8057: if (struct_value_rtx)
8058: size += GET_MODE_SIZE (Pmode);
1.1.1.5 root 8059:
1.1.1.6 root 8060: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8061: if (FUNCTION_ARG_REGNO_P (regno))
8062: {
8063: /* Search for the proper mode for copying this register's
8064: value. I'm not sure this is right, but it works so far. */
8065: enum machine_mode best_mode = VOIDmode;
1.1.1.5 root 8066:
1.1.1.6 root 8067: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
8068: mode != VOIDmode;
8069: mode = GET_MODE_WIDER_MODE (mode))
8070: if (HARD_REGNO_MODE_OK (regno, mode)
8071: && HARD_REGNO_NREGS (regno, mode) == 1)
8072: best_mode = mode;
1.1.1.5 root 8073:
1.1.1.6 root 8074: if (best_mode == VOIDmode)
8075: for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
8076: mode != VOIDmode;
8077: mode = GET_MODE_WIDER_MODE (mode))
8078: if (HARD_REGNO_MODE_OK (regno, mode)
8079: && (mov_optab->handlers[(int) mode].insn_code
8080: != CODE_FOR_nothing))
8081: best_mode = mode;
1.1.1.5 root 8082:
1.1.1.6 root 8083: mode = best_mode;
8084: if (mode == VOIDmode)
8085: abort ();
1.1.1.5 root 8086:
1.1.1.6 root 8087: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8088: if (size % align != 0)
8089: size = CEIL (size, align) * align;
8090: apply_args_reg_offset[regno] = size;
8091: size += GET_MODE_SIZE (mode);
8092: apply_args_mode[regno] = mode;
8093: }
8094: else
8095: {
8096: apply_args_mode[regno] = VOIDmode;
8097: apply_args_reg_offset[regno] = 0;
8098: }
8099: }
8100: return size;
8101: }
1.1.1.5 root 8102:
1.1.1.6 root 8103: /* Return the size required for the block returned by __builtin_apply,
8104: and initialize apply_result_mode. */
1.1.1.5 root 8105:
1.1.1.6 root 8106: static int
8107: apply_result_size ()
8108: {
8109: static int size = -1;
8110: int align, regno;
8111: enum machine_mode mode;
1.1 root 8112:
1.1.1.6 root 8113: /* The values computed by this function never change. */
8114: if (size < 0)
8115: {
8116: size = 0;
1.1 root 8117:
1.1.1.6 root 8118: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8119: if (FUNCTION_VALUE_REGNO_P (regno))
1.1 root 8120: {
1.1.1.6 root 8121: /* Search for the proper mode for copying this register's
8122: value. I'm not sure this is right, but it works so far. */
8123: enum machine_mode best_mode = VOIDmode;
8124:
8125: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
8126: mode != TImode;
8127: mode = GET_MODE_WIDER_MODE (mode))
8128: if (HARD_REGNO_MODE_OK (regno, mode))
8129: best_mode = mode;
8130:
8131: if (best_mode == VOIDmode)
8132: for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
8133: mode != VOIDmode;
8134: mode = GET_MODE_WIDER_MODE (mode))
8135: if (HARD_REGNO_MODE_OK (regno, mode)
8136: && (mov_optab->handlers[(int) mode].insn_code
8137: != CODE_FOR_nothing))
8138: best_mode = mode;
8139:
8140: mode = best_mode;
8141: if (mode == VOIDmode)
8142: abort ();
8143:
8144: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8145: if (size % align != 0)
8146: size = CEIL (size, align) * align;
8147: size += GET_MODE_SIZE (mode);
8148: apply_result_mode[regno] = mode;
1.1 root 8149: }
1.1.1.6 root 8150: else
8151: apply_result_mode[regno] = VOIDmode;
8152:
8153: /* Allow targets that use untyped_call and untyped_return to override
8154: the size so that machine-specific information can be stored here. */
8155: #ifdef APPLY_RESULT_SIZE
8156: size = APPLY_RESULT_SIZE;
8157: #endif
8158: }
8159: return size;
8160: }
8161:
8162: #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
8163: /* Create a vector describing the result block RESULT. If SAVEP is true,
8164: the result block is used to save the values; otherwise it is used to
8165: restore the values. */
8166:
8167: static rtx
8168: result_vector (savep, result)
8169: int savep;
8170: rtx result;
8171: {
8172: int regno, size, align, nelts;
8173: enum machine_mode mode;
8174: rtx reg, mem;
8175: rtx *savevec = (rtx *) alloca (FIRST_PSEUDO_REGISTER * sizeof (rtx));
8176:
8177: size = nelts = 0;
8178: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8179: if ((mode = apply_result_mode[regno]) != VOIDmode)
8180: {
8181: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8182: if (size % align != 0)
8183: size = CEIL (size, align) * align;
1.1.1.7 root 8184: reg = gen_rtx (REG, mode, savep ? regno : INCOMING_REGNO (regno));
1.1.1.6 root 8185: mem = change_address (result, mode,
8186: plus_constant (XEXP (result, 0), size));
8187: savevec[nelts++] = (savep
8188: ? gen_rtx (SET, VOIDmode, mem, reg)
8189: : gen_rtx (SET, VOIDmode, reg, mem));
8190: size += GET_MODE_SIZE (mode);
8191: }
8192: return gen_rtx (PARALLEL, VOIDmode, gen_rtvec_v (nelts, savevec));
8193: }
8194: #endif /* HAVE_untyped_call or HAVE_untyped_return */
1.1 root 8195:
1.1.1.6 root 8196: /* Save the state required to perform an untyped call with the same
8197: arguments as were passed to the current function. */
1.1 root 8198:
1.1.1.6 root 8199: static rtx
8200: expand_builtin_apply_args ()
8201: {
8202: rtx registers;
8203: int size, align, regno;
8204: enum machine_mode mode;
1.1 root 8205:
1.1.1.6 root 8206: /* Create a block where the arg-pointer, structure value address,
8207: and argument registers can be saved. */
8208: registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1.1 root 8209:
1.1.1.6 root 8210: /* Walk past the arg-pointer and structure value address. */
8211: size = GET_MODE_SIZE (Pmode);
8212: if (struct_value_rtx)
8213: size += GET_MODE_SIZE (Pmode);
1.1 root 8214:
1.1.1.6 root 8215: /* Save each register used in calling a function to the block. */
8216: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8217: if ((mode = apply_args_mode[regno]) != VOIDmode)
8218: {
1.1.1.8 root 8219: rtx tem;
8220:
1.1.1.6 root 8221: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8222: if (size % align != 0)
8223: size = CEIL (size, align) * align;
1.1.1.8 root 8224:
8225: tem = gen_rtx (REG, mode, INCOMING_REGNO (regno));
8226:
8227: #ifdef STACK_REGS
8228: /* For reg-stack.c's stack register household.
8229: Compare with a similar piece of code in function.c. */
8230:
8231: emit_insn (gen_rtx (USE, mode, tem));
8232: #endif
8233:
1.1.1.6 root 8234: emit_move_insn (change_address (registers, mode,
8235: plus_constant (XEXP (registers, 0),
8236: size)),
1.1.1.8 root 8237: tem);
1.1.1.6 root 8238: size += GET_MODE_SIZE (mode);
1.1 root 8239: }
8240:
1.1.1.6 root 8241: /* Save the arg pointer to the block. */
8242: emit_move_insn (change_address (registers, Pmode, XEXP (registers, 0)),
8243: copy_to_reg (virtual_incoming_args_rtx));
8244: size = GET_MODE_SIZE (Pmode);
1.1 root 8245:
1.1.1.6 root 8246: /* Save the structure value address unless this is passed as an
8247: "invisible" first argument. */
8248: if (struct_value_incoming_rtx)
8249: {
8250: emit_move_insn (change_address (registers, Pmode,
8251: plus_constant (XEXP (registers, 0),
8252: size)),
8253: copy_to_reg (struct_value_incoming_rtx));
8254: size += GET_MODE_SIZE (Pmode);
8255: }
1.1 root 8256:
1.1.1.6 root 8257: /* Return the address of the block. */
8258: return copy_addr_to_reg (XEXP (registers, 0));
8259: }
1.1 root 8260:
1.1.1.6 root 8261: /* Perform an untyped call and save the state required to perform an
8262: untyped return of whatever value was returned by the given function. */
1.1 root 8263:
1.1.1.6 root 8264: static rtx
8265: expand_builtin_apply (function, arguments, argsize)
8266: rtx function, arguments, argsize;
8267: {
8268: int size, align, regno;
8269: enum machine_mode mode;
8270: rtx incoming_args, result, reg, dest, call_insn;
8271: rtx old_stack_level = 0;
1.1.1.7 root 8272: rtx call_fusage = 0;
1.1 root 8273:
1.1.1.6 root 8274: /* Create a block where the return registers can be saved. */
8275: result = assign_stack_local (BLKmode, apply_result_size (), -1);
1.1 root 8276:
1.1.1.6 root 8277: /* ??? The argsize value should be adjusted here. */
8278:
8279: /* Fetch the arg pointer from the ARGUMENTS block. */
8280: incoming_args = gen_reg_rtx (Pmode);
8281: emit_move_insn (incoming_args,
8282: gen_rtx (MEM, Pmode, arguments));
8283: #ifndef STACK_GROWS_DOWNWARD
8284: incoming_args = expand_binop (Pmode, sub_optab, incoming_args, argsize,
8285: incoming_args, 0, OPTAB_LIB_WIDEN);
1.1 root 8286: #endif
8287:
1.1.1.6 root 8288: /* Perform postincrements before actually calling the function. */
8289: emit_queue ();
1.1 root 8290:
1.1.1.6 root 8291: /* Push a new argument block and copy the arguments. */
8292: do_pending_stack_adjust ();
8293: emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1.1 root 8294:
1.1.1.6 root 8295: /* Push a block of memory onto the stack to store the memory arguments.
8296: Save the address in a register, and copy the memory arguments. ??? I
8297: haven't figured out how the calling convention macros effect this,
8298: but it's likely that the source and/or destination addresses in
8299: the block copy will need updating in machine specific ways. */
8300: dest = copy_addr_to_reg (push_block (argsize, 0, 0));
8301: emit_block_move (gen_rtx (MEM, BLKmode, dest),
8302: gen_rtx (MEM, BLKmode, incoming_args),
8303: argsize,
8304: PARM_BOUNDARY / BITS_PER_UNIT);
1.1 root 8305:
1.1.1.6 root 8306: /* Refer to the argument block. */
8307: apply_args_size ();
8308: arguments = gen_rtx (MEM, BLKmode, arguments);
1.1 root 8309:
1.1.1.6 root 8310: /* Walk past the arg-pointer and structure value address. */
8311: size = GET_MODE_SIZE (Pmode);
8312: if (struct_value_rtx)
8313: size += GET_MODE_SIZE (Pmode);
8314:
8315: /* Restore each of the registers previously saved. Make USE insns
8316: for each of these registers for use in making the call. */
8317: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8318: if ((mode = apply_args_mode[regno]) != VOIDmode)
8319: {
8320: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8321: if (size % align != 0)
8322: size = CEIL (size, align) * align;
8323: reg = gen_rtx (REG, mode, regno);
8324: emit_move_insn (reg,
8325: change_address (arguments, mode,
8326: plus_constant (XEXP (arguments, 0),
8327: size)));
8328:
1.1.1.7 root 8329: use_reg (&call_fusage, reg);
1.1.1.6 root 8330: size += GET_MODE_SIZE (mode);
8331: }
8332:
8333: /* Restore the structure value address unless this is passed as an
8334: "invisible" first argument. */
8335: size = GET_MODE_SIZE (Pmode);
8336: if (struct_value_rtx)
8337: {
8338: rtx value = gen_reg_rtx (Pmode);
8339: emit_move_insn (value,
8340: change_address (arguments, Pmode,
8341: plus_constant (XEXP (arguments, 0),
8342: size)));
8343: emit_move_insn (struct_value_rtx, value);
8344: if (GET_CODE (struct_value_rtx) == REG)
1.1.1.7 root 8345: use_reg (&call_fusage, struct_value_rtx);
1.1.1.6 root 8346: size += GET_MODE_SIZE (Pmode);
8347: }
1.1 root 8348:
1.1.1.6 root 8349: /* All arguments and registers used for the call are set up by now! */
1.1.1.7 root 8350: function = prepare_call_address (function, NULL_TREE, &call_fusage, 0);
1.1.1.5 root 8351:
1.1.1.6 root 8352: /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
8353: and we don't want to load it into a register as an optimization,
8354: because prepare_call_address already did it if it should be done. */
8355: if (GET_CODE (function) != SYMBOL_REF)
8356: function = memory_address (FUNCTION_MODE, function);
1.1.1.5 root 8357:
1.1.1.6 root 8358: /* Generate the actual call instruction and save the return value. */
8359: #ifdef HAVE_untyped_call
8360: if (HAVE_untyped_call)
8361: emit_call_insn (gen_untyped_call (gen_rtx (MEM, FUNCTION_MODE, function),
8362: result, result_vector (1, result)));
8363: else
1.1 root 8364: #endif
1.1.1.6 root 8365: #ifdef HAVE_call_value
8366: if (HAVE_call_value)
8367: {
8368: rtx valreg = 0;
1.1 root 8369:
1.1.1.6 root 8370: /* Locate the unique return register. It is not possible to
8371: express a call that sets more than one return register using
8372: call_value; use untyped_call for that. In fact, untyped_call
8373: only needs to save the return registers in the given block. */
8374: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8375: if ((mode = apply_result_mode[regno]) != VOIDmode)
8376: {
8377: if (valreg)
8378: abort (); /* HAVE_untyped_call required. */
8379: valreg = gen_rtx (REG, mode, regno);
8380: }
1.1 root 8381:
1.1.1.6 root 8382: emit_call_insn (gen_call_value (valreg,
8383: gen_rtx (MEM, FUNCTION_MODE, function),
8384: const0_rtx, NULL_RTX, const0_rtx));
8385:
8386: emit_move_insn (change_address (result, GET_MODE (valreg),
8387: XEXP (result, 0)),
8388: valreg);
8389: }
8390: else
1.1 root 8391: #endif
1.1.1.6 root 8392: abort ();
1.1 root 8393:
1.1.1.7 root 8394: /* Find the CALL insn we just emitted. */
1.1.1.6 root 8395: for (call_insn = get_last_insn ();
8396: call_insn && GET_CODE (call_insn) != CALL_INSN;
8397: call_insn = PREV_INSN (call_insn))
8398: ;
1.1 root 8399:
1.1.1.6 root 8400: if (! call_insn)
8401: abort ();
1.1 root 8402:
1.1.1.7 root 8403: /* Put the register usage information on the CALL. If there is already
8404: some usage information, put ours at the end. */
8405: if (CALL_INSN_FUNCTION_USAGE (call_insn))
8406: {
8407: rtx link;
8408:
8409: for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
8410: link = XEXP (link, 1))
8411: ;
8412:
8413: XEXP (link, 1) = call_fusage;
8414: }
8415: else
8416: CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
1.1 root 8417:
1.1.1.6 root 8418: /* Restore the stack. */
8419: emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1.1 root 8420:
1.1.1.6 root 8421: /* Return the address of the result block. */
8422: return copy_addr_to_reg (XEXP (result, 0));
8423: }
1.1 root 8424:
1.1.1.6 root 8425: /* Perform an untyped return. */
1.1 root 8426:
1.1.1.6 root 8427: static void
8428: expand_builtin_return (result)
8429: rtx result;
8430: {
8431: int size, align, regno;
8432: enum machine_mode mode;
8433: rtx reg;
1.1.1.7 root 8434: rtx call_fusage = 0;
1.1 root 8435:
1.1.1.6 root 8436: apply_result_size ();
8437: result = gen_rtx (MEM, BLKmode, result);
1.1 root 8438:
1.1.1.6 root 8439: #ifdef HAVE_untyped_return
8440: if (HAVE_untyped_return)
8441: {
8442: emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
8443: emit_barrier ();
8444: return;
8445: }
8446: #endif
1.1.1.3 root 8447:
1.1.1.6 root 8448: /* Restore the return value and note that each value is used. */
8449: size = 0;
8450: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
8451: if ((mode = apply_result_mode[regno]) != VOIDmode)
8452: {
8453: align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
8454: if (size % align != 0)
8455: size = CEIL (size, align) * align;
8456: reg = gen_rtx (REG, mode, INCOMING_REGNO (regno));
8457: emit_move_insn (reg,
8458: change_address (result, mode,
8459: plus_constant (XEXP (result, 0),
8460: size)));
1.1.1.3 root 8461:
1.1.1.7 root 8462: push_to_sequence (call_fusage);
1.1.1.6 root 8463: emit_insn (gen_rtx (USE, VOIDmode, reg));
1.1.1.7 root 8464: call_fusage = get_insns ();
1.1.1.6 root 8465: end_sequence ();
8466: size += GET_MODE_SIZE (mode);
8467: }
1.1.1.3 root 8468:
1.1.1.6 root 8469: /* Put the USE insns before the return. */
1.1.1.7 root 8470: emit_insns (call_fusage);
1.1.1.3 root 8471:
1.1.1.6 root 8472: /* Return whatever values was restored by jumping directly to the end
8473: of the function. */
8474: expand_null_return ();
8475: }
8476:
8477: /* Expand code for a post- or pre- increment or decrement
8478: and return the RTX for the result.
8479: POST is 1 for postinc/decrements and 0 for preinc/decrements. */
1.1.1.3 root 8480:
1.1.1.6 root 8481: static rtx
8482: expand_increment (exp, post)
8483: register tree exp;
8484: int post;
8485: {
8486: register rtx op0, op1;
8487: register rtx temp, value;
8488: register tree incremented = TREE_OPERAND (exp, 0);
8489: optab this_optab = add_optab;
8490: int icode;
8491: enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
8492: int op0_is_copy = 0;
8493: int single_insn = 0;
8494: /* 1 means we can't store into OP0 directly,
8495: because it is a subreg narrower than a word,
8496: and we don't dare clobber the rest of the word. */
8497: int bad_subreg = 0;
1.1.1.3 root 8498:
1.1.1.6 root 8499: if (output_bytecode)
8500: {
8501: bc_expand_expr (exp);
8502: return NULL_RTX;
8503: }
8504:
8505: /* Stabilize any component ref that might need to be
8506: evaluated more than once below. */
8507: if (!post
8508: || TREE_CODE (incremented) == BIT_FIELD_REF
8509: || (TREE_CODE (incremented) == COMPONENT_REF
8510: && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
8511: || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
8512: incremented = stabilize_reference (incremented);
8513: /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
8514: ones into save exprs so that they don't accidentally get evaluated
8515: more than once by the code below. */
8516: if (TREE_CODE (incremented) == PREINCREMENT_EXPR
8517: || TREE_CODE (incremented) == PREDECREMENT_EXPR)
8518: incremented = save_expr (incremented);
1.1.1.3 root 8519:
1.1.1.6 root 8520: /* Compute the operands as RTX.
8521: Note whether OP0 is the actual lvalue or a copy of it:
8522: I believe it is a copy iff it is a register or subreg
8523: and insns were generated in computing it. */
1.1.1.3 root 8524:
1.1.1.6 root 8525: temp = get_last_insn ();
8526: op0 = expand_expr (incremented, NULL_RTX, VOIDmode, 0);
1.1.1.3 root 8527:
1.1.1.6 root 8528: /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
1.1.1.8 root 8529: in place but instead must do sign- or zero-extension during assignment,
1.1.1.6 root 8530: so we copy it into a new register and let the code below use it as
8531: a copy.
1.1.1.3 root 8532:
1.1.1.6 root 8533: Note that we can safely modify this SUBREG since it is know not to be
8534: shared (it was made by the expand_expr call above). */
1.1.1.3 root 8535:
1.1.1.6 root 8536: if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
1.1.1.7 root 8537: {
8538: if (post)
8539: SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
8540: else
8541: bad_subreg = 1;
8542: }
1.1.1.6 root 8543: else if (GET_CODE (op0) == SUBREG
8544: && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
1.1.1.7 root 8545: {
8546: /* We cannot increment this SUBREG in place. If we are
8547: post-incrementing, get a copy of the old value. Otherwise,
8548: just mark that we cannot increment in place. */
8549: if (post)
8550: op0 = copy_to_reg (op0);
8551: else
8552: bad_subreg = 1;
8553: }
1.1.1.3 root 8554:
1.1.1.6 root 8555: op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
8556: && temp != get_last_insn ());
8557: op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
1.1.1.3 root 8558:
1.1.1.6 root 8559: /* Decide whether incrementing or decrementing. */
8560: if (TREE_CODE (exp) == POSTDECREMENT_EXPR
8561: || TREE_CODE (exp) == PREDECREMENT_EXPR)
8562: this_optab = sub_optab;
1.1 root 8563:
1.1.1.6 root 8564: /* Convert decrement by a constant into a negative increment. */
8565: if (this_optab == sub_optab
8566: && GET_CODE (op1) == CONST_INT)
8567: {
8568: op1 = GEN_INT (- INTVAL (op1));
8569: this_optab = add_optab;
8570: }
1.1 root 8571:
1.1.1.6 root 8572: /* For a preincrement, see if we can do this with a single instruction. */
8573: if (!post)
8574: {
8575: icode = (int) this_optab->handlers[(int) mode].insn_code;
8576: if (icode != (int) CODE_FOR_nothing
8577: /* Make sure that OP0 is valid for operands 0 and 1
8578: of the insn we want to queue. */
8579: && (*insn_operand_predicate[icode][0]) (op0, mode)
8580: && (*insn_operand_predicate[icode][1]) (op0, mode)
8581: && (*insn_operand_predicate[icode][2]) (op1, mode))
8582: single_insn = 1;
8583: }
1.1 root 8584:
1.1.1.6 root 8585: /* If OP0 is not the actual lvalue, but rather a copy in a register,
8586: then we cannot just increment OP0. We must therefore contrive to
8587: increment the original value. Then, for postincrement, we can return
8588: OP0 since it is a copy of the old value. For preincrement, expand here
8589: unless we can do it with a single insn.
1.1 root 8590:
1.1.1.6 root 8591: Likewise if storing directly into OP0 would clobber high bits
8592: we need to preserve (bad_subreg). */
8593: if (op0_is_copy || (!post && !single_insn) || bad_subreg)
8594: {
8595: /* This is the easiest way to increment the value wherever it is.
8596: Problems with multiple evaluation of INCREMENTED are prevented
8597: because either (1) it is a component_ref or preincrement,
8598: in which case it was stabilized above, or (2) it is an array_ref
8599: with constant index in an array in a register, which is
8600: safe to reevaluate. */
8601: tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
8602: || TREE_CODE (exp) == PREDECREMENT_EXPR)
8603: ? MINUS_EXPR : PLUS_EXPR),
8604: TREE_TYPE (exp),
8605: incremented,
8606: TREE_OPERAND (exp, 1));
1.1.1.8 root 8607:
8608: while (TREE_CODE (incremented) == NOP_EXPR
8609: || TREE_CODE (incremented) == CONVERT_EXPR)
8610: {
8611: newexp = convert (TREE_TYPE (incremented), newexp);
8612: incremented = TREE_OPERAND (incremented, 0);
8613: }
8614:
1.1.1.6 root 8615: temp = expand_assignment (incremented, newexp, ! post, 0);
8616: return post ? op0 : temp;
8617: }
1.1 root 8618:
1.1.1.6 root 8619: if (post)
8620: {
8621: /* We have a true reference to the value in OP0.
8622: If there is an insn to add or subtract in this mode, queue it.
8623: Queueing the increment insn avoids the register shuffling
8624: that often results if we must increment now and first save
8625: the old value for subsequent use. */
1.1 root 8626:
1.1.1.6 root 8627: #if 0 /* Turned off to avoid making extra insn for indexed memref. */
8628: op0 = stabilize (op0);
8629: #endif
1.1 root 8630:
1.1.1.6 root 8631: icode = (int) this_optab->handlers[(int) mode].insn_code;
8632: if (icode != (int) CODE_FOR_nothing
8633: /* Make sure that OP0 is valid for operands 0 and 1
8634: of the insn we want to queue. */
8635: && (*insn_operand_predicate[icode][0]) (op0, mode)
8636: && (*insn_operand_predicate[icode][1]) (op0, mode))
1.1 root 8637: {
1.1.1.6 root 8638: if (! (*insn_operand_predicate[icode][2]) (op1, mode))
8639: op1 = force_reg (mode, op1);
1.1 root 8640:
1.1.1.6 root 8641: return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
8642: }
8643: }
1.1 root 8644:
1.1.1.6 root 8645: /* Preincrement, or we can't increment with one simple insn. */
8646: if (post)
8647: /* Save a copy of the value before inc or dec, to return it later. */
8648: temp = value = copy_to_reg (op0);
8649: else
8650: /* Arrange to return the incremented value. */
8651: /* Copy the rtx because expand_binop will protect from the queue,
8652: and the results of that would be invalid for us to return
8653: if our caller does emit_queue before using our result. */
8654: temp = copy_rtx (value = op0);
1.1 root 8655:
1.1.1.6 root 8656: /* Increment however we can. */
8657: op1 = expand_binop (mode, this_optab, value, op1, op0,
8658: TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
8659: /* Make sure the value is stored into OP0. */
8660: if (op1 != op0)
8661: emit_move_insn (op0, op1);
1.1 root 8662:
1.1.1.6 root 8663: return temp;
8664: }
8665:
8666: /* Expand all function calls contained within EXP, innermost ones first.
8667: But don't look within expressions that have sequence points.
8668: For each CALL_EXPR, record the rtx for its value
8669: in the CALL_EXPR_RTL field. */
1.1 root 8670:
1.1.1.6 root 8671: static void
8672: preexpand_calls (exp)
8673: tree exp;
8674: {
8675: register int nops, i;
8676: int type = TREE_CODE_CLASS (TREE_CODE (exp));
1.1 root 8677:
1.1.1.6 root 8678: if (! do_preexpand_calls)
8679: return;
1.1 root 8680:
1.1.1.6 root 8681: /* Only expressions and references can contain calls. */
1.1 root 8682:
1.1.1.6 root 8683: if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r')
8684: return;
1.1 root 8685:
1.1.1.6 root 8686: switch (TREE_CODE (exp))
8687: {
8688: case CALL_EXPR:
8689: /* Do nothing if already expanded. */
8690: if (CALL_EXPR_RTL (exp) != 0)
8691: return;
1.1 root 8692:
1.1.1.6 root 8693: /* Do nothing to built-in functions. */
8694: if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
8695: || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL
1.1.1.7 root 8696: || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
8697: /* Do nothing if the call returns a variable-sized object. */
8698: || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp))) != INTEGER_CST)
1.1.1.6 root 8699: CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
8700: return;
1.1 root 8701:
1.1.1.6 root 8702: case COMPOUND_EXPR:
8703: case COND_EXPR:
8704: case TRUTH_ANDIF_EXPR:
8705: case TRUTH_ORIF_EXPR:
8706: /* If we find one of these, then we can be sure
8707: the adjust will be done for it (since it makes jumps).
8708: Do it now, so that if this is inside an argument
8709: of a function, we don't get the stack adjustment
8710: after some other args have already been pushed. */
8711: do_pending_stack_adjust ();
8712: return;
1.1 root 8713:
1.1.1.6 root 8714: case BLOCK:
8715: case RTL_EXPR:
8716: case WITH_CLEANUP_EXPR:
1.1.1.8 root 8717: case CLEANUP_POINT_EXPR:
1.1.1.6 root 8718: return;
1.1 root 8719:
1.1.1.6 root 8720: case SAVE_EXPR:
8721: if (SAVE_EXPR_RTL (exp) != 0)
8722: return;
8723: }
1.1 root 8724:
1.1.1.6 root 8725: nops = tree_code_length[(int) TREE_CODE (exp)];
8726: for (i = 0; i < nops; i++)
8727: if (TREE_OPERAND (exp, i) != 0)
8728: {
8729: type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
8730: if (type == 'e' || type == '<' || type == '1' || type == '2'
8731: || type == 'r')
8732: preexpand_calls (TREE_OPERAND (exp, i));
8733: }
8734: }
8735:
8736: /* At the start of a function, record that we have no previously-pushed
8737: arguments waiting to be popped. */
1.1 root 8738:
1.1.1.6 root 8739: void
8740: init_pending_stack_adjust ()
8741: {
8742: pending_stack_adjust = 0;
8743: }
1.1 root 8744:
1.1.1.6 root 8745: /* When exiting from function, if safe, clear out any pending stack adjust
8746: so the adjustment won't get done. */
1.1 root 8747:
1.1.1.6 root 8748: void
8749: clear_pending_stack_adjust ()
8750: {
8751: #ifdef EXIT_IGNORE_STACK
8752: if (! flag_omit_frame_pointer && EXIT_IGNORE_STACK
8753: && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
8754: && ! flag_inline_functions)
8755: pending_stack_adjust = 0;
1.1 root 8756: #endif
1.1.1.6 root 8757: }
1.1 root 8758:
1.1.1.6 root 8759: /* Pop any previously-pushed arguments that have not been popped yet. */
8760:
8761: void
8762: do_pending_stack_adjust ()
8763: {
8764: if (inhibit_defer_pop == 0)
8765: {
8766: if (pending_stack_adjust != 0)
8767: adjust_stack (GEN_INT (pending_stack_adjust));
8768: pending_stack_adjust = 0;
1.1 root 8769: }
1.1.1.6 root 8770: }
1.1 root 8771:
1.1.1.7 root 8772: /* Defer the expansion all cleanups up to OLD_CLEANUPS.
8773: Returns the cleanups to be performed. */
8774:
8775: static tree
8776: defer_cleanups_to (old_cleanups)
8777: tree old_cleanups;
8778: {
8779: tree new_cleanups = NULL_TREE;
8780: tree cleanups = cleanups_this_call;
8781: tree last = NULL_TREE;
8782:
8783: while (cleanups_this_call != old_cleanups)
8784: {
8785: (*interim_eh_hook) (TREE_VALUE (cleanups_this_call));
8786: last = cleanups_this_call;
8787: cleanups_this_call = TREE_CHAIN (cleanups_this_call);
8788: }
8789:
8790: if (last)
8791: {
8792: /* Remove the list from the chain of cleanups. */
8793: TREE_CHAIN (last) = NULL_TREE;
8794:
8795: /* reverse them so that we can build them in the right order. */
8796: cleanups = nreverse (cleanups);
8797:
8798: while (cleanups)
8799: {
8800: if (new_cleanups)
8801: new_cleanups = build (COMPOUND_EXPR, TREE_TYPE (new_cleanups),
8802: TREE_VALUE (cleanups), new_cleanups);
8803: else
8804: new_cleanups = TREE_VALUE (cleanups);
8805:
8806: cleanups = TREE_CHAIN (cleanups);
8807: }
8808: }
8809:
8810: return new_cleanups;
8811: }
8812:
1.1.1.6 root 8813: /* Expand all cleanups up to OLD_CLEANUPS.
8814: Needed here, and also for language-dependent calls. */
1.1 root 8815:
1.1.1.6 root 8816: void
8817: expand_cleanups_to (old_cleanups)
8818: tree old_cleanups;
8819: {
8820: while (cleanups_this_call != old_cleanups)
8821: {
1.1.1.7 root 8822: (*interim_eh_hook) (TREE_VALUE (cleanups_this_call));
8823: expand_expr (TREE_VALUE (cleanups_this_call), const0_rtx, VOIDmode, 0);
1.1.1.6 root 8824: cleanups_this_call = TREE_CHAIN (cleanups_this_call);
8825: }
1.1 root 8826: }
8827:
1.1.1.6 root 8828: /* Expand conditional expressions. */
1.1.1.5 root 8829:
1.1.1.6 root 8830: /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
8831: LABEL is an rtx of code CODE_LABEL, in this function and all the
8832: functions here. */
1.1.1.5 root 8833:
1.1.1.6 root 8834: void
8835: jumpifnot (exp, label)
8836: tree exp;
8837: rtx label;
8838: {
8839: do_jump (exp, label, NULL_RTX);
8840: }
1.1.1.5 root 8841:
1.1.1.6 root 8842: /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
8843:
8844: void
8845: jumpif (exp, label)
8846: tree exp;
8847: rtx label;
1.1.1.5 root 8848: {
1.1.1.6 root 8849: do_jump (exp, NULL_RTX, label);
8850: }
8851:
8852: /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
8853: the result is zero, or IF_TRUE_LABEL if the result is one.
8854: Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
8855: meaning fall through in that case.
8856:
8857: do_jump always does any pending stack adjust except when it does not
8858: actually perform a jump. An example where there is no jump
8859: is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
8860:
8861: This function is responsible for optimizing cases such as
8862: &&, || and comparison operators in EXP. */
8863:
8864: void
8865: do_jump (exp, if_false_label, if_true_label)
8866: tree exp;
8867: rtx if_false_label, if_true_label;
8868: {
8869: register enum tree_code code = TREE_CODE (exp);
8870: /* Some cases need to create a label to jump to
8871: in order to properly fall through.
8872: These cases set DROP_THROUGH_LABEL nonzero. */
8873: rtx drop_through_label = 0;
8874: rtx temp;
8875: rtx comparison = 0;
8876: int i;
8877: tree type;
1.1.1.7 root 8878: enum machine_mode mode;
1.1.1.6 root 8879:
8880: emit_queue ();
8881:
8882: switch (code)
8883: {
8884: case ERROR_MARK:
8885: break;
8886:
8887: case INTEGER_CST:
8888: temp = integer_zerop (exp) ? if_false_label : if_true_label;
8889: if (temp)
8890: emit_jump (temp);
8891: break;
8892:
8893: #if 0
8894: /* This is not true with #pragma weak */
8895: case ADDR_EXPR:
8896: /* The address of something can never be zero. */
8897: if (if_true_label)
8898: emit_jump (if_true_label);
8899: break;
8900: #endif
8901:
8902: case NOP_EXPR:
8903: if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
8904: || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
8905: || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF)
8906: goto normal;
8907: case CONVERT_EXPR:
8908: /* If we are narrowing the operand, we have to do the compare in the
8909: narrower mode. */
8910: if ((TYPE_PRECISION (TREE_TYPE (exp))
8911: < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
8912: goto normal;
8913: case NON_LVALUE_EXPR:
8914: case REFERENCE_EXPR:
8915: case ABS_EXPR:
8916: case NEGATE_EXPR:
8917: case LROTATE_EXPR:
8918: case RROTATE_EXPR:
8919: /* These cannot change zero->non-zero or vice versa. */
8920: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
8921: break;
1.1.1.5 root 8922:
1.1.1.6 root 8923: #if 0
8924: /* This is never less insns than evaluating the PLUS_EXPR followed by
8925: a test and can be longer if the test is eliminated. */
8926: case PLUS_EXPR:
8927: /* Reduce to minus. */
8928: exp = build (MINUS_EXPR, TREE_TYPE (exp),
8929: TREE_OPERAND (exp, 0),
8930: fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
8931: TREE_OPERAND (exp, 1))));
8932: /* Process as MINUS. */
8933: #endif
1.1.1.5 root 8934:
1.1.1.6 root 8935: case MINUS_EXPR:
8936: /* Non-zero iff operands of minus differ. */
8937: comparison = compare (build (NE_EXPR, TREE_TYPE (exp),
8938: TREE_OPERAND (exp, 0),
8939: TREE_OPERAND (exp, 1)),
8940: NE, NE);
8941: break;
1.1.1.5 root 8942:
1.1.1.6 root 8943: case BIT_AND_EXPR:
8944: /* If we are AND'ing with a small constant, do this comparison in the
8945: smallest type that fits. If the machine doesn't have comparisons
8946: that small, it will be converted back to the wider comparison.
8947: This helps if we are testing the sign bit of a narrower object.
8948: combine can't do this for us because it can't know whether a
8949: ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
1.1.1.5 root 8950:
1.1.1.6 root 8951: if (! SLOW_BYTE_ACCESS
8952: && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
8953: && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
8954: && (i = floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))) >= 0
1.1.1.7 root 8955: && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
8956: && (type = type_for_mode (mode, 1)) != 0
1.1.1.6 root 8957: && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
8958: && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
8959: != CODE_FOR_nothing))
8960: {
8961: do_jump (convert (type, exp), if_false_label, if_true_label);
8962: break;
8963: }
8964: goto normal;
1.1.1.5 root 8965:
1.1.1.6 root 8966: case TRUTH_NOT_EXPR:
8967: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
8968: break;
1.1.1.5 root 8969:
1.1.1.6 root 8970: case TRUTH_ANDIF_EXPR:
1.1.1.7 root 8971: {
8972: rtx seq1, seq2;
8973: tree cleanups, old_cleanups;
8974:
8975: if (if_false_label == 0)
8976: if_false_label = drop_through_label = gen_label_rtx ();
8977: start_sequence ();
8978: do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
8979: seq1 = get_insns ();
8980: end_sequence ();
8981:
8982: old_cleanups = cleanups_this_call;
8983: start_sequence ();
8984: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
8985: seq2 = get_insns ();
8986: end_sequence ();
8987:
8988: cleanups = defer_cleanups_to (old_cleanups);
8989: if (cleanups)
8990: {
8991: rtx flag = gen_reg_rtx (word_mode);
8992: tree new_cleanups;
8993: tree cond;
8994:
8995: /* Flag cleanups as not needed. */
8996: emit_move_insn (flag, const0_rtx);
8997: emit_insns (seq1);
8998:
8999: /* Flag cleanups as needed. */
9000: emit_move_insn (flag, const1_rtx);
9001: emit_insns (seq2);
9002:
9003: /* convert flag, which is an rtx, into a tree. */
9004: cond = make_node (RTL_EXPR);
9005: TREE_TYPE (cond) = integer_type_node;
9006: RTL_EXPR_RTL (cond) = flag;
9007: RTL_EXPR_SEQUENCE (cond) = NULL_RTX;
1.1.1.8 root 9008: cond = save_expr (cond);
1.1.1.7 root 9009:
9010: new_cleanups = build (COND_EXPR, void_type_node,
9011: truthvalue_conversion (cond),
9012: cleanups, integer_zero_node);
9013: new_cleanups = fold (new_cleanups);
9014:
9015: /* Now add in the conditionalized cleanups. */
9016: cleanups_this_call
9017: = tree_cons (NULL_TREE, new_cleanups, cleanups_this_call);
9018: (*interim_eh_hook) (NULL_TREE);
9019: }
9020: else
9021: {
9022: emit_insns (seq1);
9023: emit_insns (seq2);
9024: }
9025: }
1.1.1.6 root 9026: break;
1.1.1.5 root 9027:
1.1.1.6 root 9028: case TRUTH_ORIF_EXPR:
1.1.1.7 root 9029: {
9030: rtx seq1, seq2;
9031: tree cleanups, old_cleanups;
9032:
9033: if (if_true_label == 0)
9034: if_true_label = drop_through_label = gen_label_rtx ();
9035: start_sequence ();
9036: do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9037: seq1 = get_insns ();
9038: end_sequence ();
9039:
9040: old_cleanups = cleanups_this_call;
9041: start_sequence ();
9042: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9043: seq2 = get_insns ();
9044: end_sequence ();
9045:
9046: cleanups = defer_cleanups_to (old_cleanups);
9047: if (cleanups)
9048: {
9049: rtx flag = gen_reg_rtx (word_mode);
9050: tree new_cleanups;
9051: tree cond;
9052:
9053: /* Flag cleanups as not needed. */
9054: emit_move_insn (flag, const0_rtx);
9055: emit_insns (seq1);
9056:
9057: /* Flag cleanups as needed. */
9058: emit_move_insn (flag, const1_rtx);
9059: emit_insns (seq2);
9060:
9061: /* convert flag, which is an rtx, into a tree. */
9062: cond = make_node (RTL_EXPR);
9063: TREE_TYPE (cond) = integer_type_node;
9064: RTL_EXPR_RTL (cond) = flag;
9065: RTL_EXPR_SEQUENCE (cond) = NULL_RTX;
1.1.1.8 root 9066: cond = save_expr (cond);
1.1.1.7 root 9067:
9068: new_cleanups = build (COND_EXPR, void_type_node,
9069: truthvalue_conversion (cond),
9070: cleanups, integer_zero_node);
9071: new_cleanups = fold (new_cleanups);
9072:
9073: /* Now add in the conditionalized cleanups. */
9074: cleanups_this_call
9075: = tree_cons (NULL_TREE, new_cleanups, cleanups_this_call);
9076: (*interim_eh_hook) (NULL_TREE);
9077: }
9078: else
9079: {
9080: emit_insns (seq1);
9081: emit_insns (seq2);
9082: }
9083: }
1.1.1.6 root 9084: break;
1.1.1.5 root 9085:
1.1.1.6 root 9086: case COMPOUND_EXPR:
9087: push_temp_slots ();
9088: expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9089: free_temp_slots ();
9090: pop_temp_slots ();
9091: emit_queue ();
9092: do_pending_stack_adjust ();
9093: do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9094: break;
1.1.1.5 root 9095:
1.1.1.6 root 9096: case COMPONENT_REF:
9097: case BIT_FIELD_REF:
9098: case ARRAY_REF:
9099: {
9100: int bitsize, bitpos, unsignedp;
9101: enum machine_mode mode;
9102: tree type;
9103: tree offset;
9104: int volatilep = 0;
1.1.1.5 root 9105:
1.1.1.6 root 9106: /* Get description of this reference. We don't actually care
9107: about the underlying object here. */
9108: get_inner_reference (exp, &bitsize, &bitpos, &offset,
9109: &mode, &unsignedp, &volatilep);
9110:
9111: type = type_for_size (bitsize, unsignedp);
9112: if (! SLOW_BYTE_ACCESS
9113: && type != 0 && bitsize >= 0
9114: && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9115: && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9116: != CODE_FOR_nothing))
1.1.1.5 root 9117: {
1.1.1.6 root 9118: do_jump (convert (type, exp), if_false_label, if_true_label);
9119: break;
9120: }
9121: goto normal;
9122: }
1.1.1.5 root 9123:
1.1.1.6 root 9124: case COND_EXPR:
9125: /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases. */
9126: if (integer_onep (TREE_OPERAND (exp, 1))
9127: && integer_zerop (TREE_OPERAND (exp, 2)))
9128: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
1.1.1.5 root 9129:
1.1.1.6 root 9130: else if (integer_zerop (TREE_OPERAND (exp, 1))
9131: && integer_onep (TREE_OPERAND (exp, 2)))
9132: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
1.1.1.5 root 9133:
1.1.1.6 root 9134: else
9135: {
9136: register rtx label1 = gen_label_rtx ();
9137: drop_through_label = gen_label_rtx ();
9138: do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9139: /* Now the THEN-expression. */
9140: do_jump (TREE_OPERAND (exp, 1),
9141: if_false_label ? if_false_label : drop_through_label,
9142: if_true_label ? if_true_label : drop_through_label);
9143: /* In case the do_jump just above never jumps. */
9144: do_pending_stack_adjust ();
9145: emit_label (label1);
9146: /* Now the ELSE-expression. */
9147: do_jump (TREE_OPERAND (exp, 2),
9148: if_false_label ? if_false_label : drop_through_label,
9149: if_true_label ? if_true_label : drop_through_label);
9150: }
9151: break;
1.1.1.5 root 9152:
1.1.1.6 root 9153: case EQ_EXPR:
1.1.1.8 root 9154: {
9155: tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9156:
9157: if (integer_zerop (TREE_OPERAND (exp, 1)))
9158: do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9159: else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9160: || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9161: do_jump
9162: (fold
9163: (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9164: fold (build (EQ_EXPR, TREE_TYPE (exp),
9165: fold (build1 (REALPART_EXPR,
9166: TREE_TYPE (inner_type),
9167: TREE_OPERAND (exp, 0))),
9168: fold (build1 (REALPART_EXPR,
9169: TREE_TYPE (inner_type),
9170: TREE_OPERAND (exp, 1))))),
9171: fold (build (EQ_EXPR, TREE_TYPE (exp),
9172: fold (build1 (IMAGPART_EXPR,
9173: TREE_TYPE (inner_type),
9174: TREE_OPERAND (exp, 0))),
9175: fold (build1 (IMAGPART_EXPR,
9176: TREE_TYPE (inner_type),
9177: TREE_OPERAND (exp, 1))))))),
9178: if_false_label, if_true_label);
9179: else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9180: && !can_compare_p (TYPE_MODE (inner_type)))
9181: do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9182: else
9183: comparison = compare (exp, EQ, EQ);
9184: break;
9185: }
1.1.1.5 root 9186:
1.1.1.6 root 9187: case NE_EXPR:
1.1.1.8 root 9188: {
9189: tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9190:
9191: if (integer_zerop (TREE_OPERAND (exp, 1)))
9192: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9193: else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9194: || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9195: do_jump
9196: (fold
9197: (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9198: fold (build (NE_EXPR, TREE_TYPE (exp),
9199: fold (build1 (REALPART_EXPR,
9200: TREE_TYPE (inner_type),
9201: TREE_OPERAND (exp, 0))),
9202: fold (build1 (REALPART_EXPR,
9203: TREE_TYPE (inner_type),
9204: TREE_OPERAND (exp, 1))))),
9205: fold (build (NE_EXPR, TREE_TYPE (exp),
9206: fold (build1 (IMAGPART_EXPR,
9207: TREE_TYPE (inner_type),
9208: TREE_OPERAND (exp, 0))),
9209: fold (build1 (IMAGPART_EXPR,
9210: TREE_TYPE (inner_type),
9211: TREE_OPERAND (exp, 1))))))),
9212: if_false_label, if_true_label);
9213: else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9214: && !can_compare_p (TYPE_MODE (inner_type)))
9215: do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9216: else
9217: comparison = compare (exp, NE, NE);
9218: break;
9219: }
1.1.1.5 root 9220:
1.1.1.6 root 9221: case LT_EXPR:
9222: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
9223: == MODE_INT)
9224: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9225: do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9226: else
9227: comparison = compare (exp, LT, LTU);
9228: break;
1.1.1.5 root 9229:
1.1.1.6 root 9230: case LE_EXPR:
9231: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
9232: == MODE_INT)
9233: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9234: do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9235: else
9236: comparison = compare (exp, LE, LEU);
9237: break;
1.1.1.5 root 9238:
1.1.1.6 root 9239: case GT_EXPR:
9240: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
9241: == MODE_INT)
9242: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9243: do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9244: else
9245: comparison = compare (exp, GT, GTU);
9246: break;
1.1.1.5 root 9247:
1.1.1.6 root 9248: case GE_EXPR:
9249: if ((GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
9250: == MODE_INT)
9251: && !can_compare_p (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9252: do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9253: else
9254: comparison = compare (exp, GE, GEU);
9255: break;
1.1.1.5 root 9256:
1.1.1.6 root 9257: default:
9258: normal:
9259: temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9260: #if 0
9261: /* This is not needed any more and causes poor code since it causes
9262: comparisons and tests from non-SI objects to have different code
9263: sequences. */
9264: /* Copy to register to avoid generating bad insns by cse
9265: from (set (mem ...) (arithop)) (set (cc0) (mem ...)). */
9266: if (!cse_not_expected && GET_CODE (temp) == MEM)
9267: temp = copy_to_reg (temp);
9268: #endif
9269: do_pending_stack_adjust ();
9270: if (GET_CODE (temp) == CONST_INT)
9271: comparison = (temp == const0_rtx ? const0_rtx : const_true_rtx);
9272: else if (GET_CODE (temp) == LABEL_REF)
9273: comparison = const_true_rtx;
9274: else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9275: && !can_compare_p (GET_MODE (temp)))
9276: /* Note swapping the labels gives us not-equal. */
9277: do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9278: else if (GET_MODE (temp) != VOIDmode)
9279: comparison = compare_from_rtx (temp, CONST0_RTX (GET_MODE (temp)),
9280: NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9281: GET_MODE (temp), NULL_RTX, 0);
9282: else
9283: abort ();
9284: }
1.1.1.5 root 9285:
1.1.1.6 root 9286: /* Do any postincrements in the expression that was tested. */
9287: emit_queue ();
1.1.1.5 root 9288:
1.1.1.6 root 9289: /* If COMPARISON is nonzero here, it is an rtx that can be substituted
9290: straight into a conditional jump instruction as the jump condition.
9291: Otherwise, all the work has been done already. */
1.1.1.5 root 9292:
1.1.1.6 root 9293: if (comparison == const_true_rtx)
1.1.1.5 root 9294: {
1.1.1.6 root 9295: if (if_true_label)
9296: emit_jump (if_true_label);
1.1.1.5 root 9297: }
1.1.1.6 root 9298: else if (comparison == const0_rtx)
9299: {
9300: if (if_false_label)
9301: emit_jump (if_false_label);
9302: }
9303: else if (comparison)
9304: do_jump_for_compare (comparison, if_false_label, if_true_label);
1.1.1.5 root 9305:
1.1.1.6 root 9306: if (drop_through_label)
9307: {
9308: /* If do_jump produces code that might be jumped around,
9309: do any stack adjusts from that code, before the place
9310: where control merges in. */
9311: do_pending_stack_adjust ();
9312: emit_label (drop_through_label);
9313: }
1.1.1.5 root 9314: }
1.1.1.6 root 9315:
9316: /* Given a comparison expression EXP for values too wide to be compared
9317: with one insn, test the comparison and jump to the appropriate label.
9318: The code of EXP is ignored; we always test GT if SWAP is 0,
9319: and LT if SWAP is 1. */
1.1.1.5 root 9320:
1.1.1.6 root 9321: static void
9322: do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
9323: tree exp;
9324: int swap;
9325: rtx if_false_label, if_true_label;
1.1.1.5 root 9326: {
1.1.1.6 root 9327: rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
9328: rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
9329: enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9330: int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9331: rtx drop_through_label = 0;
9332: int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
9333: int i;
1.1.1.5 root 9334:
1.1.1.6 root 9335: if (! if_true_label || ! if_false_label)
9336: drop_through_label = gen_label_rtx ();
9337: if (! if_true_label)
9338: if_true_label = drop_through_label;
9339: if (! if_false_label)
9340: if_false_label = drop_through_label;
1.1.1.5 root 9341:
1.1.1.6 root 9342: /* Compare a word at a time, high order first. */
9343: for (i = 0; i < nwords; i++)
9344: {
9345: rtx comp;
9346: rtx op0_word, op1_word;
1.1.1.5 root 9347:
1.1.1.6 root 9348: if (WORDS_BIG_ENDIAN)
9349: {
9350: op0_word = operand_subword_force (op0, i, mode);
9351: op1_word = operand_subword_force (op1, i, mode);
9352: }
9353: else
9354: {
9355: op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
9356: op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
9357: }
1.1.1.5 root 9358:
1.1.1.6 root 9359: /* All but high-order word must be compared as unsigned. */
9360: comp = compare_from_rtx (op0_word, op1_word,
9361: (unsignedp || i > 0) ? GTU : GT,
9362: unsignedp, word_mode, NULL_RTX, 0);
9363: if (comp == const_true_rtx)
9364: emit_jump (if_true_label);
9365: else if (comp != const0_rtx)
9366: do_jump_for_compare (comp, NULL_RTX, if_true_label);
1.1.1.5 root 9367:
1.1.1.6 root 9368: /* Consider lower words only if these are equal. */
9369: comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode,
9370: NULL_RTX, 0);
9371: if (comp == const_true_rtx)
9372: emit_jump (if_false_label);
9373: else if (comp != const0_rtx)
9374: do_jump_for_compare (comp, NULL_RTX, if_false_label);
9375: }
1.1.1.5 root 9376:
1.1.1.6 root 9377: if (if_false_label)
9378: emit_jump (if_false_label);
9379: if (drop_through_label)
9380: emit_label (drop_through_label);
9381: }
1.1.1.5 root 9382:
1.1.1.6 root 9383: /* Compare OP0 with OP1, word at a time, in mode MODE.
9384: UNSIGNEDP says to do unsigned comparison.
9385: Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
1.1.1.5 root 9386:
1.1.1.7 root 9387: void
1.1.1.6 root 9388: do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
9389: enum machine_mode mode;
9390: int unsignedp;
9391: rtx op0, op1;
9392: rtx if_false_label, if_true_label;
9393: {
9394: int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9395: rtx drop_through_label = 0;
9396: int i;
1.1.1.5 root 9397:
1.1.1.6 root 9398: if (! if_true_label || ! if_false_label)
9399: drop_through_label = gen_label_rtx ();
9400: if (! if_true_label)
9401: if_true_label = drop_through_label;
9402: if (! if_false_label)
9403: if_false_label = drop_through_label;
1.1.1.5 root 9404:
1.1.1.6 root 9405: /* Compare a word at a time, high order first. */
9406: for (i = 0; i < nwords; i++)
1.1.1.5 root 9407: {
1.1.1.6 root 9408: rtx comp;
9409: rtx op0_word, op1_word;
9410:
9411: if (WORDS_BIG_ENDIAN)
1.1.1.5 root 9412: {
1.1.1.6 root 9413: op0_word = operand_subword_force (op0, i, mode);
9414: op1_word = operand_subword_force (op1, i, mode);
9415: }
9416: else
9417: {
9418: op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
9419: op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
1.1.1.5 root 9420: }
9421:
1.1.1.6 root 9422: /* All but high-order word must be compared as unsigned. */
9423: comp = compare_from_rtx (op0_word, op1_word,
9424: (unsignedp || i > 0) ? GTU : GT,
9425: unsignedp, word_mode, NULL_RTX, 0);
9426: if (comp == const_true_rtx)
9427: emit_jump (if_true_label);
9428: else if (comp != const0_rtx)
9429: do_jump_for_compare (comp, NULL_RTX, if_true_label);
1.1.1.5 root 9430:
1.1.1.6 root 9431: /* Consider lower words only if these are equal. */
9432: comp = compare_from_rtx (op0_word, op1_word, NE, unsignedp, word_mode,
9433: NULL_RTX, 0);
9434: if (comp == const_true_rtx)
9435: emit_jump (if_false_label);
9436: else if (comp != const0_rtx)
9437: do_jump_for_compare (comp, NULL_RTX, if_false_label);
9438: }
1.1.1.5 root 9439:
1.1.1.6 root 9440: if (if_false_label)
9441: emit_jump (if_false_label);
9442: if (drop_through_label)
9443: emit_label (drop_through_label);
9444: }
1.1.1.5 root 9445:
1.1.1.6 root 9446: /* Given an EQ_EXPR expression EXP for values too wide to be compared
9447: with one insn, test the comparison and jump to the appropriate label. */
1.1.1.5 root 9448:
1.1.1.6 root 9449: static void
9450: do_jump_by_parts_equality (exp, if_false_label, if_true_label)
9451: tree exp;
9452: rtx if_false_label, if_true_label;
9453: {
9454: rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9455: rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
9456: enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9457: int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9458: int i;
9459: rtx drop_through_label = 0;
1.1.1.5 root 9460:
1.1.1.6 root 9461: if (! if_false_label)
9462: drop_through_label = if_false_label = gen_label_rtx ();
9463:
9464: for (i = 0; i < nwords; i++)
9465: {
9466: rtx comp = compare_from_rtx (operand_subword_force (op0, i, mode),
9467: operand_subword_force (op1, i, mode),
9468: EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
9469: word_mode, NULL_RTX, 0);
9470: if (comp == const_true_rtx)
9471: emit_jump (if_false_label);
9472: else if (comp != const0_rtx)
9473: do_jump_for_compare (comp, if_false_label, NULL_RTX);
1.1.1.5 root 9474: }
9475:
1.1.1.6 root 9476: if (if_true_label)
9477: emit_jump (if_true_label);
9478: if (drop_through_label)
9479: emit_label (drop_through_label);
9480: }
9481:
9482: /* Jump according to whether OP0 is 0.
9483: We assume that OP0 has an integer mode that is too wide
9484: for the available compare insns. */
1.1.1.5 root 9485:
1.1.1.6 root 9486: static void
9487: do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
9488: rtx op0;
9489: rtx if_false_label, if_true_label;
9490: {
9491: int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
9492: int i;
9493: rtx drop_through_label = 0;
1.1.1.5 root 9494:
1.1.1.6 root 9495: if (! if_false_label)
9496: drop_through_label = if_false_label = gen_label_rtx ();
1.1.1.5 root 9497:
1.1.1.6 root 9498: for (i = 0; i < nwords; i++)
9499: {
9500: rtx comp = compare_from_rtx (operand_subword_force (op0, i,
9501: GET_MODE (op0)),
9502: const0_rtx, EQ, 1, word_mode, NULL_RTX, 0);
9503: if (comp == const_true_rtx)
9504: emit_jump (if_false_label);
9505: else if (comp != const0_rtx)
9506: do_jump_for_compare (comp, if_false_label, NULL_RTX);
9507: }
1.1.1.5 root 9508:
1.1.1.6 root 9509: if (if_true_label)
9510: emit_jump (if_true_label);
9511: if (drop_through_label)
9512: emit_label (drop_through_label);
1.1.1.5 root 9513: }
9514:
1.1.1.6 root 9515: /* Given a comparison expression in rtl form, output conditional branches to
9516: IF_TRUE_LABEL, IF_FALSE_LABEL, or both. */
9517:
1.1.1.5 root 9518: static void
1.1.1.6 root 9519: do_jump_for_compare (comparison, if_false_label, if_true_label)
9520: rtx comparison, if_false_label, if_true_label;
1.1.1.5 root 9521: {
1.1.1.6 root 9522: if (if_true_label)
1.1.1.5 root 9523: {
1.1.1.6 root 9524: if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0)
9525: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_true_label));
9526: else
9527: abort ();
9528:
9529: if (if_false_label)
9530: emit_jump (if_false_label);
1.1.1.5 root 9531: }
1.1.1.6 root 9532: else if (if_false_label)
9533: {
9534: rtx insn;
9535: rtx prev = get_last_insn ();
9536: rtx branch = 0;
1.1.1.5 root 9537:
1.1.1.6 root 9538: /* Output the branch with the opposite condition. Then try to invert
9539: what is generated. If more than one insn is a branch, or if the
9540: branch is not the last insn written, abort. If we can't invert
9541: the branch, emit make a true label, redirect this jump to that,
9542: emit a jump to the false label and define the true label. */
1.1.1.5 root 9543:
1.1.1.6 root 9544: if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0)
1.1.1.7 root 9545: emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)])(if_false_label));
1.1.1.6 root 9546: else
9547: abort ();
1.1.1.5 root 9548:
1.1.1.7 root 9549: /* Here we get the first insn that was just emitted. It used to be the
9550: case that, on some machines, emitting the branch would discard
9551: the previous compare insn and emit a replacement. This isn't
9552: done anymore, but abort if we see that PREV is deleted. */
9553:
1.1.1.6 root 9554: if (prev == 0)
9555: insn = get_insns ();
1.1.1.7 root 9556: else if (INSN_DELETED_P (prev))
9557: abort ();
1.1.1.6 root 9558: else
9559: insn = NEXT_INSN (prev);
9560:
1.1.1.7 root 9561: for (; insn; insn = NEXT_INSN (insn))
1.1.1.6 root 9562: if (GET_CODE (insn) == JUMP_INSN)
9563: {
9564: if (branch)
9565: abort ();
9566: branch = insn;
9567: }
9568:
9569: if (branch != get_last_insn ())
9570: abort ();
9571:
1.1.1.7 root 9572: JUMP_LABEL (branch) = if_false_label;
1.1.1.6 root 9573: if (! invert_jump (branch, if_false_label))
9574: {
9575: if_true_label = gen_label_rtx ();
9576: redirect_jump (branch, if_true_label);
9577: emit_jump (if_false_label);
9578: emit_label (if_true_label);
9579: }
9580: }
1.1.1.5 root 9581: }
9582:
1.1.1.6 root 9583: /* Generate code for a comparison expression EXP
9584: (including code to compute the values to be compared)
9585: and set (CC0) according to the result.
9586: SIGNED_CODE should be the rtx operation for this comparison for
9587: signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
9588:
9589: We force a stack adjustment unless there are currently
9590: things pushed on the stack that aren't yet used. */
1.1 root 9591:
9592: static rtx
1.1.1.6 root 9593: compare (exp, signed_code, unsigned_code)
1.1 root 9594: register tree exp;
1.1.1.6 root 9595: enum rtx_code signed_code, unsigned_code;
1.1 root 9596: {
1.1.1.6 root 9597: register rtx op0
9598: = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9599: register rtx op1
9600: = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
9601: register tree type = TREE_TYPE (TREE_OPERAND (exp, 0));
9602: register enum machine_mode mode = TYPE_MODE (type);
9603: int unsignedp = TREE_UNSIGNED (type);
9604: enum rtx_code code = unsignedp ? unsigned_code : signed_code;
1.1.1.4 root 9605:
1.1.1.6 root 9606: return compare_from_rtx (op0, op1, code, unsignedp, mode,
9607: ((mode == BLKmode)
9608: ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
9609: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
9610: }
1.1.1.4 root 9611:
1.1.1.6 root 9612: /* Like compare but expects the values to compare as two rtx's.
9613: The decision as to signed or unsigned comparison must be made by the caller.
1.1.1.4 root 9614:
1.1.1.6 root 9615: If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9616: compared.
1.1.1.4 root 9617:
1.1.1.6 root 9618: If ALIGN is non-zero, it is the alignment of this type; if zero, the
9619: size of MODE should be used. */
1.1.1.4 root 9620:
1.1.1.6 root 9621: rtx
9622: compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
9623: register rtx op0, op1;
9624: enum rtx_code code;
9625: int unsignedp;
9626: enum machine_mode mode;
9627: rtx size;
9628: int align;
9629: {
9630: rtx tem;
1.1 root 9631:
1.1.1.6 root 9632: /* If one operand is constant, make it the second one. Only do this
9633: if the other operand is not constant as well. */
1.1 root 9634:
1.1.1.6 root 9635: if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
9636: || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
1.1 root 9637: {
1.1.1.6 root 9638: tem = op0;
9639: op0 = op1;
9640: op1 = tem;
9641: code = swap_condition (code);
1.1 root 9642: }
9643:
1.1.1.6 root 9644: if (flag_force_mem)
1.1 root 9645: {
1.1.1.6 root 9646: op0 = force_not_mem (op0);
9647: op1 = force_not_mem (op1);
1.1 root 9648: }
9649:
1.1.1.6 root 9650: do_pending_stack_adjust ();
1.1 root 9651:
1.1.1.6 root 9652: if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
9653: && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
9654: return tem;
1.1 root 9655:
1.1.1.6 root 9656: #if 0
9657: /* There's no need to do this now that combine.c can eliminate lots of
9658: sign extensions. This can be less efficient in certain cases on other
9659: machines. */
1.1 root 9660:
1.1.1.6 root 9661: /* If this is a signed equality comparison, we can do it as an
9662: unsigned comparison since zero-extension is cheaper than sign
9663: extension and comparisons with zero are done as unsigned. This is
9664: the case even on machines that can do fast sign extension, since
9665: zero-extension is easier to combine with other operations than
9666: sign-extension is. If we are comparing against a constant, we must
9667: convert it to what it would look like unsigned. */
9668: if ((code == EQ || code == NE) && ! unsignedp
9669: && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9670: {
9671: if (GET_CODE (op1) == CONST_INT
9672: && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
9673: op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
9674: unsignedp = 1;
1.1 root 9675: }
1.1.1.6 root 9676: #endif
9677:
9678: emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
1.1 root 9679:
1.1.1.6 root 9680: return gen_rtx (code, VOIDmode, cc0_rtx, const0_rtx);
1.1 root 9681: }
9682:
1.1.1.6 root 9683: /* Generate code to calculate EXP using a store-flag instruction
9684: and return an rtx for the result. EXP is either a comparison
9685: or a TRUTH_NOT_EXPR whose operand is a comparison.
1.1 root 9686:
1.1.1.6 root 9687: If TARGET is nonzero, store the result there if convenient.
1.1 root 9688:
1.1.1.6 root 9689: If ONLY_CHEAP is non-zero, only do this if it is likely to be very
9690: cheap.
1.1 root 9691:
1.1.1.6 root 9692: Return zero if there is no suitable set-flag instruction
9693: available on this machine.
1.1 root 9694:
1.1.1.6 root 9695: Once expand_expr has been called on the arguments of the comparison,
9696: we are committed to doing the store flag, since it is not safe to
9697: re-evaluate the expression. We emit the store-flag insn by calling
9698: emit_store_flag, but only expand the arguments if we have a reason
9699: to believe that emit_store_flag will be successful. If we think that
9700: it will, but it isn't, we have to simulate the store-flag with a
9701: set/jump/set sequence. */
1.1 root 9702:
1.1.1.6 root 9703: static rtx
9704: do_store_flag (exp, target, mode, only_cheap)
9705: tree exp;
9706: rtx target;
9707: enum machine_mode mode;
9708: int only_cheap;
9709: {
9710: enum rtx_code code;
9711: tree arg0, arg1, type;
9712: tree tem;
9713: enum machine_mode operand_mode;
9714: int invert = 0;
9715: int unsignedp;
9716: rtx op0, op1;
9717: enum insn_code icode;
9718: rtx subtarget = target;
9719: rtx result, label, pattern, jump_pat;
1.1 root 9720:
1.1.1.6 root 9721: /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
9722: result at the end. We can't simply invert the test since it would
9723: have already been inverted if it were valid. This case occurs for
9724: some floating-point comparisons. */
1.1 root 9725:
1.1.1.6 root 9726: if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
9727: invert = 1, exp = TREE_OPERAND (exp, 0);
1.1 root 9728:
1.1.1.6 root 9729: arg0 = TREE_OPERAND (exp, 0);
9730: arg1 = TREE_OPERAND (exp, 1);
9731: type = TREE_TYPE (arg0);
9732: operand_mode = TYPE_MODE (type);
9733: unsignedp = TREE_UNSIGNED (type);
1.1 root 9734:
1.1.1.6 root 9735: /* We won't bother with BLKmode store-flag operations because it would mean
9736: passing a lot of information to emit_store_flag. */
9737: if (operand_mode == BLKmode)
9738: return 0;
1.1 root 9739:
1.1.1.6 root 9740: STRIP_NOPS (arg0);
9741: STRIP_NOPS (arg1);
1.1 root 9742:
1.1.1.6 root 9743: /* Get the rtx comparison code to use. We know that EXP is a comparison
9744: operation of some type. Some comparisons against 1 and -1 can be
9745: converted to comparisons with zero. Do so here so that the tests
9746: below will be aware that we have a comparison with zero. These
9747: tests will not catch constants in the first operand, but constants
9748: are rarely passed as the first operand. */
1.1 root 9749:
1.1.1.6 root 9750: switch (TREE_CODE (exp))
1.1 root 9751: {
1.1.1.6 root 9752: case EQ_EXPR:
9753: code = EQ;
9754: break;
9755: case NE_EXPR:
9756: code = NE;
9757: break;
9758: case LT_EXPR:
9759: if (integer_onep (arg1))
9760: arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
9761: else
9762: code = unsignedp ? LTU : LT;
9763: break;
9764: case LE_EXPR:
9765: if (! unsignedp && integer_all_onesp (arg1))
9766: arg1 = integer_zero_node, code = LT;
9767: else
9768: code = unsignedp ? LEU : LE;
9769: break;
9770: case GT_EXPR:
9771: if (! unsignedp && integer_all_onesp (arg1))
9772: arg1 = integer_zero_node, code = GE;
9773: else
9774: code = unsignedp ? GTU : GT;
9775: break;
9776: case GE_EXPR:
9777: if (integer_onep (arg1))
9778: arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
9779: else
9780: code = unsignedp ? GEU : GE;
9781: break;
9782: default:
9783: abort ();
1.1 root 9784: }
9785:
1.1.1.6 root 9786: /* Put a constant second. */
9787: if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
1.1 root 9788: {
1.1.1.6 root 9789: tem = arg0; arg0 = arg1; arg1 = tem;
9790: code = swap_condition (code);
1.1 root 9791: }
9792:
1.1.1.6 root 9793: /* If this is an equality or inequality test of a single bit, we can
9794: do this by shifting the bit being tested to the low-order bit and
9795: masking the result with the constant 1. If the condition was EQ,
9796: we xor it with 1. This does not require an scc insn and is faster
9797: than an scc insn even if we have it. */
1.1 root 9798:
1.1.1.6 root 9799: if ((code == NE || code == EQ)
9800: && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
9801: && integer_pow2p (TREE_OPERAND (arg0, 1))
9802: && TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT)
9803: {
9804: tree inner = TREE_OPERAND (arg0, 0);
9805: int bitnum = exact_log2 (INTVAL (expand_expr (TREE_OPERAND (arg0, 1),
9806: NULL_RTX, VOIDmode, 0)));
9807: int ops_unsignedp;
1.1 root 9808:
1.1.1.6 root 9809: /* If INNER is a right shift of a constant and it plus BITNUM does
9810: not overflow, adjust BITNUM and INNER. */
1.1 root 9811:
1.1.1.6 root 9812: if (TREE_CODE (inner) == RSHIFT_EXPR
9813: && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
9814: && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
9815: && (bitnum + TREE_INT_CST_LOW (TREE_OPERAND (inner, 1))
9816: < TYPE_PRECISION (type)))
9817: {
9818: bitnum +=TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
9819: inner = TREE_OPERAND (inner, 0);
9820: }
9821:
9822: /* If we are going to be able to omit the AND below, we must do our
9823: operations as unsigned. If we must use the AND, we have a choice.
9824: Normally unsigned is faster, but for some machines signed is. */
9825: ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
9826: #ifdef LOAD_EXTEND_OP
9827: : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
9828: #else
9829: : 1
9830: #endif
9831: );
1.1 root 9832:
1.1.1.6 root 9833: if (subtarget == 0 || GET_CODE (subtarget) != REG
9834: || GET_MODE (subtarget) != operand_mode
9835: || ! safe_from_p (subtarget, inner))
9836: subtarget = 0;
1.1 root 9837:
1.1.1.6 root 9838: op0 = expand_expr (inner, subtarget, VOIDmode, 0);
1.1.1.3 root 9839:
1.1.1.6 root 9840: if (bitnum != 0)
9841: op0 = expand_shift (RSHIFT_EXPR, GET_MODE (op0), op0,
9842: size_int (bitnum), subtarget, ops_unsignedp);
1.1 root 9843:
1.1.1.6 root 9844: if (GET_MODE (op0) != mode)
9845: op0 = convert_to_mode (mode, op0, ops_unsignedp);
1.1 root 9846:
1.1.1.6 root 9847: if ((code == EQ && ! invert) || (code == NE && invert))
9848: op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
9849: ops_unsignedp, OPTAB_LIB_WIDEN);
1.1 root 9850:
1.1.1.6 root 9851: /* Put the AND last so it can combine with more things. */
9852: if (bitnum != TYPE_PRECISION (type) - 1)
9853: op0 = expand_and (op0, const1_rtx, subtarget);
9854:
9855: return op0;
9856: }
9857:
9858: /* Now see if we are likely to be able to do this. Return if not. */
9859: if (! can_compare_p (operand_mode))
9860: return 0;
9861: icode = setcc_gen_code[(int) code];
9862: if (icode == CODE_FOR_nothing
9863: || (only_cheap && insn_operand_mode[(int) icode][0] != mode))
1.1 root 9864: {
1.1.1.6 root 9865: /* We can only do this if it is one of the special cases that
9866: can be handled without an scc insn. */
9867: if ((code == LT && integer_zerop (arg1))
9868: || (! only_cheap && code == GE && integer_zerop (arg1)))
9869: ;
9870: else if (BRANCH_COST >= 0
9871: && ! only_cheap && (code == NE || code == EQ)
9872: && TREE_CODE (type) != REAL_TYPE
9873: && ((abs_optab->handlers[(int) operand_mode].insn_code
9874: != CODE_FOR_nothing)
9875: || (ffs_optab->handlers[(int) operand_mode].insn_code
9876: != CODE_FOR_nothing)))
9877: ;
9878: else
9879: return 0;
9880: }
9881:
9882: preexpand_calls (exp);
9883: if (subtarget == 0 || GET_CODE (subtarget) != REG
9884: || GET_MODE (subtarget) != operand_mode
9885: || ! safe_from_p (subtarget, arg1))
9886: subtarget = 0;
1.1 root 9887:
1.1.1.6 root 9888: op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
9889: op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
1.1 root 9890:
1.1.1.6 root 9891: if (target == 0)
9892: target = gen_reg_rtx (mode);
1.1 root 9893:
1.1.1.6 root 9894: /* Pass copies of OP0 and OP1 in case they contain a QUEUED. This is safe
9895: because, if the emit_store_flag does anything it will succeed and
9896: OP0 and OP1 will not be used subsequently. */
1.1 root 9897:
1.1.1.6 root 9898: result = emit_store_flag (target, code,
9899: queued_subexp_p (op0) ? copy_rtx (op0) : op0,
9900: queued_subexp_p (op1) ? copy_rtx (op1) : op1,
9901: operand_mode, unsignedp, 1);
1.1 root 9902:
1.1.1.6 root 9903: if (result)
9904: {
9905: if (invert)
9906: result = expand_binop (mode, xor_optab, result, const1_rtx,
9907: result, 0, OPTAB_LIB_WIDEN);
9908: return result;
9909: }
1.1 root 9910:
1.1.1.6 root 9911: /* If this failed, we have to do this with set/compare/jump/set code. */
9912: if (target == 0 || GET_CODE (target) != REG
9913: || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
9914: target = gen_reg_rtx (GET_MODE (target));
1.1 root 9915:
1.1.1.6 root 9916: emit_move_insn (target, invert ? const0_rtx : const1_rtx);
9917: result = compare_from_rtx (op0, op1, code, unsignedp,
9918: operand_mode, NULL_RTX, 0);
9919: if (GET_CODE (result) == CONST_INT)
9920: return (((result == const0_rtx && ! invert)
9921: || (result != const0_rtx && invert))
9922: ? const0_rtx : const1_rtx);
1.1 root 9923:
1.1.1.6 root 9924: label = gen_label_rtx ();
9925: if (bcc_gen_fctn[(int) code] == 0)
9926: abort ();
1.1 root 9927:
1.1.1.6 root 9928: emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
9929: emit_move_insn (target, invert ? const1_rtx : const0_rtx);
9930: emit_label (label);
1.1 root 9931:
1.1.1.6 root 9932: return target;
9933: }
9934:
9935: /* Generate a tablejump instruction (used for switch statements). */
1.1 root 9936:
1.1.1.6 root 9937: #ifdef HAVE_tablejump
1.1 root 9938:
1.1.1.6 root 9939: /* INDEX is the value being switched on, with the lowest value
9940: in the table already subtracted.
9941: MODE is its expected mode (needed if INDEX is constant).
9942: RANGE is the length of the jump table.
9943: TABLE_LABEL is a CODE_LABEL rtx for the table itself.
1.1 root 9944:
1.1.1.6 root 9945: DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
9946: index value is out of range. */
1.1 root 9947:
1.1.1.6 root 9948: void
9949: do_tablejump (index, mode, range, table_label, default_label)
9950: rtx index, range, table_label, default_label;
9951: enum machine_mode mode;
9952: {
9953: register rtx temp, vector;
1.1 root 9954:
1.1.1.6 root 9955: /* Do an unsigned comparison (in the proper mode) between the index
9956: expression and the value which represents the length of the range.
9957: Since we just finished subtracting the lower bound of the range
9958: from the index expression, this comparison allows us to simultaneously
9959: check that the original index expression value is both greater than
9960: or equal to the minimum value of the range and less than or equal to
9961: the maximum value of the range. */
1.1 root 9962:
1.1.1.7 root 9963: emit_cmp_insn (index, range, GTU, NULL_RTX, mode, 1, 0);
9964: emit_jump_insn (gen_bgtu (default_label));
1.1 root 9965:
1.1.1.6 root 9966: /* If index is in range, it must fit in Pmode.
9967: Convert to Pmode so we can index with it. */
9968: if (mode != Pmode)
9969: index = convert_to_mode (Pmode, index, 1);
1.1 root 9970:
1.1.1.6 root 9971: /* Don't let a MEM slip thru, because then INDEX that comes
9972: out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
9973: and break_out_memory_refs will go to work on it and mess it up. */
9974: #ifdef PIC_CASE_VECTOR_ADDRESS
9975: if (flag_pic && GET_CODE (index) != REG)
9976: index = copy_to_mode_reg (Pmode, index);
9977: #endif
1.1 root 9978:
1.1.1.6 root 9979: /* If flag_force_addr were to affect this address
9980: it could interfere with the tricky assumptions made
9981: about addresses that contain label-refs,
9982: which may be valid only very near the tablejump itself. */
9983: /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
9984: GET_MODE_SIZE, because this indicates how large insns are. The other
9985: uses should all be Pmode, because they are addresses. This code
9986: could fail if addresses and insns are not the same size. */
9987: index = gen_rtx (PLUS, Pmode,
9988: gen_rtx (MULT, Pmode, index,
9989: GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
9990: gen_rtx (LABEL_REF, Pmode, table_label));
9991: #ifdef PIC_CASE_VECTOR_ADDRESS
9992: if (flag_pic)
9993: index = PIC_CASE_VECTOR_ADDRESS (index);
9994: else
9995: #endif
9996: index = memory_address_noforce (CASE_VECTOR_MODE, index);
9997: temp = gen_reg_rtx (CASE_VECTOR_MODE);
9998: vector = gen_rtx (MEM, CASE_VECTOR_MODE, index);
9999: RTX_UNCHANGING_P (vector) = 1;
10000: convert_move (temp, vector, 0);
1.1 root 10001:
1.1.1.6 root 10002: emit_jump_insn (gen_tablejump (temp, table_label));
1.1 root 10003:
1.1.1.6 root 10004: #ifndef CASE_VECTOR_PC_RELATIVE
10005: /* If we are generating PIC code or if the table is PC-relative, the
10006: table and JUMP_INSN must be adjacent, so don't output a BARRIER. */
10007: if (! flag_pic)
10008: emit_barrier ();
10009: #endif
10010: }
1.1 root 10011:
1.1.1.6 root 10012: #endif /* HAVE_tablejump */
1.1 root 10013:
10014:
1.1.1.6 root 10015: /* Emit a suitable bytecode to load a value from memory, assuming a pointer
10016: to that value is on the top of the stack. The resulting type is TYPE, and
10017: the source declaration is DECL. */
10018:
10019: void
10020: bc_load_memory (type, decl)
10021: tree type, decl;
10022: {
10023: enum bytecode_opcode opcode;
10024:
10025:
10026: /* Bit fields are special. We only know about signed and
10027: unsigned ints, and enums. The latter are treated as
10028: signed integers. */
10029:
10030: if (DECL_BIT_FIELD (decl))
10031: if (TREE_CODE (type) == ENUMERAL_TYPE
10032: || TREE_CODE (type) == INTEGER_TYPE)
10033: opcode = TREE_UNSIGNED (type) ? zxloadBI : sxloadBI;
10034: else
10035: abort ();
10036: else
10037: /* See corresponding comment in bc_store_memory(). */
10038: if (TYPE_MODE (type) == BLKmode
10039: || TYPE_MODE (type) == VOIDmode)
10040: return;
10041: else
10042: opcode = mode_to_load_map [(int) TYPE_MODE (type)];
10043:
10044: if (opcode == neverneverland)
10045: abort ();
10046:
10047: bc_emit_bytecode (opcode);
10048:
10049: #ifdef DEBUG_PRINT_CODE
10050: fputc ('\n', stderr);
1.1 root 10051: #endif
1.1.1.6 root 10052: }
1.1 root 10053:
10054:
1.1.1.6 root 10055: /* Store the contents of the second stack slot to the address in the
10056: top stack slot. DECL is the declaration of the destination and is used
10057: to determine whether we're dealing with a bitfield. */
1.1 root 10058:
1.1.1.6 root 10059: void
10060: bc_store_memory (type, decl)
10061: tree type, decl;
10062: {
10063: enum bytecode_opcode opcode;
10064:
10065:
10066: if (DECL_BIT_FIELD (decl))
1.1 root 10067: {
1.1.1.6 root 10068: if (TREE_CODE (type) == ENUMERAL_TYPE
10069: || TREE_CODE (type) == INTEGER_TYPE)
10070: opcode = sstoreBI;
10071: else
10072: abort ();
1.1 root 10073: }
1.1.1.6 root 10074: else
10075: if (TYPE_MODE (type) == BLKmode)
10076: {
10077: /* Copy structure. This expands to a block copy instruction, storeBLK.
10078: In addition to the arguments expected by the other store instructions,
10079: it also expects a type size (SImode) on top of the stack, which is the
10080: structure size in size units (usually bytes). The two first arguments
10081: are already on the stack; so we just put the size on level 1. For some
10082: other languages, the size may be variable, this is why we don't encode
10083: it as a storeBLK literal, but rather treat it as a full-fledged expression. */
10084:
10085: bc_expand_expr (TYPE_SIZE (type));
10086: opcode = storeBLK;
10087: }
10088: else
10089: opcode = mode_to_store_map [(int) TYPE_MODE (type)];
1.1 root 10090:
1.1.1.6 root 10091: if (opcode == neverneverland)
10092: abort ();
1.1 root 10093:
1.1.1.6 root 10094: bc_emit_bytecode (opcode);
10095:
10096: #ifdef DEBUG_PRINT_CODE
10097: fputc ('\n', stderr);
10098: #endif
1.1 root 10099: }
10100:
1.1.1.6 root 10101:
10102: /* Allocate local stack space sufficient to hold a value of the given
10103: SIZE at alignment boundary ALIGNMENT bits. ALIGNMENT must be an
10104: integral power of 2. A special case is locals of type VOID, which
10105: have size 0 and alignment 1 - any "voidish" SIZE or ALIGNMENT is
10106: remapped into the corresponding attribute of SI. */
10107:
10108: rtx
10109: bc_allocate_local (size, alignment)
10110: int size, alignment;
1.1 root 10111: {
1.1.1.6 root 10112: rtx retval;
10113: int byte_alignment;
1.1 root 10114:
1.1.1.6 root 10115: if (size < 0)
10116: abort ();
1.1 root 10117:
1.1.1.6 root 10118: /* Normalize size and alignment */
10119: if (!size)
10120: size = UNITS_PER_WORD;
1.1 root 10121:
1.1.1.6 root 10122: if (alignment < BITS_PER_UNIT)
10123: byte_alignment = 1 << (INT_ALIGN - 1);
10124: else
10125: /* Align */
10126: byte_alignment = alignment / BITS_PER_UNIT;
1.1 root 10127:
1.1.1.6 root 10128: if (local_vars_size & (byte_alignment - 1))
10129: local_vars_size += byte_alignment - (local_vars_size & (byte_alignment - 1));
1.1 root 10130:
1.1.1.6 root 10131: retval = bc_gen_rtx ((char *) 0, local_vars_size, (struct bc_label *) 0);
10132: local_vars_size += size;
1.1 root 10133:
1.1.1.6 root 10134: return retval;
1.1 root 10135: }
10136:
1.1.1.5 root 10137:
1.1.1.6 root 10138: /* Allocate variable-sized local array. Variable-sized arrays are
10139: actually pointers to the address in memory where they are stored. */
10140:
10141: rtx
10142: bc_allocate_variable_array (size)
10143: tree size;
1.1.1.5 root 10144: {
1.1.1.6 root 10145: rtx retval;
10146: const int ptralign = (1 << (PTR_ALIGN - 1));
1.1.1.5 root 10147:
1.1.1.6 root 10148: /* Align pointer */
10149: if (local_vars_size & ptralign)
10150: local_vars_size += ptralign - (local_vars_size & ptralign);
1.1.1.5 root 10151:
1.1.1.6 root 10152: /* Note down local space needed: pointer to block; also return
10153: dummy rtx */
1.1.1.5 root 10154:
1.1.1.6 root 10155: retval = bc_gen_rtx ((char *) 0, local_vars_size, (struct bc_label *) 0);
10156: local_vars_size += POINTER_SIZE / BITS_PER_UNIT;
10157: return retval;
10158: }
1.1.1.5 root 10159:
10160:
1.1.1.6 root 10161: /* Push the machine address for the given external variable offset. */
10162: void
10163: bc_load_externaddr (externaddr)
10164: rtx externaddr;
10165: {
10166: bc_emit_bytecode (constP);
10167: bc_emit_code_labelref (BYTECODE_LABEL (externaddr),
10168: BYTECODE_BC_LABEL (externaddr)->offset);
1.1.1.5 root 10169:
1.1.1.6 root 10170: #ifdef DEBUG_PRINT_CODE
10171: fputc ('\n', stderr);
10172: #endif
1.1.1.5 root 10173: }
10174:
1.1 root 10175:
1.1.1.6 root 10176: static char *
10177: bc_strdup (s)
10178: char *s;
1.1 root 10179: {
1.1.1.6 root 10180: char *new = (char *) xmalloc ((strlen (s) + 1) * sizeof *s);
10181: strcpy (new, s);
10182: return new;
10183: }
1.1 root 10184:
10185:
1.1.1.6 root 10186: /* Like above, but expects an IDENTIFIER. */
10187: void
10188: bc_load_externaddr_id (id, offset)
10189: tree id;
10190: int offset;
10191: {
10192: if (!IDENTIFIER_POINTER (id))
10193: abort ();
1.1 root 10194:
1.1.1.6 root 10195: bc_emit_bytecode (constP);
10196: bc_emit_code_labelref (bc_xstrdup (IDENTIFIER_POINTER (id)), offset);
10197:
10198: #ifdef DEBUG_PRINT_CODE
10199: fputc ('\n', stderr);
10200: #endif
1.1 root 10201: }
10202:
1.1.1.6 root 10203:
10204: /* Push the machine address for the given local variable offset. */
10205: void
10206: bc_load_localaddr (localaddr)
10207: rtx localaddr;
1.1 root 10208: {
1.1.1.6 root 10209: bc_emit_instruction (localP, (HOST_WIDE_INT) BYTECODE_BC_LABEL (localaddr)->offset);
10210: }
1.1 root 10211:
10212:
1.1.1.6 root 10213: /* Push the machine address for the given parameter offset.
10214: NOTE: offset is in bits. */
10215: void
10216: bc_load_parmaddr (parmaddr)
10217: rtx parmaddr;
10218: {
10219: bc_emit_instruction (argP, ((HOST_WIDE_INT) BYTECODE_BC_LABEL (parmaddr)->offset
10220: / BITS_PER_UNIT));
10221: }
10222:
10223:
10224: /* Convert a[i] into *(a + i). */
10225: tree
10226: bc_canonicalize_array_ref (exp)
10227: tree exp;
10228: {
10229: tree type = TREE_TYPE (exp);
10230: tree array_adr = build1 (ADDR_EXPR, TYPE_POINTER_TO (type),
10231: TREE_OPERAND (exp, 0));
10232: tree index = TREE_OPERAND (exp, 1);
1.1 root 10233:
1.1.1.6 root 10234:
10235: /* Convert the integer argument to a type the same size as a pointer
10236: so the multiply won't overflow spuriously. */
10237:
10238: if (TYPE_PRECISION (TREE_TYPE (index)) != POINTER_SIZE)
10239: index = convert (type_for_size (POINTER_SIZE, 0), index);
10240:
10241: /* The array address isn't volatile even if the array is.
10242: (Of course this isn't terribly relevant since the bytecode
10243: translator treats nearly everything as volatile anyway.) */
10244: TREE_THIS_VOLATILE (array_adr) = 0;
10245:
10246: return build1 (INDIRECT_REF, type,
10247: fold (build (PLUS_EXPR,
10248: TYPE_POINTER_TO (type),
10249: array_adr,
10250: fold (build (MULT_EXPR,
10251: TYPE_POINTER_TO (type),
10252: index,
10253: size_in_bytes (type))))));
1.1 root 10254: }
10255:
10256:
1.1.1.6 root 10257: /* Load the address of the component referenced by the given
10258: COMPONENT_REF expression.
10259:
10260: Returns innermost lvalue. */
10261:
10262: tree
10263: bc_expand_component_address (exp)
10264: tree exp;
1.1 root 10265: {
1.1.1.6 root 10266: tree tem, chain;
10267: enum machine_mode mode;
10268: int bitpos = 0;
10269: HOST_WIDE_INT SIval;
1.1 root 10270:
10271:
1.1.1.6 root 10272: tem = TREE_OPERAND (exp, 1);
10273: mode = DECL_MODE (tem);
1.1 root 10274:
10275:
1.1.1.6 root 10276: /* Compute cumulative bit offset for nested component refs
10277: and array refs, and find the ultimate containing object. */
10278:
10279: for (tem = exp;; tem = TREE_OPERAND (tem, 0))
10280: {
10281: if (TREE_CODE (tem) == COMPONENT_REF)
10282: bitpos += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (tem, 1)));
1.1 root 10283: else
1.1.1.6 root 10284: if (TREE_CODE (tem) == ARRAY_REF
10285: && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
10286: && TREE_CODE (TYPE_SIZE (TREE_TYPE (tem))) == INTEGER_CST)
1.1 root 10287:
1.1.1.6 root 10288: bitpos += (TREE_INT_CST_LOW (TREE_OPERAND (tem, 1))
10289: * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tem)))
10290: /* * TYPE_SIZE_UNIT (TREE_TYPE (tem)) */);
10291: else
10292: break;
10293: }
1.1 root 10294:
1.1.1.6 root 10295: bc_expand_expr (tem);
1.1 root 10296:
1.1.1.6 root 10297:
10298: /* For bitfields also push their offset and size */
10299: if (DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
10300: bc_push_offset_and_size (bitpos, /* DECL_SIZE_UNIT */ (TREE_OPERAND (exp, 1)));
10301: else
10302: if (SIval = bitpos / BITS_PER_UNIT)
10303: bc_emit_instruction (addconstPSI, SIval);
10304:
10305: return (TREE_OPERAND (exp, 1));
1.1 root 10306: }
10307:
10308:
1.1.1.6 root 10309: /* Emit code to push two SI constants */
10310: void
10311: bc_push_offset_and_size (offset, size)
10312: HOST_WIDE_INT offset, size;
1.1 root 10313: {
1.1.1.6 root 10314: bc_emit_instruction (constSI, offset);
10315: bc_emit_instruction (constSI, size);
1.1 root 10316: }
10317:
10318:
1.1.1.6 root 10319: /* Emit byte code to push the address of the given lvalue expression to
10320: the stack. If it's a bit field, we also push offset and size info.
1.1 root 10321:
1.1.1.6 root 10322: Returns innermost component, which allows us to determine not only
10323: its type, but also whether it's a bitfield. */
1.1 root 10324:
1.1.1.6 root 10325: tree
10326: bc_expand_address (exp)
10327: tree exp;
1.1 root 10328: {
1.1.1.6 root 10329: /* Safeguard */
10330: if (!exp || TREE_CODE (exp) == ERROR_MARK)
10331: return (exp);
1.1.1.5 root 10332:
1.1 root 10333:
1.1.1.6 root 10334: switch (TREE_CODE (exp))
1.1 root 10335: {
1.1.1.6 root 10336: case ARRAY_REF:
1.1 root 10337:
1.1.1.6 root 10338: return (bc_expand_address (bc_canonicalize_array_ref (exp)));
1.1 root 10339:
1.1.1.6 root 10340: case COMPONENT_REF:
1.1 root 10341:
1.1.1.6 root 10342: return (bc_expand_component_address (exp));
1.1 root 10343:
1.1.1.6 root 10344: case INDIRECT_REF:
1.1.1.4 root 10345:
1.1.1.6 root 10346: bc_expand_expr (TREE_OPERAND (exp, 0));
1.1 root 10347:
1.1.1.6 root 10348: /* For variable-sized types: retrieve pointer. Sometimes the
10349: TYPE_SIZE tree is NULL. Is this a bug or a feature? Let's
10350: also make sure we have an operand, just in case... */
10351:
10352: if (TREE_OPERAND (exp, 0)
10353: && TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)))
10354: && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)))) != INTEGER_CST)
10355: bc_emit_instruction (loadP);
1.1.1.3 root 10356:
1.1.1.6 root 10357: /* If packed, also return offset and size */
10358: if (DECL_BIT_FIELD (TREE_OPERAND (exp, 0)))
10359:
10360: bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (exp, 0))),
10361: TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (exp, 0))));
1.1 root 10362:
1.1.1.6 root 10363: return (TREE_OPERAND (exp, 0));
1.1 root 10364:
1.1.1.6 root 10365: case FUNCTION_DECL:
1.1 root 10366:
1.1.1.6 root 10367: bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
10368: BYTECODE_BC_LABEL (DECL_RTL (exp))->offset);
10369: break;
1.1 root 10370:
1.1.1.6 root 10371: case PARM_DECL:
1.1 root 10372:
1.1.1.6 root 10373: bc_load_parmaddr (DECL_RTL (exp));
1.1.1.3 root 10374:
1.1.1.6 root 10375: /* For variable-sized types: retrieve pointer */
10376: if (TYPE_SIZE (TREE_TYPE (exp))
10377: && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)
10378: bc_emit_instruction (loadP);
10379:
10380: /* If packed, also return offset and size */
10381: if (DECL_BIT_FIELD (exp))
10382: bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (exp)),
10383: TREE_INT_CST_LOW (DECL_SIZE (exp)));
1.1.1.3 root 10384:
1.1.1.6 root 10385: break;
1.1.1.3 root 10386:
1.1.1.6 root 10387: case RESULT_DECL:
1.1 root 10388:
1.1.1.6 root 10389: bc_emit_instruction (returnP);
10390: break;
1.1 root 10391:
1.1.1.6 root 10392: case VAR_DECL:
1.1 root 10393:
1.1.1.6 root 10394: #if 0
10395: if (BYTECODE_LABEL (DECL_RTL (exp)))
10396: bc_load_externaddr (DECL_RTL (exp));
10397: #endif
10398:
10399: if (DECL_EXTERNAL (exp))
10400: bc_load_externaddr_id (DECL_ASSEMBLER_NAME (exp),
10401: (BYTECODE_BC_LABEL (DECL_RTL (exp)))->offset);
1.1 root 10402: else
1.1.1.6 root 10403: bc_load_localaddr (DECL_RTL (exp));
10404:
10405: /* For variable-sized types: retrieve pointer */
10406: if (TYPE_SIZE (TREE_TYPE (exp))
10407: && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)
10408: bc_emit_instruction (loadP);
10409:
10410: /* If packed, also return offset and size */
10411: if (DECL_BIT_FIELD (exp))
10412: bc_push_offset_and_size (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (exp)),
10413: TREE_INT_CST_LOW (DECL_SIZE (exp)));
10414:
1.1 root 10415: break;
1.1.1.6 root 10416:
10417: case STRING_CST:
10418: {
10419: rtx r;
10420:
10421: bc_emit_bytecode (constP);
10422: r = output_constant_def (exp);
10423: bc_emit_code_labelref (BYTECODE_LABEL (r), BYTECODE_BC_LABEL (r)->offset);
10424:
10425: #ifdef DEBUG_PRINT_CODE
10426: fputc ('\n', stderr);
10427: #endif
10428: }
1.1 root 10429: break;
1.1.1.6 root 10430:
10431: default:
10432:
10433: abort();
1.1 root 10434: break;
1.1.1.6 root 10435: }
10436:
10437: /* Most lvalues don't have components. */
10438: return (exp);
10439: }
10440:
10441:
10442: /* Emit a type code to be used by the runtime support in handling
10443: parameter passing. The type code consists of the machine mode
10444: plus the minimal alignment shifted left 8 bits. */
10445:
10446: tree
10447: bc_runtime_type_code (type)
10448: tree type;
10449: {
10450: int val;
10451:
10452: switch (TREE_CODE (type))
10453: {
10454: case VOID_TYPE:
10455: case INTEGER_TYPE:
10456: case REAL_TYPE:
10457: case COMPLEX_TYPE:
10458: case ENUMERAL_TYPE:
10459: case POINTER_TYPE:
10460: case RECORD_TYPE:
10461:
10462: val = (int) TYPE_MODE (type) | TYPE_ALIGN (type) << 8;
10463: break;
10464:
10465: case ERROR_MARK:
10466:
10467: val = 0;
1.1 root 10468: break;
1.1.1.6 root 10469:
1.1 root 10470: default:
1.1.1.6 root 10471:
1.1 root 10472: abort ();
10473: }
1.1.1.6 root 10474: return build_int_2 (val, 0);
10475: }
1.1 root 10476:
1.1.1.2 root 10477:
1.1.1.6 root 10478: /* Generate constructor label */
10479: char *
10480: bc_gen_constr_label ()
10481: {
10482: static int label_counter;
10483: static char label[20];
1.1 root 10484:
1.1.1.6 root 10485: sprintf (label, "*LR%d", label_counter++);
1.1 root 10486:
1.1.1.6 root 10487: return (obstack_copy0 (&permanent_obstack, label, strlen (label)));
10488: }
1.1 root 10489:
10490:
1.1.1.6 root 10491: /* Evaluate constructor CONSTR and return pointer to it on level one. We
10492: expand the constructor data as static data, and push a pointer to it.
10493: The pointer is put in the pointer table and is retrieved by a constP
10494: bytecode instruction. We then loop and store each constructor member in
10495: the corresponding component. Finally, we return the original pointer on
10496: the stack. */
1.1 root 10497:
1.1.1.6 root 10498: void
10499: bc_expand_constructor (constr)
10500: tree constr;
10501: {
10502: char *l;
10503: HOST_WIDE_INT ptroffs;
10504: rtx constr_rtx;
1.1 root 10505:
1.1.1.6 root 10506:
10507: /* Literal constructors are handled as constants, whereas
10508: non-literals are evaluated and stored element by element
10509: into the data segment. */
10510:
10511: /* Allocate space in proper segment and push pointer to space on stack.
10512: */
1.1 root 10513:
1.1.1.6 root 10514: l = bc_gen_constr_label ();
1.1 root 10515:
1.1.1.6 root 10516: if (TREE_CONSTANT (constr))
10517: {
10518: text_section ();
1.1 root 10519:
1.1.1.6 root 10520: bc_emit_const_labeldef (l);
10521: bc_output_constructor (constr, int_size_in_bytes (TREE_TYPE (constr)));
10522: }
10523: else
1.1 root 10524: {
1.1.1.6 root 10525: data_section ();
10526:
10527: bc_emit_data_labeldef (l);
10528: bc_output_data_constructor (constr);
1.1 root 10529: }
10530:
1.1.1.6 root 10531:
10532: /* Add reference to pointer table and recall pointer to stack;
10533: this code is common for both types of constructors: literals
10534: and non-literals. */
1.1 root 10535:
1.1.1.6 root 10536: ptroffs = bc_define_pointer (l);
10537: bc_emit_instruction (constP, ptroffs);
1.1 root 10538:
1.1.1.6 root 10539: /* This is all that has to be done if it's a literal. */
10540: if (TREE_CONSTANT (constr))
10541: return;
1.1.1.4 root 10542:
1.1 root 10543:
1.1.1.6 root 10544: /* At this point, we have the pointer to the structure on top of the stack.
10545: Generate sequences of store_memory calls for the constructor. */
10546:
10547: /* constructor type is structure */
10548: if (TREE_CODE (TREE_TYPE (constr)) == RECORD_TYPE)
1.1.1.3 root 10549: {
1.1.1.6 root 10550: register tree elt;
10551:
10552: /* If the constructor has fewer fields than the structure,
10553: clear the whole structure first. */
10554:
10555: if (list_length (CONSTRUCTOR_ELTS (constr))
10556: != list_length (TYPE_FIELDS (TREE_TYPE (constr))))
10557: {
10558: bc_emit_instruction (duplicate);
10559: bc_emit_instruction (constSI, (HOST_WIDE_INT) int_size_in_bytes (TREE_TYPE (constr)));
10560: bc_emit_instruction (clearBLK);
10561: }
10562:
10563: /* Store each element of the constructor into the corresponding
10564: field of TARGET. */
10565:
10566: for (elt = CONSTRUCTOR_ELTS (constr); elt; elt = TREE_CHAIN (elt))
10567: {
10568: register tree field = TREE_PURPOSE (elt);
10569: register enum machine_mode mode;
10570: int bitsize;
10571: int bitpos;
10572: int unsignedp;
10573:
10574: bitsize = TREE_INT_CST_LOW (DECL_SIZE (field)) /* * DECL_SIZE_UNIT (field) */;
10575: mode = DECL_MODE (field);
10576: unsignedp = TREE_UNSIGNED (field);
10577:
10578: bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
10579:
10580: bc_store_field (elt, bitsize, bitpos, mode, TREE_VALUE (elt), TREE_TYPE (TREE_VALUE (elt)),
10581: /* The alignment of TARGET is
10582: at least what its type requires. */
10583: VOIDmode, 0,
10584: TYPE_ALIGN (TREE_TYPE (constr)) / BITS_PER_UNIT,
10585: int_size_in_bytes (TREE_TYPE (constr)));
10586: }
1.1.1.3 root 10587: }
1.1.1.6 root 10588: else
10589:
10590: /* Constructor type is array */
10591: if (TREE_CODE (TREE_TYPE (constr)) == ARRAY_TYPE)
10592: {
10593: register tree elt;
10594: register int i;
10595: tree domain = TYPE_DOMAIN (TREE_TYPE (constr));
10596: int minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
10597: int maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
10598: tree elttype = TREE_TYPE (TREE_TYPE (constr));
10599:
10600: /* If the constructor has fewer fields than the structure,
10601: clear the whole structure first. */
10602:
10603: if (list_length (CONSTRUCTOR_ELTS (constr)) < maxelt - minelt + 1)
10604: {
10605: bc_emit_instruction (duplicate);
10606: bc_emit_instruction (constSI, (HOST_WIDE_INT) int_size_in_bytes (TREE_TYPE (constr)));
10607: bc_emit_instruction (clearBLK);
10608: }
10609:
10610:
10611: /* Store each element of the constructor into the corresponding
10612: element of TARGET, determined by counting the elements. */
10613:
10614: for (elt = CONSTRUCTOR_ELTS (constr), i = 0;
10615: elt;
10616: elt = TREE_CHAIN (elt), i++)
10617: {
10618: register enum machine_mode mode;
10619: int bitsize;
10620: int bitpos;
10621: int unsignedp;
10622:
10623: mode = TYPE_MODE (elttype);
10624: bitsize = GET_MODE_BITSIZE (mode);
10625: unsignedp = TREE_UNSIGNED (elttype);
10626:
10627: bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype))
10628: /* * TYPE_SIZE_UNIT (elttype) */ );
10629:
10630: bc_store_field (elt, bitsize, bitpos, mode,
10631: TREE_VALUE (elt), TREE_TYPE (TREE_VALUE (elt)),
10632: /* The alignment of TARGET is
10633: at least what its type requires. */
10634: VOIDmode, 0,
10635: TYPE_ALIGN (TREE_TYPE (constr)) / BITS_PER_UNIT,
10636: int_size_in_bytes (TREE_TYPE (constr)));
10637: }
10638:
10639: }
10640: }
1.1 root 10641:
10642:
1.1.1.6 root 10643: /* Store the value of EXP (an expression tree) into member FIELD of
10644: structure at address on stack, which has type TYPE, mode MODE and
10645: occupies BITSIZE bits, starting BITPOS bits from the beginning of the
10646: structure.
1.1 root 10647:
1.1.1.6 root 10648: ALIGN is the alignment that TARGET is known to have, measured in bytes.
10649: TOTAL_SIZE is its size in bytes, or -1 if variable. */
1.1 root 10650:
1.1.1.6 root 10651: void
10652: bc_store_field (field, bitsize, bitpos, mode, exp, type,
10653: value_mode, unsignedp, align, total_size)
10654: int bitsize, bitpos;
10655: enum machine_mode mode;
10656: tree field, exp, type;
10657: enum machine_mode value_mode;
10658: int unsignedp;
10659: int align;
10660: int total_size;
10661: {
1.1 root 10662:
1.1.1.6 root 10663: /* Expand expression and copy pointer */
10664: bc_expand_expr (exp);
10665: bc_emit_instruction (over);
1.1 root 10666:
10667:
1.1.1.6 root 10668: /* If the component is a bit field, we cannot use addressing to access
10669: it. Use bit-field techniques to store in it. */
1.1 root 10670:
1.1.1.6 root 10671: if (DECL_BIT_FIELD (field))
10672: {
10673: bc_store_bit_field (bitpos, bitsize, unsignedp);
10674: return;
10675: }
10676: else
10677: /* Not bit field */
10678: {
10679: HOST_WIDE_INT offset = bitpos / BITS_PER_UNIT;
10680:
10681: /* Advance pointer to the desired member */
10682: if (offset)
10683: bc_emit_instruction (addconstPSI, offset);
10684:
10685: /* Store */
10686: bc_store_memory (type, field);
10687: }
10688: }
1.1 root 10689:
1.1.1.6 root 10690:
10691: /* Store SI/SU in bitfield */
1.1 root 10692: void
1.1.1.6 root 10693: bc_store_bit_field (offset, size, unsignedp)
10694: int offset, size, unsignedp;
1.1 root 10695: {
1.1.1.6 root 10696: /* Push bitfield offset and size */
10697: bc_push_offset_and_size (offset, size);
1.1 root 10698:
1.1.1.6 root 10699: /* Store */
10700: bc_emit_instruction (sstoreBI);
10701: }
1.1.1.2 root 10702:
1.1.1.3 root 10703:
1.1.1.6 root 10704: /* Load SI/SU from bitfield */
10705: void
10706: bc_load_bit_field (offset, size, unsignedp)
10707: int offset, size, unsignedp;
10708: {
10709: /* Push bitfield offset and size */
10710: bc_push_offset_and_size (offset, size);
1.1.1.3 root 10711:
1.1.1.6 root 10712: /* Load: sign-extend if signed, else zero-extend */
10713: bc_emit_instruction (unsignedp ? zxloadBI : sxloadBI);
10714: }
1.1 root 10715:
10716:
1.1.1.6 root 10717: /* Adjust interpreter stack by NLEVELS. Positive means drop NLEVELS
10718: (adjust stack pointer upwards), negative means add that number of
10719: levels (adjust the stack pointer downwards). Only positive values
10720: normally make sense. */
10721:
10722: void
10723: bc_adjust_stack (nlevels)
10724: int nlevels;
10725: {
10726: switch (nlevels)
10727: {
10728: case 0:
10729: break;
10730:
10731: case 2:
10732: bc_emit_instruction (drop);
10733:
10734: case 1:
10735: bc_emit_instruction (drop);
10736: break;
10737:
10738: default:
10739:
10740: bc_emit_instruction (adjstackSI, (HOST_WIDE_INT) nlevels);
10741: stack_depth -= nlevels;
10742: }
10743:
10744: #if defined (VALIDATE_STACK_FOR_BC)
10745: VALIDATE_STACK_FOR_BC ();
1.1 root 10746: #endif
10747: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.