![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jump.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 jump.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Optimize jump instructions, for GNU compiler.
2: Copyright (C) 1987, 1988, 1989, 1991 Free Software Foundation, Inc.
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
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* This is the jump-optimization pass of the compiler.
22: It is run two or three times: once before cse, sometimes once after cse,
23: and once after reload (before final).
24:
25: jump_optimize deletes unreachable code and labels that are not used.
26: It also deletes jumps that jump to the following insn,
27: and simplifies jumps around unconditional jumps and jumps
28: to unconditional jumps.
29:
30: Each CODE_LABEL has a count of the times it is used
31: stored in the LABEL_NUSES internal field, and each JUMP_INSN
32: has one label that it refers to stored in the
33: JUMP_LABEL internal field. With this we can detect labels that
34: become unused because of the deletion of all the jumps that
35: formerly used them. The JUMP_LABEL info is sometimes looked
36: at by later passes.
37:
38: Optionally, cross-jumping can be done. Currently it is done
39: only the last time (when after reload and before final).
40: In fact, the code for cross-jumping now assumes that register
41: allocation has been done, since it uses `rtx_renumbered_equal_p'.
42:
43: Jump optimization is done after cse when cse's constant-propagation
44: causes jumps to become unconditional or to be deleted.
45:
46: Unreachable loops are not detected here, because the labels
47: have references and the insns appear reachable from the labels.
48: find_basic_blocks in flow.c finds and deletes such loops.
49:
50: The subroutines delete_insn, redirect_jump, and invert_jump are used
51: from other passes as well. */
52:
53: #include "config.h"
54: #include "rtl.h"
55: #include "flags.h"
56: #include "hard-reg-set.h"
57: #include "regs.h"
58: #include "expr.h"
59: #include "insn-config.h"
60: #include "insn-flags.h"
61: #include "real.h"
62:
63: /* ??? Eventually must record somehow the labels used by jumps
64: from nested functions. */
65: /* Pre-record the next or previous real insn for each label?
66: No, this pass is very fast anyway. */
67: /* Condense consecutive labels?
68: This would make life analysis faster, maybe. */
69: /* Optimize jump y; x: ... y: jumpif... x?
70: Don't know if it is worth bothering with. */
71: /* Optimize two cases of conditional jump to conditional jump?
72: This can never delete any instruction or make anything dead,
73: or even change what is live at any point.
74: So perhaps let combiner do it. */
75:
76: /* Vector indexed by uid.
77: For each CODE_LABEL, index by its uid to get first unconditional jump
78: that jumps to the label.
79: For each JUMP_INSN, index by its uid to get the next unconditional jump
80: that jumps to the same label.
81: Element 0 is the start of a chain of all return insns.
82: (It is safe to use element 0 because insn uid 0 is not used. */
83:
84: static rtx *jump_chain;
85:
86: /* List of labels referred to from initializers.
87: These can never be deleted. */
88: rtx forced_labels;
89:
90: /* Maximum index in jump_chain. */
91:
92: static int max_jump_chain;
93:
94: /* Set nonzero by jump_optimize if control can fall through
95: to the end of the function. */
96: int can_reach_end;
97:
98: /* Indicates whether death notes are significant in cross jump analysis.
99: Normally they are not significant, because of A and B jump to C,
100: and R dies in A, it must die in B. But this might not be true after
101: stack register conversion, and we must compare death notes in that
102: case. */
103:
104: static int cross_jump_death_matters = 0;
105:
106: static int duplicate_loop_exit_test ();
107: rtx delete_insn ();
108: int redirect_jump ();
109: static int redirect_exp ();
110: void redirect_tablejump ();
111: static int delete_labelref_insn ();
112: int invert_jump ();
113: static int invert_exp ();
114: int condjump_p ();
115: int simplejump_p ();
116:
117: extern rtx gen_jump ();
118:
119: static void mark_jump_label ();
120: void delete_jump ();
121: static void delete_from_jump_chain ();
122: static int tension_vector_labels ();
123: static void find_cross_jump ();
124: static void do_cross_jump ();
125: static int jump_back_p ();
126:
127: /* Delete no-op jumps and optimize jumps to jumps
128: and jumps around jumps.
129: Delete unused labels and unreachable code.
130:
131: If CROSS_JUMP is 1, detect matching code
132: before a jump and its destination and unify them.
133: If CROSS_JUMP is 2, do cross-jumping, but pay attention to death notes.
134:
135: If NOOP_MOVES is nonzero, delete no-op move insns.
136:
137: If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
138: after regscan, and it is safe to use regno_first_uid and regno_last_uid.
139:
140: If `optimize' is zero, don't change any code,
141: just determine whether control drops off the end of the function.
142: This case occurs when we have -W and not -O.
143: It works because `delete_insn' checks the value of `optimize'
144: and refrains from actually deleting when that is 0. */
145:
146: void
147: jump_optimize (f, cross_jump, noop_moves, after_regscan)
148: rtx f;
149: int cross_jump;
150: int noop_moves;
151: int after_regscan;
152: {
153: register rtx insn;
154: int changed;
155: int first = 1;
156: int max_uid = 0;
157: rtx last_insn;
158:
159: cross_jump_death_matters = (cross_jump == 2);
160:
161: /* Initialize LABEL_NUSES and JUMP_LABEL fields. */
162:
163: for (insn = f; insn; insn = NEXT_INSN (insn))
164: {
165: if (GET_CODE (insn) == CODE_LABEL)
166: LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
167: else if (GET_CODE (insn) == JUMP_INSN)
168: JUMP_LABEL (insn) = 0;
169: if (INSN_UID (insn) > max_uid)
170: max_uid = INSN_UID (insn);
171: }
172:
173: max_uid++;
174:
175: /* Delete insns following barriers, up to next label. */
176:
177: for (insn = f; insn;)
178: {
179: if (GET_CODE (insn) == BARRIER)
180: {
181: insn = NEXT_INSN (insn);
182: while (insn != 0 && GET_CODE (insn) != CODE_LABEL)
183: {
184: if (GET_CODE (insn) == NOTE
185: && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)
186: insn = NEXT_INSN (insn);
187: else
188: insn = delete_insn (insn);
189: }
190: /* INSN is now the code_label. */
191: }
192: else
193: insn = NEXT_INSN (insn);
194: }
195:
196: /* Leave some extra room for labels and duplicate exit test insns
197: we make. */
198: max_jump_chain = max_uid * 14 / 10;
199: jump_chain = (rtx *) alloca (max_jump_chain * sizeof (rtx));
200: bzero (jump_chain, max_jump_chain * sizeof (rtx));
201:
202: /* Mark the label each jump jumps to.
203: Combine consecutive labels, and count uses of labels.
204:
205: For each label, make a chain (using `jump_chain')
206: of all the *unconditional* jumps that jump to it;
207: also make a chain of all returns. */
208:
209: for (insn = f; insn; insn = NEXT_INSN (insn))
210: if ((GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == INSN
211: || GET_CODE (insn) == CALL_INSN)
212: && ! INSN_DELETED_P (insn))
213: {
214: mark_jump_label (PATTERN (insn), insn, cross_jump);
215: if (GET_CODE (insn) == JUMP_INSN)
216: {
217: if (JUMP_LABEL (insn) != 0 && simplejump_p (insn))
218: {
219: jump_chain[INSN_UID (insn)]
220: = jump_chain[INSN_UID (JUMP_LABEL (insn))];
221: jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
222: }
223: if (GET_CODE (PATTERN (insn)) == RETURN)
224: {
225: jump_chain[INSN_UID (insn)] = jump_chain[0];
226: jump_chain[0] = insn;
227: }
228: }
229: }
230:
231: /* Keep track of labels used from static data;
232: they cannot ever be deleted. */
233:
234: for (insn = forced_labels; insn; insn = XEXP (insn, 1))
235: LABEL_NUSES (XEXP (insn, 0))++;
236:
237: /* Delete all labels already not referenced.
238: Also find the last insn. */
239:
240: last_insn = 0;
241: for (insn = f; insn; )
242: {
243: if (GET_CODE (insn) == CODE_LABEL && LABEL_NUSES (insn) == 0)
244: insn = delete_insn (insn);
245: else
246: {
247: last_insn = insn;
248: insn = NEXT_INSN (insn);
249: }
250: }
251:
252: if (!optimize)
253: {
254: /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
255: If so record that this function can drop off the end. */
256:
257: insn = last_insn;
258: {
259: int n_labels = 1;
260: while (insn
261: /* One label can follow the end-note: the return label. */
262: && ((GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
263: /* Ordinary insns can follow it if returning a structure. */
264: || GET_CODE (insn) == INSN
265: /* If machine uses explicit RETURN insns, no epilogue,
266: then one of them follows the note. */
267: || (GET_CODE (insn) == JUMP_INSN
268: && GET_CODE (PATTERN (insn)) == RETURN)
269: /* Other kinds of notes can follow also. */
270: || (GET_CODE (insn) == NOTE
271: && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)))
272: insn = PREV_INSN (insn);
273: }
274:
275: /* Report if control can fall through at the end of the function. */
276: if (insn && GET_CODE (insn) == NOTE
277: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END
278: && ! INSN_DELETED_P (insn))
279: can_reach_end = 1;
280:
281: /* Zero the "deleted" flag of all the "deleted" insns. */
282: for (insn = f; insn; insn = NEXT_INSN (insn))
283: INSN_DELETED_P (insn) = 0;
284: return;
285: }
286:
287: #ifdef HAVE_return
288: if (HAVE_return)
289: {
290: /* If we fall through to the epilogue, see if we can insert a RETURN insn
291: in front of it. If the machine allows it at this point (we might be
292: after reload for a leaf routine), it will improve optimization for it
293: to be there. */
294: insn = get_last_insn ();
295: while (insn && GET_CODE (insn) == NOTE)
296: insn = PREV_INSN (insn);
297:
298: if (insn && GET_CODE (insn) != BARRIER)
299: {
300: emit_jump_insn (gen_return ());
301: emit_barrier ();
302: }
303: }
304: #endif
305:
306: if (noop_moves)
307: for (insn = f; insn; )
308: {
309: register rtx next = NEXT_INSN (insn);
310:
311: if (GET_CODE (insn) == INSN)
312: {
313: register rtx body = PATTERN (insn);
314:
315: /* Combine stack_adjusts with following push_insns. */
316: #ifdef PUSH_ROUNDING
317: if (GET_CODE (body) == SET
318: && SET_DEST (body) == stack_pointer_rtx
319: && GET_CODE (SET_SRC (body)) == PLUS
320: && XEXP (SET_SRC (body), 0) == stack_pointer_rtx
321: && GET_CODE (XEXP (SET_SRC (body), 1)) == CONST_INT
322: && INTVAL (XEXP (SET_SRC (body), 1)) > 0)
323: {
324: rtx p;
325: rtx stack_adjust_insn = insn;
326: int stack_adjust_amount = INTVAL (XEXP (SET_SRC (body), 1));
327: int total_pushed = 0;
328: int pushes = 0;
329:
330: /* Find all successive push insns. */
331: p = insn;
332: /* Don't convert more than three pushes;
333: that starts adding too many displaced addresses
334: and the whole thing starts becoming a losing
335: proposition. */
336: while (pushes < 3)
337: {
338: rtx pbody, dest;
339: p = next_nonnote_insn (p);
340: if (p == 0 || GET_CODE (p) != INSN)
341: break;
342: pbody = PATTERN (p);
343: if (GET_CODE (pbody) != SET)
344: break;
345: dest = SET_DEST (pbody);
346: /* Allow a no-op move between the adjust and the push. */
347: if (GET_CODE (dest) == REG
348: && GET_CODE (SET_SRC (pbody)) == REG
349: && REGNO (dest) == REGNO (SET_SRC (pbody)))
350: continue;
351: if (! (GET_CODE (dest) == MEM
352: && GET_CODE (XEXP (dest, 0)) == POST_INC
353: && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
354: break;
355: pushes++;
356: if (total_pushed + GET_MODE_SIZE (SET_DEST (pbody))
357: > stack_adjust_amount)
358: break;
359: total_pushed += GET_MODE_SIZE (SET_DEST (pbody));
360: }
361:
362: /* Discard the amount pushed from the stack adjust;
363: maybe eliminate it entirely. */
364: if (total_pushed >= stack_adjust_amount)
365: {
366: delete_insn (stack_adjust_insn);
367: total_pushed = stack_adjust_amount;
368: }
369: else
370: XEXP (SET_SRC (PATTERN (stack_adjust_insn)), 1)
371: = gen_rtx (CONST_INT, VOIDmode,
372: stack_adjust_amount - total_pushed);
373:
374: /* Change the appropriate push insns to ordinary stores. */
375: p = insn;
376: while (total_pushed > 0)
377: {
378: rtx pbody, dest;
379: p = next_nonnote_insn (p);
380: if (GET_CODE (p) != INSN)
381: break;
382: pbody = PATTERN (p);
383: if (GET_CODE (pbody) == SET)
384: break;
385: dest = SET_DEST (pbody);
386: if (! (GET_CODE (dest) == MEM
387: && GET_CODE (XEXP (dest, 0)) == POST_INC
388: && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx))
389: break;
390: total_pushed -= GET_MODE_SIZE (SET_DEST (pbody));
391: /* If this push doesn't fully fit in the space
392: of the stack adjust that we deleted,
393: make another stack adjust here for what we
394: didn't use up. There should be peepholes
395: to recognize the resulting sequence of insns. */
396: if (total_pushed < 0)
397: {
398: emit_insn_before (gen_add2_insn (stack_pointer_rtx,
399: gen_rtx (CONST_INT, VOIDmode, - total_pushed)),
400: p);
401: break;
402: }
403: XEXP (dest, 0)
404: = plus_constant (stack_pointer_rtx, total_pushed);
405: }
406: }
407: #endif
408:
409: /* Detect and delete no-op move instructions
410: resulting from not allocating a parameter in a register. */
411:
412: if (GET_CODE (body) == SET
413: && (SET_DEST (body) == SET_SRC (body)
414: || (GET_CODE (SET_DEST (body)) == MEM
415: && GET_CODE (SET_SRC (body)) == MEM
416: && rtx_equal_p (SET_SRC (body), SET_DEST (body))))
417: && ! (GET_CODE (SET_DEST (body)) == MEM
418: && MEM_VOLATILE_P (SET_DEST (body)))
419: && ! (GET_CODE (SET_SRC (body)) == MEM
420: && MEM_VOLATILE_P (SET_SRC (body))))
421: delete_insn (insn);
422:
423: /* Detect and ignore no-op move instructions
424: resulting from smart or fortuitous register allocation. */
425:
426: else if (GET_CODE (body) == SET)
427: {
428: int sreg = true_regnum (SET_SRC (body));
429: int dreg = true_regnum (SET_DEST (body));
430:
431: if (sreg == dreg && sreg >= 0)
432: delete_insn (insn);
433: else if (sreg >= 0 && dreg >= 0)
434: {
435: rtx trial;
436: rtx tem = find_equiv_reg (0, insn, 0,
437: sreg, 0, dreg,
438: GET_MODE (SET_SRC (body)));
439:
440: #ifdef PRESERVE_DEATH_INFO_REGNO_P
441: /* Deleting insn could lose a death-note for SREG or DREG
442: so don't do it if final needs accurate death-notes. */
443: if (! PRESERVE_DEATH_INFO_REGNO_P (sreg)
444: && ! PRESERVE_DEATH_INFO_REGNO_P (dreg))
445: #endif
446: {
447: /* DREG may have been the target of a REG_DEAD note in
448: the insn which makes INSN redundant. If so, reorg
449: would still think it is dead. So search for such a
450: note and delete it if we find it. */
451: for (trial = prev_nonnote_insn (insn);
452: trial && GET_CODE (trial) != CODE_LABEL;
453: trial = prev_nonnote_insn (trial))
454: if (find_regno_note (trial, REG_DEAD, dreg))
455: {
456: remove_death (dreg, trial);
457: break;
458: }
459:
460: if (tem != 0
461: && GET_MODE (tem) == GET_MODE (SET_DEST (body)))
462: delete_insn (insn);
463: }
464: }
465: else if (dreg >= 0 && CONSTANT_P (SET_SRC (body))
466: && find_equiv_reg (SET_SRC (body), insn, 0, dreg, 0,
467: 0, GET_MODE (SET_DEST (body))))
468: {
469: /* This handles the case where we have two consecutive
470: assignments of the same constant to pseudos that didn't
471: get a hard reg. Each SET from the constant will be
472: converted into a SET of the spill register and an
473: output reload will be made following it. This produces
474: two loads of the same constant into the same spill
475: register. */
476:
477: rtx in_insn = insn;
478:
479: /* Look back for a death note for the first reg.
480: If there is one, it is no longer accurate. */
481: while (in_insn && GET_CODE (in_insn) != CODE_LABEL)
482: {
483: if ((GET_CODE (in_insn) == INSN
484: || GET_CODE (in_insn) == JUMP_INSN)
485: && find_regno_note (in_insn, REG_DEAD, dreg))
486: {
487: remove_death (dreg, in_insn);
488: break;
489: }
490: in_insn = PREV_INSN (in_insn);
491: }
492:
493: /* Delete the second load of the value. */
494: delete_insn (insn);
495: }
496: }
497: else if (GET_CODE (body) == PARALLEL)
498: {
499: /* If each part is a set between two identical registers or
500: a USE or CLOBBER, delete the insn. */
501: int i, sreg, dreg;
502: rtx tem;
503:
504: for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
505: {
506: tem = XVECEXP (body, 0, i);
507: if (GET_CODE (tem) == USE || GET_CODE (tem) == CLOBBER)
508: continue;
509:
510: if (GET_CODE (tem) != SET
511: || (sreg = true_regnum (SET_SRC (tem))) < 0
512: || (dreg = true_regnum (SET_DEST (tem))) < 0
513: || dreg != sreg)
514: break;
515: }
516:
517: if (i < 0)
518: delete_insn (insn);
519: }
520: #if !BYTES_BIG_ENDIAN /* Not worth the hair to detect this
521: in the big-endian case. */
522: /* Also delete insns to store bit fields if they are no-ops. */
523: else if (GET_CODE (body) == SET
524: && GET_CODE (SET_DEST (body)) == ZERO_EXTRACT
525: && XEXP (SET_DEST (body), 2) == const0_rtx
526: && XEXP (SET_DEST (body), 0) == SET_SRC (body)
527: && ! (GET_CODE (SET_SRC (body)) == MEM
528: && MEM_VOLATILE_P (SET_SRC (body))))
529: delete_insn (insn);
530: #endif /* not BYTES_BIG_ENDIAN */
531: }
532: insn = next;
533: }
534:
535: /* Now iterate optimizing jumps until nothing changes over one pass. */
536: changed = 1;
537: while (changed)
538: {
539: register rtx next;
540: changed = 0;
541:
542: for (insn = f; insn; insn = next)
543: {
544: rtx reallabelprev;
545: rtx temp, temp1, temp2, temp3, temp4, temp5;
546: rtx nlabel;
547: int this_is_simplejump, this_is_condjump;
548: #if 0
549: /* If NOT the first iteration, if this is the last jump pass
550: (just before final), do the special peephole optimizations.
551: Avoiding the first iteration gives ordinary jump opts
552: a chance to work before peephole opts. */
553:
554: if (reload_completed && !first && !flag_no_peephole)
555: if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
556: peephole (insn);
557: #endif
558:
559: /* That could have deleted some insns after INSN, so check now
560: what the following insn is. */
561:
562: next = NEXT_INSN (insn);
563:
564: /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
565: jump. Try to optimize by duplicating the loop exit test if so.
566: This is only safe immediately after regscan, because it uses
567: the values of regno_first_uid and regno_last_uid. */
568: if (after_regscan && GET_CODE (insn) == NOTE
569: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
570: && (temp1 = next_nonnote_insn (insn)) != 0
571: && simplejump_p (temp1))
572: {
573: temp = PREV_INSN (insn);
574: if (duplicate_loop_exit_test (insn))
575: {
576: changed = 1;
577: next = NEXT_INSN (temp);
578: continue;
579: }
580: }
581:
582: if (GET_CODE (insn) != JUMP_INSN)
583: continue;
584:
585: this_is_simplejump = simplejump_p (insn);
586: this_is_condjump = condjump_p (insn);
587:
588: /* Tension the labels in dispatch tables. */
589:
590: if (GET_CODE (PATTERN (insn)) == ADDR_VEC)
591: changed |= tension_vector_labels (PATTERN (insn), 0);
592: if (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
593: changed |= tension_vector_labels (PATTERN (insn), 1);
594:
595: /* If a dispatch table always goes to the same place,
596: get rid of it and replace the insn that uses it. */
597:
598: if (GET_CODE (PATTERN (insn)) == ADDR_VEC
599: || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
600: {
601: int i;
602: rtx pat = PATTERN (insn);
603: int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC;
604: int len = XVECLEN (pat, diff_vec_p);
605: rtx dispatch = prev_real_insn (insn);
606:
607: for (i = 0; i < len; i++)
608: if (XEXP (XVECEXP (pat, diff_vec_p, i), 0)
609: != XEXP (XVECEXP (pat, diff_vec_p, 0), 0))
610: break;
611: if (i == len
612: && GET_CODE (dispatch) == JUMP_INSN
613: && JUMP_LABEL (dispatch) != 0
614: /* Don't mess with a casesi insn. */
615: && !(GET_CODE (PATTERN (dispatch)) == SET
616: && (GET_CODE (SET_SRC (PATTERN (dispatch)))
617: == IF_THEN_ELSE))
618: && next_real_insn (JUMP_LABEL (dispatch)) == insn)
619: {
620: redirect_tablejump (dispatch,
621: XEXP (XVECEXP (pat, diff_vec_p, 0), 0));
622: changed = 1;
623: }
624: }
625:
626: reallabelprev = prev_active_insn (JUMP_LABEL (insn));
627:
628: /* If a jump references the end of the function, try to turn
629: it into a RETURN insn, possibly a conditional one. */
630: if (JUMP_LABEL (insn)
631: && next_active_insn (JUMP_LABEL (insn)) == 0)
632: changed |= redirect_jump (insn, 0);
633:
634: /* Detect jump to following insn. */
635: if (reallabelprev == insn && condjump_p (insn))
636: {
637: delete_jump (insn);
638: changed = 1;
639: continue;
640: }
641:
1.1.1.2 root 642: /* If we have an unconditional jump preceded by a USE, try to put
1.1 root 643: the USE before the target and jump there. This simplifies many
644: of the optimizations below since we don't have to worry about
645: dealing with these USE insns. We only do this if the label
646: being branch to already has the identical USE or if code
647: never falls through to that label. */
648:
649: if (this_is_simplejump
650: && (temp = prev_nonnote_insn (insn)) != 0
651: && GET_CODE (temp) == INSN && GET_CODE (PATTERN (temp)) == USE
652: && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
653: && (GET_CODE (temp1) == BARRIER
654: || (GET_CODE (temp1) == INSN
655: && rtx_equal_p (PATTERN (temp), PATTERN (temp1)))))
656: {
657: if (GET_CODE (temp1) == BARRIER)
658: {
659: reorder_insns (temp, temp, temp1);
660: temp1 = NEXT_INSN (temp1);
661: }
662: else
663: delete_insn (temp);
664:
665: redirect_jump (insn, get_label_before (temp1));
666: reallabelprev = prev_real_insn (temp1);
667: changed = 1;
668: }
669:
670: /* Simplify if (...) x = a; else x = b; by converting it
671: to x = b; if (...) x = a;
672: if B is sufficiently simple, the test doesn't involve X,
673: and nothing in the test modifies B or X.
674:
675: If we have small register classes, we also can't do this if X
676: is a hard register.
677:
678: If the "x = b;" insn has any REG_NOTES, we don't do this because
679: of the possibility that we are running after CSE and there is a
680: REG_EQUAL note that is only valid if the branch has already been
681: taken. If we move the insn with the REG_EQUAL note, we may
682: fold the comparison to always be false in a later CSE pass.
683: (We could also delete the REG_NOTES when moving the insn, but it
684: seems simpler to not move it.) An exception is that we can move
685: the insn if the only note is a REG_EQUAL or REG_EQUIV whose
686: value is the same as "b".
687:
688: INSN is the branch over the `else' part.
689:
690: We set:
691:
1.1.1.2 root 692: TEMP to the jump insn preceding "x = a;"
1.1 root 693: TEMP1 to X
694: TEMP2 to the insn that sets "x = b;"
695: TEMP3 to the insn that sets "x = a;" */
696:
697: if (this_is_simplejump
698: && (temp3 = prev_active_insn (insn)) != 0
699: && GET_CODE (temp3) == INSN
700: && GET_CODE (PATTERN (temp3)) == SET
701: && GET_CODE (temp1 = SET_DEST (PATTERN (temp3))) == REG
702: #ifdef SMALL_REGISTER_CLASSES
703: && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
704: #endif
705: && (temp2 = next_active_insn (insn)) != 0
706: && GET_CODE (temp2) == INSN
707: && GET_CODE (PATTERN (temp2)) == SET
708: && rtx_equal_p (SET_DEST (PATTERN (temp2)), temp1)
709: && (GET_CODE (SET_SRC (PATTERN (temp2))) == REG
710: || CONSTANT_P (SET_SRC (PATTERN (temp2))))
711: && (REG_NOTES (temp2) == 0
712: || ((REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUAL
713: || REG_NOTE_KIND (REG_NOTES (temp2)) == REG_EQUIV)
714: && XEXP (REG_NOTES (temp2), 1) == 0
715: && rtx_equal_p (XEXP (REG_NOTES (temp2), 0),
716: SET_SRC (PATTERN (temp2)))))
717: && (temp = prev_active_insn (temp3)) != 0
718: && condjump_p (temp) && ! simplejump_p (temp)
719: /* TEMP must skip over the "x = a;" insn */
720: && prev_real_insn (JUMP_LABEL (temp)) == insn
721: && no_labels_between_p (insn, JUMP_LABEL (temp))
722: /* There must be no other entries to the "x = b;" insn. */
723: && no_labels_between_p (JUMP_LABEL (temp), temp2)
724: /* INSN must either branch to the insn after TEMP2 or the insn
725: after TEMP2 must branch to the same place as INSN. */
726: && (reallabelprev == temp2
727: || ((temp4 = next_active_insn (temp2)) != 0
728: && simplejump_p (temp4)
729: && JUMP_LABEL (temp4) == JUMP_LABEL (insn))))
730: {
731: /* The test expression, X, may be a complicated test with
732: multiple branches. See if we can find all the uses of
733: the label that TEMP branches to without hitting a CALL_INSN
734: or a jump to somewhere else. */
735: rtx target = JUMP_LABEL (temp);
736: int nuses = LABEL_NUSES (target);
737: rtx p, q;
738:
739: /* Set P to the first jump insn that goes around "x = a;". */
740: for (p = temp; nuses && p; p = prev_nonnote_insn (p))
741: {
742: if (GET_CODE (p) == JUMP_INSN)
743: {
744: if (condjump_p (p) && ! simplejump_p (p)
745: && JUMP_LABEL (p) == target)
746: {
747: nuses--;
748: if (nuses == 0)
749: break;
750: }
751: else
752: break;
753: }
754: else if (GET_CODE (p) == CALL_INSN)
755: break;
756: }
757:
758: #ifdef HAVE_cc0
759: /* We cannot insert anything between a set of cc and its use
760: so if P uses cc0, we must back up to the previous insn. */
761: q = prev_nonnote_insn (p);
762: if (q && GET_RTX_CLASS (GET_CODE (q)) == 'i'
763: && sets_cc0_p (PATTERN (q)))
764: p = q;
765: #endif
766:
767: if (p)
768: p = PREV_INSN (p);
769:
770: /* If we found all the uses and there was no data conflict, we
771: can move the assignment unless we can branch into the middle
772: from somewhere. */
773: if (nuses == 0 && p
774: && no_labels_between_p (p, insn)
775: && ! reg_referenced_between_p (temp1, p, NEXT_INSN (temp3))
776: && ! reg_set_between_p (temp1, p, temp3)
777: && (GET_CODE (SET_SRC (PATTERN (temp2))) == CONST_INT
778: || ! reg_set_between_p (SET_SRC (PATTERN (temp2)),
779: p, temp2)))
780: {
781: reorder_insns_with_line_notes (temp2, temp2, p);
782:
783: /* Set NEXT to an insn that we know won't go away. */
784: next = next_active_insn (insn);
785:
786: /* Delete the jump around the set. Note that we must do
787: this before we redirect the test jumps so that it won't
788: delete the code immediately following the assignment
789: we moved (which might be a jump). */
790:
791: delete_insn (insn);
792:
793: /* We either have two consecutive labels or a jump to
794: a jump, so adjust all the JUMP_INSNs to branch to where
795: INSN branches to. */
796: for (p = NEXT_INSN (p); p != next; p = NEXT_INSN (p))
797: if (GET_CODE (p) == JUMP_INSN)
798: redirect_jump (p, target);
799:
800: changed = 1;
801: continue;
802: }
803: }
804:
805: /* If we have x = a; if (...) x = b;
806: and either A or B is zero, or if we have if (...) x = 0;
807: and jumps are expensive, try to use a store-flag insn to
808: avoid the jump. (If the jump would be faster, the machine
809: should not have defined the scc insns!). These cases are often
810: made by the previous optimization.
811:
812: INSN here is the jump around the store. We set:
813:
814: TEMP to the "x = b;" insn.
815: TEMP1 to X.
816: TEMP2 to B (const0_rtx in the second case).
817: TEMP3 to A (X in the second case).
818: TEMP4 to the condition being tested.
819: TEMP5 to the earliest insn used to find the condition. */
820:
821: if (/* We can't do this after reload has completed. */
822: ! reload_completed
823: && this_is_condjump && ! this_is_simplejump
824: /* Set TEMP to the "x = b;" insn. */
825: && (temp = next_nonnote_insn (insn)) != 0
826: && GET_CODE (temp) == INSN
827: && GET_CODE (PATTERN (temp)) == SET
828: && GET_CODE (temp1 = SET_DEST (PATTERN (temp))) == REG
829: #ifdef SMALL_REGISTER_CLASSES
830: && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
831: #endif
832: && GET_MODE_CLASS (GET_MODE (temp1)) == MODE_INT
833: && (GET_CODE (temp2 = SET_SRC (PATTERN (temp))) == REG
834: || GET_CODE (temp2) == CONST_INT)
835: /* Allow either form, but prefer the former if both apply. */
836: && (((temp3 = reg_set_last (temp1, insn)) != 0
837: && ((GET_CODE (temp3) == REG
838: #ifdef SMALL_REGISTER_CLASSES
839: && REGNO (temp3) >= FIRST_PSEUDO_REGISTER
840: #endif
841: )
842: || GET_CODE (temp3) == CONST_INT))
843: /* Make the latter case look like x = x; if (...) x = 0; */
844: || ((temp3 = temp1, BRANCH_COST > 1)
845: && temp2 == const0_rtx))
846: /* INSN must either branch to the insn after TEMP or the insn
847: after TEMP must branch to the same place as INSN. */
848: && (reallabelprev == temp
849: || ((temp4 = next_active_insn (temp)) != 0
850: && simplejump_p (temp4)
851: && JUMP_LABEL (temp4) == JUMP_LABEL (insn)))
852: && (temp4 = get_condition (insn, &temp5)) != 0
853:
854: /* If B is zero, OK; if A is zero, can only do this if we
855: can reverse the condition. */
856: && (temp2 == const0_rtx
857: || (temp3 == const0_rtx
858: && (can_reverse_comparison_p (temp4, insn)))))
859: {
860: enum rtx_code code = GET_CODE (temp4);
861: rtx yes = temp3, var = temp1;
862: int normalizep;
863: rtx target;
864:
865: /* If necessary, reverse the condition. */
866: if (temp3 == const0_rtx)
867: code = reverse_condition (code), yes = temp2;
868:
869: /* See if we can do this with a store-flag insn. */
870: start_sequence ();
871:
872: /* If YES is the constant 1, it is best to just compute
873: the result directly. If YES is constant and STORE_FLAG_VALUE
874: includes all of its bits, it is best to compute the flag
875: value unnormalized and `and' it with YES. Otherwise,
876: normalize to -1 and `and' with YES. */
877: normalizep = (yes == const1_rtx ? 1
878: : (GET_CODE (yes) == CONST_INT
879: && (INTVAL (yes) & ~ STORE_FLAG_VALUE) == 0) ? 0
880: : -1);
881:
882: /* We will be putting the store-flag insn immediately in
883: front of the comparison that was originally being done,
884: so we know all the variables in TEMP4 will be valid.
885: However, this might be in front of the assignment of
886: A to VAR. If it is, it would clobber the store-flag
887: we will be emitting.
888:
889: Therefore, emit into a temporary which will be copied to
890: VAR immediately after TEMP. */
891:
892: target = emit_store_flag (gen_reg_rtx (GET_MODE (var)), code,
893: XEXP (temp4, 0), XEXP (temp4, 1),
894: VOIDmode,
895: (code == LTU || code == LEU
896: || code == GEU || code == GTU),
897: normalizep);
898: if (target)
899: {
900: rtx seq;
901:
902: if (normalizep != 1)
903: target = expand_and (yes, target,
904: (GET_CODE (target) == REG
905: ? target : 0));
906: seq = gen_sequence ();
907: end_sequence ();
908: emit_insn_before (seq, temp5);
909: emit_insn_after (gen_move_insn (var, target), insn);
910: delete_insn (temp);
911: next = NEXT_INSN (insn);
912: #ifdef HAVE_cc0
913: delete_insn (prev_nonnote_insn (insn));
914: #endif
915: delete_insn (insn);
916: changed = 1;
917: continue;
918: }
919: else
920: end_sequence ();
921: }
922:
923: /* If branches are expensive, convert
924: if (foo) bar++; to bar += (foo != 0);
925: and similarly for "bar--;"
926:
927: INSN is the conditional branch around the arithmetic. We set:
928:
929: TEMP is the arithmetic insn.
1.1.1.3 ! root 930: TEMP1 is the SET doing the arithmetic.
1.1 root 931: TEMP2 is the operand being incremented or decremented.
932: TEMP3 to the condition being tested.
933: TEMP4 to the earliest insn used to find the condition. */
934:
935: if (BRANCH_COST >= 2
936: && ! reload_completed
937: && this_is_condjump && ! this_is_simplejump
938: && (temp = next_nonnote_insn (insn)) != 0
939: && (temp1 = single_set (temp)) != 0
940: && (temp2 = SET_DEST (temp1),
941: GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT)
942: && GET_CODE (SET_SRC (temp1)) == PLUS
943: && (XEXP (SET_SRC (temp1), 1) == const1_rtx
944: || XEXP (SET_SRC (temp1), 1) == constm1_rtx)
945: && rtx_equal_p (temp2, XEXP (SET_SRC (temp1), 0))
946: /* INSN must either branch to the insn after TEMP or the insn
947: after TEMP must branch to the same place as INSN. */
948: && (reallabelprev == temp
949: || ((temp3 = next_active_insn (temp)) != 0
950: && simplejump_p (temp3)
951: && JUMP_LABEL (temp3) == JUMP_LABEL (insn)))
952: && (temp3 = get_condition (insn, &temp4)) != 0
953: && can_reverse_comparison_p (temp3, insn))
954: {
1.1.1.3 ! root 955: rtx temp6, target = 0, seq, init_insn = 0, init = temp2;
1.1 root 956: enum rtx_code code = reverse_condition (GET_CODE (temp3));
957:
958: start_sequence ();
959:
1.1.1.3 ! root 960: /* It must be the case that TEMP2 is not modified in the range
! 961: [TEMP4, INSN). The one exception we make is if the insn
! 962: before INSN sets TEMP2 to something which is also unchanged
! 963: in that range. In that case, we can move the initialization
! 964: into our sequence. */
! 965:
! 966: if ((temp5 = prev_active_insn (insn)) != 0
! 967: && GET_CODE (temp5) == INSN
! 968: && (temp6 = single_set (temp5)) != 0
! 969: && rtx_equal_p (temp2, SET_DEST (temp6))
! 970: && (CONSTANT_P (SET_SRC (temp6))
! 971: || GET_CODE (SET_SRC (temp6)) == REG
! 972: || GET_CODE (SET_SRC (temp6)) == SUBREG))
! 973: {
! 974: emit_insn (PATTERN (temp5));
! 975: init_insn = temp5;
! 976: init = SET_SRC (temp6);
! 977: }
! 978:
! 979: if (CONSTANT_P (init)
! 980: || ! reg_set_between_p (init, PREV_INSN (temp4), insn))
! 981: target = emit_store_flag (gen_reg_rtx (GET_MODE (temp2)), code,
! 982: XEXP (temp3, 0), XEXP (temp3, 1),
! 983: VOIDmode,
! 984: (code == LTU || code == LEU
! 985: || code == GTU || code == GEU), 1);
1.1 root 986:
987: /* If we can do the store-flag, do the addition or
988: subtraction. */
989:
990: if (target)
991: target = expand_binop (GET_MODE (temp2),
992: (XEXP (SET_SRC (temp1), 1) == const1_rtx
993: ? add_optab : sub_optab),
994: temp2, target, temp2, OPTAB_WIDEN);
995:
996: if (target != 0)
997: {
998: /* Put the result back in temp2 in case it isn't already.
999: Then replace the jump, possible a CC0-setting insn in
1000: front of the jump, and TEMP, with the sequence we have
1001: made. */
1002:
1003: if (target != temp2)
1004: emit_move_insn (temp2, target);
1005:
1006: seq = get_insns ();
1007: end_sequence ();
1008:
1009: emit_insns_before (seq, temp4);
1010: delete_insn (temp);
1.1.1.3 ! root 1011:
! 1012: if (init_insn)
! 1013: delete_insn (init_insn);
! 1014:
1.1 root 1015: next = NEXT_INSN (insn);
1016: #ifdef HAVE_cc0
1017: delete_insn (prev_nonnote_insn (insn));
1018: #endif
1019: delete_insn (insn);
1020: changed = 1;
1021: continue;
1022: }
1023: else
1024: end_sequence ();
1025: }
1026:
1027: /* Simplify if (...) x = 1; else {...} if (x) ...
1028: We recognize this case scanning backwards as well.
1029:
1030: TEMP is the assignment to x;
1031: TEMP1 is the label at the head of the second if. */
1032: /* ?? This should call get_condition to find the values being
1033: compared, instead of looking for a COMPARE insn when HAVE_cc0
1034: is not defined. This would allow it to work on the m88k. */
1035: /* ?? This optimization is only safe before cse is run if HAVE_cc0
1036: is not defined and the condition is tested by a separate compare
1037: insn. This is because the code below assumes that the result
1038: of the compare dies in the following branch.
1039:
1040: Not only that, but there might be other insns between the
1041: compare and branch whose results are live. Those insns need
1042: to be executed.
1043:
1044: A way to fix this is to move the insns at JUMP_LABEL (insn)
1045: to before INSN. If we are running before flow, they will
1046: be deleted if they aren't needed. But this doesn't work
1047: well after flow.
1048:
1049: This is really a special-case of jump threading, anyway. The
1050: right thing to do is to replace this and jump threading with
1051: much simpler code in cse.
1052:
1053: This code has been turned off in the non-cc0 case in the
1054: meantime. */
1055:
1056: #ifdef HAVE_cc0
1057: else if (this_is_simplejump
1058: /* Safe to skip USE and CLOBBER insns here
1059: since they will not be deleted. */
1060: && (temp = prev_active_insn (insn))
1061: && no_labels_between_p (temp, insn)
1062: && GET_CODE (temp) == INSN
1063: && GET_CODE (PATTERN (temp)) == SET
1064: && GET_CODE (SET_DEST (PATTERN (temp))) == REG
1065: && CONSTANT_P (SET_SRC (PATTERN (temp)))
1066: && (temp1 = next_active_insn (JUMP_LABEL (insn)))
1067: /* If we find that the next value tested is `x'
1068: (TEMP1 is the insn where this happens), win. */
1069: && GET_CODE (temp1) == INSN
1070: && GET_CODE (PATTERN (temp1)) == SET
1071: #ifdef HAVE_cc0
1072: /* Does temp1 `tst' the value of x? */
1073: && SET_SRC (PATTERN (temp1)) == SET_DEST (PATTERN (temp))
1074: && SET_DEST (PATTERN (temp1)) == cc0_rtx
1075: && (temp1 = next_nonnote_insn (temp1))
1076: #else
1077: /* Does temp1 compare the value of x against zero? */
1078: && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
1079: && XEXP (SET_SRC (PATTERN (temp1)), 1) == const0_rtx
1080: && (XEXP (SET_SRC (PATTERN (temp1)), 0)
1081: == SET_DEST (PATTERN (temp)))
1082: && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
1083: && (temp1 = find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
1084: #endif
1085: && condjump_p (temp1))
1086: {
1087: /* Get the if_then_else from the condjump. */
1088: rtx choice = SET_SRC (PATTERN (temp1));
1089: if (GET_CODE (choice) == IF_THEN_ELSE)
1090: {
1091: enum rtx_code code = GET_CODE (XEXP (choice, 0));
1092: rtx val = SET_SRC (PATTERN (temp));
1093: rtx cond
1094: = simplify_relational_operation (code, GET_MODE (SET_DEST (PATTERN (temp))),
1095: val, const0_rtx);
1096: rtx ultimate;
1097:
1098: if (cond == const_true_rtx)
1099: ultimate = XEXP (choice, 1);
1100: else if (cond == const0_rtx)
1101: ultimate = XEXP (choice, 2);
1102: else
1103: ultimate = 0;
1104:
1105: if (ultimate == pc_rtx)
1106: ultimate = get_label_after (temp1);
1107: else if (ultimate && GET_CODE (ultimate) != RETURN)
1108: ultimate = XEXP (ultimate, 0);
1109:
1110: if (ultimate)
1111: changed |= redirect_jump (insn, ultimate);
1112: }
1113: }
1114: #endif
1115:
1116: #if 0
1117: /* @@ This needs a bit of work before it will be right.
1118:
1119: Any type of comparison can be accepted for the first and
1120: second compare. When rewriting the first jump, we must
1121: compute the what conditions can reach label3, and use the
1122: appropriate code. We can not simply reverse/swap the code
1123: of the first jump. In some cases, the second jump must be
1124: rewritten also.
1125:
1126: For example,
1127: < == converts to > ==
1128: < != converts to == >
1129: etc.
1130:
1131: If the code is written to only accept an '==' test for the second
1132: compare, then all that needs to be done is to swap the condition
1133: of the first branch.
1134:
1135: It is questionable whether we want this optimization anyways,
1136: since if the user wrote code like this because he/she knew that
1.1.1.3 ! root 1137: the jump to label1 is taken most of the time, then rewriting
1.1 root 1138: this gives slower code. */
1139: /* @@ This should call get_condition to find the values being
1140: compared, instead of looking for a COMPARE insn when HAVE_cc0
1141: is not defined. This would allow it to work on the m88k. */
1142: /* @@ This optimization is only safe before cse is run if HAVE_cc0
1143: is not defined and the condition is tested by a separate compare
1144: insn. This is because the code below assumes that the result
1145: of the compare dies in the following branch. */
1146:
1147: /* Simplify test a ~= b
1148: condjump label1;
1149: test a == b
1150: condjump label2;
1151: jump label3;
1152: label1:
1153:
1154: rewriting as
1155: test a ~~= b
1156: condjump label3
1157: test a == b
1158: condjump label2
1159: label1:
1160:
1161: where ~= is an inequality, e.g. >, and ~~= is the swapped
1162: inequality, e.g. <.
1163:
1164: We recognize this case scanning backwards.
1165:
1166: TEMP is the conditional jump to `label2';
1167: TEMP1 is the test for `a == b';
1168: TEMP2 is the conditional jump to `label1';
1169: TEMP3 is the test for `a ~= b'. */
1170: else if (this_is_simplejump
1171: && (temp = prev_active_insn (insn))
1172: && no_labels_between_p (temp, insn)
1173: && condjump_p (temp)
1174: && (temp1 = prev_active_insn (temp))
1175: && no_labels_between_p (temp1, temp)
1176: && GET_CODE (temp1) == INSN
1177: && GET_CODE (PATTERN (temp1)) == SET
1178: #ifdef HAVE_cc0
1179: && sets_cc0_p (PATTERN (temp1)) == 1
1180: #else
1181: && GET_CODE (SET_SRC (PATTERN (temp1))) == COMPARE
1182: && GET_CODE (SET_DEST (PATTERN (temp1))) == REG
1183: && (temp == find_next_ref (SET_DEST (PATTERN (temp1)), temp1))
1184: #endif
1185: && (temp2 = prev_active_insn (temp1))
1186: && no_labels_between_p (temp2, temp1)
1187: && condjump_p (temp2)
1188: && JUMP_LABEL (temp2) == next_nonnote_insn (NEXT_INSN (insn))
1189: && (temp3 = prev_active_insn (temp2))
1190: && no_labels_between_p (temp3, temp2)
1191: && GET_CODE (PATTERN (temp3)) == SET
1192: && rtx_equal_p (SET_DEST (PATTERN (temp3)),
1193: SET_DEST (PATTERN (temp1)))
1194: && rtx_equal_p (SET_SRC (PATTERN (temp1)),
1195: SET_SRC (PATTERN (temp3)))
1196: && ! inequality_comparisons_p (PATTERN (temp))
1197: && inequality_comparisons_p (PATTERN (temp2)))
1198: {
1199: rtx fallthrough_label = JUMP_LABEL (temp2);
1200:
1201: ++LABEL_NUSES (fallthrough_label);
1202: if (swap_jump (temp2, JUMP_LABEL (insn)))
1203: {
1204: delete_insn (insn);
1205: changed = 1;
1206: }
1207:
1208: if (--LABEL_NUSES (fallthrough_label) == 0)
1209: delete_insn (fallthrough_label);
1210: }
1211: #endif
1212: /* Simplify if (...) {... x = 1;} if (x) ...
1213:
1214: We recognize this case backwards.
1215:
1216: TEMP is the test of `x';
1217: TEMP1 is the assignment to `x' at the end of the
1218: previous statement. */
1219: /* @@ This should call get_condition to find the values being
1220: compared, instead of looking for a COMPARE insn when HAVE_cc0
1221: is not defined. This would allow it to work on the m88k. */
1222: /* @@ This optimization is only safe before cse is run if HAVE_cc0
1223: is not defined and the condition is tested by a separate compare
1224: insn. This is because the code below assumes that the result
1225: of the compare dies in the following branch. */
1226:
1227: /* ??? This has to be turned off. The problem is that the
1228: unconditional jump might indirectly end up branching to the
1229: label between TEMP1 and TEMP. We can't detect this, in general,
1230: since it may become a jump to there after further optimizations.
1231: If that jump is done, it will be deleted, so we will retry
1232: this optimization in the next pass, thus an infinite loop.
1233:
1234: The present code prevents this by putting the jump after the
1235: label, but this is not logically correct. */
1236: #if 0
1237: else if (this_is_condjump
1238: /* Safe to skip USE and CLOBBER insns here
1239: since they will not be deleted. */
1240: && (temp = prev_active_insn (insn))
1241: && no_labels_between_p (temp, insn)
1242: && GET_CODE (temp) == INSN
1243: && GET_CODE (PATTERN (temp)) == SET
1244: #ifdef HAVE_cc0
1245: && sets_cc0_p (PATTERN (temp)) == 1
1246: && GET_CODE (SET_SRC (PATTERN (temp))) == REG
1247: #else
1248: /* Temp must be a compare insn, we can not accept a register
1249: to register move here, since it may not be simply a
1250: tst insn. */
1251: && GET_CODE (SET_SRC (PATTERN (temp))) == COMPARE
1252: && XEXP (SET_SRC (PATTERN (temp)), 1) == const0_rtx
1253: && GET_CODE (XEXP (SET_SRC (PATTERN (temp)), 0)) == REG
1254: && GET_CODE (SET_DEST (PATTERN (temp))) == REG
1255: && insn == find_next_ref (SET_DEST (PATTERN (temp)), temp)
1256: #endif
1257: /* May skip USE or CLOBBER insns here
1258: for checking for opportunity, since we
1259: take care of them later. */
1260: && (temp1 = prev_active_insn (temp))
1261: && GET_CODE (temp1) == INSN
1262: && GET_CODE (PATTERN (temp1)) == SET
1263: #ifdef HAVE_cc0
1264: && SET_SRC (PATTERN (temp)) == SET_DEST (PATTERN (temp1))
1265: #else
1266: && (XEXP (SET_SRC (PATTERN (temp)), 0)
1267: == SET_DEST (PATTERN (temp1)))
1268: #endif
1269: && CONSTANT_P (SET_SRC (PATTERN (temp1)))
1270: /* If this isn't true, cse will do the job. */
1271: && ! no_labels_between_p (temp1, temp))
1272: {
1273: /* Get the if_then_else from the condjump. */
1274: rtx choice = SET_SRC (PATTERN (insn));
1275: if (GET_CODE (choice) == IF_THEN_ELSE
1276: && (GET_CODE (XEXP (choice, 0)) == EQ
1277: || GET_CODE (XEXP (choice, 0)) == NE))
1278: {
1279: int want_nonzero = (GET_CODE (XEXP (choice, 0)) == NE);
1280: rtx last_insn;
1281: rtx ultimate;
1282: rtx p;
1283:
1284: /* Get the place that condjump will jump to
1285: if it is reached from here. */
1286: if ((SET_SRC (PATTERN (temp1)) != const0_rtx)
1287: == want_nonzero)
1288: ultimate = XEXP (choice, 1);
1289: else
1290: ultimate = XEXP (choice, 2);
1291: /* Get it as a CODE_LABEL. */
1292: if (ultimate == pc_rtx)
1293: ultimate = get_label_after (insn);
1294: else
1295: /* Get the label out of the LABEL_REF. */
1296: ultimate = XEXP (ultimate, 0);
1297:
1298: /* Insert the jump immediately before TEMP, specifically
1299: after the label that is between TEMP1 and TEMP. */
1300: last_insn = PREV_INSN (temp);
1301:
1302: /* If we would be branching to the next insn, the jump
1303: would immediately be deleted and the re-inserted in
1304: a subsequent pass over the code. So don't do anything
1305: in that case. */
1306: if (next_active_insn (last_insn)
1307: != next_active_insn (ultimate))
1308: {
1309: emit_barrier_after (last_insn);
1310: p = emit_jump_insn_after (gen_jump (ultimate),
1311: last_insn);
1312: JUMP_LABEL (p) = ultimate;
1313: ++LABEL_NUSES (ultimate);
1314: if (INSN_UID (ultimate) < max_jump_chain
1315: && INSN_CODE (p) < max_jump_chain)
1316: {
1317: jump_chain[INSN_UID (p)]
1318: = jump_chain[INSN_UID (ultimate)];
1319: jump_chain[INSN_UID (ultimate)] = p;
1320: }
1321: changed = 1;
1322: continue;
1323: }
1324: }
1325: }
1326: #endif
1327: /* Detect a conditional jump going to the same place
1328: as an immediately following unconditional jump. */
1329: else if (this_is_condjump
1330: && (temp = next_active_insn (insn)) != 0
1331: && simplejump_p (temp)
1332: && (next_active_insn (JUMP_LABEL (insn))
1333: == next_active_insn (JUMP_LABEL (temp))))
1334: {
1335: delete_jump (insn);
1336: changed = 1;
1337: continue;
1338: }
1339: /* Detect a conditional jump jumping over an unconditional jump. */
1340:
1341: else if (this_is_condjump && ! this_is_simplejump
1342: && reallabelprev != 0
1343: && GET_CODE (reallabelprev) == JUMP_INSN
1344: && prev_active_insn (reallabelprev) == insn
1345: && no_labels_between_p (insn, reallabelprev)
1346: && simplejump_p (reallabelprev))
1347: {
1348: /* When we invert the unconditional jump, we will be
1349: decrementing the usage count of its old label.
1350: Make sure that we don't delete it now because that
1351: might cause the following code to be deleted. */
1352: rtx prev_uses = prev_nonnote_insn (reallabelprev);
1353: rtx prev_label = JUMP_LABEL (insn);
1354:
1355: ++LABEL_NUSES (prev_label);
1356:
1357: if (invert_jump (insn, JUMP_LABEL (reallabelprev)))
1358: {
1359: /* It is very likely that if there are USE insns before
1360: this jump, they hold REG_DEAD notes. These REG_DEAD
1361: notes are no longer valid due to this optimization,
1362: and will cause the life-analysis that following passes
1363: (notably delayed-branch scheduling) to think that
1364: these registers are dead when they are not.
1365:
1366: To prevent this trouble, we just remove the USE insns
1367: from the insn chain. */
1368:
1369: while (prev_uses && GET_CODE (prev_uses) == INSN
1370: && GET_CODE (PATTERN (prev_uses)) == USE)
1371: {
1372: rtx useless = prev_uses;
1373: prev_uses = prev_nonnote_insn (prev_uses);
1374: delete_insn (useless);
1375: }
1376:
1377: delete_insn (reallabelprev);
1378: next = insn;
1379: changed = 1;
1380: }
1381:
1382: /* We can now safely delete the label if it is unreferenced
1383: since the delete_insn above has deleted the BARRIER. */
1384: if (--LABEL_NUSES (prev_label) == 0)
1385: delete_insn (prev_label);
1386: continue;
1387: }
1388: else
1389: {
1390: /* Detect a jump to a jump. */
1391:
1392: nlabel = follow_jumps (JUMP_LABEL (insn));
1393: if (nlabel != JUMP_LABEL (insn)
1394: && redirect_jump (insn, nlabel))
1395: {
1396: changed = 1;
1397: next = insn;
1398: }
1399:
1400: /* Look for if (foo) bar; else break; */
1401: /* The insns look like this:
1402: insn = condjump label1;
1403: ...range1 (some insns)...
1404: jump label2;
1405: label1:
1406: ...range2 (some insns)...
1407: jump somewhere unconditionally
1408: label2: */
1409: {
1410: rtx label1 = next_label (insn);
1411: rtx range1end = label1 ? prev_active_insn (label1) : 0;
1412: /* Don't do this optimization on the first round, so that
1413: jump-around-a-jump gets simplified before we ask here
1414: whether a jump is unconditional.
1415:
1416: Also don't do it when we are called after reload since
1417: it will confuse reorg. */
1418: if (! first
1419: && (reload_completed ? ! flag_delayed_branch : 1)
1420: /* Make sure INSN is something we can invert. */
1421: && condjump_p (insn)
1422: && label1 != 0
1423: && JUMP_LABEL (insn) == label1
1424: && LABEL_NUSES (label1) == 1
1425: && GET_CODE (range1end) == JUMP_INSN
1426: && simplejump_p (range1end))
1427: {
1428: rtx label2 = next_label (label1);
1429: rtx range2end = label2 ? prev_active_insn (label2) : 0;
1430: if (range1end != range2end
1431: && JUMP_LABEL (range1end) == label2
1432: && GET_CODE (range2end) == JUMP_INSN
1433: && GET_CODE (NEXT_INSN (range2end)) == BARRIER
1434: /* Invert the jump condition, so we
1435: still execute the same insns in each case. */
1436: && invert_jump (insn, label1))
1437: {
1438: rtx range1beg = next_active_insn (insn);
1439: rtx range2beg = next_active_insn (label1);
1440: rtx range1after, range2after;
1441: rtx range1before, range2before;
1442:
1.1.1.2 root 1443: /* Include in each range any line number before it. */
1444: while (PREV_INSN (range1beg)
1445: && GET_CODE (PREV_INSN (range1beg)) == NOTE
1446: && NOTE_LINE_NUMBER (PREV_INSN (range1beg)) > 0)
1447: range1beg = PREV_INSN (range1beg);
1448:
1449: while (PREV_INSN (range2beg)
1450: && GET_CODE (PREV_INSN (range2beg)) == NOTE
1451: && NOTE_LINE_NUMBER (PREV_INSN (range2beg)) > 0)
1452: range2beg = PREV_INSN (range2beg);
1453:
1.1 root 1454: /* Don't move NOTEs for blocks or loops; shift them
1455: outside the ranges, where they'll stay put. */
1.1.1.3 ! root 1456: range1beg = squeeze_notes (range1beg, range1end);
! 1457: range2beg = squeeze_notes (range2beg, range2end);
1.1 root 1458:
1459: /* Get current surrounds of the 2 ranges. */
1460: range1before = PREV_INSN (range1beg);
1461: range2before = PREV_INSN (range2beg);
1462: range1after = NEXT_INSN (range1end);
1463: range2after = NEXT_INSN (range2end);
1464:
1465: /* Splice range2 where range1 was. */
1466: NEXT_INSN (range1before) = range2beg;
1467: PREV_INSN (range2beg) = range1before;
1468: NEXT_INSN (range2end) = range1after;
1469: PREV_INSN (range1after) = range2end;
1470: /* Splice range1 where range2 was. */
1471: NEXT_INSN (range2before) = range1beg;
1472: PREV_INSN (range1beg) = range2before;
1473: NEXT_INSN (range1end) = range2after;
1474: PREV_INSN (range2after) = range1end;
1475: changed = 1;
1476: continue;
1477: }
1478: }
1479: }
1480:
1481: /* Now that the jump has been tensioned,
1482: try cross jumping: check for identical code
1483: before the jump and before its target label. */
1484:
1485: /* First, cross jumping of conditional jumps: */
1486:
1487: if (cross_jump && condjump_p (insn))
1488: {
1489: rtx newjpos, newlpos;
1490: rtx x = prev_real_insn (JUMP_LABEL (insn));
1491:
1492: /* A conditional jump may be crossjumped
1493: only if the place it jumps to follows
1494: an opposing jump that comes back here. */
1495:
1496: if (x != 0 && ! jump_back_p (x, insn))
1497: /* We have no opposing jump;
1498: cannot cross jump this insn. */
1499: x = 0;
1500:
1501: newjpos = 0;
1502: /* TARGET is nonzero if it is ok to cross jump
1503: to code before TARGET. If so, see if matches. */
1504: if (x != 0)
1505: find_cross_jump (insn, x, 2,
1506: &newjpos, &newlpos);
1507:
1508: if (newjpos != 0)
1509: {
1510: do_cross_jump (insn, newjpos, newlpos);
1511: /* Make the old conditional jump
1512: into an unconditional one. */
1513: SET_SRC (PATTERN (insn))
1514: = gen_rtx (LABEL_REF, VOIDmode, JUMP_LABEL (insn));
1515: INSN_CODE (insn) = -1;
1516: emit_barrier_after (insn);
1517: /* Add to jump_chain unless this is a new label
1518: whose UID is too large. */
1519: if (INSN_UID (JUMP_LABEL (insn)) < max_jump_chain)
1520: {
1521: jump_chain[INSN_UID (insn)]
1522: = jump_chain[INSN_UID (JUMP_LABEL (insn))];
1523: jump_chain[INSN_UID (JUMP_LABEL (insn))] = insn;
1524: }
1525: changed = 1;
1526: next = insn;
1527: }
1528: }
1529:
1530: /* Cross jumping of unconditional jumps:
1531: a few differences. */
1532:
1533: if (cross_jump && simplejump_p (insn))
1534: {
1535: rtx newjpos, newlpos;
1536: rtx target;
1537:
1538: newjpos = 0;
1539:
1540: /* TARGET is nonzero if it is ok to cross jump
1541: to code before TARGET. If so, see if matches. */
1542: find_cross_jump (insn, JUMP_LABEL (insn), 1,
1543: &newjpos, &newlpos);
1544:
1545: /* If cannot cross jump to code before the label,
1546: see if we can cross jump to another jump to
1547: the same label. */
1548: /* Try each other jump to this label. */
1549: if (INSN_UID (JUMP_LABEL (insn)) < max_uid)
1550: for (target = jump_chain[INSN_UID (JUMP_LABEL (insn))];
1551: target != 0 && newjpos == 0;
1552: target = jump_chain[INSN_UID (target)])
1553: if (target != insn
1554: && JUMP_LABEL (target) == JUMP_LABEL (insn)
1555: /* Ignore TARGET if it's deleted. */
1556: && ! INSN_DELETED_P (target))
1557: find_cross_jump (insn, target, 2,
1558: &newjpos, &newlpos);
1559:
1560: if (newjpos != 0)
1561: {
1562: do_cross_jump (insn, newjpos, newlpos);
1563: changed = 1;
1564: next = insn;
1565: }
1566: }
1567:
1568: /* This code was dead in the previous jump.c! */
1569: if (cross_jump && GET_CODE (PATTERN (insn)) == RETURN)
1570: {
1571: /* Return insns all "jump to the same place"
1572: so we can cross-jump between any two of them. */
1573:
1574: rtx newjpos, newlpos, target;
1575:
1576: newjpos = 0;
1577:
1578: /* If cannot cross jump to code before the label,
1579: see if we can cross jump to another jump to
1580: the same label. */
1581: /* Try each other jump to this label. */
1582: for (target = jump_chain[0];
1583: target != 0 && newjpos == 0;
1584: target = jump_chain[INSN_UID (target)])
1585: if (target != insn
1586: && ! INSN_DELETED_P (target)
1587: && GET_CODE (PATTERN (target)) == RETURN)
1588: find_cross_jump (insn, target, 2,
1589: &newjpos, &newlpos);
1590:
1591: if (newjpos != 0)
1592: {
1593: do_cross_jump (insn, newjpos, newlpos);
1594: changed = 1;
1595: next = insn;
1596: }
1597: }
1598: }
1599: }
1600:
1601: first = 0;
1602: }
1603:
1604: /* Delete extraneous line number notes.
1605: Note that two consecutive notes for different lines are not really
1606: extraneous. There should be some indication where that line belonged,
1607: even if it became empty. */
1608:
1609: {
1610: rtx last_note = 0;
1611:
1612: for (insn = f; insn; insn = NEXT_INSN (insn))
1613: if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) >= 0)
1614: {
1615: /* Delete this note if it is identical to previous note. */
1616: if (last_note
1617: && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
1618: && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note))
1619: {
1620: delete_insn (insn);
1621: continue;
1622: }
1623:
1624: last_note = insn;
1625: }
1626: }
1627:
1628: /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
1629: If so, delete it, and record that this function can drop off the end. */
1630:
1631: insn = last_insn;
1632: {
1633: int n_labels = 1;
1634: while (insn
1635: /* One label can follow the end-note: the return label. */
1636: && ((GET_CODE (insn) == CODE_LABEL && n_labels-- > 0)
1637: /* Ordinary insns can follow it if returning a structure. */
1638: || GET_CODE (insn) == INSN
1639: /* If machine uses explicit RETURN insns, no epilogue,
1640: then one of them follows the note. */
1641: || (GET_CODE (insn) == JUMP_INSN
1642: && GET_CODE (PATTERN (insn)) == RETURN)
1643: /* Other kinds of notes can follow also. */
1644: || (GET_CODE (insn) == NOTE
1645: && NOTE_LINE_NUMBER (insn) != NOTE_INSN_FUNCTION_END)))
1646: insn = PREV_INSN (insn);
1647: }
1648:
1649: /* Report if control can fall through at the end of the function. */
1650: if (insn && GET_CODE (insn) == NOTE
1651: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END)
1652: {
1653: can_reach_end = 1;
1654: delete_insn (insn);
1655: }
1656:
1657: /* Show JUMP_CHAIN no longer valid. */
1658: jump_chain = 0;
1659: }
1660:
1661: /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
1662: jump. Assume that this unconditional jump is to the exit test code. If
1663: the code is sufficiently simple, make a copy of it before INSN,
1664: followed by a jump to the exit of the loop. Then delete the unconditional
1665: jump after INSN.
1666:
1667: Note that it is possible we can get confused here if the jump immediately
1668: after the loop start branches outside the loop but within an outer loop.
1669: If we are near the exit of that loop, we will copy its exit test. This
1670: will not generate incorrect code, but could suppress some optimizations.
1671: However, such cases are degenerate loops anyway.
1672:
1673: Return 1 if we made the change, else 0.
1674:
1675: This is only safe immediately after a regscan pass because it uses the
1676: values of regno_first_uid and regno_last_uid. */
1677:
1678: static int
1679: duplicate_loop_exit_test (loop_start)
1680: rtx loop_start;
1681: {
1682: rtx insn, set, p;
1683: rtx copy, link;
1684: int num_insns = 0;
1685: rtx exitcode = NEXT_INSN (JUMP_LABEL (next_nonnote_insn (loop_start)));
1686: rtx lastexit;
1687: int max_reg = max_reg_num ();
1688: rtx *reg_map = 0;
1689:
1690: /* Scan the exit code. We do not perform this optimization if any insn:
1691:
1692: is a CALL_INSN
1693: is a CODE_LABEL
1694: has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
1695: is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
1696: is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
1697: are not valid
1698:
1699: Also, don't do this if the exit code is more than 20 insns. */
1700:
1701: for (insn = exitcode;
1702: insn
1703: && ! (GET_CODE (insn) == NOTE
1704: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
1705: insn = NEXT_INSN (insn))
1706: {
1707: switch (GET_CODE (insn))
1708: {
1709: case CODE_LABEL:
1710: case CALL_INSN:
1711: return 0;
1712: case NOTE:
1713: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
1714: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1715: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
1716: return 0;
1717: break;
1718: case JUMP_INSN:
1719: case INSN:
1720: if (++num_insns > 20
1721: || find_reg_note (insn, REG_RETVAL, 0)
1722: || find_reg_note (insn, REG_LIBCALL, 0))
1723: return 0;
1724: break;
1725: }
1726: }
1727:
1728: /* Unless INSN is zero, we can do the optimization. */
1729: if (insn == 0)
1730: return 0;
1731:
1732: lastexit = insn;
1733:
1734: /* See if any insn sets a register only used in the loop exit code and
1735: not a user variable. If so, replace it with a new register. */
1736: for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
1737: if (GET_CODE (insn) == INSN
1738: && (set = single_set (insn)) != 0
1739: && GET_CODE (SET_DEST (set)) == REG
1740: && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
1741: && regno_first_uid[REGNO (SET_DEST (set))] == INSN_UID (insn))
1742: {
1743: for (p = NEXT_INSN (insn); p != lastexit; p = NEXT_INSN (p))
1744: if (regno_last_uid[REGNO (SET_DEST (set))] == INSN_UID (p))
1745: break;
1746:
1747: if (p != lastexit)
1748: {
1749: /* We can do the replacement. Allocate reg_map if this is the
1750: first replacement we found. */
1751: if (reg_map == 0)
1752: {
1753: reg_map = (rtx *) alloca (max_reg * sizeof (rtx));
1754: bzero (reg_map, max_reg * sizeof (rtx));
1755: }
1756:
1757: REG_LOOP_TEST_P (SET_DEST (set)) = 1;
1758:
1759: reg_map[REGNO (SET_DEST (set))]
1760: = gen_reg_rtx (GET_MODE (SET_DEST (set)));
1761: }
1762: }
1763:
1764: /* Now copy each insn. */
1765: for (insn = exitcode; insn != lastexit; insn = NEXT_INSN (insn))
1766: switch (GET_CODE (insn))
1767: {
1768: case BARRIER:
1769: copy = emit_barrier_before (loop_start);
1770: break;
1771: case NOTE:
1772: /* Only copy line-number notes. */
1773: if (NOTE_LINE_NUMBER (insn) >= 0)
1774: {
1775: copy = emit_note_before (NOTE_LINE_NUMBER (insn), loop_start);
1776: NOTE_SOURCE_FILE (copy) = NOTE_SOURCE_FILE (insn);
1777: }
1778: break;
1779:
1780: case INSN:
1781: copy = emit_insn_before (copy_rtx (PATTERN (insn)), loop_start);
1782: if (reg_map)
1783: replace_regs (PATTERN (copy), reg_map, max_reg, 1);
1784:
1785: mark_jump_label (PATTERN (copy), copy, 0);
1786:
1787: /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
1788: make them. */
1789: for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1790: if (REG_NOTE_KIND (link) != REG_LABEL)
1791: REG_NOTES (copy)
1792: = copy_rtx (gen_rtx (EXPR_LIST, REG_NOTE_KIND (link),
1793: XEXP (link, 0), REG_NOTES (copy)));
1794: if (reg_map && REG_NOTES (copy))
1795: replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
1796: break;
1797:
1798: case JUMP_INSN:
1799: copy = emit_jump_insn_before (copy_rtx (PATTERN (insn)), loop_start);
1800: if (reg_map)
1801: replace_regs (PATTERN (copy), reg_map, max_reg, 1);
1802: mark_jump_label (PATTERN (copy), copy, 0);
1803: if (REG_NOTES (insn))
1804: {
1805: REG_NOTES (copy) = copy_rtx (REG_NOTES (insn));
1806: if (reg_map)
1807: replace_regs (REG_NOTES (copy), reg_map, max_reg, 1);
1808: }
1809:
1810: /* If this is a simple jump, add it to the jump chain. */
1811:
1812: if (INSN_UID (copy) < max_jump_chain && JUMP_LABEL (copy)
1813: && simplejump_p (copy))
1814: {
1815: jump_chain[INSN_UID (copy)]
1816: = jump_chain[INSN_UID (JUMP_LABEL (copy))];
1817: jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
1818: }
1819: break;
1820:
1821: default:
1822: abort ();
1823: }
1824:
1825: /* Now clean up by emitting a jump to the end label and deleting the jump
1826: at the start of the loop. */
1827: if (GET_CODE (copy) != BARRIER)
1828: {
1829: copy = emit_jump_insn_before (gen_jump (get_label_after (insn)),
1830: loop_start);
1831: mark_jump_label (PATTERN (copy), copy, 0);
1832: if (INSN_UID (copy) < max_jump_chain
1833: && INSN_UID (JUMP_LABEL (copy)) < max_jump_chain)
1834: {
1835: jump_chain[INSN_UID (copy)]
1836: = jump_chain[INSN_UID (JUMP_LABEL (copy))];
1837: jump_chain[INSN_UID (JUMP_LABEL (copy))] = copy;
1838: }
1839: emit_barrier_before (loop_start);
1840: }
1841:
1842: delete_insn (next_nonnote_insn (loop_start));
1843:
1844: /* Mark the exit code as the virtual top of the converted loop. */
1845: emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode);
1846:
1847: return 1;
1848: }
1849:
1850: /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, and
1.1.1.3 ! root 1851: loop-end notes between START and END out before START. Assume that
! 1852: END is not such a note. START may be such a note. Returns the value
! 1853: of the new starting insn, which may be different if the original start
! 1854: was such a note. */
1.1 root 1855:
1.1.1.3 ! root 1856: rtx
1.1 root 1857: squeeze_notes (start, end)
1858: rtx start, end;
1859: {
1860: rtx insn;
1861: rtx next;
1862:
1863: for (insn = start; insn != end; insn = next)
1864: {
1865: next = NEXT_INSN (insn);
1866: if (GET_CODE (insn) == NOTE
1867: && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
1868: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1869: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
1870: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
1871: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT
1872: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP))
1873: {
1.1.1.3 ! root 1874: if (insn == start)
! 1875: start = next;
! 1876: else
! 1877: {
! 1878: rtx prev = PREV_INSN (insn);
! 1879: PREV_INSN (insn) = PREV_INSN (start);
! 1880: NEXT_INSN (insn) = start;
! 1881: NEXT_INSN (PREV_INSN (insn)) = insn;
! 1882: PREV_INSN (NEXT_INSN (insn)) = insn;
! 1883: NEXT_INSN (prev) = next;
! 1884: PREV_INSN (next) = prev;
! 1885: }
1.1 root 1886: }
1887: }
1.1.1.3 ! root 1888:
! 1889: return start;
1.1 root 1890: }
1891:
1892: /* Compare the instructions before insn E1 with those before E2
1893: to find an opportunity for cross jumping.
1894: (This means detecting identical sequences of insns followed by
1895: jumps to the same place, or followed by a label and a jump
1896: to that label, and replacing one with a jump to the other.)
1897:
1898: Assume E1 is a jump that jumps to label E2
1899: (that is not always true but it might as well be).
1900: Find the longest possible equivalent sequences
1901: and store the first insns of those sequences into *F1 and *F2.
1902: Store zero there if no equivalent preceding instructions are found.
1903:
1904: We give up if we find a label in stream 1.
1905: Actually we could transfer that label into stream 2. */
1906:
1907: static void
1908: find_cross_jump (e1, e2, minimum, f1, f2)
1909: rtx e1, e2;
1910: int minimum;
1911: rtx *f1, *f2;
1912: {
1913: register rtx i1 = e1, i2 = e2;
1914: register rtx p1, p2;
1915: int lose = 0;
1916:
1917: rtx last1 = 0, last2 = 0;
1918: rtx afterlast1 = 0, afterlast2 = 0;
1919: rtx prev1;
1920:
1921: *f1 = 0;
1922: *f2 = 0;
1923:
1924: while (1)
1925: {
1926: i1 = prev_nonnote_insn (i1);
1927:
1928: i2 = PREV_INSN (i2);
1929: while (i2 && (GET_CODE (i2) == NOTE || GET_CODE (i2) == CODE_LABEL))
1930: i2 = PREV_INSN (i2);
1931:
1932: if (i1 == 0)
1933: break;
1934:
1935: /* Don't allow the range of insns preceding E1 or E2
1936: to include the other (E2 or E1). */
1937: if (i2 == e1 || i1 == e2)
1938: break;
1939:
1940: /* If we will get to this code by jumping, those jumps will be
1941: tensioned to go directly to the new label (before I2),
1942: so this cross-jumping won't cost extra. So reduce the minimum. */
1943: if (GET_CODE (i1) == CODE_LABEL)
1944: {
1945: --minimum;
1946: break;
1947: }
1948:
1949: if (i2 == 0 || GET_CODE (i1) != GET_CODE (i2))
1950: break;
1951:
1952: p1 = PATTERN (i1);
1953: p2 = PATTERN (i2);
1954:
1955: #ifdef STACK_REGS
1956: /* If cross_jump_death_matters is not 0, the insn's mode
1957: indicates whether or not the insn contains any stack-like
1958: regs. */
1959:
1960: if (cross_jump_death_matters && GET_MODE (i1) == QImode)
1961: {
1962: /* If register stack conversion has already been done, then
1963: death notes must also be compared before it is certain that
1964: the two instruction streams match. */
1965:
1966: rtx note;
1967: HARD_REG_SET i1_regset, i2_regset;
1968:
1969: CLEAR_HARD_REG_SET (i1_regset);
1970: CLEAR_HARD_REG_SET (i2_regset);
1971:
1972: for (note = REG_NOTES (i1); note; note = XEXP (note, 1))
1973: if (REG_NOTE_KIND (note) == REG_DEAD
1974: && STACK_REG_P (XEXP (note, 0)))
1975: SET_HARD_REG_BIT (i1_regset, REGNO (XEXP (note, 0)));
1976:
1977: for (note = REG_NOTES (i2); note; note = XEXP (note, 1))
1978: if (REG_NOTE_KIND (note) == REG_DEAD
1979: && STACK_REG_P (XEXP (note, 0)))
1980: SET_HARD_REG_BIT (i2_regset, REGNO (XEXP (note, 0)));
1981:
1982: GO_IF_HARD_REG_EQUAL (i1_regset, i2_regset, done);
1983:
1984: lose = 1;
1985:
1986: done:
1987: ;
1988: }
1989: #endif
1990:
1991: if (lose || GET_CODE (p1) != GET_CODE (p2)
1992: || ! rtx_renumbered_equal_p (p1, p2))
1993: {
1994: /* The following code helps take care of G++ cleanups. */
1995: rtx equiv1;
1996: rtx equiv2;
1997:
1998: if (!lose && GET_CODE (p1) == GET_CODE (p2)
1999: && ((equiv1 = find_reg_note (i1, REG_EQUAL, 0)) != 0
2000: || (equiv1 = find_reg_note (i1, REG_EQUIV, 0)) != 0)
2001: && ((equiv2 = find_reg_note (i2, REG_EQUAL, 0)) != 0
2002: || (equiv2 = find_reg_note (i2, REG_EQUIV, 0)) != 0)
2003: /* If the equivalences are not to a constant, they may
2004: reference pseudos that no longer exist, so we can't
2005: use them. */
2006: && CONSTANT_P (XEXP (equiv1, 0))
2007: && rtx_equal_p (XEXP (equiv1, 0), XEXP (equiv2, 0)))
2008: {
2009: rtx s1 = single_set (i1);
2010: rtx s2 = single_set (i2);
2011: if (s1 != 0 && s2 != 0
2012: && rtx_renumbered_equal_p (SET_DEST (s1), SET_DEST (s2)))
2013: {
2014: validate_change (i1, &SET_SRC (s1), XEXP (equiv1, 0), 1);
2015: validate_change (i2, &SET_SRC (s2), XEXP (equiv2, 0), 1);
2016: if (! rtx_renumbered_equal_p (p1, p2))
2017: cancel_changes (0);
2018: else if (apply_change_group ())
2019: goto win;
2020: }
2021: }
2022:
2023: /* Insns fail to match; cross jumping is limited to the following
2024: insns. */
2025:
2026: #ifdef HAVE_cc0
2027: /* Don't allow the insn after a compare to be shared by
2028: cross-jumping unless the compare is also shared.
2029: Here, if either of these non-matching insns is a compare,
2030: exclude the following insn from possible cross-jumping. */
2031: if (sets_cc0_p (p1) || sets_cc0_p (p2))
2032: last1 = afterlast1, last2 = afterlast2, ++minimum;
2033: #endif
2034:
2035: /* If cross-jumping here will feed a jump-around-jump
2036: optimization, this jump won't cost extra, so reduce
2037: the minimum. */
2038: if (GET_CODE (i1) == JUMP_INSN
2039: && JUMP_LABEL (i1)
2040: && prev_real_insn (JUMP_LABEL (i1)) == e1)
2041: --minimum;
2042: break;
2043: }
2044:
2045: win:
2046: if (GET_CODE (p1) != USE && GET_CODE (p1) != CLOBBER)
2047: {
2048: /* Ok, this insn is potentially includable in a cross-jump here. */
2049: afterlast1 = last1, afterlast2 = last2;
2050: last1 = i1, last2 = i2, --minimum;
2051: }
2052: }
2053:
2054: /* We have to be careful that we do not cross-jump into the middle of
2055: USE-CALL_INSN-CLOBBER sequence. This sequence is used instead of
2056: putting the USE and CLOBBERs inside the CALL_INSN. The delay slot
2057: scheduler needs to know what registers are used and modified by the
2058: CALL_INSN and needs the adjacent USE and CLOBBERs to do so.
2059:
2060: ??? At some point we should probably change this so that these are
2061: part of the CALL_INSN. The way we are doing it now is a kludge that
2062: is now causing trouble. */
2063:
2064: if (last1 != 0 && GET_CODE (last1) == CALL_INSN
2065: && (prev1 = prev_nonnote_insn (last1))
2066: && GET_CODE (prev1) == INSN
2067: && GET_CODE (PATTERN (prev1)) == USE)
2068: {
2069: /* Remove this CALL_INSN from the range we can cross-jump. */
2070: last1 = next_real_insn (last1);
2071: last2 = next_real_insn (last2);
2072:
2073: minimum++;
2074: }
2075:
2076: /* Skip past CLOBBERS since they may be right after a CALL_INSN. It
2077: isn't worth checking for the CALL_INSN. */
2078: while (last1 != 0 && GET_CODE (PATTERN (last1)) == CLOBBER)
2079: last1 = next_real_insn (last1), last2 = next_real_insn (last2);
2080:
2081: if (minimum <= 0 && last1 != 0 && last1 != e1)
2082: *f1 = last1, *f2 = last2;
2083: }
2084:
2085: static void
2086: do_cross_jump (insn, newjpos, newlpos)
2087: rtx insn, newjpos, newlpos;
2088: {
2089: /* Find an existing label at this point
2090: or make a new one if there is none. */
2091: register rtx label = get_label_before (newlpos);
2092:
2093: /* Make the same jump insn jump to the new point. */
2094: if (GET_CODE (PATTERN (insn)) == RETURN)
2095: {
2096: /* Remove from jump chain of returns. */
2097: delete_from_jump_chain (insn);
2098: /* Change the insn. */
2099: PATTERN (insn) = gen_jump (label);
2100: INSN_CODE (insn) = -1;
2101: JUMP_LABEL (insn) = label;
2102: LABEL_NUSES (label)++;
2103: /* Add to new the jump chain. */
2104: if (INSN_UID (label) < max_jump_chain
2105: && INSN_UID (insn) < max_jump_chain)
2106: {
2107: jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (label)];
2108: jump_chain[INSN_UID (label)] = insn;
2109: }
2110: }
2111: else
2112: redirect_jump (insn, label);
2113:
2114: /* Delete the matching insns before the jump. Also, remove any REG_EQUAL
2115: or REG_EQUIV note in the NEWLPOS stream that isn't also present in
2116: the NEWJPOS stream. */
2117:
2118: while (newjpos != insn)
2119: {
2120: rtx lnote;
2121:
2122: for (lnote = REG_NOTES (newlpos); lnote; lnote = XEXP (lnote, 1))
2123: if ((REG_NOTE_KIND (lnote) == REG_EQUAL
2124: || REG_NOTE_KIND (lnote) == REG_EQUIV)
2125: && ! find_reg_note (newjpos, REG_EQUAL, XEXP (lnote, 0))
2126: && ! find_reg_note (newjpos, REG_EQUIV, XEXP (lnote, 0)))
2127: remove_note (newlpos, lnote);
2128:
2129: delete_insn (newjpos);
2130: newjpos = next_real_insn (newjpos);
2131: newlpos = next_real_insn (newlpos);
2132: }
2133: }
2134:
2135: /* Return the label before INSN, or put a new label there. */
2136:
2137: rtx
2138: get_label_before (insn)
2139: rtx insn;
2140: {
2141: rtx label;
2142:
2143: /* Find an existing label at this point
2144: or make a new one if there is none. */
2145: label = prev_nonnote_insn (insn);
2146:
2147: if (label == 0 || GET_CODE (label) != CODE_LABEL)
2148: {
2149: rtx prev = PREV_INSN (insn);
2150:
1.1.1.3 ! root 2151: /* Don't put a label between a CALL_INSN and USE insns that precede
1.1 root 2152: it. */
2153:
2154: if (GET_CODE (insn) == CALL_INSN
2155: || (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE
2156: && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
2157: while (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == USE)
2158: prev = PREV_INSN (prev);
2159:
2160: label = gen_label_rtx ();
2161: emit_label_after (label, prev);
2162: LABEL_NUSES (label) = 0;
2163: }
2164: return label;
2165: }
2166:
2167: /* Return the label after INSN, or put a new label there. */
2168:
2169: rtx
2170: get_label_after (insn)
2171: rtx insn;
2172: {
2173: rtx label;
2174:
2175: /* Find an existing label at this point
2176: or make a new one if there is none. */
2177: label = next_nonnote_insn (insn);
2178:
2179: if (label == 0 || GET_CODE (label) != CODE_LABEL)
2180: {
2181: /* Don't put a label between a CALL_INSN and CLOBBER insns
2182: following it. */
2183:
2184: if (GET_CODE (insn) == CALL_INSN
2185: || (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE
2186: && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN))
2187: while (GET_CODE (NEXT_INSN (insn)) == INSN
2188: && GET_CODE (PATTERN (NEXT_INSN (insn))) == CLOBBER)
2189: insn = NEXT_INSN (insn);
2190:
2191: label = gen_label_rtx ();
2192: emit_label_after (label, insn);
2193: LABEL_NUSES (label) = 0;
2194: }
2195: return label;
2196: }
2197:
2198: /* Return 1 if INSN is a jump that jumps to right after TARGET
2199: only on the condition that TARGET itself would drop through.
2200: Assumes that TARGET is a conditional jump. */
2201:
2202: static int
2203: jump_back_p (insn, target)
2204: rtx insn, target;
2205: {
2206: rtx cinsn, ctarget;
2207: enum rtx_code codei, codet;
2208:
2209: if (simplejump_p (insn) || ! condjump_p (insn)
2210: || simplejump_p (target)
2211: || target != prev_real_insn (JUMP_LABEL (insn)))
2212: return 0;
2213:
2214: cinsn = XEXP (SET_SRC (PATTERN (insn)), 0);
2215: ctarget = XEXP (SET_SRC (PATTERN (target)), 0);
2216:
2217: codei = GET_CODE (cinsn);
2218: codet = GET_CODE (ctarget);
2219:
2220: if (XEXP (SET_SRC (PATTERN (insn)), 1) == pc_rtx)
2221: {
2222: if (! can_reverse_comparison_p (cinsn, insn))
2223: return 0;
2224: codei = reverse_condition (codei);
2225: }
2226:
2227: if (XEXP (SET_SRC (PATTERN (target)), 2) == pc_rtx)
2228: {
2229: if (! can_reverse_comparison_p (ctarget, target))
2230: return 0;
2231: codet = reverse_condition (codet);
2232: }
2233:
2234: return (codei == codet
2235: && rtx_renumbered_equal_p (XEXP (cinsn, 0), XEXP (ctarget, 0))
2236: && rtx_renumbered_equal_p (XEXP (cinsn, 1), XEXP (ctarget, 1)));
2237: }
2238:
2239: /* Given a comparison, COMPARISON, inside a conditional jump insn, INSN,
2240: return non-zero if it is safe to reverse this comparison. It is if our
2241: floating-point is not IEEE, if this is an NE or EQ comparison, or if
2242: this is known to be an integer comparison. */
2243:
2244: int
2245: can_reverse_comparison_p (comparison, insn)
2246: rtx comparison;
2247: rtx insn;
2248: {
2249: rtx arg0;
2250:
2251: /* If this is not actually a comparison, we can't reverse it. */
2252: if (GET_RTX_CLASS (GET_CODE (comparison)) != '<')
2253: return 0;
2254:
2255: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
2256: /* If this is an NE comparison, it is safe to reverse it to an EQ
2257: comparison and vice versa, even for floating point. If no operands
2258: are NaNs, the reversal is valid. If some operand is a NaN, EQ is
2259: always false and NE is always true, so the reversal is also valid. */
2260: || GET_CODE (comparison) == NE
2261: || GET_CODE (comparison) == EQ)
2262: return 1;
2263:
2264: arg0 = XEXP (comparison, 0);
2265:
2266: /* Make sure ARG0 is one of the actual objects being compared. If we
2267: can't do this, we can't be sure the comparison can be reversed.
2268:
2269: Handle cc0 and a MODE_CC register. */
2270: if ((GET_CODE (arg0) == REG && GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC)
2271: #ifdef HAVE_cc0
2272: || arg0 == cc0_rtx
2273: #endif
2274: )
2275: {
2276: rtx prev = prev_nonnote_insn (insn);
2277: rtx set = single_set (prev);
2278:
2279: if (set == 0 || SET_DEST (set) != arg0)
2280: return 0;
2281:
2282: arg0 = SET_SRC (set);
2283:
2284: if (GET_CODE (arg0) == COMPARE)
2285: arg0 = XEXP (arg0, 0);
2286: }
2287:
2288: /* We can reverse this if ARG0 is a CONST_INT or if its mode is
2289: not VOIDmode and neither a MODE_CC nor MODE_FLOAT type. */
2290: return (GET_CODE (arg0) == CONST_INT
2291: || (GET_MODE (arg0) != VOIDmode
2292: && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_CC
2293: && GET_MODE_CLASS (GET_MODE (arg0)) != MODE_FLOAT));
2294: }
2295:
2296: /* Given an rtx-code for a comparison, return the code
2297: for the negated comparison.
2298: WATCH OUT! reverse_condition is not safe to use on a jump
2299: that might be acting on the results of an IEEE floating point comparison,
2300: because of the special treatment of non-signaling nans in comparisons.
2301: Use can_reverse_comparison_p to be sure. */
2302:
2303: enum rtx_code
2304: reverse_condition (code)
2305: enum rtx_code code;
2306: {
2307: switch (code)
2308: {
2309: case EQ:
2310: return NE;
2311:
2312: case NE:
2313: return EQ;
2314:
2315: case GT:
2316: return LE;
2317:
2318: case GE:
2319: return LT;
2320:
2321: case LT:
2322: return GE;
2323:
2324: case LE:
2325: return GT;
2326:
2327: case GTU:
2328: return LEU;
2329:
2330: case GEU:
2331: return LTU;
2332:
2333: case LTU:
2334: return GEU;
2335:
2336: case LEU:
2337: return GTU;
2338:
2339: default:
2340: abort ();
2341: return UNKNOWN;
2342: }
2343: }
2344:
2345: /* Similar, but return the code when two operands of a comparison are swapped.
2346: This IS safe for IEEE floating-point. */
2347:
2348: enum rtx_code
2349: swap_condition (code)
2350: enum rtx_code code;
2351: {
2352: switch (code)
2353: {
2354: case EQ:
2355: case NE:
2356: return code;
2357:
2358: case GT:
2359: return LT;
2360:
2361: case GE:
2362: return LE;
2363:
2364: case LT:
2365: return GT;
2366:
2367: case LE:
2368: return GE;
2369:
2370: case GTU:
2371: return LTU;
2372:
2373: case GEU:
2374: return LEU;
2375:
2376: case LTU:
2377: return GTU;
2378:
2379: case LEU:
2380: return GEU;
2381:
2382: default:
2383: abort ();
2384: return UNKNOWN;
2385: }
2386: }
2387:
2388: /* Given a comparison CODE, return the corresponding unsigned comparison.
2389: If CODE is an equality comparison or already an unsigned comparison,
2390: CODE is returned. */
2391:
2392: enum rtx_code
2393: unsigned_condition (code)
2394: enum rtx_code code;
2395: {
2396: switch (code)
2397: {
2398: case EQ:
2399: case NE:
2400: case GTU:
2401: case GEU:
2402: case LTU:
2403: case LEU:
2404: return code;
2405:
2406: case GT:
2407: return GTU;
2408:
2409: case GE:
2410: return GEU;
2411:
2412: case LT:
2413: return LTU;
2414:
2415: case LE:
2416: return LEU;
2417:
2418: default:
2419: abort ();
2420: }
2421: }
2422:
2423: /* Similarly, return the signed version of a comparison. */
2424:
2425: enum rtx_code
2426: signed_condition (code)
2427: enum rtx_code code;
2428: {
2429: switch (code)
2430: {
2431: case EQ:
2432: case NE:
2433: case GT:
2434: case GE:
2435: case LT:
2436: case LE:
2437: return code;
2438:
2439: case GTU:
2440: return GT;
2441:
2442: case GEU:
2443: return GE;
2444:
2445: case LTU:
2446: return LT;
2447:
2448: case LEU:
2449: return LE;
2450:
2451: default:
2452: abort ();
2453: }
2454: }
2455:
2456: /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
2457: truth of CODE1 implies the truth of CODE2. */
2458:
2459: int
2460: comparison_dominates_p (code1, code2)
2461: enum rtx_code code1, code2;
2462: {
2463: if (code1 == code2)
2464: return 1;
2465:
2466: switch (code1)
2467: {
2468: case EQ:
2469: if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU)
2470: return 1;
2471: break;
2472:
2473: case LT:
2474: if (code2 == LE)
2475: return 1;
2476: break;
2477:
2478: case GT:
2479: if (code2 == GE)
2480: return 1;
2481: break;
2482:
2483: case LTU:
2484: if (code2 == LEU)
2485: return 1;
2486: break;
2487:
2488: case GTU:
2489: if (code2 == GEU)
2490: return 1;
2491: break;
2492: }
2493:
2494: return 0;
2495: }
2496:
2497: /* Return 1 if INSN is an unconditional jump and nothing else. */
2498:
2499: int
2500: simplejump_p (insn)
2501: rtx insn;
2502: {
2503: return (GET_CODE (insn) == JUMP_INSN
2504: && GET_CODE (PATTERN (insn)) == SET
2505: && GET_CODE (SET_DEST (PATTERN (insn))) == PC
2506: && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
2507: }
2508:
2509: /* Return nonzero if INSN is a (possibly) conditional jump
2510: and nothing more. */
2511:
2512: int
2513: condjump_p (insn)
2514: rtx insn;
2515: {
2516: register rtx x = PATTERN (insn);
2517: if (GET_CODE (x) != SET)
2518: return 0;
2519: if (GET_CODE (SET_DEST (x)) != PC)
2520: return 0;
2521: if (GET_CODE (SET_SRC (x)) == LABEL_REF)
2522: return 1;
2523: if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
2524: return 0;
2525: if (XEXP (SET_SRC (x), 2) == pc_rtx
2526: && (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
2527: || GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
2528: return 1;
2529: if (XEXP (SET_SRC (x), 1) == pc_rtx
2530: && (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
2531: || GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
2532: return 1;
2533: return 0;
2534: }
2535:
2536: /* Return 1 if X is an RTX that does nothing but set the condition codes
2537: and CLOBBER or USE registers.
2538: Return -1 if X does explicitly set the condition codes,
2539: but also does other things. */
2540:
2541: int
2542: sets_cc0_p (x)
2543: rtx x;
2544: {
2545: #ifdef HAVE_cc0
2546: if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
2547: return 1;
2548: if (GET_CODE (x) == PARALLEL)
2549: {
2550: int i;
2551: int sets_cc0 = 0;
2552: int other_things = 0;
2553: for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
2554: {
2555: if (GET_CODE (XVECEXP (x, 0, i)) == SET
2556: && SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
2557: sets_cc0 = 1;
2558: else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
2559: other_things = 1;
2560: }
2561: return ! sets_cc0 ? 0 : other_things ? -1 : 1;
2562: }
2563: return 0;
2564: #else
2565: abort ();
2566: #endif
2567: }
2568:
2569: /* Follow any unconditional jump at LABEL;
2570: return the ultimate label reached by any such chain of jumps.
2571: If LABEL is not followed by a jump, return LABEL.
2572: If the chain loops or we can't find end, return LABEL,
2573: since that tells caller to avoid changing the insn.
2574:
2575: If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
2576: a USE or CLOBBER. */
2577:
2578: rtx
2579: follow_jumps (label)
2580: rtx label;
2581: {
2582: register rtx insn;
2583: register rtx next;
2584: register rtx value = label;
2585: register int depth;
2586:
2587: for (depth = 0;
2588: (depth < 10
2589: && (insn = next_active_insn (value)) != 0
2590: && GET_CODE (insn) == JUMP_INSN
2591: && (JUMP_LABEL (insn) != 0 || GET_CODE (PATTERN (insn)) == RETURN)
2592: && (next = NEXT_INSN (insn))
2593: && GET_CODE (next) == BARRIER);
2594: depth++)
2595: {
2596: /* Don't chain through the insn that jumps into a loop
2597: from outside the loop,
2598: since that would create multiple loop entry jumps
2599: and prevent loop optimization. */
2600: rtx tem;
2601: if (!reload_completed)
2602: for (tem = value; tem != insn; tem = NEXT_INSN (tem))
2603: if (GET_CODE (tem) == NOTE
2604: && NOTE_LINE_NUMBER (tem) == NOTE_INSN_LOOP_BEG)
2605: return value;
2606:
2607: /* If we have found a cycle, make the insn jump to itself. */
2608: if (JUMP_LABEL (insn) == label)
2609: return label;
2610: value = JUMP_LABEL (insn);
2611: }
2612: if (depth == 10)
2613: return label;
2614: return value;
2615: }
2616:
2617: /* Assuming that field IDX of X is a vector of label_refs,
2618: replace each of them by the ultimate label reached by it.
2619: Return nonzero if a change is made.
2620: If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG. */
2621:
2622: static int
2623: tension_vector_labels (x, idx)
2624: register rtx x;
2625: register int idx;
2626: {
2627: int changed = 0;
2628: register int i;
2629: for (i = XVECLEN (x, idx) - 1; i >= 0; i--)
2630: {
2631: register rtx olabel = XEXP (XVECEXP (x, idx, i), 0);
2632: register rtx nlabel = follow_jumps (olabel);
2633: if (nlabel && nlabel != olabel)
2634: {
2635: XEXP (XVECEXP (x, idx, i), 0) = nlabel;
2636: ++LABEL_NUSES (nlabel);
2637: if (--LABEL_NUSES (olabel) == 0)
2638: delete_insn (olabel);
2639: changed = 1;
2640: }
2641: }
2642: return changed;
2643: }
2644:
2645: /* Find all CODE_LABELs referred to in X, and increment their use counts.
2646: If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
2647: in INSN, then store one of them in JUMP_LABEL (INSN).
2648: If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
2649: referenced in INSN, add a REG_LABEL note containing that label to INSN.
2650: Also, when there are consecutive labels, canonicalize on the last of them.
2651:
2652: Note that two labels separated by a loop-beginning note
2653: must be kept distinct if we have not yet done loop-optimization,
2654: because the gap between them is where loop-optimize
2655: will want to move invariant code to. CROSS_JUMP tells us
2656: that loop-optimization is done with.
2657:
2658: Once reload has completed (CROSS_JUMP non-zero), we need not consider
2659: two labels distinct if they are separated by only USE or CLOBBER insns. */
2660:
2661: static void
2662: mark_jump_label (x, insn, cross_jump)
2663: register rtx x;
2664: rtx insn;
2665: int cross_jump;
2666: {
2667: register RTX_CODE code = GET_CODE (x);
2668: register int i;
2669: register char *fmt;
2670:
2671: switch (code)
2672: {
2673: case PC:
2674: case CC0:
2675: case REG:
2676: case SUBREG:
2677: case CONST_INT:
2678: case SYMBOL_REF:
2679: case CONST_DOUBLE:
2680: case CLOBBER:
2681: case CALL:
2682: return;
2683:
1.1.1.3 ! root 2684: case MEM:
! 2685: /* If this is a constant-pool reference, see if it is a label. */
! 2686: if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
! 2687: && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
! 2688: mark_jump_label (get_pool_constant (XEXP (x, 0)), insn, cross_jump);
! 2689: break;
! 2690:
1.1 root 2691: case LABEL_REF:
2692: {
2693: register rtx label = XEXP (x, 0);
2694: register rtx next;
2695: if (GET_CODE (label) != CODE_LABEL)
2696: abort ();
2697: /* If there are other labels following this one,
2698: replace it with the last of the consecutive labels. */
2699: for (next = NEXT_INSN (label); next; next = NEXT_INSN (next))
2700: {
2701: if (GET_CODE (next) == CODE_LABEL)
2702: label = next;
2703: else if (cross_jump && GET_CODE (next) == INSN
2704: && (GET_CODE (PATTERN (next)) == USE
2705: || GET_CODE (PATTERN (next)) == CLOBBER))
2706: continue;
2707: else if (GET_CODE (next) != NOTE)
2708: break;
2709: else if (! cross_jump
2710: && (NOTE_LINE_NUMBER (next) == NOTE_INSN_LOOP_BEG
2711: || NOTE_LINE_NUMBER (next) == NOTE_INSN_FUNCTION_END))
2712: break;
2713: }
2714: XEXP (x, 0) = label;
2715: ++LABEL_NUSES (label);
2716: if (insn)
2717: {
2718: if (GET_CODE (insn) == JUMP_INSN)
2719: JUMP_LABEL (insn) = label;
1.1.1.2 root 2720: else if (! find_reg_note (insn, REG_LABEL, label))
1.1 root 2721: {
2722: rtx next = next_real_insn (label);
2723: /* Don't record labels that refer to dispatch tables.
2724: This is not necessary, since the tablejump
2725: references the same label.
2726: And if we did record them, flow.c would make worse code. */
2727: if (next == 0
2728: || ! (GET_CODE (next) == JUMP_INSN
2729: && (GET_CODE (PATTERN (next)) == ADDR_VEC
2730: || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC)))
2731: REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_LABEL, label,
2732: REG_NOTES (insn));
2733: }
2734: }
2735: return;
2736: }
2737:
2738: /* Do walk the labels in a vector, but not the first operand of an
2739: ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
2740: case ADDR_VEC:
2741: case ADDR_DIFF_VEC:
2742: {
2743: int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
2744:
2745: for (i = 0; i < XVECLEN (x, eltnum); i++)
2746: mark_jump_label (XVECEXP (x, eltnum, i), 0, cross_jump);
2747: return;
2748: }
2749: }
2750:
2751: fmt = GET_RTX_FORMAT (code);
2752: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2753: {
2754: if (fmt[i] == 'e')
2755: mark_jump_label (XEXP (x, i), insn, cross_jump);
2756: else if (fmt[i] == 'E')
2757: {
2758: register int j;
2759: for (j = 0; j < XVECLEN (x, i); j++)
2760: mark_jump_label (XVECEXP (x, i, j), insn, cross_jump);
2761: }
2762: }
2763: }
2764:
2765: /* If all INSN does is set the pc, delete it,
2766: and delete the insn that set the condition codes for it
2767: if that's what the previous thing was. */
2768:
2769: void
2770: delete_jump (insn)
2771: rtx insn;
2772: {
2773: register rtx x = PATTERN (insn);
2774: register rtx prev;
2775:
2776: if (GET_CODE (x) == SET
2777: && GET_CODE (SET_DEST (x)) == PC)
2778: {
2779: prev = prev_nonnote_insn (insn);
2780: #ifdef HAVE_cc0
2781: /* We assume that at this stage
2782: CC's are always set explicitly
2783: and always immediately before the jump that
2784: will use them. So if the previous insn
2785: exists to set the CC's, delete it
2786: (unless it performs auto-increments, etc.). */
2787: if (prev && GET_CODE (prev) == INSN
2788: && sets_cc0_p (PATTERN (prev)))
2789: {
2790: if (sets_cc0_p (PATTERN (prev)) > 0
2791: && !FIND_REG_INC_NOTE (prev, 0))
2792: delete_insn (prev);
2793: else
2794: /* Otherwise, show that cc0 won't be used. */
2795: REG_NOTES (prev) = gen_rtx (EXPR_LIST, REG_UNUSED,
2796: cc0_rtx, REG_NOTES (prev));
2797: }
2798: #else
2799: {
2800: rtx note;
2801:
2802: /* If we are running before flow.c, we need do nothing since flow.c
2803: will delete the set of the condition code if it is dead. We also
2804: can't know if the register being used as the condition code is
2805: dead or not at this point.
2806:
2807: Otherwise, look at all our REG_DEAD notes. If a previous insn
2808: does nothing other than set a register that dies in this jump,
2809: we can delete the insn. */
2810:
2811: for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2812: {
2813: rtx our_prev;
2814:
2815: if (REG_NOTE_KIND (note) != REG_DEAD
2816: /* Verify that the REG_NOTE has a legal value. */
2817: || GET_CODE (XEXP (note, 0)) != REG)
2818: continue;
2819:
2820: for (our_prev = prev_nonnote_insn (insn);
2821: our_prev && GET_CODE (our_prev) == INSN;
2822: our_prev = prev_nonnote_insn (our_prev))
2823: {
2824: /* If we reach a SEQUENCE, it is too complex to try to
2825: do anything with it, so give up. */
2826: if (GET_CODE (PATTERN (our_prev)) == SEQUENCE)
2827: break;
2828:
2829: if (GET_CODE (PATTERN (our_prev)) == USE
2830: && GET_CODE (XEXP (PATTERN (our_prev), 0)) == INSN)
2831: /* reorg creates USEs that look like this. We leave them
2832: alone because reorg needs them for its own purposes. */
2833: break;
2834:
2835: if (reg_set_p (XEXP (note, 0), PATTERN (our_prev)))
2836: {
2837: if (FIND_REG_INC_NOTE (our_prev, 0))
2838: break;
2839:
2840: if (GET_CODE (PATTERN (our_prev)) == PARALLEL)
2841: {
2842: /* If we find a SET of something else, we can't
2843: delete the insn. */
2844:
2845: int i;
2846:
2847: for (i = 0; i < XVECLEN (PATTERN (our_prev), 0); i++)
2848: {
2849: rtx part = XVECEXP (PATTERN (our_prev), 0, i);
2850:
2851: if (GET_CODE (part) == SET
2852: && SET_DEST (part) != XEXP (note, 0))
2853: break;
2854: }
2855:
2856: if (i == XVECLEN (PATTERN (our_prev), 0))
2857: delete_insn (our_prev);
2858: }
2859: else if (GET_CODE (PATTERN (our_prev)) == SET
2860: && SET_DEST (PATTERN (our_prev)) == XEXP (note, 0))
2861: delete_insn (our_prev);
2862:
2863: break;
2864: }
2865:
2866: /* If OUR_PREV references the register that dies here,
2867: it is an additional use. Hence any prior SET isn't
2868: dead. */
2869: if (reg_overlap_mentioned_p (XEXP (note, 0),
2870: PATTERN (our_prev)))
2871: break;
2872: }
2873: }
2874: }
2875: #endif
2876: /* Now delete the jump insn itself. */
2877: delete_insn (insn);
2878: }
2879: }
2880:
2881: /* Delete insn INSN from the chain of insns and update label ref counts.
2882: May delete some following insns as a consequence; may even delete
2883: a label elsewhere and insns that follow it.
2884:
2885: Returns the first insn after INSN that was not deleted. */
2886:
2887: rtx
2888: delete_insn (insn)
2889: register rtx insn;
2890: {
2891: register rtx next = NEXT_INSN (insn);
2892: register rtx prev = PREV_INSN (insn);
2893:
2894: while (next && INSN_DELETED_P (next))
2895: next = NEXT_INSN (next);
2896:
2897: /* This insn is already deleted => return first following nondeleted. */
2898: if (INSN_DELETED_P (insn))
2899: return next;
2900:
2901: /* Mark this insn as deleted. */
2902:
2903: INSN_DELETED_P (insn) = 1;
2904:
2905: /* If this is an unconditional jump, delete it from the jump chain. */
2906: if (simplejump_p (insn))
2907: delete_from_jump_chain (insn);
2908:
2909: /* If instruction is followed by a barrier,
2910: delete the barrier too. */
2911:
2912: if (next != 0 && GET_CODE (next) == BARRIER)
2913: {
2914: INSN_DELETED_P (next) = 1;
2915: next = NEXT_INSN (next);
2916: }
2917:
2918: /* Patch out INSN (and the barrier if any) */
2919:
2920: if (optimize)
2921: {
2922: if (prev)
2923: {
2924: NEXT_INSN (prev) = next;
2925: if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
2926: NEXT_INSN (XVECEXP (PATTERN (prev), 0,
2927: XVECLEN (PATTERN (prev), 0) - 1)) = next;
2928: }
2929:
2930: if (next)
2931: {
2932: PREV_INSN (next) = prev;
2933: if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
2934: PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
2935: }
2936:
2937: if (prev && NEXT_INSN (prev) == 0)
2938: set_last_insn (prev);
2939: }
2940:
2941: /* If deleting a jump, decrement the count of the label,
2942: and delete the label if it is now unused. */
2943:
2944: if (GET_CODE (insn) == JUMP_INSN && JUMP_LABEL (insn))
2945: if (--LABEL_NUSES (JUMP_LABEL (insn)) == 0)
2946: {
2947: /* This can delete NEXT or PREV,
2948: either directly if NEXT is JUMP_LABEL (INSN),
2949: or indirectly through more levels of jumps. */
2950: delete_insn (JUMP_LABEL (insn));
2951: /* I feel a little doubtful about this loop,
2952: but I see no clean and sure alternative way
2953: to find the first insn after INSN that is not now deleted.
2954: I hope this works. */
2955: while (next && INSN_DELETED_P (next))
2956: next = NEXT_INSN (next);
2957: return next;
2958: }
2959:
2960: while (prev && (INSN_DELETED_P (prev) || GET_CODE (prev) == NOTE))
2961: prev = PREV_INSN (prev);
2962:
2963: /* If INSN was a label and a dispatch table follows it,
2964: delete the dispatch table. The tablejump must have gone already.
2965: It isn't useful to fall through into a table. */
2966:
2967: if (GET_CODE (insn) == CODE_LABEL
2968: && NEXT_INSN (insn) != 0
2969: && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
2970: && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
2971: || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
2972: next = delete_insn (NEXT_INSN (insn));
2973:
2974: /* If INSN was a label, delete insns following it if now unreachable. */
2975:
2976: if (GET_CODE (insn) == CODE_LABEL && prev
2977: && GET_CODE (prev) == BARRIER)
2978: {
2979: register RTX_CODE code;
2980: while (next != 0
2981: && ((code = GET_CODE (next)) == INSN
2982: || code == JUMP_INSN || code == CALL_INSN
1.1.1.3 ! root 2983: || code == NOTE
! 2984: || (code == CODE_LABEL && INSN_DELETED_P (next))))
1.1 root 2985: {
2986: if (code == NOTE
2987: && NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
2988: next = NEXT_INSN (next);
1.1.1.3 ! root 2989: /* Keep going past other deleted labels to delete what follows. */
! 2990: else if (code == CODE_LABEL && INSN_DELETED_P (next))
! 2991: next = NEXT_INSN (next);
1.1 root 2992: else
2993: /* Note: if this deletes a jump, it can cause more
2994: deletion of unreachable code, after a different label.
2995: As long as the value from this recursive call is correct,
2996: this invocation functions correctly. */
2997: next = delete_insn (next);
2998: }
2999: }
3000:
3001: return next;
3002: }
3003:
3004: /* Advance from INSN till reaching something not deleted
3005: then return that. May return INSN itself. */
3006:
3007: rtx
3008: next_nondeleted_insn (insn)
3009: rtx insn;
3010: {
3011: while (INSN_DELETED_P (insn))
3012: insn = NEXT_INSN (insn);
3013: return insn;
3014: }
3015:
3016: /* Delete a range of insns from FROM to TO, inclusive.
3017: This is for the sake of peephole optimization, so assume
3018: that whatever these insns do will still be done by a new
3019: peephole insn that will replace them. */
3020:
3021: void
3022: delete_for_peephole (from, to)
3023: register rtx from, to;
3024: {
3025: register rtx insn = from;
3026:
3027: while (1)
3028: {
3029: register rtx next = NEXT_INSN (insn);
3030: register rtx prev = PREV_INSN (insn);
3031:
3032: if (GET_CODE (insn) != NOTE)
3033: {
3034: INSN_DELETED_P (insn) = 1;
3035:
3036: /* Patch this insn out of the chain. */
3037: /* We don't do this all at once, because we
3038: must preserve all NOTEs. */
3039: if (prev)
3040: NEXT_INSN (prev) = next;
3041:
3042: if (next)
3043: PREV_INSN (next) = prev;
3044: }
3045:
3046: if (insn == to)
3047: break;
3048: insn = next;
3049: }
3050:
3051: /* Note that if TO is an unconditional jump
3052: we *do not* delete the BARRIER that follows,
3053: since the peephole that replaces this sequence
3054: is also an unconditional jump in that case. */
3055: }
3056:
3057: /* Invert the condition of the jump JUMP, and make it jump
3058: to label NLABEL instead of where it jumps now. */
3059:
3060: int
3061: invert_jump (jump, nlabel)
3062: rtx jump, nlabel;
3063: {
3064: register rtx olabel = JUMP_LABEL (jump);
3065:
3066: /* We have to either invert the condition and change the label or
3067: do neither. Either operation could fail. We first try to invert
3068: the jump. If that succeeds, we try changing the label. If that fails,
3069: we invert the jump back to what it was. */
3070:
3071: if (! invert_exp (PATTERN (jump), jump))
3072: return 0;
3073:
3074: if (redirect_jump (jump, nlabel))
3075: return 1;
3076:
3077: if (! invert_exp (PATTERN (jump), jump))
3078: /* This should just be putting it back the way it was. */
3079: abort ();
3080:
3081: return 0;
3082: }
3083:
3084: /* Invert the jump condition of rtx X contained in jump insn, INSN.
3085:
3086: Return 1 if we can do so, 0 if we cannot find a way to do so that
3087: matches a pattern. */
3088:
3089: static int
3090: invert_exp (x, insn)
3091: rtx x;
3092: rtx insn;
3093: {
3094: register RTX_CODE code;
3095: register int i;
3096: register char *fmt;
3097:
3098: code = GET_CODE (x);
3099:
3100: if (code == IF_THEN_ELSE)
3101: {
3102: register rtx comp = XEXP (x, 0);
3103: register rtx tem;
3104:
3105: /* We can do this in two ways: The preferable way, which can only
3106: be done if this is not an integer comparison, is to reverse
3107: the comparison code. Otherwise, swap the THEN-part and ELSE-part
3108: of the IF_THEN_ELSE. If we can't do either, fail. */
3109:
3110: if (can_reverse_comparison_p (comp, insn)
3111: && validate_change (insn, &XEXP (x, 0),
3112: gen_rtx (reverse_condition (GET_CODE (comp)),
3113: GET_MODE (comp), XEXP (comp, 0),
3114: XEXP (comp, 1)), 0))
3115: return 1;
3116:
3117: tem = XEXP (x, 1);
3118: validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
3119: validate_change (insn, &XEXP (x, 2), tem, 1);
3120: return apply_change_group ();
3121: }
3122:
3123: fmt = GET_RTX_FORMAT (code);
3124: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3125: {
3126: if (fmt[i] == 'e')
3127: if (! invert_exp (XEXP (x, i), insn))
3128: return 0;
3129: if (fmt[i] == 'E')
3130: {
3131: register int j;
3132: for (j = 0; j < XVECLEN (x, i); j++)
3133: if (!invert_exp (XVECEXP (x, i, j), insn))
3134: return 0;
3135: }
3136: }
3137:
3138: return 1;
3139: }
3140:
3141: /* Make jump JUMP jump to label NLABEL instead of where it jumps now.
3142: If the old jump target label is unused as a result,
3143: it and the code following it may be deleted.
3144:
3145: If NLABEL is zero, we are to turn the jump into a (possibly conditional)
3146: RETURN insn.
3147:
3148: The return value will be 1 if the change was made, 0 if it wasn't (this
3149: can only occur for NLABEL == 0). */
3150:
3151: int
3152: redirect_jump (jump, nlabel)
3153: rtx jump, nlabel;
3154: {
3155: register rtx olabel = JUMP_LABEL (jump);
3156:
3157: if (nlabel == olabel)
3158: return 1;
3159:
3160: if (! redirect_exp (&PATTERN (jump), olabel, nlabel, jump))
3161: return 0;
3162:
3163: /* If this is an unconditional branch, delete it from the jump_chain of
3164: OLABEL and add it to the jump_chain of NLABEL (assuming both labels
3165: have UID's in range and JUMP_CHAIN is valid). */
3166: if (jump_chain && (simplejump_p (jump)
3167: || GET_CODE (PATTERN (jump)) == RETURN))
3168: {
3169: int label_index = nlabel ? INSN_UID (nlabel) : 0;
3170:
3171: delete_from_jump_chain (jump);
3172: if (label_index < max_jump_chain
3173: && INSN_UID (jump) < max_jump_chain)
3174: {
3175: jump_chain[INSN_UID (jump)] = jump_chain[label_index];
3176: jump_chain[label_index] = jump;
3177: }
3178: }
3179:
3180: JUMP_LABEL (jump) = nlabel;
3181: if (nlabel)
3182: ++LABEL_NUSES (nlabel);
3183:
3184: if (olabel && --LABEL_NUSES (olabel) == 0)
3185: delete_insn (olabel);
3186:
3187: return 1;
3188: }
3189:
3190: /* Delete the instruction JUMP from any jump chain it might be on. */
3191:
3192: static void
3193: delete_from_jump_chain (jump)
3194: rtx jump;
3195: {
3196: int index;
3197: rtx olabel = JUMP_LABEL (jump);
3198:
3199: /* Handle unconditional jumps. */
3200: if (jump_chain && olabel != 0
3201: && INSN_UID (olabel) < max_jump_chain
3202: && simplejump_p (jump))
3203: index = INSN_UID (olabel);
3204: /* Handle return insns. */
3205: else if (jump_chain && GET_CODE (PATTERN (jump)) == RETURN)
3206: index = 0;
3207: else return;
3208:
3209: if (jump_chain[index] == jump)
3210: jump_chain[index] = jump_chain[INSN_UID (jump)];
3211: else
3212: {
3213: rtx insn;
3214:
3215: for (insn = jump_chain[index];
3216: insn != 0;
3217: insn = jump_chain[INSN_UID (insn)])
3218: if (jump_chain[INSN_UID (insn)] == jump)
3219: {
3220: jump_chain[INSN_UID (insn)] = jump_chain[INSN_UID (jump)];
3221: break;
3222: }
3223: }
3224: }
3225:
3226: /* If NLABEL is nonzero, throughout the rtx at LOC,
3227: alter (LABEL_REF OLABEL) to (LABEL_REF NLABEL). If OLABEL is
3228: zero, alter (RETURN) to (LABEL_REF NLABEL).
3229:
3230: If NLABEL is zero, alter (LABEL_REF OLABEL) to (RETURN) and check
3231: validity with validate_change. Convert (set (pc) (label_ref olabel))
3232: to (return).
3233:
3234: Return 0 if we found a change we would like to make but it is invalid.
3235: Otherwise, return 1. */
3236:
3237: static int
3238: redirect_exp (loc, olabel, nlabel, insn)
3239: rtx *loc;
3240: rtx olabel, nlabel;
3241: rtx insn;
3242: {
3243: register rtx x = *loc;
3244: register RTX_CODE code = GET_CODE (x);
3245: register int i;
3246: register char *fmt;
3247:
3248: if (code == LABEL_REF)
3249: {
3250: if (XEXP (x, 0) == olabel)
3251: {
3252: if (nlabel)
3253: XEXP (x, 0) = nlabel;
3254: else
3255: return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0);
3256: return 1;
3257: }
3258: }
3259: else if (code == RETURN && olabel == 0)
3260: {
3261: x = gen_rtx (LABEL_REF, VOIDmode, nlabel);
3262: if (loc == &PATTERN (insn))
3263: x = gen_rtx (SET, VOIDmode, pc_rtx, x);
3264: return validate_change (insn, loc, x, 0);
3265: }
3266:
3267: if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
3268: && GET_CODE (SET_SRC (x)) == LABEL_REF
3269: && XEXP (SET_SRC (x), 0) == olabel)
3270: return validate_change (insn, loc, gen_rtx (RETURN, VOIDmode), 0);
3271:
3272: fmt = GET_RTX_FORMAT (code);
3273: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3274: {
3275: if (fmt[i] == 'e')
3276: if (! redirect_exp (&XEXP (x, i), olabel, nlabel, insn))
3277: return 0;
3278: if (fmt[i] == 'E')
3279: {
3280: register int j;
3281: for (j = 0; j < XVECLEN (x, i); j++)
3282: if (! redirect_exp (&XVECEXP (x, i, j), olabel, nlabel, insn))
3283: return 0;
3284: }
3285: }
3286:
3287: return 1;
3288: }
3289:
3290: /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
3291:
3292: If the old jump target label (before the dispatch table) becomes unused,
3293: it and the dispatch table may be deleted. In that case, find the insn
1.1.1.3 ! root 3294: before the jump references that label and delete it and logical successors
1.1 root 3295: too. */
3296:
3297: void
3298: redirect_tablejump (jump, nlabel)
3299: rtx jump, nlabel;
3300: {
3301: register rtx olabel = JUMP_LABEL (jump);
3302:
3303: /* Add this jump to the jump_chain of NLABEL. */
3304: if (jump_chain && INSN_UID (nlabel) < max_jump_chain
3305: && INSN_UID (jump) < max_jump_chain)
3306: {
3307: jump_chain[INSN_UID (jump)] = jump_chain[INSN_UID (nlabel)];
3308: jump_chain[INSN_UID (nlabel)] = jump;
3309: }
3310:
3311: PATTERN (jump) = gen_jump (nlabel);
3312: JUMP_LABEL (jump) = nlabel;
3313: ++LABEL_NUSES (nlabel);
3314: INSN_CODE (jump) = -1;
3315:
3316: if (--LABEL_NUSES (olabel) == 0)
3317: {
3318: delete_labelref_insn (jump, olabel, 0);
3319: delete_insn (olabel);
3320: }
3321: }
3322:
3323: /* Find the insn referencing LABEL that is a logical predecessor of INSN.
3324: If we found one, delete it and then delete this insn if DELETE_THIS is
3325: non-zero. Return non-zero if INSN or a predecessor references LABEL. */
3326:
3327: static int
3328: delete_labelref_insn (insn, label, delete_this)
3329: rtx insn, label;
3330: int delete_this;
3331: {
3332: int deleted = 0;
3333: rtx link;
3334:
3335: if (GET_CODE (insn) != NOTE
3336: && reg_mentioned_p (label, PATTERN (insn)))
3337: {
3338: if (delete_this)
3339: {
3340: delete_insn (insn);
3341: deleted = 1;
3342: }
3343: else
3344: return 1;
3345: }
3346:
3347: for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
3348: if (delete_labelref_insn (XEXP (link, 0), label, 1))
3349: {
3350: if (delete_this)
3351: {
3352: delete_insn (insn);
3353: deleted = 1;
3354: }
3355: else
3356: return 1;
3357: }
3358:
3359: return deleted;
3360: }
3361:
3362: /* Like rtx_equal_p except that it considers two REGs as equal
3363: if they renumber to the same value. */
3364:
3365: int
3366: rtx_renumbered_equal_p (x, y)
3367: rtx x, y;
3368: {
3369: register int i;
3370: register RTX_CODE code = GET_CODE (x);
3371: register char *fmt;
3372:
3373: if (x == y)
3374: return 1;
3375: if ((code == REG || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG))
3376: && (GET_CODE (y) == REG || (GET_CODE (y) == SUBREG
3377: && GET_CODE (SUBREG_REG (y)) == REG)))
3378: {
3379: register int j;
3380:
3381: if (GET_MODE (x) != GET_MODE (y))
3382: return 0;
3383:
3384: /* If we haven't done any renumbering, don't
3385: make any assumptions. */
3386: if (reg_renumber == 0)
3387: return rtx_equal_p (x, y);
3388:
3389: if (code == SUBREG)
3390: {
3391: i = REGNO (SUBREG_REG (x));
3392: if (reg_renumber[i] >= 0)
3393: i = reg_renumber[i];
3394: i += SUBREG_WORD (x);
3395: }
3396: else
3397: {
3398: i = REGNO (x);
3399: if (reg_renumber[i] >= 0)
3400: i = reg_renumber[i];
3401: }
3402: if (GET_CODE (y) == SUBREG)
3403: {
3404: j = REGNO (SUBREG_REG (y));
3405: if (reg_renumber[j] >= 0)
3406: j = reg_renumber[j];
3407: j += SUBREG_WORD (y);
3408: }
3409: else
3410: {
3411: j = REGNO (y);
3412: if (reg_renumber[j] >= 0)
3413: j = reg_renumber[j];
3414: }
3415: return i == j;
3416: }
3417: /* Now we have disposed of all the cases
3418: in which different rtx codes can match. */
3419: if (code != GET_CODE (y))
3420: return 0;
3421: switch (code)
3422: {
3423: case PC:
3424: case CC0:
3425: case ADDR_VEC:
3426: case ADDR_DIFF_VEC:
3427: return 0;
3428:
3429: case CONST_INT:
3430: return XINT (x, 0) == XINT (y, 0);
3431:
3432: case LABEL_REF:
3433: /* Two label-refs are equivalent if they point at labels
3434: in the same position in the instruction stream. */
3435: return (next_real_insn (XEXP (x, 0))
3436: == next_real_insn (XEXP (y, 0)));
3437:
3438: case SYMBOL_REF:
3439: return XSTR (x, 0) == XSTR (y, 0);
3440: }
3441:
3442: /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
3443:
3444: if (GET_MODE (x) != GET_MODE (y))
3445: return 0;
3446:
3447: /* Compare the elements. If any pair of corresponding elements
3448: fail to match, return 0 for the whole things. */
3449:
3450: fmt = GET_RTX_FORMAT (code);
3451: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3452: {
3453: register int j;
3454: switch (fmt[i])
3455: {
3456: case 'i':
3457: if (XINT (x, i) != XINT (y, i))
3458: return 0;
3459: break;
3460:
3461: case 's':
3462: if (strcmp (XSTR (x, i), XSTR (y, i)))
3463: return 0;
3464: break;
3465:
3466: case 'e':
3467: if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
3468: return 0;
3469: break;
3470:
3471: case 'u':
3472: if (XEXP (x, i) != XEXP (y, i))
3473: return 0;
3474: /* fall through. */
3475: case '0':
3476: break;
3477:
3478: case 'E':
3479: if (XVECLEN (x, i) != XVECLEN (y, i))
3480: return 0;
3481: for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3482: if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
3483: return 0;
3484: break;
3485:
3486: default:
3487: abort ();
3488: }
3489: }
3490: return 1;
3491: }
3492:
3493: /* If X is a hard register or equivalent to one or a subregister of one,
3494: return the hard register number. If X is a pseudo register that was not
3495: assigned a hard register, return the pseudo register number. Otherwise,
3496: return -1. Any rtx is valid for X. */
3497:
3498: int
3499: true_regnum (x)
3500: rtx x;
3501: {
3502: if (GET_CODE (x) == REG)
3503: {
3504: if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
3505: return reg_renumber[REGNO (x)];
3506: return REGNO (x);
3507: }
3508: if (GET_CODE (x) == SUBREG)
3509: {
3510: int base = true_regnum (SUBREG_REG (x));
3511: if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
3512: return SUBREG_WORD (x) + base;
3513: }
3514: return -1;
3515: }
3516:
3517: /* Optimize code of the form:
3518:
3519: for (x = a[i]; x; ...)
3520: ...
3521: for (x = a[i]; x; ...)
3522: ...
3523: foo:
3524:
3525: Loop optimize will change the above code into
3526:
3527: if (x = a[i])
3528: for (;;)
3529: { ...; if (! (x = ...)) break; }
3530: if (x = a[i])
3531: for (;;)
3532: { ...; if (! (x = ...)) break; }
3533: foo:
3534:
3535: In general, if the first test fails, the program can branch
3536: directly to `foo' and skip the second try which is doomed to fail.
3537: We run this after loop optimization and before flow analysis. */
3538:
3539: /* When comparing the insn patterns, we track the fact that different
3540: pseudo-register numbers may have been used in each computation.
3541: The following array stores an equivalence -- same_regs[I] == J means
3542: that pseudo register I was used in the first set of tests in a context
3543: where J was used in the second set. We also count the number of such
3544: pending equivalences. If nonzero, the expressions really aren't the
3545: same. */
3546:
3547: static short *same_regs;
3548:
3549: static int num_same_regs;
3550:
3551: /* Track any registers modified between the target of the first jump and
3552: the second jump. They never compare equal. */
3553:
3554: static char *modified_regs;
3555:
3556: /* Record if memory was modified. */
3557:
3558: static int modified_mem;
3559:
3560: /* Called via note_stores on each insn between the target of the first
3561: branch and the second branch. It marks any changed registers. */
3562:
3563: static void
3564: mark_modified_reg (dest, x)
3565: rtx dest;
3566: rtx x;
3567: {
3568: int regno, i;
3569:
3570: if (GET_CODE (dest) == SUBREG)
3571: dest = SUBREG_REG (dest);
3572:
3573: if (GET_CODE (dest) == MEM)
3574: modified_mem = 1;
3575:
3576: if (GET_CODE (dest) != REG)
3577: return;
3578:
3579: regno = REGNO (dest);
3580: if (regno >= FIRST_PSEUDO_REGISTER)
3581: modified_regs[regno] = 1;
3582: else
3583: for (i = 0; i < HARD_REGNO_NREGS (regno, GET_MODE (dest)); i++)
3584: modified_regs[regno + i] = 1;
3585: }
3586:
3587: /* F is the first insn in the chain of insns. */
3588:
3589: void
3590: thread_jumps (f, max_reg, verbose)
3591: rtx f;
3592: int max_reg;
3593: int verbose;
3594: {
3595: /* Basic algorithm is to find a conditional branch,
3596: the label it may branch to, and the branch after
3597: that label. If the two branches test the same condition,
3598: walk back from both branch paths until the insn patterns
3599: differ, or code labels are hit. If we make it back to
3600: the target of the first branch, then we know that the first branch
3601: will either always succeed or always fail depending on the relative
3602: senses of the two branches. So adjust the first branch accordingly
3603: in this case. */
3604:
3605: rtx label, b1, b2, t1, t2;
3606: enum rtx_code code1, code2;
3607: rtx b1op0, b1op1, b2op0, b2op1;
3608: int changed = 1;
3609: int i;
3610: short *all_reset;
3611:
3612: /* Allocate register tables and quick-reset table. */
3613: modified_regs = (char *) alloca (max_reg * sizeof (char));
3614: same_regs = (short *) alloca (max_reg * sizeof (short));
3615: all_reset = (short *) alloca (max_reg * sizeof (short));
3616: for (i = 0; i < max_reg; i++)
3617: all_reset[i] = -1;
3618:
3619: while (changed)
3620: {
3621: changed = 0;
3622:
3623: for (b1 = f; b1; b1 = NEXT_INSN (b1))
3624: {
3625: /* Get to a candidate branch insn. */
3626: if (GET_CODE (b1) != JUMP_INSN
3627: || ! condjump_p (b1) || simplejump_p (b1)
3628: || JUMP_LABEL (b1) == 0)
3629: continue;
3630:
3631: bzero (modified_regs, max_reg * sizeof (char));
3632: modified_mem = 0;
3633:
3634: bcopy (all_reset, same_regs, max_reg * sizeof (short));
3635: num_same_regs = 0;
3636:
3637: label = JUMP_LABEL (b1);
3638:
3639: /* Look for a branch after the target. Record any registers and
3640: memory modified between the target and the branch. Stop when we
3641: get to a label since we can't know what was changed there. */
3642: for (b2 = NEXT_INSN (label); b2; b2 = NEXT_INSN (b2))
3643: {
3644: if (GET_CODE (b2) == CODE_LABEL)
3645: break;
3646:
3647: else if (GET_CODE (b2) == JUMP_INSN)
3648: {
3649: /* If this is an unconditional jump and is the only use of
3650: its target label, we can follow it. */
3651: if (simplejump_p (b2)
3652: && JUMP_LABEL (b2) != 0
3653: && LABEL_NUSES (JUMP_LABEL (b2)) == 1)
3654: {
3655: b2 = JUMP_LABEL (b2);
3656: continue;
3657: }
3658: else
3659: break;
3660: }
3661:
3662: if (GET_CODE (b2) != CALL_INSN && GET_CODE (b2) != INSN)
3663: continue;
3664:
3665: if (GET_CODE (b2) == CALL_INSN)
3666: {
3667: modified_mem = 1;
3668: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3669: if (call_used_regs[i] && ! fixed_regs[i]
3670: && i != STACK_POINTER_REGNUM
3671: && i != FRAME_POINTER_REGNUM
3672: && i != ARG_POINTER_REGNUM)
3673: modified_regs[i] = 1;
3674: }
3675:
3676: note_stores (PATTERN (b2), mark_modified_reg);
3677: }
3678:
3679: /* Check the next candidate branch insn from the label
3680: of the first. */
3681: if (b2 == 0
3682: || GET_CODE (b2) != JUMP_INSN
3683: || b2 == b1
3684: || ! condjump_p (b2)
3685: || simplejump_p (b2))
3686: continue;
3687:
3688: /* Get the comparison codes and operands, reversing the
3689: codes if appropriate. If we don't have comparison codes,
3690: we can't do anything. */
3691: b1op0 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 0);
3692: b1op1 = XEXP (XEXP (SET_SRC (PATTERN (b1)), 0), 1);
3693: code1 = GET_CODE (XEXP (SET_SRC (PATTERN (b1)), 0));
3694: if (XEXP (SET_SRC (PATTERN (b1)), 1) == pc_rtx)
3695: code1 = reverse_condition (code1);
3696:
3697: b2op0 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 0);
3698: b2op1 = XEXP (XEXP (SET_SRC (PATTERN (b2)), 0), 1);
3699: code2 = GET_CODE (XEXP (SET_SRC (PATTERN (b2)), 0));
3700: if (XEXP (SET_SRC (PATTERN (b2)), 1) == pc_rtx)
3701: code2 = reverse_condition (code2);
3702:
3703: /* If they test the same things and knowing that B1 branches
3704: tells us whether or not B2 branches, check if we
3705: can thread the branch. */
3706: if (rtx_equal_for_thread_p (b1op0, b2op0, b2)
3707: && rtx_equal_for_thread_p (b1op1, b2op1, b2)
3708: && (comparison_dominates_p (code1, code2)
3709: || comparison_dominates_p (code1, reverse_condition (code2))))
3710: {
3711: t1 = prev_nonnote_insn (b1);
3712: t2 = prev_nonnote_insn (b2);
3713:
3714: while (t1 != 0 && t2 != 0)
3715: {
3716: if (t1 == 0 || t2 == 0)
3717: break;
3718:
3719: if (t2 == label)
3720: {
3721: /* We have reached the target of the first branch.
3722: If there are no pending register equivalents,
3723: we know that this branch will either always
3724: succeed (if the senses of the two branches are
3725: the same) or always fail (if not). */
3726: rtx new_label;
3727:
3728: if (num_same_regs != 0)
3729: break;
3730:
3731: if (comparison_dominates_p (code1, code2))
3732: new_label = JUMP_LABEL (b2);
3733: else
3734: new_label = get_label_after (b2);
3735:
3736: if (JUMP_LABEL (b1) != new_label
3737: && redirect_jump (b1, new_label))
3738: changed = 1;
3739: break;
3740: }
3741:
3742: /* If either of these is not a normal insn (it might be
3743: a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail. (NOTEs
3744: have already been skipped above.) Similarly, fail
3745: if the insns are different. */
3746: if (GET_CODE (t1) != INSN || GET_CODE (t2) != INSN
3747: || recog_memoized (t1) != recog_memoized (t2)
3748: || ! rtx_equal_for_thread_p (PATTERN (t1),
3749: PATTERN (t2), t2))
3750: break;
3751:
3752: t1 = prev_nonnote_insn (t1);
3753: t2 = prev_nonnote_insn (t2);
3754: }
3755: }
3756: }
3757: }
3758: }
3759:
3760: /* This is like RTX_EQUAL_P except that it knows about our handling of
3761: possibly equivalent registers and knows to consider volatile and
3762: modified objects as not equal.
3763:
3764: YINSN is the insn containing Y. */
3765:
3766: int
3767: rtx_equal_for_thread_p (x, y, yinsn)
3768: rtx x, y;
3769: rtx yinsn;
3770: {
3771: register int i;
3772: register int j;
3773: register enum rtx_code code;
3774: register char *fmt;
3775:
3776: code = GET_CODE (x);
3777: /* Rtx's of different codes cannot be equal. */
3778: if (code != GET_CODE (y))
3779: return 0;
3780:
3781: /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
3782: (REG:SI x) and (REG:HI x) are NOT equivalent. */
3783:
3784: if (GET_MODE (x) != GET_MODE (y))
3785: return 0;
3786:
3787: /* Handle special-cases first. */
3788: switch (code)
3789: {
3790: case REG:
3791: if (REGNO (x) == REGNO (y) && ! modified_regs[REGNO (x)])
3792: return 1;
3793:
3794: /* If neither is user variable or hard register, check for possible
3795: equivalence. */
3796: if (REG_USERVAR_P (x) || REG_USERVAR_P (y)
3797: || REGNO (x) < FIRST_PSEUDO_REGISTER
3798: || REGNO (y) < FIRST_PSEUDO_REGISTER)
3799: return 0;
3800:
3801: if (same_regs[REGNO (x)] == -1)
3802: {
3803: same_regs[REGNO (x)] = REGNO (y);
3804: num_same_regs++;
3805:
3806: /* If this is the first time we are seeing a register on the `Y'
3807: side, see if it is the last use. If not, we can't thread the
3808: jump, so mark it as not equivalent. */
3809: if (regno_last_uid[REGNO (y)] != INSN_UID (yinsn))
3810: return 0;
3811:
3812: return 1;
3813: }
3814: else
3815: return (same_regs[REGNO (x)] == REGNO (y));
3816:
3817: break;
3818:
3819: case MEM:
1.1.1.3 ! root 3820: /* If memory modified or either volatile, not equivalent.
1.1 root 3821: Else, check address. */
3822: if (modified_mem || MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
3823: return 0;
3824:
3825: return rtx_equal_for_thread_p (XEXP (x, 0), XEXP (y, 0), yinsn);
3826:
3827: case ASM_INPUT:
3828: if (MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
3829: return 0;
3830:
3831: break;
3832:
3833: case SET:
3834: /* Cancel a pending `same_regs' if setting equivalenced registers.
3835: Then process source. */
3836: if (GET_CODE (SET_DEST (x)) == REG
3837: && GET_CODE (SET_DEST (y)) == REG)
3838: {
3839: if (same_regs[REGNO (SET_DEST (x))] == REGNO (SET_DEST (y)))
3840: {
3841: same_regs[REGNO (SET_DEST (x))] = -1;
3842: num_same_regs--;
3843: }
3844: else if (REGNO (SET_DEST (x)) != REGNO (SET_DEST (y)))
3845: return 0;
3846: }
3847: else
3848: if (rtx_equal_for_thread_p (SET_DEST (x), SET_DEST (y), yinsn) == 0)
3849: return 0;
3850:
3851: return rtx_equal_for_thread_p (SET_SRC (x), SET_SRC (y), yinsn);
3852:
3853: case LABEL_REF:
3854: return XEXP (x, 0) == XEXP (y, 0);
3855:
3856: case SYMBOL_REF:
3857: return XSTR (x, 0) == XSTR (y, 0);
3858: }
3859:
3860: if (x == y)
3861: return 1;
3862:
3863: fmt = GET_RTX_FORMAT (code);
3864: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3865: {
3866: switch (fmt[i])
3867: {
3868: case 'n':
3869: case 'i':
3870: if (XINT (x, i) != XINT (y, i))
3871: return 0;
3872: break;
3873:
3874: case 'V':
3875: case 'E':
3876: /* Two vectors must have the same length. */
3877: if (XVECLEN (x, i) != XVECLEN (y, i))
3878: return 0;
3879:
3880: /* And the corresponding elements must match. */
3881: for (j = 0; j < XVECLEN (x, i); j++)
3882: if (rtx_equal_for_thread_p (XVECEXP (x, i, j),
3883: XVECEXP (y, i, j), yinsn) == 0)
3884: return 0;
3885: break;
3886:
3887: case 'e':
3888: if (rtx_equal_for_thread_p (XEXP (x, i), XEXP (y, i), yinsn) == 0)
3889: return 0;
3890: break;
3891:
3892: case 'S':
3893: case 's':
3894: if (strcmp (XSTR (x, i), XSTR (y, i)))
3895: return 0;
3896: break;
3897:
3898: case 'u':
3899: /* These are just backpointers, so they don't matter. */
3900: break;
3901:
3902: case '0':
3903: break;
3904:
3905: /* It is believed that rtx's at this level will never
3906: contain anything but integers and other rtx's,
3907: except for within LABEL_REFs and SYMBOL_REFs. */
3908: default:
3909: abort ();
3910: }
3911: }
3912: return 1;
3913: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.