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