| blob | 8286948216dc8c8cad8903016eb54e1d50f0651d |
1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This is the jump-optimization pass of the compiler.
23 It is run two or three times: once before cse, sometimes once after cse,
24 and once after reload (before final).
26 jump_optimize deletes unreachable code and labels that are not used.
27 It also deletes jumps that jump to the following insn,
28 and simplifies jumps around unconditional jumps and jumps
29 to unconditional jumps.
31 Each CODE_LABEL has a count of the times it is used
32 stored in the LABEL_NUSES internal field, and each JUMP_INSN
33 has one label that it refers to stored in the
34 JUMP_LABEL internal field. With this we can detect labels that
35 become unused because of the deletion of all the jumps that
36 formerly used them. The JUMP_LABEL info is sometimes looked
37 at by later passes.
39 Optionally, cross-jumping can be done. Currently it is done
40 only the last time (when after reload and before final).
41 In fact, the code for cross-jumping now assumes that register
42 allocation has been done, since it uses `rtx_renumbered_equal_p'.
44 Jump optimization is done after cse when cse's constant-propagation
45 causes jumps to become unconditional or to be deleted.
47 Unreachable loops are not detected here, because the labels
48 have references and the insns appear reachable from the labels.
49 find_basic_blocks in flow.c finds and deletes such loops.
51 The subroutines delete_insn, redirect_jump, and invert_jump are used
52 from other passes as well. */
70 /* ??? Eventually must record somehow the labels used by jumps
71 from nested functions. */
72 /* Pre-record the next or previous real insn for each label?
73 No, this pass is very fast anyway. */
74 /* Condense consecutive labels?
75 This would make life analysis faster, maybe. */
76 /* Optimize jump y; x: ... y: jumpif... x?
77 Don't know if it is worth bothering with. */
78 /* Optimize two cases of conditional jump to conditional jump?
79 This can never delete any instruction or make anything dead,
80 or even change what is live at any point.
81 So perhaps let combiner do it. */
83 /* Vector indexed by uid.
84 For each CODE_LABEL, index by its uid to get first unconditional jump
85 that jumps to the label.
86 For each JUMP_INSN, index by its uid to get the next unconditional jump
87 that jumps to the same label.
88 Element 0 is the start of a chain of all return insns.
89 (It is safe to use element 0 because insn uid 0 is not used. */
93 /* Maximum index in jump_chain. */
97 /* Indicates whether death notes are significant in cross jump analysis.
98 Normally they are not significant, because of A and B jump to C,
99 and R dies in A, it must die in B. But this might not be true after
100 stack register conversion, and we must compare death notes in that
101 case. */
127 \f
128 /* Main external entry point into the jump optimizer. See comments before
129 jump_optimize_1 for descriptions of the arguments. */
130 void
132 rtx f;
136 {
138 }
140 /* Alternate entry into the jump optimizer. This entry point only rebuilds
141 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
142 instructions. */
143 void
145 rtx f;
146 {
148 }
150 /* Alternate entry into the jump optimizer. Do only trivial optimizations. */
152 void
154 rtx f;
155 {
157 }
158 \f
159 /* Delete no-op jumps and optimize jumps to jumps
160 and jumps around jumps.
161 Delete unused labels and unreachable code.
163 If CROSS_JUMP is 1, detect matching code
164 before a jump and its destination and unify them.
165 If CROSS_JUMP is 2, do cross-jumping, but pay attention to death notes.
167 If NOOP_MOVES is nonzero, delete no-op move insns.
169 If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
170 after regscan, and it is safe to use regno_first_uid and regno_last_uid.
172 If MARK_LABELS_ONLY is nonzero, then we only rebuild the jump chain
173 and JUMP_LABEL field for jumping insns.
175 If `optimize' is zero, don't change any code,
176 just determine whether control drops off the end of the function.
177 This case occurs when we have -W and not -O.
178 It works because `delete_insn' checks the value of `optimize'
179 and refrains from actually deleting when that is 0.
181 If MINIMAL is nonzero, then we only perform trivial optimizations:
183 * Removal of unreachable code after BARRIERs.
184 * Removal of unreferenced CODE_LABELs.
185 * Removal of a jump to the next instruction.
186 * Removal of a conditional jump followed by an unconditional jump
187 to the same target as the conditional jump.
188 * Simplify a conditional jump around an unconditional jump.
189 * Simplify a jump to a jump.
190 * Delete extraneous line number notes.
191 */
193 static void
196 rtx f;
202 {
208 rtx last_insn;
214 /* Leave some extra room for labels and duplicate exit test insns
215 we make. */
221 /* Keep track of labels used from static data; we don't track them
222 closely enough to delete them here, so make sure their reference
223 count doesn't drop to zero. */
229 /* Keep track of labels used for marking handlers for exception
230 regions; they cannot usually be deleted. */
236 /* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL
237 notes and recompute LABEL_NUSES. */
248 /* If we haven't yet gotten to reload and we have just run regscan,
249 delete any insn that sets a register that isn't used elsewhere.
250 This helps some of the optimizations below by having less insns
251 being jumped around. */
255 {
263 /* We use regno_last_note_uid so as not to delete the setting
264 of a reg that's used in notes. A subsequent optimization
265 might arrange to use that reg for real. */
269 /* An ADDRESSOF expression can turn into a use of the internal arg
270 pointer, so do not delete the initialization of the internal
271 arg pointer yet. If it is truly dead, flow will delete the
272 initializing insn. */
275 }
277 /* Now iterate optimizing jumps until nothing changes over one pass. */
281 {
285 {
286 rtx reallabelprev;
288 rtx temp4 ATTRIBUTE_UNUSED;
289 rtx nlabel;
296 /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
297 jump. Try to optimize by duplicating the loop exit test if so.
298 This is only safe immediately after regscan, because it uses
299 the values of regno_first_uid and regno_last_uid. */
305 {
308 {
312 }
313 }
322 /* Tension the labels in dispatch tables. */
329 /* See if this jump goes to another jump and redirect if so. */
337 /* If a dispatch table always goes to the same place,
338 get rid of it and replace the insn that uses it. */
342 {
348 rtx set;
359 /* Don't mess with a casesi insn.
360 XXX according to the comment before computed_jump_p(),
361 all casesi insns should be a parallel of the jump
362 and a USE of a LABEL_REF. */
366 {
370 }
371 }
375 /* Detect jump to following insn. */
379 {
383 /* Remove the "inactive" but "real" insns (i.e. uses and
384 clobbers) in between here and there. */
391 }
393 /* Detect a conditional jump going to the same place
394 as an immediately following unconditional jump. */
400 {
401 /* Don't mess up test coverage analysis. */
409 {
410 /* Ensure that we jump to the later of the two labels.
411 Consider:
413 if (test) goto L2;
414 goto L1;
415 ...
416 L1:
417 (clobber return-reg)
418 L2:
419 (use return-reg)
421 If we leave the goto L1, we'll incorrectly leave
422 return-reg dead for TEST true. */
435 }
436 }
438 /* Detect a conditional jump jumping over an unconditional jump. */
447 {
448 /* When we invert the unconditional jump, we will be
449 decrementing the usage count of its old label.
450 Make sure that we don't delete it now because that
451 might cause the following code to be deleted. */
459 {
460 /* It is very likely that if there are USE insns before
461 this jump, they hold REG_DEAD notes. These REG_DEAD
462 notes are no longer valid due to this optimization,
463 and will cause the life-analysis that following passes
464 (notably delayed-branch scheduling) to think that
465 these registers are dead when they are not.
467 To prevent this trouble, we just remove the USE insns
468 from the insn chain. */
472 {
476 }
480 }
482 /* We can now safely delete the label if it is unreferenced
483 since the delete_insn above has deleted the BARRIER. */
488 }
490 /* If we have an unconditional jump preceded by a USE, try to put
491 the USE before the target and jump there. This simplifies many
492 of the optimizations below since we don't have to worry about
493 dealing with these USE insns. We only do this if the label
494 being branch to already has the identical USE or if code
495 never falls through to that label. */
505 /* Don't do this optimization if we have a loop containing
506 only the USE instruction, and the loop start label has
507 a usage count of 1. This is because we will redo this
508 optimization everytime through the outer loop, and jump
509 opt will never exit. */
513 {
515 {
518 }
525 }
527 #ifdef HAVE_trap
528 /* Detect a conditional jump jumping over an unconditional trap. */
540 {
546 {
552 }
553 }
554 /* Detect a jump jumping to an unconditional trap. */
559 && (this_is_any_uncondjump
560 || (this_is_any_condjump
562 {
567 {
569 /* Replace an unconditional jump to a trap with a trap. */
571 {
576 }
581 {
586 }
587 }
588 /* If the trap condition and jump condition are mutually
589 exclusive, redirect the jump to the following insn. */
591 && this_is_any_condjump
596 {
599 }
600 }
601 #endif
602 else
603 {
604 /* Now that the jump has been tensioned,
605 try cross jumping: check for identical code
606 before the jump and before its target label. */
608 /* First, cross jumping of conditional jumps: */
611 {
615 /* A conditional jump may be crossjumped
616 only if the place it jumps to follows
617 an opposing jump that comes back here. */
620 /* We have no opposing jump;
621 cannot cross jump this insn. */
625 /* TARGET is nonzero if it is ok to cross jump
626 to code before TARGET. If so, see if matches. */
632 {
634 /* Make the old conditional jump
635 into an unconditional one. */
640 /* Add to jump_chain unless this is a new label
641 whose UID is too large. */
643 {
647 }
650 }
651 }
653 /* Cross jumping of unconditional jumps:
654 a few differences. */
657 {
659 rtx target;
663 /* TARGET is nonzero if it is ok to cross jump
664 to code before TARGET. If so, see if matches. */
668 /* If cannot cross jump to code before the label,
669 see if we can cross jump to another jump to
670 the same label. */
671 /* Try each other jump to this label. */
678 /* Ignore TARGET if it's deleted. */
684 {
688 }
689 }
691 /* This code was dead in the previous jump.c! */
693 {
694 /* Return insns all "jump to the same place"
695 so we can cross-jump between any two of them. */
701 /* If cannot cross jump to code before the label,
702 see if we can cross jump to another jump to
703 the same label. */
704 /* Try each other jump to this label. */
715 {
719 }
720 }
721 }
722 }
725 }
727 /* Delete extraneous line number notes.
728 Note that two consecutive notes for different lines are not really
729 extraneous. There should be some indication where that line belonged,
730 even if it became empty. */
732 {
737 {
739 /* Any previous line note was for the prologue; gdb wants a new
740 note after the prologue even if it is for the same line. */
743 {
744 /* Delete this note if it is identical to previous note. */
748 {
751 }
754 }
755 }
756 }
758 end:
759 /* Clean up. */
762 }
763 \f
764 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
765 notes whose labels don't occur in the insn any more. Returns the
766 largest INSN_UID found. */
767 static int
769 rtx f;
770 {
772 rtx insn;
775 {
781 {
785 {
790 }
791 }
794 }
797 }
799 /* Delete insns following barriers, up to next label.
801 Also delete no-op jumps created by gcse. */
803 static void
805 rtx f;
806 {
807 rtx insn;
808 rtx set;
811 {
813 {
819 {
821 {
822 /* Detect when we're deleting a tablejump; get rid of
823 the jump table as well. */
830 {
833 }
834 else
836 }
840 else
842 }
843 /* INSN is now the code_label. */
844 }
846 /* Also remove (set (pc) (pc)) insns which can be created by
847 gcse. We eliminate such insns now to avoid having them
848 cause problems later. */
856 else
858 }
859 }
861 /* Mark the label each jump jumps to.
862 Combine consecutive labels, and count uses of labels.
864 For each label, make a chain (using `jump_chain')
865 of all the *unconditional* jumps that jump to it;
866 also make a chain of all returns.
868 CROSS_JUMP indicates whether we are doing cross jumping
869 and if we are whether we will be paying attention to
870 death notes or not. */
872 static void
874 rtx f;
876 {
877 rtx insn;
881 {
884 {
889 /* Canonicalize the tail recursion label attached to the
890 CALL_PLACEHOLDER insn. */
892 {
897 }
900 }
904 {
905 /* When we know the LABEL_REF contained in a REG used in
906 an indirect jump, we'll have a REG_LABEL note so that
907 flow can tell where it's going. */
909 {
912 {
913 /* But a LABEL_REF around the REG_LABEL note, so
914 that we can canonicalize it. */
921 }
922 }
924 {
928 }
930 {
933 }
934 }
935 }
936 }
938 /* Delete all labels already not referenced.
939 Also find and return the last insn. */
941 static rtx
943 rtx f;
944 {
946 rtx insn;
949 {
954 else
955 {
958 }
959 }
962 }
964 /* Delete various simple forms of moves which have no necessary
965 side effect. */
967 static void
969 rtx f;
970 {
974 {
978 {
981 /* Detect and delete no-op move instructions
982 resulting from not allocating a parameter in a register. */
995 /* Detect and ignore no-op move instructions
996 resulting from smart or fortuitous register allocation. */
999 {
1006 {
1007 rtx trial;
1014 {
1015 /* DREG may have been the target of a REG_DEAD note in
1016 the insn which makes INSN redundant. If so, reorg
1017 would still think it is dead. So search for such a
1018 note and delete it if we find it. */
1024 {
1027 }
1029 /* Deleting insn could lose a death-note for SREG. */
1031 {
1032 /* Change this into a USE so that we won't emit
1033 code for it, but still can keep the note. */
1037 /* Remove all reg notes but the REG_DEAD one. */
1040 }
1041 else
1043 }
1044 }
1049 {
1050 /* This handles the case where we have two consecutive
1051 assignments of the same constant to pseudos that didn't
1052 get a hard reg. Each SET from the constant will be
1053 converted into a SET of the spill register and an
1054 output reload will be made following it. This produces
1055 two loads of the same constant into the same spill
1056 register. */
1060 /* Look back for a death note for the first reg.
1061 If there is one, it is no longer accurate. */
1063 {
1067 {
1070 }
1072 }
1074 /* Delete the second load of the value. */
1076 }
1077 }
1079 {
1080 /* If each part is a set between two identical registers or
1081 a USE or CLOBBER, delete the insn. */
1083 rtx tem;
1086 {
1096 }
1100 }
1101 /* Also delete insns to store bit fields if they are no-ops. */
1102 /* Not worth the hair to detect this in the big-endian case. */
1111 }
1113 }
1114 }
1116 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
1117 jump. Assume that this unconditional jump is to the exit test code. If
1118 the code is sufficiently simple, make a copy of it before INSN,
1119 followed by a jump to the exit of the loop. Then delete the unconditional
1120 jump after INSN.
1122 Return 1 if we made the change, else 0.
1124 This is only safe immediately after a regscan pass because it uses the
1125 values of regno_first_uid and regno_last_uid. */
1127 static int
1129 rtx loop_start;
1130 {
1135 rtx lastexit;
1139 /* Scan the exit code. We do not perform this optimization if any insn:
1141 is a CALL_INSN
1142 is a CODE_LABEL
1143 has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
1144 is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
1145 is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
1146 is not valid.
1148 We also do not do this if we find an insn with ASM_OPERANDS. While
1149 this restriction should not be necessary, copying an insn with
1150 ASM_OPERANDS can confuse asm_noperands in some cases.
1152 Also, don't do this if the exit code is more than 20 insns. */
1155 insn
1159 {
1161 {
1166 /* We could be in front of the wrong NOTE_INSN_LOOP_END if there is
1167 a jump immediately after the loop start that branches outside
1168 the loop but within an outer loop, near the exit test.
1169 If we copied this exit test and created a phony
1170 NOTE_INSN_LOOP_VTOP, this could make instructions immediately
1171 before the exit test look like these could be safely moved
1172 out of the loop even if they actually may be never executed.
1173 This can be avoided by checking here for NOTE_INSN_LOOP_CONT. */
1182 /* If we were to duplicate this code, we would not move
1183 the BLOCK notes, and so debugging the moved code would
1184 be difficult. Thus, we only move the code with -O2 or
1185 higher. */
1191 /* The code below would grossly mishandle REG_WAS_0 notes,
1192 so get rid of them here. */
1202 }
1203 }
1205 /* Unless INSN is zero, we can do the optimization. */
1211 /* See if any insn sets a register only used in the loop exit code and
1212 not a user variable. If so, replace it with a new register. */
1221 {
1227 {
1228 /* We can do the replacement. Allocate reg_map if this is the
1229 first replacement we found. */
1236 }
1237 }
1239 /* Now copy each insn. */
1241 {
1243 {
1248 /* Only copy line-number notes. */
1250 {
1253 }
1263 /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
1264 make them. */
1267 {
1273 else
1278 }
1286 loop_start);
1291 {
1295 }
1297 /* If this is a simple jump, add it to the jump chain. */
1301 {
1305 }
1310 }
1312 /* Record the first insn we copied. We need it so that we can
1313 scan the copied insns for new pseudo registers. */
1316 }
1318 /* Now clean up by emitting a jump to the end label and deleting the jump
1319 at the start of the loop. */
1321 {
1323 loop_start);
1325 /* Record the first insn we copied. We need it so that we can
1326 scan the copied insns for new pseudo registers. This may not
1327 be strictly necessary since we should have copied at least one
1328 insn above. But I am going to be safe. */
1335 {
1339 }
1341 }
1343 /* Now scan from the first insn we copied to the last insn we copied
1344 (copy) for new pseudo registers. Do this after the code to jump to
1345 the end label since that might create a new pseudo too. */
1348 /* Mark the exit code as the virtual top of the converted loop. */
1353 /* Clean up. */
1358 }
1359 \f
1360 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, loop-end,
1361 notes between START and END out before START. Assume that END is not
1362 such a note. START may be such a note. Returns the value of the new
1363 starting insn, which may be different if the original start was such a
1364 note. */
1366 rtx
1369 {
1370 rtx insn;
1371 rtx next;
1374 {
1383 {
1386 else
1387 {
1395 }
1396 }
1397 }
1400 }
1401 \f
1402 /* Compare the instructions before insn E1 with those before E2
1403 to find an opportunity for cross jumping.
1404 (This means detecting identical sequences of insns followed by
1405 jumps to the same place, or followed by a label and a jump
1406 to that label, and replacing one with a jump to the other.)
1408 Assume E1 is a jump that jumps to label E2
1409 (that is not always true but it might as well be).
1410 Find the longest possible equivalent sequences
1411 and store the first insns of those sequences into *F1 and *F2.
1412 Store zero there if no equivalent preceding instructions are found.
1414 We give up if we find a label in stream 1.
1415 Actually we could transfer that label into stream 2. */
1417 static void
1422 {
1434 {
1444 /* Don't allow the range of insns preceding E1 or E2
1445 to include the other (E2 or E1). */
1449 /* If we will get to this code by jumping, those jumps will be
1450 tensioned to go directly to the new label (before I2),
1451 so this cross-jumping won't cost extra. So reduce the minimum. */
1453 {
1456 }
1464 /* If this is a CALL_INSN, compare register usage information.
1465 If we don't check this on stack register machines, the two
1466 CALL_INSNs might be merged leaving reg-stack.c with mismatching
1467 numbers of stack registers in the same basic block.
1468 If we don't check this on machines with delay slots, a delay slot may
1469 be filled that clobbers a parameter expected by the subroutine.
1471 ??? We take the simple route for now and assume that if they're
1472 equal, they were constructed identically. */
1479 #ifdef STACK_REGS
1480 /* If cross_jump_death_matters is not 0, the insn's mode
1481 indicates whether or not the insn contains any stack-like
1482 regs. */
1485 {
1486 /* If register stack conversion has already been done, then
1487 death notes must also be compared before it is certain that
1488 the two instruction streams match. */
1490 rtx note;
1510 done:
1511 ;
1512 }
1513 #endif
1515 /* Don't allow old-style asm or volatile extended asms to be accepted
1516 for cross jumping purposes. It is conceptually correct to allow
1517 them, since cross-jumping preserves the dynamic instruction order
1518 even though it is changing the static instruction order. However,
1519 if an asm is being used to emit an assembler pseudo-op, such as
1520 the MIPS `.set reorder' pseudo-op, then the static instruction order
1521 matters and it must be preserved. */
1529 {
1530 /* The following code helps take care of G++ cleanups. */
1531 rtx equiv1;
1532 rtx equiv2;
1539 /* If the equivalences are not to a constant, they may
1540 reference pseudos that no longer exist, so we can't
1541 use them. */
1544 {
1549 {
1556 }
1557 }
1559 /* Insns fail to match; cross jumping is limited to the following
1560 insns. */
1562 #ifdef HAVE_cc0
1563 /* Don't allow the insn after a compare to be shared by
1564 cross-jumping unless the compare is also shared.
1565 Here, if either of these non-matching insns is a compare,
1566 exclude the following insn from possible cross-jumping. */
1569 #endif
1571 /* If cross-jumping here will feed a jump-around-jump
1572 optimization, this jump won't cost extra, so reduce
1573 the minimum. */
1579 }
1581 win:
1583 {
1584 /* Ok, this insn is potentially includable in a cross-jump here. */
1587 }
1588 }
1592 }
1594 static void
1597 {
1598 /* Find an existing label at this point
1599 or make a new one if there is none. */
1602 /* Make the same jump insn jump to the new point. */
1604 {
1605 /* Remove from jump chain of returns. */
1607 /* Change the insn. */
1612 /* Add to new the jump chain. */
1615 {
1618 }
1619 }
1620 else
1623 /* Delete the matching insns before the jump. Also, remove any REG_EQUAL
1624 or REG_EQUIV note in the NEWLPOS stream that isn't also present in
1625 the NEWJPOS stream. */
1628 {
1629 rtx lnote;
1641 }
1642 }
1643 \f
1644 /* Return the label before INSN, or put a new label there. */
1646 rtx
1648 rtx insn;
1649 {
1650 rtx label;
1652 /* Find an existing label at this point
1653 or make a new one if there is none. */
1657 {
1663 }
1665 }
1667 /* Return the label after INSN, or put a new label there. */
1669 rtx
1671 rtx insn;
1672 {
1673 rtx label;
1675 /* Find an existing label at this point
1676 or make a new one if there is none. */
1680 {
1684 }
1686 }
1687 \f
1688 /* Return 1 if INSN is a jump that jumps to right after TARGET
1689 only on the condition that TARGET itself would drop through.
1690 Assumes that TARGET is a conditional jump. */
1692 static int
1695 {
1714 {
1718 }
1721 {
1725 }
1730 }
1731 \f
1732 /* Given a comparison (CODE ARG0 ARG1), inside a insn, INSN, return an code
1733 of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
1734 UNKNOWN may be returned in case we are having CC_MODE compare and we don't
1735 know whether it's source is floating point or integer comparison. Machine
1736 description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
1737 to help this function avoid overhead in these cases. */
1738 enum rtx_code
1742 {
1745 /* If this is not actually a comparison, we can't reverse it. */
1753 /* First see if machine description supply us way to reverse the comparison.
1754 Give it priority over everything else to allow machine description to do
1755 tricks. */
1756 #ifdef REVERSIBLE_CC_MODE
1759 {
1760 #ifdef REVERSE_CONDITION
1762 #endif
1764 }
1765 #endif
1767 /* Try few special cases based on the comparison code. */
1769 {
1776 /* It is always safe to reverse EQ and NE, even for the floating
1777 point. Similary the unsigned comparisons are never used for
1778 floating point so we can reverse them in the default way. */
1784 /* In case we already see unordered comparison, we can be sure to
1785 be dealing with floating point so we don't need any more tests. */
1791 /* We don't have safe way to reverse these yet. */
1795 }
1797 /* In case we give up IEEE compatibility, all comparisons are reversible. */
1803 #ifdef HAVE_cc0
1805 #endif
1806 )
1807 {
1808 rtx prev;
1809 /* Try to search for the comparison to determine the real mode.
1810 This code is expensive, but with sane machine description it
1811 will be never used, since REVERSIBLE_CC_MODE will return true
1812 in all cases. */
1819 {
1823 {
1827 {
1834 }
1835 /* We can get past reg-reg moves. This may be usefull for model
1836 of i387 comparisons that first move flag registers around. */
1838 {
1841 }
1842 }
1843 /* If register is clobbered in some ununderstandable way,
1844 give up. */
1847 }
1848 }
1850 /* An integer condition. */
1858 }
1860 /* An wrapper around the previous function to take COMPARISON as rtx
1861 expression. This simplifies many callers. */
1862 enum rtx_code
1865 {
1871 }
1872 \f
1873 /* Given a comparison, COMPARISON, inside a conditional jump insn, INSN,
1874 return non-zero if it is safe to reverse this comparison. It is if our
1875 floating-point is not IEEE, if this is an NE or EQ comparison, or if
1876 this is known to be an integer comparison.
1878 Use of this function is depreached and you should use
1879 REVERSED_COMPARISON_CODE bits instead.
1880 */
1882 int
1884 rtx comparison;
1885 rtx insn;
1886 {
1889 /* If this is not actually a comparison, we can't reverse it. */
1897 /* The code will follow can_reverse_comparison_p with reverse_condition,
1898 so see if it will get proper result. */
1900 }
1902 /* Given an rtx-code for a comparison, return the code for the negated
1903 comparison. If no such code exists, return UNKNOWN.
1905 WATCH OUT! reverse_condition is not safe to use on a jump that might
1906 be acting on the results of an IEEE floating point comparison, because
1907 of the special treatment of non-signaling nans in comparisons.
1908 Use reversed_comparison_code instead. */
1910 enum rtx_code
1913 {
1915 {
1951 }
1952 }
1954 /* Similar, but we're allowed to generate unordered comparisons, which
1955 makes it safe for IEEE floating-point. Of course, we have to recognize
1956 that the target will support them too... */
1958 enum rtx_code
1961 {
1962 /* Non-IEEE formats don't have unordered conditions. */
1967 {
1999 }
2000 }
2002 /* Similar, but return the code when two operands of a comparison are swapped.
2003 This IS safe for IEEE floating-point. */
2005 enum rtx_code
2008 {
2010 {
2046 }
2047 }
2049 /* Given a comparison CODE, return the corresponding unsigned comparison.
2050 If CODE is an equality comparison or already an unsigned comparison,
2051 CODE is returned. */
2053 enum rtx_code
2056 {
2058 {
2078 }
2079 }
2081 /* Similarly, return the signed version of a comparison. */
2083 enum rtx_code
2086 {
2088 {
2108 }
2109 }
2110 \f
2111 /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
2112 truth of CODE1 implies the truth of CODE2. */
2114 int
2117 {
2118 /* UNKNOWN comparison codes can happen as a result of trying to revert
2119 comparison codes.
2120 They can't match anything, so we have to reject them here. */
2128 {
2189 }
2192 }
2193 \f
2194 /* Return 1 if INSN is an unconditional jump and nothing else. */
2196 int
2198 rtx insn;
2199 {
2204 }
2206 /* Return nonzero if INSN is a (possibly) conditional jump
2207 and nothing more.
2209 Use this function is deprecated, since we need to support combined
2210 branch and compare insns. Use any_condjump_p instead whenever possible. */
2212 int
2214 rtx insn;
2215 {
2225 else
2235 }
2237 /* Return nonzero if INSN is a (possibly) conditional jump inside a
2238 PARALLEL.
2240 Use this function is deprecated, since we need to support combined
2241 branch and compare insns. Use any_condjump_p instead whenever possible. */
2243 int
2245 rtx insn;
2246 {
2251 else
2271 }
2273 /* Return set of PC, otherwise NULL. */
2275 rtx
2277 rtx insn;
2278 {
2279 rtx pat;
2284 /* The set is allowed to appear either as the insn pattern or
2285 the first set in a PARALLEL. */
2292 }
2294 /* Return true when insn is an unconditional direct jump,
2295 possibly bundled inside a PARALLEL. */
2297 int
2299 rtx insn;
2300 {
2307 }
2309 /* Return true when insn is a conditional jump. This function works for
2310 instructions containing PC sets in PARALLELs. The instruction may have
2311 various other effects so before removing the jump you must verify
2312 onlyjump_p.
2314 Note that unlike condjump_p it returns false for unconditional jumps. */
2316 int
2318 rtx insn;
2319 {
2333 }
2335 /* Return the label of a conditional jump. */
2337 rtx
2339 rtx insn;
2340 {
2355 }
2357 /* Return true if INSN is a (possibly conditional) return insn. */
2359 static int
2363 {
2366 }
2368 int
2370 rtx insn;
2371 {
2375 }
2377 /* Return true if INSN is a jump that only transfers control and
2378 nothing more. */
2380 int
2382 rtx insn;
2383 {
2384 rtx set;
2398 }
2400 #ifdef HAVE_cc0
2402 /* Return 1 if X is an RTX that does nothing but set the condition codes
2403 and CLOBBER or USE registers.
2404 Return -1 if X does explicitly set the condition codes,
2405 but also does other things. */
2407 int
2409 rtx x ATTRIBUTE_UNUSED;
2410 {
2414 {
2419 {
2425 }
2427 }
2429 }
2430 #endif
2431 \f
2432 /* Follow any unconditional jump at LABEL;
2433 return the ultimate label reached by any such chain of jumps.
2434 If LABEL is not followed by a jump, return LABEL.
2435 If the chain loops or we can't find end, return LABEL,
2436 since that tells caller to avoid changing the insn.
2438 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
2439 a USE or CLOBBER. */
2441 rtx
2443 rtx label;
2444 {
2459 depth++)
2460 {
2461 /* Don't chain through the insn that jumps into a loop
2462 from outside the loop,
2463 since that would create multiple loop entry jumps
2464 and prevent loop optimization. */
2465 rtx tem;
2470 /* ??? Optional. Disables some optimizations, but makes
2471 gcov output more accurate with -O. */
2475 /* If we have found a cycle, make the insn jump to itself. */
2485 }
2489 }
2491 /* Assuming that field IDX of X is a vector of label_refs,
2492 replace each of them by the ultimate label reached by it.
2493 Return nonzero if a change is made.
2494 If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG. */
2496 static int
2500 {
2504 {
2508 {
2514 }
2515 }
2517 }
2518 \f
2519 /* Find all CODE_LABELs referred to in X, and increment their use counts.
2520 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
2521 in INSN, then store one of them in JUMP_LABEL (INSN).
2522 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
2523 referenced in INSN, add a REG_LABEL note containing that label to INSN.
2524 Also, when there are consecutive labels, canonicalize on the last of them.
2526 Note that two labels separated by a loop-beginning note
2527 must be kept distinct if we have not yet done loop-optimization,
2528 because the gap between them is where loop-optimize
2529 will want to move invariant code to. CROSS_JUMP tells us
2530 that loop-optimization is done with.
2532 Once reload has completed (CROSS_JUMP non-zero), we need not consider
2533 two labels distinct if they are separated by only USE or CLOBBER insns. */
2535 void
2538 rtx insn;
2541 {
2547 {
2566 /* If this is a constant-pool reference, see if it is a label. */
2572 {
2575 rtx next;
2577 /* Ignore remaining references to unreachable labels that
2578 have been deleted. */
2586 /* Ignore references to labels of containing functions. */
2590 /* If there are other labels following this one,
2591 replace it with the last of the consecutive labels. */
2593 {
2605 /* ??? Optional. Disables some optimizations, but
2606 makes gcov output more accurate with -O. */
2607 || (flag_test_coverage
2610 }
2617 {
2620 else
2621 {
2622 /* If we've changed the label, update notes accordingly. */
2624 {
2625 rtx note;
2627 /* We may have a REG_LABEL note to indicate that this
2628 instruction uses the label. */
2633 /* We may also have a REG_EQUAL note to indicate that
2634 a register is being set to the address of the
2635 label. */
2641 }
2643 /* Add a REG_LABEL note for LABEL unless there already
2644 is one. All uses of a label, except for labels
2645 that are the targets of jumps, must have a
2646 REG_LABEL note. */
2650 }
2651 }
2653 }
2655 /* Do walk the labels in a vector, but not the first operand of an
2656 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
2660 {
2666 }
2671 }
2675 {
2679 {
2683 }
2684 }
2685 }
2687 /* If all INSN does is set the pc, delete it,
2688 and delete the insn that set the condition codes for it
2689 if that's what the previous thing was. */
2691 void
2693 rtx insn;
2694 {
2699 }
2701 /* Verify INSN is a BARRIER and delete it. */
2703 void
2705 rtx insn;
2706 {
2711 }
2713 /* Recursively delete prior insns that compute the value (used only by INSN
2714 which the caller is deleting) stored in the register mentioned by NOTE
2715 which is a REG_DEAD note associated with INSN. */
2717 static void
2719 rtx note;
2720 rtx insn;
2721 {
2722 rtx our_prev;
2729 {
2732 /* If we reach a CALL which is not calling a const function
2733 or the callee pops the arguments, then give up. */
2739 /* If we reach a SEQUENCE, it is too complex to try to
2740 do anything with it, so give up. */
2746 /* reorg creates USEs that look like this. We leave them
2747 alone because reorg needs them for its own purposes. */
2751 {
2756 {
2757 /* If we find a SET of something else, we can't
2758 delete the insn. */
2763 {
2769 }
2773 }
2776 {
2778 int dest_endregno
2779 = (dest_regno
2784 int endregno
2785 = (regno
2793 /* We may have a multi-word hard register and some, but not
2794 all, of the words of the register are needed in subsequent
2795 insns. Write REG_UNUSED notes for those parts that were not
2796 needed. */
2799 {
2812 }
2813 }
2816 }
2818 /* If PAT references the register that dies here, it is an
2819 additional use. Hence any prior SET isn't dead. However, this
2820 insn becomes the new place for the REG_DEAD note. */
2822 {
2826 }
2827 }
2828 }
2830 /* Delete INSN and recursively delete insns that compute values used only
2831 by INSN. This uses the REG_DEAD notes computed during flow analysis.
2832 If we are running before flow.c, we need do nothing since flow.c will
2833 delete dead code. We also can't know if the registers being used are
2834 dead or not at this point.
2836 Otherwise, look at all our REG_DEAD notes. If a previous insn does
2837 nothing other than set a register that dies in this insn, we can delete
2838 that insn as well.
2840 On machines with CC0, if CC0 is used in this insn, we may be able to
2841 delete the insn that set it. */
2843 static void
2845 rtx insn;
2846 {
2849 #ifdef HAVE_cc0
2851 {
2853 /* We assume that at this stage
2854 CC's are always set explicitly
2855 and always immediately before the jump that
2856 will use them. So if the previous insn
2857 exists to set the CC's, delete it
2858 (unless it performs auto-increments, etc.). */
2861 {
2865 else
2866 /* Otherwise, show that cc0 won't be used. */
2869 }
2870 }
2871 #endif
2874 {
2878 /* Verify that the REG_NOTE is legitimate. */
2883 }
2886 }
2887 \f
2888 /* Delete insn INSN from the chain of insns and update label ref counts.
2889 May delete some following insns as a consequence; may even delete
2890 a label elsewhere and insns that follow it.
2892 Returns the first insn after INSN that was not deleted. */
2894 rtx
2897 {
2902 rtx note;
2907 /* This insn is already deleted => return first following nondeleted. */
2914 /* Don't delete user-declared labels. When optimizing, convert them
2915 to special NOTEs instead. When not optimizing, leave them alone. */
2917 {
2919 {
2924 }
2927 }
2928 else
2929 /* Mark this insn as deleted. */
2932 /* If this is an unconditional jump, delete it from the jump chain. */
2936 /* If instruction is followed by a barrier,
2937 delete the barrier too. */
2940 {
2943 }
2945 /* Patch out INSN (and the barrier if any) */
2948 {
2950 {
2955 }
2958 {
2962 }
2966 }
2968 /* If deleting a jump, decrement the count of the label,
2969 and delete the label if it is now unused. */
2972 {
2976 {
2977 /* This can delete NEXT or PREV,
2978 either directly if NEXT is JUMP_LABEL (INSN),
2979 or indirectly through more levels of jumps. */
2982 /* I feel a little doubtful about this loop,
2983 but I see no clean and sure alternative way
2984 to find the first insn after INSN that is not now deleted.
2985 I hope this works. */
2989 }
2994 {
2995 /* If we're deleting the tablejump, delete the dispatch table.
2996 We may not be able to kill the label immediately preceeding
2997 just yet, as it might be referenced in code leading up to
2998 the tablejump. */
3000 }
3001 }
3003 /* Likewise if we're deleting a dispatch table. */
3008 {
3019 }
3021 /* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
3025 /* This could also be a NOTE_INSN_DELETED_LABEL note. */
3033 /* If INSN was a label and a dispatch table follows it,
3034 delete the dispatch table. The tablejump must have gone already.
3035 It isn't useful to fall through into a table. */
3044 /* If INSN was a label, delete insns following it if now unreachable. */
3047 {
3053 {
3057 /* Keep going past other deleted labels to delete what follows. */
3060 else
3061 /* Note: if this deletes a jump, it can cause more
3062 deletion of unreachable code, after a different label.
3063 As long as the value from this recursive call is correct,
3064 this invocation functions correctly. */
3066 }
3067 }
3070 }
3072 /* Advance from INSN till reaching something not deleted
3073 then return that. May return INSN itself. */
3075 rtx
3077 rtx insn;
3078 {
3082 }
3083 \f
3084 /* Delete a range of insns from FROM to TO, inclusive.
3085 This is for the sake of peephole optimization, so assume
3086 that whatever these insns do will still be done by a new
3087 peephole insn that will replace them. */
3089 void
3092 {
3096 {
3101 {
3104 /* Patch this insn out of the chain. */
3105 /* We don't do this all at once, because we
3106 must preserve all NOTEs. */
3112 }
3117 }
3119 /* Note that if TO is an unconditional jump
3120 we *do not* delete the BARRIER that follows,
3121 since the peephole that replaces this sequence
3122 is also an unconditional jump in that case. */
3123 }
3124 \f
3125 /* We have determined that INSN is never reached, and are about to
3126 delete it. Print a warning if the user asked for one.
3128 To try to make this warning more useful, this should only be called
3129 once per basic block not reached, and it only warns when the basic
3130 block contains more than one line from the current function, and
3131 contains at least one operation. CSE and inlining can duplicate insns,
3132 so it's possible to get spurious warnings from this. */
3134 void
3136 rtx avoided_insn;
3137 {
3138 rtx insn;
3146 /* Scan forwards, looking at LINE_NUMBER notes, until
3147 we hit a LABEL or we run out of insns. */
3150 {
3155 {
3158 else
3161 }
3164 }
3169 }
3170 \f
3171 /* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
3172 NLABEL as a return. Accrue modifications into the change group. */
3174 static void
3178 rtx insn;
3179 {
3186 {
3188 {
3189 rtx n;
3192 else
3197 }
3198 }
3200 {
3206 }
3211 {
3214 }
3218 {
3222 {
3226 }
3227 }
3228 }
3230 /* Similar, but apply the change group and report success or failure. */
3232 static int
3235 rtx insn;
3236 {
3241 else
3249 }
3251 /* Make JUMP go to NLABEL instead of where it jumps now. Accrue
3252 the modifications into the change group. Return false if we did
3253 not see how to do that. */
3255 int
3258 {
3264 else
3269 }
3271 /* Make JUMP go to NLABEL instead of where it jumps now. If the old
3272 jump target label is unused as a result, it and the code following
3273 it may be deleted.
3275 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
3276 RETURN insn.
3278 The return value will be 1 if the change was made, 0 if it wasn't
3279 (this can only occur for NLABEL == 0). */
3281 int
3285 {
3294 /* If this is an unconditional branch, delete it from the jump_chain of
3295 OLABEL and add it to the jump_chain of NLABEL (assuming both labels
3296 have UID's in range and JUMP_CHAIN is valid). */
3299 {
3305 {
3308 }
3309 }
3315 /* If we're eliding the jump over exception cleanups at the end of a
3316 function, move the function end note so that -Wreturn-type works. */
3327 }
3329 /* Invert the jump condition of rtx X contained in jump insn, INSN.
3330 Accrue the modifications into the change group. */
3332 static void
3334 rtx insn;
3335 {
3346 {
3351 /* We can do this in two ways: The preferable way, which can only
3352 be done if this is not an integer comparison, is to reverse
3353 the comparison code. Otherwise, swap the THEN-part and ELSE-part
3354 of the IF_THEN_ELSE. If we can't do either, fail. */
3359 {
3366 }
3371 }
3372 else
3374 }
3376 /* Invert the jump condition of conditional jump insn, INSN.
3378 Return 1 if we can do so, 0 if we cannot find a way to do so that
3379 matches a pattern. */
3381 static int
3383 rtx insn;
3384 {
3390 }
3392 /* Invert the condition of the jump JUMP, and make it jump to label
3393 NLABEL instead of where it jumps now. Accrue changes into the
3394 change group. Return false if we didn't see how to perform the
3395 inversion and redirection. */
3397 int
3400 {
3409 }
3411 /* Invert the condition of the jump JUMP, and make it jump to label
3412 NLABEL instead of where it jumps now. Return true if successful. */
3414 int
3418 {
3419 /* We have to either invert the condition and change the label or
3420 do neither. Either operation could fail. We first try to invert
3421 the jump. If that succeeds, we try changing the label. If that fails,
3422 we invert the jump back to what it was. */
3428 {
3429 /* An inverted jump means that a probability taken becomes a
3430 probability not taken. Subtract the branch probability from the
3431 probability base to convert it back to a taken probability. */
3438 }
3441 /* This should just be putting it back the way it was. */
3445 }
3447 /* Delete the instruction JUMP from any jump chain it might be on. */
3449 static void
3451 rtx jump;
3452 {
3456 /* Handle unconditional jumps. */
3461 /* Handle return insns. */
3464 else
3469 else
3470 {
3471 rtx insn;
3477 {
3480 }
3481 }
3482 }
3483 \f
3484 /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
3486 If the old jump target label (before the dispatch table) becomes unused,
3487 it and the dispatch table may be deleted. In that case, find the insn
3488 before the jump references that label and delete it and logical successors
3489 too. */
3491 static void
3494 {
3498 /* Add this jump to the jump_chain of NLABEL. */
3501 {
3504 }
3507 {
3511 /* Verify that the REG_NOTE is legitimate. */
3515 else
3516 {
3519 }
3520 }
3528 {
3531 }
3532 }
3534 /* Find the insn referencing LABEL that is a logical predecessor of INSN.
3535 If we found one, delete it and then delete this insn if DELETE_THIS is
3536 non-zero. Return non-zero if INSN or a predecessor references LABEL. */
3538 static int
3542 {
3544 rtx link;
3548 {
3550 {
3553 }
3554 else
3556 }
3560 {
3562 {
3565 }
3566 else
3568 }
3571 }
3572 \f
3573 /* Like rtx_equal_p except that it considers two REGs as equal
3574 if they renumber to the same value and considers two commutative
3575 operations to be the same if the order of the operands has been
3576 reversed.
3578 ??? Addition is not commutative on the PA due to the weird implicit
3579 space register selection rules for memory addresses. Therefore, we
3580 don't consider a + b == b + a.
3582 We could/should make this test a little tighter. Possibly only
3583 disabling it on the PA via some backend macro or only disabling this
3584 case when the PLUS is inside a MEM. */
3586 int
3589 {
3600 {
3607 /* If we haven't done any renumbering, don't
3608 make any assumptions. */
3613 {
3618 {
3621 }
3622 }
3624 else
3625 {
3629 }
3632 {
3637 {
3640 }
3641 }
3643 else
3644 {
3648 }
3651 }
3653 /* Now we have disposed of all the cases
3654 in which different rtx codes can match. */
3659 {
3670 /* We can't assume nonlocal labels have their following insns yet. */
3674 /* Two label-refs are equivalent if they point at labels
3675 in the same position in the instruction stream. */
3683 /* If we didn't match EQ equality above, they aren't the same. */
3688 }
3690 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
3695 /* For commutative operations, the RTX match if the operand match in any
3696 order. Also handle the simple binary and unary cases without a loop.
3698 ??? Don't consider PLUS a commutative operator; see comments above. */
3711 /* Compare the elements. If any pair of corresponding elements
3712 fail to match, return 0 for the whole things. */
3716 {
3719 {
3743 /* fall through. */
3757 }
3758 }
3760 }
3761 \f
3762 /* If X is a hard register or equivalent to one or a subregister of one,
3763 return the hard register number. If X is a pseudo register that was not
3764 assigned a hard register, return the pseudo register number. Otherwise,
3765 return -1. Any rtx is valid for X. */
3767 int
3769 rtx x;
3770 {
3772 {
3776 }
3778 {
3782 }
3784 }
3785 \f
3786 /* Optimize code of the form:
3788 for (x = a[i]; x; ...)
3789 ...
3790 for (x = a[i]; x; ...)
3791 ...
3792 foo:
3794 Loop optimize will change the above code into
3796 if (x = a[i])
3797 for (;;)
3798 { ...; if (! (x = ...)) break; }
3799 if (x = a[i])
3800 for (;;)
3801 { ...; if (! (x = ...)) break; }
3802 foo:
3804 In general, if the first test fails, the program can branch
3805 directly to `foo' and skip the second try which is doomed to fail.
3806 We run this after loop optimization and before flow analysis. */
3808 /* When comparing the insn patterns, we track the fact that different
3809 pseudo-register numbers may have been used in each computation.
3810 The following array stores an equivalence -- same_regs[I] == J means
3811 that pseudo register I was used in the first set of tests in a context
3812 where J was used in the second set. We also count the number of such
3813 pending equivalences. If nonzero, the expressions really aren't the
3814 same. */
3820 /* Track any registers modified between the target of the first jump and
3821 the second jump. They never compare equal. */
3825 /* Record if memory was modified. */
3829 /* Called via note_stores on each insn between the target of the first
3830 branch and the second branch. It marks any changed registers. */
3832 static void
3834 rtx dest;
3835 rtx x;
3837 {
3853 /* Don't consider a hard condition code register as modified,
3854 if it is only being set. thread_jumps will check if it is set
3855 to the same value. */
3862 }
3864 /* F is the first insn in the chain of insns. */
3866 void
3868 rtx f;
3871 {
3872 /* Basic algorithm is to find a conditional branch,
3873 the label it may branch to, and the branch after
3874 that label. If the two branches test the same condition,
3875 walk back from both branch paths until the insn patterns
3876 differ, or code labels are hit. If we make it back to
3877 the target of the first branch, then we know that the first branch
3878 will either always succeed or always fail depending on the relative
3879 senses of the two branches. So adjust the first branch accordingly
3880 in this case. */
3890 /* Allocate register tables and quick-reset table. */
3898 {
3902 {
3903 rtx set;
3904 rtx set2;
3906 /* Get to a candidate branch insn. */
3919 /* Look for a branch after the target. Record any registers and
3920 memory modified between the target and the branch. Stop when we
3921 get to a label since we can't know what was changed there. */
3923 {
3928 {
3929 /* If this is an unconditional jump and is the only use of
3930 its target label, we can follow it. */
3935 {
3938 }
3939 else
3941 }
3947 {
3956 }
3959 }
3961 /* Check the next candidate branch insn from the label
3962 of the first. */
3972 /* Get the comparison codes and operands, reversing the
3973 codes if appropriate. If we don't have comparison codes,
3974 we can't do anything. */
3981 else
3990 else
3993 /* If they test the same things and knowing that B1 branches
3994 tells us whether or not B2 branches, check if we
3995 can thread the branch. */
4001 {
4006 {
4008 {
4009 /* We have reached the target of the first branch.
4010 If there are no pending register equivalents,
4011 we know that this branch will either always
4012 succeed (if the senses of the two branches are
4013 the same) or always fail (if not). */
4014 rtx new_label;
4021 else
4025 {
4031 {
4032 /* Don't thread to the loop label. If a loop
4033 label is reused, loop optimization will
4034 be disabled for that loop. */
4037 }
4039 }
4041 }
4043 /* If either of these is not a normal insn (it might be
4044 a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail. (NOTEs
4045 have already been skipped above.) Similarly, fail
4046 if the insns are different. */
4055 }
4056 }
4057 }
4058 }
4060 /* Clean up. */
4064 }
4065 \f
4066 /* This is like RTX_EQUAL_P except that it knows about our handling of
4067 possibly equivalent registers and knows to consider volatile and
4068 modified objects as not equal.
4070 YINSN is the insn containing Y. */
4072 int
4075 rtx yinsn;
4076 {
4083 /* Rtx's of different codes cannot be equal. */
4087 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
4088 (REG:SI x) and (REG:HI x) are NOT equivalent. */
4093 /* For floating-point, consider everything unequal. This is a bit
4094 pessimistic, but this pass would only rarely do anything for FP
4095 anyway. */
4100 /* For commutative operations, the RTX match if the operand match in any
4101 order. Also handle the simple binary and unary cases without a loop. */
4113 /* Handle special-cases first. */
4115 {
4120 /* If neither is user variable or hard register, check for possible
4121 equivalence. */
4128 {
4130 num_same_regs++;
4132 /* If this is the first time we are seeing a register on the `Y'
4133 side, see if it is the last use. If not, we can't thread the
4134 jump, so mark it as not equivalent. */
4139 }
4140 else
4146 /* If memory modified or either volatile, not equivalent.
4147 Else, check address. */
4160 /* Cancel a pending `same_regs' if setting equivalenced registers.
4161 Then process source. */
4164 {
4166 {
4168 num_same_regs--;
4169 }
4172 }
4173 else
4174 {
4177 }
4189 }
4196 {
4198 {
4212 /* Two vectors must have the same length. */
4216 /* And the corresponding elements must match. */
4235 /* These are just backpointers, so they don't matter. */
4242 /* It is believed that rtx's at this level will never
4243 contain anything but integers and other rtx's,
4244 except for within LABEL_REFs and SYMBOL_REFs. */
4247 }
4248 }
4250 }