![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to integrate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to integrate.c CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1: /* Procedure integration for GNU CC.
2: Copyright (C) 1988 Free Software Foundation, Inc.
3: Contributed by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is distributed in the hope that it will be useful,
8: but WITHOUT ANY WARRANTY. No author or distributor
9: accepts responsibility to anyone for the consequences of using it
10: or for whether it serves any particular purpose or works at all,
11: unless he says so in writing. Refer to the GNU CC General Public
12: License for full details.
13:
14: Everyone is granted permission to copy, modify and redistribute
15: GNU CC, but only under the conditions described in the
16: GNU CC General Public License. A copy of this license is
17: supposed to have been given to you along with GNU CC so you
18: can know your rights and responsibilities. It should be in a
19: file named COPYING. Among other things, the copyright notice
20: and this notice must be preserved on all copies. */
21:
22:
23: #include <ctype.h>
24: #include <stdio.h>
25: #include <strings.h>
26:
27: #include "config.h"
28: #include "rtl.h"
29: #include "tree.h"
30: #include "flags.h"
31: #include "insn-flags.h"
32: #include "expr.h"
33:
34: #include "obstack.h"
35: #define obstack_chunk_alloc xmalloc
36: #define obstack_chunk_free free
37: extern int xmalloc ();
38: extern void free ();
39:
40: extern struct obstack permanent_obstack, maybepermanent_obstack;
41: extern struct obstack *rtl_obstack, *saveable_obstack, *current_obstack;
42:
43: #define MIN(x,y) ((x < y) ? x : y)
44:
45: extern tree pushdecl ();
46:
47: /* This is the target of the inline function being expanded,
48: or NULL if there is none. */
49: static rtx inline_target;
50:
51: /* We must take special care not to disrupt life too severely
52: when performing procedure integration. One thing that that
53: involves is not creating illegitimate address which reload
54: cannot fix. Since we don't know what the frame pointer is
55: not capable of (in a machine independent way), we create
56: a pseudo-frame pointer which will have to do for now. */
57: static rtx inline_fp_rtx;
58:
59: /* Convert old frame-pointer offsets to new. Parameters which only
60: produce values (no addresses, and are never assigned), map directly
61: to the pseudo-reg of the incoming value. Parameters that are
62: assigned to but do not have their address taken are given a fresh
63: pseudo-register. Parameters that have their address take are
64: given a fresh stack-slot. */
65: static rtx *parm_map;
66:
67: /* ?? Should this be done here?? It is not right now.
68: Keep track of whether a given pseudo-register is the sum
69: of the frame pointer and a const_int (or zero). */
70: static char *fp_addr_p;
71:
72: /* For the local variables of the procdure being integrated that live
73: on the frame, FRAME_POINTER_DELTA says how much to change their
74: offsets by, so that they now live in the correct place on the
75: frame of the function being compiled. */
76: static int fp_delta;
77:
78: /* Return a copy of an rtx (as needed), substituting pseudo-register,
79: labels, and frame-pointer offsets as necessary. */
80: static rtx copy_rtx_and_substitute ();
81:
82: static void copy_parm_decls ();
83: static void copy_decl_tree ();
84:
85: static rtx try_fold_cc0 ();
86:
87: /* We do some simple constant folding optimization. This optimization
88: really exists primarily to save time inlining a function. It
89: also help users who ask for inline functions without -O. */
90: static rtx fold_out_const_cc0 ();
91:
92: /* Zero if the current function (whose FUNCTION_DECL is FNDECL)
93: is safe and reasonable to integrate into other functions.
94: Nonzero means value is a warning message with a single %s
95: for the function's name. */
96:
97: char *
98: function_cannot_inline_p (fndecl)
99: register tree fndecl;
100: {
101: register rtx insn;
102: tree last = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
103: int nargs = list_length (DECL_ARGUMENTS (fndecl));
104: int max_insns = 4 * (4 + nargs + 16*TREE_INLINE (fndecl));
105: register int ninsns = 0;
106: register tree parms;
107:
108: /* No inlines with varargs. `grokdeclarator' gives a warning
109: message about that if `inline' is specified. This code
110: it put in to catch the volunteers. */
111: if (last && TREE_VALUE (last) != void_type_node)
112: return "varargs function `%s' cannot be inline";
113:
114: /* If its not even close, don't even look. */
115: if (get_max_uid () > 2 * max_insns)
116: return "function `%s' too large to be inline";
117:
118: /* Don't inline functions which have BLKmode arguments.
119: Don't inline functions that take the address of
120: a parameter and do not specify a function prototype. */
121: for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms))
122: {
123: if (TYPE_MODE (TREE_TYPE (parms)) == BLKmode)
124: return "function `%s' with large aggregate parameter cannot be inline";
125: if (last == NULL_TREE && TREE_ADDRESSABLE (parms))
126: return "function `%s' without prototype uses address of parameter;\n cannot be inline";
127: }
128:
129: if (get_max_uid () > max_insns)
130: {
131: for (ninsns = 0, insn = get_first_nonparm_insn (); insn && ninsns < max_insns;
132: insn = NEXT_INSN (insn))
133: {
134: if (GET_CODE (insn) == INSN
135: || GET_CODE (insn) == JUMP_INSN
136: || GET_CODE (insn) == CALL_INSN)
137: ninsns++;
138: }
139:
140: if (ninsns >= max_insns)
141: return "function `%s' too large to be inline";
142: }
143:
144: return 0;
145: }
146:
147: /* Variables used within save_for_inline. */
148:
149: /* Mapping from old pesudo-register to new pseudo-registers.
150: The first element of this map is reg_map[FIRST_PSEUDO_REGISTER].
151: It allocated in `save_current_insns' and `expand_function_inline',
152: and deallocated on exit from each of those routines. */
153: static rtx *reg_map;
154:
155: /* Mapping from old code-labels to new code-labels.
156: The first element of this map is label_map[min_labelno].
157: It allocated in `save_current_insns' and `expand_function_inline',
158: and deallocated on exit from each of those routines. */
159: static rtx *label_map;
160:
161: /* Map pseudo reg number into the PARM_DECL for the parm living in the reg.
162: Zero for a reg that isn't a parm's home.
163: Only reg numbers less than max_parm_reg are mapped here. */
164: static tree *parmdecl_map;
165:
166: /* Keep track of first pseudo-register beyond those that are parms. */
167: static int max_parm_reg;
168:
169: /* On machines that perform a function return with a single
170: instruction, such as the VAX, these return insns must be
171: mapped into branch statements. */
172: extern rtx return_label;
173:
174: /* Copy an rtx for save_for_inline. */
175: static rtx copy_for_inline ();
176:
177: /* Make the insns and PARM_DECLs of the current function permanent
178: and record other information in DECL_SAVED_INSNS to allow inlining
179: of this function in subsequent calls. */
180:
181: void
182: save_for_inline (fndecl)
183: tree fndecl;
184: {
185: extern rtx *regno_reg_rtx; /* in emit-rtl.c. */
186: extern current_function_args_size;
187:
188: rtx first_insn, last_insn, insn;
189: rtx head, copy;
190: tree parms;
191: int max_labelno, min_labelno, i, len;
192: int max_reg;
193:
194: /* Make and emit a return-label if we have not already done so. */
195:
196: if (return_label == 0)
197: {
198: return_label = gen_label_rtx ();
199: emit_label (return_label);
200: }
201:
202: /* Get some bounds on the labels and registers used. */
203:
204: max_labelno = max_label_num ();
205: min_labelno = get_first_label_num ();
206: max_parm_reg = max_parm_reg_num ();
207: max_reg = max_reg_num ();
208:
209: /* Set up PARMDECL_MAP which maps pseudo-reg number to its PARM_DECL.
210:
211: Set TREE_VOLATILE to 0 if the parm is in a register, otherwise 1.
212: Later we set TREE_READONLY to 0 if the parm is modified inside the fn. */
213:
214: parmdecl_map = (tree *) alloca (max_parm_reg * sizeof (tree));
215:
216: for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms))
217: {
218: rtx p = DECL_RTL (parms);
219:
220: if (GET_CODE (p) == REG)
221: {
222: parmdecl_map[REGNO (p)] = parms;
223: TREE_VOLATILE (parms) = 0;
224: }
225: else
226: TREE_VOLATILE (parms) = 1;
227: TREE_READONLY (parms) = 1;
228: }
229:
230: /* The list of DECL_SAVES_INSNS, starts off with a header which
231: contains the following information:
232:
233: the first insn of the function (not including the insns that copy
234: parameters into registers).
235: the first label used by that function,
236: the last label used by that function,
237: and the total number of registers used. */
238:
239: head = gen_inline_header_rtx (NULL, NULL, min_labelno, max_labelno,
240: max_parm_reg, max_reg,
241: current_function_args_size);
242:
243: /* We have now allocated all that needs to be allocated permanently
244: on the rtx obstack. Set our high-water mark, so that we
245: can free the rest of this when the time comes. */
246:
247: preserve_data ();
248:
249: /* Copy the chain insns of this function.
250: Install the copied chain as the insns of this function,
251: for continued compilation;
252: the original chain is recorded as the DECL_SAVED_INSNS
253: for inlining future calls. */
254:
255: /* If there are insns that copy parms from the stack into pseudo registers,
256: those insns are not copied. `expand_inline_function' must
257: emit the correct code to handle such things. */
258:
259: insn = get_insns ();
260: if (GET_CODE (insn) != NOTE)
261: abort ();
262: first_insn = rtx_alloc (NOTE);
263: NOTE_SOURCE_FILE (first_insn) = NOTE_SOURCE_FILE (insn);
264: NOTE_LINE_NUMBER (first_insn) = NOTE_LINE_NUMBER (insn);
265: INSN_UID (first_insn) = INSN_UID (insn);
266: PREV_INSN (first_insn) = NULL;
267: NEXT_INSN (first_insn) = NULL;
268: last_insn = first_insn;
269:
270: /* Each pseudo-reg in the old insn chain must have a unique rtx in the copy.
271: Make these new rtx's now, and install them in regno_reg_rtx, so they
272: will be the official pseudo-reg rtx's for the rest of compilation. */
273:
274: reg_map = (rtx *) alloca ((max_reg + 1) * sizeof (rtx));
275:
276: len = sizeof (struct rtx_def) + (GET_RTX_LENGTH (REG) - 1) * sizeof (rtunion);
277: for (i = max_reg - 1; i >= FIRST_PSEUDO_REGISTER; i--)
278: reg_map[i] = (rtx)obstack_copy (&maybepermanent_obstack, regno_reg_rtx[i], len);
279: bcopy (reg_map + FIRST_PSEUDO_REGISTER,
280: regno_reg_rtx + FIRST_PSEUDO_REGISTER,
281: (max_reg_num () - FIRST_PSEUDO_REGISTER) * sizeof (rtx));
282:
283: /* Likewise each label rtx must have a unique rtx as its copy. */
284:
285: label_map = (rtx *)alloca ((max_labelno - min_labelno) * sizeof (rtx));
286: label_map -= min_labelno;
287:
288: for (i = min_labelno; i < max_labelno; i++)
289: label_map[i] = gen_label_rtx ();
290:
291: /* Now copy the chain of insns. */
292:
293: for (insn = NEXT_INSN (insn); insn; insn = NEXT_INSN (insn))
294: {
295: switch (GET_CODE (insn))
296: {
297: case NOTE:
298: copy = rtx_alloc (NOTE);
299: NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
300: NOTE_LINE_NUMBER (copy) = NOTE_LINE_NUMBER (insn);
301: break;
302:
303: case INSN:
304: case CALL_INSN:
305: case JUMP_INSN:
306: copy = rtx_alloc (GET_CODE (insn));
307: PATTERN (copy) = copy_for_inline (PATTERN (insn));
308: INSN_CODE (copy) = -1;
309: LOG_LINKS (copy) = NULL;
310: REG_NOTES (copy) = copy_for_inline (REG_NOTES (insn));
311: break;
312:
313: case CODE_LABEL:
314: copy = label_map[CODE_LABEL_NUMBER (insn)];
315: break;
316:
317: case BARRIER:
318: copy = rtx_alloc (BARRIER);
319: break;
320:
321: default:
322: abort ();
323: }
324: INSN_UID (copy) = INSN_UID (insn);
325: NEXT_INSN (last_insn) = copy;
326: PREV_INSN (copy) = last_insn;
327: last_insn = copy;
328: }
329:
330: NEXT_INSN (last_insn) = NULL;
331:
332: NEXT_INSN (head) = get_first_nonparm_insn ();
333: FIRST_PARM_INSN (head) = get_insns ();
334: DECL_SAVED_INSNS (fndecl) = head;
335: DECL_FRAME_SIZE (fndecl) = get_frame_size ();
336: TREE_INLINE (fndecl) = 1;
337:
338: parmdecl_map = 0;
339: label_map = 0;
340: reg_map = 0;
341: return_label = 0;
342:
343: set_new_first_and_last_insn (first_insn, last_insn);
344: }
345:
346: /* Copy the rtx ORIG recursively, replacing pseudo-regs and labels
347: according to `reg_map' and `label_map'.
348: All other kinds of rtx are copied except those that can never be
349: changed during compilation. */
350:
351: static rtx
352: copy_for_inline (orig)
353: rtx orig;
354: {
355: register rtx x = orig;
356: register int i;
357: register enum rtx_code code;
358: register char *format_ptr;
359:
360: if (x == 0)
361: return x;
362:
363: code = GET_CODE (x);
364:
365: /* These types may be freely shared. */
366:
367: switch (code)
368: {
369: case QUEUED:
370: case CONST_INT:
371: case CONST_DOUBLE:
372: case SYMBOL_REF:
373: case CODE_LABEL:
374: case PC:
375: case CC0:
376: return x;
377:
378: case MEM:
379: /* A MEM is allowed to be shared if its address is constant
380: or is a constant plus one of the special registers. */
381: if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
382: return x;
383: if (GET_CODE (XEXP (x, 0)) == PLUS
384: && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
385: && (REGNO (XEXP (XEXP (x, 0), 0)) == FRAME_POINTER_REGNUM
386: || REGNO (XEXP (XEXP (x, 0), 0)) == ARG_POINTER_REGNUM)
387: && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1)))
388: if (GET_CODE (XEXP (x, 0)) == REG
389: && (REGNO (XEXP (x, 0)) == FRAME_POINTER_REGNUM
390: || REGNO (XEXP (x, 0)) == ARG_POINTER_REGNUM)
391: && CONSTANT_ADDRESS_P (XEXP (x, 1)))
392: return x;
393: break;
394:
395: case LABEL_REF:
396: {
397: /* Must point to the new insn. */
398: return gen_rtx (LABEL_REF, GET_MODE (orig),
399: label_map[CODE_LABEL_NUMBER (XEXP (orig, 0))]);
400: }
401:
402: case REG:
403: if (REGNO (x) >= FIRST_PSEUDO_REGISTER)
404: return reg_map [REGNO (x)];
405: else
406: return x;
407:
408: /* If a parm that gets modified lives in a pseudo-reg,
409: set its TREE_VOLATILE to prevent certain optimizations. */
410: case SET:
411: {
412: rtx dest = SET_DEST (x);
413:
414: if (GET_CODE (dest) == REG
415: && REGNO (dest) < max_parm_reg
416: && REGNO (dest) >= FIRST_PSEUDO_REGISTER)
417: TREE_READONLY (parmdecl_map[REGNO (dest)]) = 0;
418: }
419: break;
420: }
421:
422: /* Replace this rtx with a copy of itself. */
423:
424: x = rtx_alloc (code);
425: bcopy (orig, x, sizeof (int) * (GET_RTX_LENGTH (code) + 1));
426:
427: /* Now scan the subexpressions recursively.
428: We can store any replaced subexpressions directly into X
429: since we know X is not shared! Any vectors in X
430: must be copied if X was copied. */
431:
432: format_ptr = GET_RTX_FORMAT (code);
433:
434: for (i = 0; i < GET_RTX_LENGTH (code); i++)
435: {
436: switch (*format_ptr++)
437: {
438: case 'e':
439: XEXP (x, i) = copy_for_inline (XEXP (x, i));
440: break;
441:
442: case 'E':
443: if (XVEC (x, i) != NULL)
444: {
445: register int j;
446:
447: XVEC (x, i) = gen_rtvec_v (XVECLEN (x, i), &XVECEXP (x, i, 0));
448: for (j = 0; j < XVECLEN (x, i); j++)
449: XVECEXP (x, i, j)
450: = copy_for_inline (XVECEXP (x, i, j));
451: }
452: break;
453: }
454: }
455: return x;
456: }
457:
458: /* Integrate the procedure defined by FNDECL. Note that this function
459: may wind up calling itself. Since the static variables are not
460: reentrant, we do not assign them until after the possibility
461: or recursion is eliminated.
462:
463: If IGNORE is nonzero, do not produce a value.
464: Otherwise store the value in TARGET if it is nonzero and that is convenient.
465:
466: Value is:
467: (rtx)-1 if we could not substitute the function
468: 0 if we substituted it and it does not produce a value
469: else an rtx for where the value is stored. */
470:
471: rtx
472: expand_inline_function (fndecl, parms, target, ignore, type, structure_value_addr)
473: tree fndecl, parms;
474: rtx target;
475: int ignore;
476: tree type;
477: rtx structure_value_addr;
478: {
479: tree formal, actual;
480: rtx header = DECL_SAVED_INSNS (fndecl);
481: rtx insns = FIRST_FUNCTION_INSN (header);
482: rtx insn, protect;
483: rtx last_insn = get_last_insn ();
484: int max_regno = MAX_REGNUM (header) + 1;
485: register int i;
486: int keep;
487: int min_labelno = FIRST_LABELNO (header);
488: int max_labelno = LAST_LABELNO (header);
489: int nargs;
490: rtx *arg_vec;
491: rtx return_label = 0;
492: rtx follows_call = 0;
493:
494: if (max_regno < FIRST_PSEUDO_REGISTER)
495: return (rtx)-1;
496:
497: nargs = list_length (DECL_ARGUMENTS (fndecl));
498:
499: /* We expect PARMS to have the right length; don't crash if not. */
500: if (list_length (parms) != nargs)
501: return (rtx)-1;
502:
503: /* Make a fresh binding contour that we can easily remove. */
504: pushlevel (0);
505: expand_start_bindings (0);
506:
507: /* Get all the actual args as RTL, and store them in ARG_VEC. */
508:
509: arg_vec = (rtx *)alloca (nargs * sizeof (rtx));
510:
511: for (formal = DECL_ARGUMENTS (fndecl),
512: actual = parms,
513: i = 0;
514: formal;
515: formal = TREE_CHAIN (formal),
516: actual = TREE_CHAIN (actual),
517: i++)
518: {
519: tree arg = TREE_VALUE (actual); /* this has already been converted */
520: enum machine_mode tmode = TYPE_MODE (TREE_TYPE (formal));
521: tree decl = formal;
522: rtx copy;
523:
524: emit_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
525:
526: if (TREE_ADDRESSABLE (formal))
527: {
528: int size = int_size_in_bytes (TREE_TYPE (formal));
529: copy = assign_stack_local (tmode, size);
530: store_expr (arg, copy, 0);
531: }
532: else if (! TREE_READONLY (formal)
533: || TREE_VOLATILE (formal))
534: {
535: /* If parm is modified or if it hasn't a pseudo reg,
536: we may not simply substitute the actual value;
537: copy it through a register. */
538: copy = gen_reg_rtx (tmode);
539: store_expr (arg, copy, 0);
540: }
541: else
542: {
543: copy = expand_expr (arg, 0, tmode, 0);
544:
545: /* We do not use CONSTANT_ADDRESS_P here because
546: the set of cases where that might make a difference
547: are a subset of the cases that arise even when
548: it is a CONSTANT_ADDRESS_P (i.e., fp_delta
549: gets into the act. */
550: if (GET_CODE (copy) != REG && ! CONSTANT_P (copy))
551: copy = copy_to_reg (copy);
552: }
553: arg_vec[i] = copy;
554: }
555:
556: copy_parm_decls (DECL_ARGUMENTS (fndecl), arg_vec);
557:
558: /* Perform postincrements before actually calling the function. */
559: emit_queue ();
560:
561: /* clean up stack so that variables might have smaller offsets. */
562: do_pending_stack_adjust ();
563:
564: /* Pass the function the address in which to return a structure value. */
565: if (structure_value_addr)
566: emit_move_insn (struct_value_rtx, structure_value_addr);
567:
568: /* Now prepare for copying the insns.
569: Set up reg_map, parm_map and label_map saying how to translate
570: the pseudo-registers, stack-parm references and labels when copying. */
571:
572: reg_map = (rtx *) alloca (max_regno * sizeof (rtx));
573: bzero (reg_map, max_regno * sizeof (rtx));
574:
575: if (DECL_ARGUMENTS (fndecl))
576: {
577: tree decl = DECL_ARGUMENTS (fndecl);
578: tree last = tree_last (decl);
579: int offset = FUNCTION_ARGS_SIZE (header);
580: parm_map =
581: (rtx *)alloca ((offset / UNITS_PER_WORD) * sizeof (rtx));
582: bzero (parm_map, (offset / UNITS_PER_WORD) * sizeof (rtx));
583: parm_map -= FIRST_PARM_OFFSET / UNITS_PER_WORD;
584:
585: for (formal = decl, i = 0; formal; formal = TREE_CHAIN (formal), i++)
586: {
587: /* Create an entry in PARM_MAP that says what pseudo register
588: is associated with an address we might compute. */
589: parm_map[DECL_OFFSET (formal) / BITS_PER_WORD] = arg_vec[i];
590: /* Create an entry in REG_MAP that says what rtx is associated
591: with a pseudo register from the function being inlined. */
592: if (GET_CODE (DECL_RTL (formal)) == REG)
593: reg_map[REGNO (DECL_RTL (formal))] = arg_vec[i];
594: }
595: }
596: else
597: {
598: parm_map = NULL;
599: }
600:
601: label_map = (rtx *)alloca ((max_labelno - min_labelno) * sizeof (rtx));
602: label_map -= min_labelno;
603:
604: for (i = min_labelno; i < max_labelno; i++)
605: label_map[i] = gen_label_rtx ();
606:
607: /* Set up a target to translate the inline function's value-register. */
608:
609: if (structure_value_addr != 0 || TYPE_MODE (type) == VOIDmode)
610: inline_target = 0;
611: else if (target && GET_MODE (target) == TYPE_MODE (type))
612: inline_target = target;
613: else
614: inline_target = gen_reg_rtx (TYPE_MODE (type));
615:
616: /* We are about to make space in this function's stack frame
617: for a copy of the stack frame of the inline function.
618: First, create an RTX that points to that stack frame
619: with the same offset usually used for the frame pointer.
620: This will be substituted for all frame-pointer references. */
621:
622: fp_delta = get_frame_size ();
623: #ifdef FRAME_GROWS_DOWNWARD
624: fp_delta = - fp_delta;
625: #endif
626: fp_delta -= STARTING_FRAME_OFFSET;
627:
628: inline_fp_rtx
629: = copy_to_mode_reg (Pmode,
630: plus_constant (frame_pointer_rtx, fp_delta));
631:
632: /* Now allocate the space for that to point at. */
633:
634: assign_stack_local (VOIDmode, DECL_FRAME_SIZE (fndecl));
635:
636: /* Now copy the insns one by one. */
637:
638: for (insn = insns; insn; insn = NEXT_INSN (insn))
639: {
640: rtx copy, pattern, next = 0;
641:
642: switch (GET_CODE (insn))
643: {
644: case INSN:
645: pattern = PATTERN (insn);
646:
647: /* Special handling for the insn immediately after a CALL_INSN
648: that returned a value:
649: If it does copy the value, we must avoid the usual translation
650: of the return-register into INLINE_TARGET.
651: If it just USEs the value, the inline function expects it to
652: stay in the return-register and be returned,
653: so copy it into INLINE_TARGET. */
654:
655: if (follows_call
656: /* Allow a stack-adjust, handled normally, to come in between
657: the call and the value-copying insn. */
658: && ! (GET_CODE (pattern) == SET
659: && SET_DEST (pattern) == stack_pointer_rtx))
660: {
661: if (GET_CODE (pattern) == SET
662: && rtx_equal_p (SET_SRC (pattern), follows_call))
663: /* This insn copies the value: take special care to copy
664: that value to this insn's destination. */
665: {
666: copy = emit_insn (gen_rtx (SET, VOIDmode,
667: copy_rtx_and_substitute (SET_DEST (pattern)),
668: follows_call));
669: copy->integrated = 1;
670: follows_call = 0;
671: break;
672: }
673: else if (GET_CODE (pattern) == USE
674: && rtx_equal_p (XEXP (pattern, 0), follows_call))
675: /* This insn does nothing but says the value is expected
676: to flow through to the inline function's return-value.
677: Make that happen, then ignore this insn. */
678: {
679: copy = emit_insn (gen_rtx (SET, VOIDmode, inline_target,
680: follows_call));
681: copy->integrated = 1;
682: follows_call = 0;
683: break;
684: }
685: /* If it does neither, this value must be ignored. */
686: follows_call = 0;
687: }
688:
689: /* The (USE (REG n)) at return from the function should be ignored
690: since we are changing (REG n) into inline_target. */
691: if (GET_CODE (pattern) == USE
692: && GET_CODE (XEXP (pattern, 0)) == REG
693: && FUNCTION_VALUE_REGNO_P (REGNO (XEXP (pattern, 0))))
694: break;
695:
696: /* Try to do some quick constant folding here.
697: This will save save execution time of the compiler,
698: as well time and space of the program if done here. */
699: if (GET_CODE (pattern) == SET
700: && SET_DEST (pattern) == cc0_rtx)
701: next = try_fold_cc0 (insn);
702:
703: if (next != 0)
704: {
705: insn = next;
706: }
707: else
708: {
709: copy = emit_insn (copy_rtx_and_substitute (pattern));
710: copy->integrated = 1;
711: }
712: break;
713:
714: case JUMP_INSN:
715: follows_call = 0;
716: if (GET_CODE (PATTERN (insn)) == RETURN)
717: {
718: if (return_label == 0)
719: return_label = gen_label_rtx ();
720: emit_jump (return_label);
721: break;
722: }
723: copy = emit_jump_insn (copy_rtx_and_substitute (PATTERN (insn)));
724: copy->integrated = 1;
725: break;
726:
727: case CALL_INSN:
728: {
729: rtx newbod;
730: /* If the call's body is (set (reg...) (call...)),
731: the register is a function return register, but DON'T
732: translate it into INLINE_TARGET because it describes the
733: called function, not the caller's return value. */
734: if (GET_CODE (PATTERN (insn)) == SET)
735: newbod = gen_rtx (SET, VOIDmode, SET_DEST (PATTERN (insn)),
736: copy_rtx_and_substitute (SET_SRC (PATTERN (insn))));
737: else
738: newbod = copy_rtx_and_substitute (PATTERN (insn));
739: copy = emit_call_insn (newbod);
740: }
741: copy->integrated = 1;
742: /* Special handling needed for the following INSN depending on
743: whether it copies the value from the fcn return reg. */
744: if (GET_CODE (PATTERN (insn)) == SET)
745: follows_call = SET_DEST (PATTERN (insn));
746: break;
747:
748: case CODE_LABEL:
749: emit_label (label_map[CODE_LABEL_NUMBER (insn)]);
750: follows_call = 0;
751: break;
752:
753: case BARRIER:
754: emit_barrier ();
755: break;
756:
757: case NOTE:
758: emit_note (NOTE_SOURCE_FILE (insn), NOTE_LINE_NUMBER (insn));
759: break;
760:
761: default:
762: abort ();
763: break;
764: }
765: }
766:
767: if (return_label)
768: emit_label (return_label);
769:
770: /* Make copies of the decls of the symbols in the inline function, so that
771: the copies of the variables get declared in the current function. */
772: copy_decl_tree (DECL_INITIAL (fndecl), 0);
773:
774: /* End the scope containing the copied formal parameter variables. */
775:
776: expand_end_bindings (getdecls (), 1);
777: poplevel (1, 1, 0);
778:
779: reg_map = NULL;
780: label_map = NULL;
781:
782: if (ignore || TYPE_MODE (type) == VOIDmode)
783: return 0;
784:
785: if (structure_value_addr)
786: {
787: if (target)
788: return target;
789: return gen_rtx (MEM, BLKmode,
790: memory_address (BLKmode, structure_value_addr));
791: }
792:
793: return inline_target;
794: }
795:
796: /* Given a chain of PARM_DECLs, ARGS, and a vector of RTL homes VEC,
797: copy each decl into a VAR_DECL, push all of those decls
798: and give each one the corresponding home. */
799:
800: static void
801: copy_parm_decls (args, vec)
802: tree args;
803: rtx *vec;
804: {
805: register tree tail;
806: register int i;
807:
808: for (tail = args, i = 0; tail; tail = TREE_CHAIN (tail), i++)
809: {
810: register tree decl = pushdecl (build_decl (VAR_DECL, DECL_NAME (tail),
811: TREE_TYPE (tail)));
812: DECL_RTL (decl) = vec[i];
813: }
814: }
815:
816: /* Given a LET_STMT node, push decls and levels
817: so as to construct in the current function a tree of contexts
818: isomorphic to the one that is given. */
819:
820: static void
821: copy_decl_tree (let, level)
822: tree let;
823: int level;
824: {
825: tree t;
826:
827: pushlevel (0);
828:
829: for (t = STMT_VARS (let); t; t = TREE_CHAIN (t))
830: {
831: tree d = build_decl (TREE_CODE (t), DECL_NAME (t), TREE_TYPE (t));
832: DECL_SOURCE_LINE (d) = DECL_SOURCE_LINE (t);
833: DECL_SOURCE_FILE (d) = DECL_SOURCE_FILE (t);
834: if (DECL_RTL (t) != 0)
835: DECL_RTL (d) = copy_rtx_and_substitute (DECL_RTL (t));
836: TREE_EXTERNAL (d) = TREE_EXTERNAL (t);
837: TREE_STATIC (d) = TREE_STATIC (t);
838: TREE_PUBLIC (d) = TREE_PUBLIC (t);
839: TREE_LITERAL (d) = TREE_LITERAL (t);
840: TREE_ADDRESSABLE (d) = TREE_ADDRESSABLE (t);
841: TREE_READONLY (d) = TREE_READONLY (t);
842: TREE_VOLATILE (d) = TREE_VOLATILE (t);
843: pushdecl (d);
844: }
845:
846: for (t = STMT_BODY (let); t; t = TREE_CHAIN (t))
847: copy_decl_tree (t, level + 1);
848:
849: poplevel (level > 0, 0, 0);
850: }
851:
852: /* Create a new copy of an rtx.
853: Recursively copies the operands of the rtx,
854: except for those few rtx codes that are sharable. */
855:
856: static rtx
857: copy_rtx_and_substitute (orig)
858: register rtx orig;
859: {
860: register rtx copy, temp;
861: register int i, j;
862: register RTX_CODE code;
863: register enum machine_mode mode;
864: register char *format_ptr;
865: int regno;
866:
867: if (orig == 0)
868: return 0;
869:
870: code = GET_CODE (orig);
871: mode = GET_MODE (orig);
872:
873: switch (code)
874: {
875: case REG:
876: /* If a frame-pointer register shows up, then we
877: must `fix' the reference. If the stack pointer
878: register shows up, it must be part of stack-adjustments
879: (*not* because we eliminated the frame pointer!).
880: Small hard registers are returned as-is. Pseudo-registers
881: go through their `reg_map'. */
882: regno = REGNO (orig);
883: if (regno < FIRST_PSEUDO_REGISTER)
884: {
885: if (FUNCTION_VALUE_REGNO_P (regno))
886: return inline_target;
887: if (regno == FRAME_POINTER_REGNUM)
888: return plus_constant (orig, fp_delta);
889: return orig;
890: }
891: if (reg_map[regno] == NULL)
892: reg_map[regno] = gen_reg_rtx (mode);
893: return reg_map[regno];
894:
895: case CODE_LABEL:
896: return label_map[CODE_LABEL_NUMBER (orig)];
897:
898: case LABEL_REF:
899: copy = rtx_alloc (LABEL_REF);
900: PUT_MODE (copy, mode);
901: XEXP (copy, 0) = label_map[CODE_LABEL_NUMBER (XEXP (orig, 0))];
902: return copy;
903:
904: case PC:
905: case CC0:
906: case CONST_INT:
907: case CONST_DOUBLE:
908: case SYMBOL_REF:
909: return orig;
910:
911: case PLUS:
912: /* Note: the PLUS case is not nearly as careful as the MEM
913: case in terms of preserving addresses. The reason for this
914: is that it is expected that if a PLUS_EXPR turns out not
915: to be a legitimate address, reload can fix that up, without
916: doing major damage. However, a MEM rtx must preside
917: over a legitimate address. The MEM case has lots of hair
918: to deal with what happens when it sits on a PLUS... */
919: /* Take care of the easy case quickly. */
920: if (XEXP (orig, 0) == frame_pointer_rtx
921: || XEXP (orig, 1) == frame_pointer_rtx
922: || (ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
923: && (XEXP (orig, 0) == arg_pointer_rtx
924: || XEXP (orig, 1) == arg_pointer_rtx)))
925: {
926: if (XEXP (orig, 0) == frame_pointer_rtx
927: || XEXP (orig, 0) == arg_pointer_rtx)
928: copy = XEXP (orig, 1);
929: else
930: copy = XEXP (orig, 0);
931:
932: if (GET_CODE (copy) == CONST_INT)
933: {
934: int c = INTVAL (copy);
935:
936: if (c > 0)
937: {
938: copy = parm_map[c / UNITS_PER_WORD];
939: return XEXP (copy, 0);
940: }
941: return gen_rtx (PLUS, mode,
942: frame_pointer_rtx,
943: gen_rtx (CONST_INT, SImode,
944: c + fp_delta));
945: }
946: copy = copy_rtx_and_substitute (copy);
947: temp = gen_rtx (PLUS, mode, frame_pointer_rtx, copy);
948: return plus_constant (temp, fp_delta);
949: }
950: else if (reg_mentioned_p (frame_pointer_rtx, orig)
951: || (ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
952: && reg_mentioned_p (arg_pointer_rtx, orig)))
953: {
954: /* If we have a complex sum which has a frame pointer
955: in it, and it was a legitimate address, then
956: keep it that way. */
957: if (memory_address_p (mode, orig))
958: {
959: if (GET_CODE (XEXP (orig, 0)) == CONST_INT)
960: {
961: copy = copy_rtx_and_substitute (XEXP (orig, 1));
962: temp = plus_constant (copy, INTVAL (XEXP (orig, 0)));
963: }
964: else if (GET_CODE (XEXP (orig, 1)) == CONST_INT)
965: {
966: copy = copy_rtx_and_substitute (XEXP (orig, 0));
967: temp = plus_constant (copy, INTVAL (XEXP (orig, 1)));
968: }
969: else
970: {
971: temp = gen_rtx (PLUS, GET_MODE (orig),
972: copy_rtx_and_substitute (XEXP (orig, 0)),
973: copy_rtx_and_substitute (XEXP (orig, 1)));
974: }
975: temp = memory_address (mode, temp);
976: }
977: else
978: temp = gen_rtx (PLUS, GET_MODE (orig),
979: copy_rtx_and_substitute (XEXP (orig, 0)),
980: copy_rtx_and_substitute (XEXP (orig, 1)));
981: }
982: else
983: temp = gen_rtx (PLUS, GET_MODE (orig),
984: copy_rtx_and_substitute (XEXP (orig, 0)),
985: copy_rtx_and_substitute (XEXP (orig, 1)));
986:
987: return temp;
988:
989: case MEM:
990: /* Take care of easiest case here. */
991: copy = XEXP (orig, 0);
992: if (copy == frame_pointer_rtx || copy == arg_pointer_rtx)
993: return gen_rtx (MEM, mode,
994: plus_constant (frame_pointer_rtx, fp_delta));
995: if (GET_CODE (copy) == PLUS)
996: {
997: if (XEXP (copy, 0) == frame_pointer_rtx
998: || XEXP (copy, 1) == frame_pointer_rtx
999: || (ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
1000: && (XEXP (copy, 0) == arg_pointer_rtx
1001: || XEXP (copy, 1) == arg_pointer_rtx)))
1002: {
1003: rtx reg;
1004: if (XEXP (copy, 0) == frame_pointer_rtx
1005: || XEXP (copy, 0) == arg_pointer_rtx)
1006: reg = XEXP (copy, 0), copy = XEXP (copy, 1);
1007: else
1008: reg = XEXP (copy, 1), copy = XEXP (copy, 0);
1009:
1010: if (GET_CODE (copy) == CONST_INT)
1011: {
1012: int c = INTVAL (copy);
1013:
1014: if (reg == arg_pointer_rtx
1015: && c >= FIRST_PARM_OFFSET)
1016: {
1017: copy = parm_map[c / UNITS_PER_WORD];
1018:
1019: /* If the MEM is only some of the bytes in the parm,
1020: truncate the parm value to the desired mode. */
1021: if (GET_MODE (copy) != mode
1022: && GET_MODE (copy) != VOIDmode)
1023: return convert_to_mode (mode, copy, 0);
1024: return copy;
1025: }
1026: temp = gen_rtx (PLUS, Pmode,
1027: frame_pointer_rtx,
1028: gen_rtx (CONST_INT, SImode,
1029: c + fp_delta));
1030: if (! memory_address_p (Pmode, temp))
1031: return gen_rtx (MEM, mode, plus_constant (inline_fp_rtx, c));
1032: }
1033: copy = copy_rtx_and_substitute (copy);
1034: temp = gen_rtx (PLUS, Pmode, frame_pointer_rtx, copy);
1035: temp = plus_constant (temp, fp_delta);
1036: temp = memory_address (Pmode, temp);
1037: }
1038: else if (reg_mentioned_p (frame_pointer_rtx, copy)
1039: || (ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
1040: && reg_mentioned_p (arg_pointer_rtx, copy)))
1041: {
1042: if (GET_CODE (XEXP (copy, 0)) == CONST_INT)
1043: {
1044: temp = copy_rtx_and_substitute (XEXP (copy, 1));
1045: temp = plus_constant (temp, INTVAL (XEXP (copy, 0)));
1046: }
1047: else if (GET_CODE (XEXP (copy, 1)) == CONST_INT)
1048: {
1049: temp = copy_rtx_and_substitute (XEXP (copy, 0));
1050: temp = plus_constant (temp, INTVAL (XEXP (copy, 1)));
1051: }
1052: else
1053: {
1054: temp = gen_rtx (PLUS, GET_MODE (copy),
1055: copy_rtx_and_substitute (XEXP (copy, 0)),
1056: copy_rtx_and_substitute (XEXP (copy, 1)));
1057: }
1058: }
1059: else
1060: {
1061: if (GET_CODE (XEXP (copy, 1)) == CONST_INT)
1062: temp = plus_constant (copy_rtx_and_substitute (XEXP (copy, 0)),
1063: INTVAL (XEXP (copy, 1)));
1064: else if (GET_CODE (XEXP (copy, 0)) == CONST_INT)
1065: temp = plus_constant (copy_rtx_and_substitute (XEXP (copy, 1)),
1066: INTVAL (XEXP (copy, 0)));
1067: else
1068: {
1069: rtx left = copy_rtx_and_substitute (XEXP (copy, 0));
1070: rtx right = copy_rtx_and_substitute (XEXP (copy, 1));
1071:
1072: temp = gen_rtx (PLUS, GET_MODE (copy), left, right);
1073: }
1074: }
1075: }
1076: else
1077: temp = copy_rtx_and_substitute (copy);
1078:
1079: return change_address (orig, mode, temp);
1080:
1081: case RETURN:
1082: abort ();
1083: }
1084:
1085: copy = rtx_alloc (code);
1086: PUT_MODE (copy, mode);
1087: copy->in_struct = orig->in_struct;
1088: copy->volatil = orig->volatil;
1089: copy->unchanging = orig->unchanging;
1090:
1091: format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
1092:
1093: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
1094: {
1095: rtx new;
1096:
1097: switch (*format_ptr++)
1098: {
1099: case 'u':
1100: case '0':
1101: break;
1102:
1103: case 'e':
1104: XEXP (copy, i) = copy_rtx_and_substitute (XEXP (orig, i));
1105: break;
1106:
1107: case 'E':
1108: XVEC (copy, i) = XVEC (orig, i);
1109: if (XVEC (orig, i) != NULL)
1110: {
1111: XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
1112: for (j = 0; j < XVECLEN (copy, i); j++)
1113: XVECEXP (copy, i, j) = copy_rtx_and_substitute (XVECEXP (orig, i, j));
1114: }
1115: break;
1116:
1117: case 'i':
1118: XINT (copy, i) = XINT (orig, i);
1119: break;
1120:
1121: case 's':
1122: XSTR (copy, i) = XSTR (orig, i);
1123: break;
1124:
1125: default:
1126: fprintf (stderr,
1127: "switch format wrong in rtl2.copy_rtx_and_substitute(). format was: %c.\n",
1128: format_ptr[-1]);
1129: abort ();
1130: }
1131: }
1132: return copy;
1133: }
1134:
1135: /* Attempt to simplify INSN while copying it from an inline fn,
1136: assuming it is a SET that sets CC0.
1137:
1138: If we simplify it, we emit the appropriate insns and return
1139: the last insn that we have handled (since we may handle the insn
1140: that follows INSN as well as INSN itself).
1141:
1142: Otherwise we do nothing and return zero. */
1143:
1144: static rtx
1145: try_fold_cc0 (insn)
1146: rtx insn;
1147: {
1148: rtx cnst = copy_rtx_and_substitute (SET_SRC (PATTERN (insn)));
1149: rtx pat, copy;
1150:
1151: if (CONSTANT_P (cnst)
1152: /* @@ Cautious: Don't know how many of these tests we need. */
1153: && NEXT_INSN (insn)
1154: && GET_CODE (pat = PATTERN (NEXT_INSN (insn))) == SET
1155: && SET_DEST (pat) == pc_rtx
1156: && GET_CODE (pat = SET_SRC (pat)) == IF_THEN_ELSE
1157: && GET_RTX_LENGTH (GET_CODE (XEXP (pat, 0))) == 2)
1158: {
1159: rtx cnst2;
1160: rtx cond = XEXP (pat, 0);
1161:
1162: if ((XEXP (cond, 0) == cc0_rtx
1163: && CONSTANT_P (XEXP (cond, 1))
1164: && (cnst2 = XEXP (cond, 1)))
1165: || (XEXP (cond, 1) == cc0_rtx
1166: && CONSTANT_P (XEXP (cond, 0))
1167: && (cnst2 = XEXP (cond, 0))))
1168: {
1169: copy = fold_out_const_cc0 (cond, XEXP (pat, 1), XEXP (pat, 2),
1170: cnst, cnst2);
1171: if (copy)
1172: {
1173: if (GET_CODE (copy) == LABEL_REF)
1174: {
1175: /* We will branch unconditionally to
1176: the label specified by COPY.
1177: Eliminate dead code by running down the
1178: list of insn until we see a CODE_LABEL.
1179: If the CODE_LABEL is the one specified
1180: by COPY, we win, and can delete all code
1181: up to (but not necessarily including)
1182: that label. Otherwise only win a little:
1183: emit the branch insn, and continue expanding. */
1184: rtx tmp = NEXT_INSN (insn);
1185: while (tmp && GET_CODE (tmp) != CODE_LABEL)
1186: tmp = NEXT_INSN (tmp);
1187: if (! tmp)
1188: abort ();
1189: if (label_map[CODE_LABEL_NUMBER (tmp)] == XEXP (copy, 0))
1190: {
1191: /* Big win. */
1192: return PREV_INSN (tmp);
1193: }
1194: else
1195: {
1196: /* Small win. Emit the unconditional branch,
1197: followed by a BARRIER, so that jump optimization
1198: will know what to do. */
1199: emit_jump (copy);
1200: return NEXT_INSN (insn);
1201: }
1202: }
1203: else if (copy == pc_rtx)
1204: {
1205: /* Do not take the branch, just fall through.
1206: Jump optimize should handle the elimination of
1207: dead code if appropriate. */
1208: return NEXT_INSN (insn);
1209: }
1210: else
1211: abort ();
1212: }
1213: }
1214: }
1215: return 0;
1216: }
1217:
1218: /* If (COND_RTX CNST1 CNST2) yield a result we can treat
1219: as being constant, return THEN_RTX if the result is always
1220: non-zero, and return ELSE_RTX otherwise. */
1221: static rtx
1222: fold_out_const_cc0 (cond_rtx, then_rtx, else_rtx, cnst1, cnst2)
1223: rtx cond_rtx, then_rtx, else_rtx;
1224: rtx cnst1, cnst2;
1225: {
1226: int value1, value2;
1227: int int1 = GET_CODE (cnst1) == CONST_INT;
1228: int int2 = GET_CODE (cnst2) == CONST_INT;
1229: if (int1)
1230: value1 = INTVAL (cnst1);
1231: else
1232: value1 = 1;
1233: if (int2)
1234: value2 = INTVAL (cnst2);
1235: else
1236: value2 = 1;
1237:
1238: switch (GET_CODE (cond_rtx))
1239: {
1240: case NE:
1241: if (int1 && int2)
1242: if (value1 != value2)
1243: return copy_rtx_and_substitute (then_rtx);
1244: else
1245: return copy_rtx_and_substitute (else_rtx);
1246: if (value1 == 0 || value2 == 0)
1247: return copy_rtx_and_substitute (then_rtx);
1248: if (int1 == 0 && int2 == 0)
1249: if (rtx_equal_p (cnst1, cnst2))
1250: return copy_rtx_and_substitute (else_rtx);
1251: break;
1252: case EQ:
1253: if (int1 && int2)
1254: if (value1 == value2)
1255: return copy_rtx_and_substitute (then_rtx);
1256: else
1257: return copy_rtx_and_substitute (else_rtx);
1258: if (value1 == 0 || value2 == 0)
1259: return copy_rtx_and_substitute (else_rtx);
1260: if (int1 == 0 && int2 == 0)
1261: if (rtx_equal_p (cnst1, cnst2))
1262: return copy_rtx_and_substitute (then_rtx);
1263: break;
1264: case GE:
1265: if (int1 && int2)
1266: if (value1 >= value2)
1267: return copy_rtx_and_substitute (then_rtx);
1268: else
1269: return copy_rtx_and_substitute (else_rtx);
1270: if (value1 == 0)
1271: return copy_rtx_and_substitute (else_rtx);
1272: if (value2 == 0)
1273: return copy_rtx_and_substitute (then_rtx);
1274: break;
1275: case GT:
1276: if (int1 && int2)
1277: if (value1 > value2)
1278: return copy_rtx_and_substitute (then_rtx);
1279: else
1280: return copy_rtx_and_substitute (else_rtx);
1281: if (value1 == 0)
1282: return copy_rtx_and_substitute (else_rtx);
1283: if (value2 == 0)
1284: return copy_rtx_and_substitute (then_rtx);
1285: break;
1286: case LE:
1287: if (int1 && int2)
1288: if (value1 <= value2)
1289: return copy_rtx_and_substitute (then_rtx);
1290: else
1291: return copy_rtx_and_substitute (else_rtx);
1292: if (value1 == 0)
1293: return copy_rtx_and_substitute (then_rtx);
1294: if (value2 == 0)
1295: return copy_rtx_and_substitute (else_rtx);
1296: break;
1297: case LT:
1298: if (int1 && int2)
1299: if (value1 < value2)
1300: return copy_rtx_and_substitute (then_rtx);
1301: else
1302: return copy_rtx_and_substitute (else_rtx);
1303: if (value1 == 0)
1304: return copy_rtx_and_substitute (then_rtx);
1305: if (value2 == 0)
1306: return copy_rtx_and_substitute (else_rtx);
1307: break;
1308: case GEU:
1309: if (int1 && int2)
1310: if ((unsigned)value1 >= (unsigned)value2)
1311: return copy_rtx_and_substitute (then_rtx);
1312: else
1313: return copy_rtx_and_substitute (else_rtx);
1314: if (value1 == 0)
1315: return copy_rtx_and_substitute (else_rtx);
1316: if (value2 == 0)
1317: return copy_rtx_and_substitute (then_rtx);
1318: break;
1319: case GTU:
1320: if (int1 && int2)
1321: if ((unsigned)value1 > (unsigned)value2)
1322: return copy_rtx_and_substitute (then_rtx);
1323: else
1324: return copy_rtx_and_substitute (else_rtx);
1325: if (value1 == 0)
1326: return copy_rtx_and_substitute (else_rtx);
1327: if (value2 == 0)
1328: return copy_rtx_and_substitute (then_rtx);
1329: break;
1330: case LEU:
1331: if (int1 && int2)
1332: if ((unsigned)value1 <= (unsigned)value2)
1333: return copy_rtx_and_substitute (then_rtx);
1334: else
1335: return copy_rtx_and_substitute (else_rtx);
1336: if (value1 == 0)
1337: return copy_rtx_and_substitute (then_rtx);
1338: if (value2 == 0)
1339: return copy_rtx_and_substitute (else_rtx);
1340: break;
1341: case LTU:
1342: if (int1 && int2)
1343: if ((unsigned)value1 < (unsigned)value2)
1344: return copy_rtx_and_substitute (then_rtx);
1345: else
1346: return copy_rtx_and_substitute (else_rtx);
1347: if (value1 == 0)
1348: return copy_rtx_and_substitute (then_rtx);
1349: if (value2 == 0)
1350: return copy_rtx_and_substitute (else_rtx);
1351: break;
1352: }
1353: /* Could not hack it. */
1354: return 0;
1355: }
1356:
1357: /* Output the assembly language code for the function FNDECL
1358: from its DECL_SAVED_INSNS. Used for inline functions that are output
1359: at end of compilation instead of where they came in the source. */
1360:
1361: void
1362: output_inline_function (fndecl)
1363: tree fndecl;
1364: {
1365: rtx head = DECL_SAVED_INSNS (fndecl);
1366: rtx last;
1367:
1368: temporary_allocation ();
1369:
1370: /* This call is only used to initialize global variables.
1371: The rtl code it emits will be discarded below. */
1372: expand_function_start (fndecl);
1373:
1374: /* Set stack frame size. */
1375: assign_stack_local (BLKmode, DECL_FRAME_SIZE (fndecl));
1376:
1377: restore_reg_data (FIRST_PARM_INSN (head));
1378:
1379: expand_function_end (fndecl);
1380:
1381: for (last = head; NEXT_INSN (last); last = NEXT_INSN (last))
1382: ;
1383:
1384: set_new_first_and_last_insn (FIRST_PARM_INSN (head), last);
1385:
1386: /* Compile this function all the way down to assembly code. */
1387: rest_of_compilation (fndecl);
1388:
1389: permanent_allocation ();
1390: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.