| blob | d816b126ac471b133a517a23b8e03f95f85dfe00 |
1 /* Optimize jump instructions, for GNU compiler.
2 Copyright (C) 1987, 88, 89, 91-99, 2000 Free Software Foundation, Inc.
4 This file is part of GNU CC.
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.
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.
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, 59 Temple Place - Suite 330,
19 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. */
71 /* ??? Eventually must record somehow the labels used by jumps
72 from nested functions. */
73 /* Pre-record the next or previous real insn for each label?
74 No, this pass is very fast anyway. */
75 /* Condense consecutive labels?
76 This would make life analysis faster, maybe. */
77 /* Optimize jump y; x: ... y: jumpif... x?
78 Don't know if it is worth bothering with. */
79 /* Optimize two cases of conditional jump to conditional jump?
80 This can never delete any instruction or make anything dead,
81 or even change what is live at any point.
82 So perhaps let combiner do it. */
84 /* Vector indexed by uid.
85 For each CODE_LABEL, index by its uid to get first unconditional jump
86 that jumps to the label.
87 For each JUMP_INSN, index by its uid to get the next unconditional jump
88 that jumps to the same label.
89 Element 0 is the start of a chain of all return insns.
90 (It is safe to use element 0 because insn uid 0 is not used. */
94 /* Maximum index in jump_chain. */
98 /* Set nonzero by jump_optimize if control can fall through
99 to the end of the function. */
102 /* Indicates whether death notes are significant in cross jump analysis.
103 Normally they are not significant, because of A and B jump to C,
104 and R dies in A, it must die in B. But this might not be true after
105 stack register conversion, and we must compare death notes in that
106 case. */
128 #if ! defined(HAVE_cc0) && ! defined(HAVE_conditional_arithmetic)
130 #endif
134 /* Main external entry point into the jump optimizer. See comments before
135 jump_optimize_1 for descriptions of the arguments. */
136 void
138 rtx f;
142 {
144 }
146 /* Alternate entry into the jump optimizer. This entry point only rebuilds
147 the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
148 instructions. */
149 void
151 rtx f;
152 {
154 }
156 \f
157 /* Delete no-op jumps and optimize jumps to jumps
158 and jumps around jumps.
159 Delete unused labels and unreachable code.
161 If CROSS_JUMP is 1, detect matching code
162 before a jump and its destination and unify them.
163 If CROSS_JUMP is 2, do cross-jumping, but pay attention to death notes.
165 If NOOP_MOVES is nonzero, delete no-op move insns.
167 If AFTER_REGSCAN is nonzero, then this jump pass is being run immediately
168 after regscan, and it is safe to use regno_first_uid and regno_last_uid.
170 If MARK_LABELS_ONLY is nonzero, then we only rebuild the jump chain
171 and JUMP_LABEL field for jumping insns.
173 If `optimize' is zero, don't change any code,
174 just determine whether control drops off the end of the function.
175 This case occurs when we have -W and not -O.
176 It works because `delete_insn' checks the value of `optimize'
177 and refrains from actually deleting when that is 0. */
179 static void
181 rtx f;
186 {
192 rtx last_insn;
197 /* If we are performing cross jump optimizations, then initialize
198 tables mapping UIDs to EH regions to avoid incorrect movement
199 of insns from one EH region to another. */
205 /* Leave some extra room for labels and duplicate exit test insns
206 we make. */
212 /* Keep track of labels used from static data;
213 they cannot ever be deleted. */
220 /* Keep track of labels used for marking handlers for exception
221 regions; they cannot usually be deleted. */
226 /* Quit now if we just wanted to rebuild the JUMP_LABEL and REG_LABEL
227 notes and recompute LABEL_NUSES. */
238 /* If we haven't yet gotten to reload and we have just run regscan,
239 delete any insn that sets a register that isn't used elsewhere.
240 This helps some of the optimizations below by having less insns
241 being jumped around. */
245 {
253 /* We use regno_last_note_uid so as not to delete the setting
254 of a reg that's used in notes. A subsequent optimization
255 might arrange to use that reg for real. */
259 /* An ADDRESSOF expression can turn into a use of the internal arg
260 pointer, so do not delete the initialization of the internal
261 arg pointer yet. If it is truly dead, flow will delete the
262 initializing insn. */
265 }
267 /* Now iterate optimizing jumps until nothing changes over one pass. */
271 {
275 {
276 rtx reallabelprev;
278 rtx nlabel;
284 /* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
285 jump. Try to optimize by duplicating the loop exit test if so.
286 This is only safe immediately after regscan, because it uses
287 the values of regno_first_uid and regno_last_uid. */
292 {
295 {
299 }
300 }
309 /* Tension the labels in dispatch tables. */
316 /* See if this jump goes to another jump and redirect if so. */
324 /* If a dispatch table always goes to the same place,
325 get rid of it and replace the insn that uses it. */
329 {
335 rtx set;
346 /* Don't mess with a casesi insn.
347 XXX according to the comment before computed_jump_p(),
348 all casesi insns should be a parallel of the jump
349 and a USE of a LABEL_REF. */
353 {
357 }
358 }
360 /* If a jump references the end of the function, try to turn
361 it into a RETURN insn, possibly a conditional one. */
370 /* Detect jump to following insn. */
372 {
377 }
379 /* Detect a conditional jump going to the same place
380 as an immediately following unconditional jump. */
386 {
387 /* Don't mess up test coverage analysis. */
395 {
399 }
400 }
402 /* Detect a conditional jump jumping over an unconditional jump. */
405 && ! this_is_simplejump
411 {
412 /* When we invert the unconditional jump, we will be
413 decrementing the usage count of its old label.
414 Make sure that we don't delete it now because that
415 might cause the following code to be deleted. */
423 {
424 /* It is very likely that if there are USE insns before
425 this jump, they hold REG_DEAD notes. These REG_DEAD
426 notes are no longer valid due to this optimization,
427 and will cause the life-analysis that following passes
428 (notably delayed-branch scheduling) to think that
429 these registers are dead when they are not.
431 To prevent this trouble, we just remove the USE insns
432 from the insn chain. */
436 {
440 }
444 }
446 /* We can now safely delete the label if it is unreferenced
447 since the delete_insn above has deleted the BARRIER. */
452 }
454 /* If we have an unconditional jump preceded by a USE, try to put
455 the USE before the target and jump there. This simplifies many
456 of the optimizations below since we don't have to worry about
457 dealing with these USE insns. We only do this if the label
458 being branch to already has the identical USE or if code
459 never falls through to that label. */
469 /* Don't do this optimization if we have a loop containing
470 only the USE instruction, and the loop start label has
471 a usage count of 1. This is because we will redo this
472 optimization everytime through the outer loop, and jump
473 opt will never exit. */
477 {
479 {
482 }
489 }
491 /* Simplify if (...) x = a; else x = b; by converting it
492 to x = b; if (...) x = a;
493 if B is sufficiently simple, the test doesn't involve X,
494 and nothing in the test modifies B or X.
496 If we have small register classes, we also can't do this if X
497 is a hard register.
499 If the "x = b;" insn has any REG_NOTES, we don't do this because
500 of the possibility that we are running after CSE and there is a
501 REG_EQUAL note that is only valid if the branch has already been
502 taken. If we move the insn with the REG_EQUAL note, we may
503 fold the comparison to always be false in a later CSE pass.
504 (We could also delete the REG_NOTES when moving the insn, but it
505 seems simpler to not move it.) An exception is that we can move
506 the insn if the only note is a REG_EQUAL or REG_EQUIV whose
507 value is the same as "b".
509 INSN is the branch over the `else' part.
511 We set:
513 TEMP to the jump insn preceding "x = a;"
514 TEMP1 to X
515 TEMP2 to the insn that sets "x = b;"
516 TEMP3 to the insn that sets "x = a;"
517 TEMP4 to the set of "x = b"; */
524 && (! SMALL_REGISTER_CLASSES
540 /* TEMP must skip over the "x = a;" insn */
543 /* There must be no other entries to the "x = b;" insn. */
545 /* INSN must either branch to the insn after TEMP2 or the insn
546 after TEMP2 must branch to the same place as INSN. */
551 {
552 /* The test expression, X, may be a complicated test with
553 multiple branches. See if we can find all the uses of
554 the label that TEMP branches to without hitting a CALL_INSN
555 or a jump to somewhere else. */
558 rtx p;
559 #ifdef HAVE_cc0
560 rtx q;
561 #endif
563 /* Set P to the first jump insn that goes around "x = a;". */
565 {
567 {
570 {
571 nuses--;
574 }
575 else
577 }
580 }
582 #ifdef HAVE_cc0
583 /* We cannot insert anything between a set of cc and its use
584 so if P uses cc0, we must back up to the previous insn. */
589 #endif
594 /* If we found all the uses and there was no data conflict, we
595 can move the assignment unless we can branch into the middle
596 from somewhere. */
603 /* Verify that registers used by the jump are not clobbered
604 by the instruction being moved. */
608 {
612 /* Set NEXT to an insn that we know won't go away. */
615 /* Delete the jump around the set. Note that we must do
616 this before we redirect the test jumps so that it won't
617 delete the code immediately following the assignment
618 we moved (which might be a jump). */
622 /* We either have two consecutive labels or a jump to
623 a jump, so adjust all the JUMP_INSNs to branch to where
624 INSN branches to. */
632 }
633 }
635 /* Simplify if (...) { x = a; goto l; } x = b; by converting it
636 to x = a; if (...) goto l; x = b;
637 if A is sufficiently simple, the test doesn't involve X,
638 and nothing in the test modifies A or X.
640 If we have small register classes, we also can't do this if X
641 is a hard register.
643 If the "x = a;" insn has any REG_NOTES, we don't do this because
644 of the possibility that we are running after CSE and there is a
645 REG_EQUAL note that is only valid if the branch has already been
646 taken. If we move the insn with the REG_EQUAL note, we may
647 fold the comparison to always be false in a later CSE pass.
648 (We could also delete the REG_NOTES when moving the insn, but it
649 seems simpler to not move it.) An exception is that we can move
650 the insn if the only note is a REG_EQUAL or REG_EQUIV whose
651 value is the same as "a".
653 INSN is the goto.
655 We set:
657 TEMP to the jump insn preceding "x = a;"
658 TEMP1 to X
659 TEMP2 to the insn that sets "x = b;"
660 TEMP3 to the insn that sets "x = a;"
661 TEMP4 to the set of "x = a"; */
668 && (! SMALL_REGISTER_CLASSES
684 /* TEMP must skip over the "x = a;" insn */
687 {
691 #ifdef HAVE_cc0
692 /* We cannot insert anything between a set of cc and its use. */
696 #endif
706 /* Verify that registers used by the jump are not clobbered
707 by the instruction being moved. */
712 {
717 /* Set NEXT to an insn that we know won't go away. */
720 }
725 }
727 #if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
729 /* If we have if (...) x = exp; and branches are expensive,
730 EXP is a single insn, does not have any side effects, cannot
731 trap, and is not too costly, convert this to
732 t = exp; if (...) x = t;
734 Don't do this when we have CC0 because it is unlikely to help
735 and we'd need to worry about where to place the new insn and
736 the potential for conflicts. We also can't do this when we have
737 notes on the insn for the same reason as above.
739 If we have conditional arithmetic, this will make this
740 harder to optimize later and isn't needed, so don't do it
741 in that case either.
743 We set:
745 TEMP to the "x = exp;" insn.
746 TEMP1 to the single set in the "x = exp;" insn.
747 TEMP2 to "x". */
761 && (! SMALL_REGISTER_CLASSES
769 {
774 {
782 {
785 }
786 }
787 }
789 /* Similarly, if it takes two insns to compute EXP but they
790 have the same destination. Here TEMP3 will be the second
791 insn and TEMP4 the SET from that insn. */
809 && (! SMALL_REGISTER_CLASSES
819 {
825 {
826 /* Use the earliest of temp5 and temp6. */
832 emit_insn_after_with_line_notes
840 {
843 }
844 }
845 }
847 /* Finally, handle the case where two insns are used to
848 compute EXP but a temporary register is used. Here we must
849 ensure that the temporary register is not used anywhere else. */
852 && after_regscan
880 && (! SMALL_REGISTER_CLASSES
886 {
892 {
893 /* Use the earliest of temp5 and temp6. */
906 {
909 }
910 }
911 }
914 #ifdef HAVE_conditional_arithmetic
915 /* ??? This is disabled in genconfig, as this simple-minded
916 transformation can incredibly lengthen register lifetimes.
918 Consider this example from cexp.c's yyparse:
920 234 (set (pc)
921 (if_then_else (ne (reg:DI 149) (const_int 0 [0x0]))
922 (label_ref 248) (pc)))
923 237 (set (reg/i:DI 0 $0) (const_int 1 [0x1]))
924 239 (set (pc) (label_ref 2382))
925 248 (code_label ("yybackup"))
927 This will be transformed to:
929 237 (set (reg/i:DI 0 $0)
930 (if_then_else:DI (eq (reg:DI 149) (const_int 0 [0x0]))
931 (const_int 1 [0x1]) (reg/i:DI 0 $0)))
932 239 (set (pc)
933 (if_then_else (eq (reg:DI 149) (const_int 0 [0x0]))
934 (label_ref 2382) (pc)))
936 which, from this narrow viewpoint looks fine. Except that
937 between this and 3 other ocurrences of the same pattern, $0
938 is now live for basically the entire function, and we'll
939 get an abort in caller_save.
941 Any replacement for this code should recall that a set of
942 a register that is not live need not, and indeed should not,
943 be conditionalized. Either that, or delay the transformation
944 until after register allocation. */
946 /* See if this is a conditional jump around a small number of
947 instructions that we can conditionalize. Don't do this before
948 the initial CSE pass or after reload.
950 We reject any insns that have side effects or may trap.
951 Strictly speaking, this is not needed since the machine may
952 support conditionalizing these too, but we won't deal with that
953 now. Specifically, this means that we can't conditionalize a
954 CALL_INSN, which some machines, such as the ARC, can do, but
955 this is a very minor optimization. */
960 insn))
961 {
972 /* Scan forward BRANCH_COST real insns looking for the JUMP_LABEL
973 of this insn. We see if we think we can conditionalize the
974 insns we pass. For now, we only deal with insns that have
975 one SET. We stop after an insn that modifies anything in
976 OURCOND, if we have too many insns, or if we have an insn
977 with a side effect or that may trip. Note that we will
978 be modifying any unconditional jumps we encounter to be
979 conditional; this will have the effect of also doing this
980 optimization on the "else" the next time around. */
985 {
986 /* Ignore everything but an active insn. */
992 /* If this was an unconditional jump, record it since we'll
993 need to remove the BARRIER if we succeed. We can only
994 have one such jump since there must be a label after
995 the BARRIER and it's either ours, in which case it's the
996 only one or some other, in which case we'd fail.
997 Likewise if it's a CALL_INSN followed by a BARRIER. */
1003 {
1006 else
1007 changed_jump
1009 }
1011 /* See if we are allowed another insn and if this insn
1012 if one we think we may be able to handle. */
1014 || last_insn
1022 gen_rtx_IF_THEN_ELSE
1027 else
1028 {
1029 /* This is a CALL_INSN that doesn't have a SET. */
1036 gen_rtx_IF_THEN_ELSE
1040 }
1045 }
1047 /* If we've reached our jump label, haven't failed, and all
1048 the changes above are valid, we can delete this jump
1049 insn. Also remove a BARRIER after any jump that used
1050 to be unconditional and remove any REG_EQUAL or REG_EQUIV
1051 that might have previously been present on insns we
1052 made conditional. */
1055 {
1066 {
1068 {
1071 }
1074 }
1079 }
1080 else
1081 {
1084 }
1085 }
1086 #endif
1087 /* If branches are expensive, convert
1088 if (foo) bar++; to bar += (foo != 0);
1089 and similarly for "bar--;"
1091 INSN is the conditional branch around the arithmetic. We set:
1093 TEMP is the arithmetic insn.
1094 TEMP1 is the SET doing the arithmetic.
1095 TEMP2 is the operand being incremented or decremented.
1096 TEMP3 to the condition being tested.
1097 TEMP4 to the earliest insn used to find the condition. */
1100 #ifdef HAVE_incscc
1101 || HAVE_incscc
1102 #endif
1103 #ifdef HAVE_decscc
1104 || HAVE_decscc
1105 #endif
1106 )
1107 && ! reload_completed
1119 /* INSN must either branch to the insn after TEMP or the insn
1120 after TEMP must branch to the same place as INSN. */
1126 /* We must be comparing objects whose modes imply the size.
1127 We could handle BLKmode if (1) emit_store_flag could
1128 and (2) we could find the size reliably. */
1131 {
1137 /* It must be the case that TEMP2 is not modified in the range
1138 [TEMP4, INSN). The one exception we make is if the insn
1139 before INSN sets TEMP2 to something which is also unchanged
1140 in that range. In that case, we can move the initialization
1141 into our sequence. */
1151 {
1155 }
1161 VOIDmode,
1165 /* If we can do the store-flag, do the addition or
1166 subtraction. */
1175 {
1176 /* Put the result back in temp2 in case it isn't already.
1177 Then replace the jump, possible a CC0-setting insn in
1178 front of the jump, and TEMP, with the sequence we have
1179 made. */
1194 #ifdef HAVE_cc0
1196 #endif
1200 {
1203 }
1207 }
1208 else
1210 }
1212 /* Try to use a conditional move (if the target has them), or a
1213 store-flag insn. If the target has conditional arithmetic as
1214 well as conditional move, the above code will have done something.
1215 Note that we prefer the above code since it is more general: the
1216 code below can make changes that require work to undo.
1218 The general case here is:
1220 1) x = a; if (...) x = b; and
1221 2) if (...) x = b;
1223 If the jump would be faster, the machine should not have defined
1224 the movcc or scc insns!. These cases are often made by the
1225 previous optimization.
1227 The second case is treated as x = x; if (...) x = b;.
1229 INSN here is the jump around the store. We set:
1231 TEMP to the "x op= b;" insn.
1232 TEMP1 to X.
1233 TEMP2 to B.
1234 TEMP3 to A (X in the second case).
1235 TEMP4 to the condition being tested.
1236 TEMP5 to the earliest insn used to find the condition.
1237 TEMP6 to the SET of TEMP. */
1240 ! reload_completed
1241 #ifdef HAVE_conditional_arithmetic
1242 /* Defer this until after CSE so the above code gets the
1243 first crack at it. */
1244 && cse_not_expected
1245 #endif
1247 /* Set TEMP to the "x = b;" insn. */
1252 && (! SMALL_REGISTER_CLASSES
1256 /* Allow either form, but prefer the former if both apply.
1257 There is no point in using the old value of TEMP1 if
1258 it is a register, since cse will alias them. It can
1259 lose if the old value were a hard register since CSE
1260 won't replace hard registers. Avoid using TEMP3 if
1261 small register classes and it is a hard register. */
1265 /* Make the latter case look like x = x; if (...) x = b; */
1267 /* INSN must either branch to the insn after TEMP or the insn
1268 after TEMP must branch to the same place as INSN. */
1274 /* We must be comparing objects whose modes imply the size.
1275 We could handle BLKmode if (1) emit_store_flag could
1276 and (2) we could find the size reliably. */
1278 /* Even if branches are cheap, the store_flag optimization
1279 can win when the operation to be performed can be
1280 expressed directly. */
1281 #ifdef HAVE_cc0
1282 /* If the previous insn sets CC0 and something else, we can't
1283 do this since we are going to delete that insn. */
1290 #endif
1291 )
1292 {
1293 #ifdef HAVE_conditional_move
1294 /* First try a conditional move. */
1295 {
1301 /* Copy the compared variables into cond0 and cond1, so that
1302 any side effects performed in or after the old comparison,
1303 will not affect our compare which will come later. */
1304 /* ??? Is it possible to just use the comparison in the jump
1305 insn? After all, we're going to delete it. We'd have
1306 to modify emit_conditional_move to take a comparison rtx
1307 instead or write a new function. */
1309 /* We want the target to be able to simplify comparisons with
1310 zero (and maybe other constants as well), so don't create
1311 pseudos for them. There's no need to either. */
1315 else
1321 else
1324 /* Careful about copying these values -- an IOR or what may
1325 need to do other things, like clobber flags. */
1326 /* ??? Assume for the moment that AVAL is ok. */
1331 /* We're dealing with a single_set insn with no side effects
1332 on SET_SRC. We do need to be reasonably certain that if
1333 we need to force BVAL into a register that we won't
1334 clobber the flags -- general_operand should suffice. */
1337 else
1338 {
1344 }
1353 {
1357 /* Save the conditional move sequence but don't emit it
1358 yet. On some machines, like the alpha, it is possible
1359 that temp5 == insn, so next generate the sequence that
1360 saves the compared values and then emit both
1361 sequences ensuring seq1 occurs before seq2. */
1365 /* "Now that we can't fail..." Famous last words.
1366 Generate the copy insns that preserve the compared
1367 values. */
1375 /* Validate the sequence -- this may be some weird
1376 bit-extract-and-test instruction for which there
1377 exists no complimentary bit-extract insn. */
1381 {
1384 }
1387 {
1390 /* Insert conditional move after insn, to be sure
1391 that the jump and a possible compare won't be
1392 separated. */
1395 /* ??? We can also delete the insn that sets X to A.
1396 Flow will do it too though. */
1402 {
1404 old_max_reg);
1406 }
1410 }
1411 }
1412 else
1414 }
1415 #endif
1417 /* That didn't work, try a store-flag insn.
1419 We further divide the cases into:
1421 1) x = a; if (...) x = b; and either A or B is zero,
1422 2) if (...) x = 0; and jumps are expensive,
1423 3) x = a; if (...) x = b; and A and B are constants where all
1424 the set bits in A are also set in B and jumps are expensive,
1425 4) x = a; if (...) x = b; and A and B non-zero, and jumps are
1426 more expensive, and
1427 5) if (...) x = b; if jumps are even more expensive. */
1430 /* We will be passing this as operand into expand_and. No
1431 good if it's not valid as an operand. */
1434 /* Make the latter case look like
1435 x = x; if (...) x = 0; */
1440 /* If B is zero, OK; if A is zero, can only do (1) if we
1441 can reverse the condition. See if (3) applies possibly
1442 by reversing the condition. Prefer reversing to (4) when
1443 branches are very expensive. */
1447 /* Check that the mask is a power of two,
1448 so that it can probably be generated
1449 with a shift. */
1466 insn)))))
1468 )
1469 {
1473 rtx target;
1475 /* If necessary, reverse the condition. */
1478 else
1481 /* If CVAL is non-zero, normalize to -1. Otherwise, if UVAL
1482 is the constant 1, it is best to just compute the result
1483 directly. If UVAL is constant and STORE_FLAG_VALUE
1484 includes all of its bits, it is best to compute the flag
1485 value unnormalized and `and' it with UVAL. Otherwise,
1486 normalize to -1 and `and' with UVAL. */
1493 /* We will be putting the store-flag insn immediately in
1494 front of the comparison that was originally being done,
1495 so we know all the variables in TEMP4 will be valid.
1496 However, this might be in front of the assignment of
1497 A to VAR. If it is, it would clobber the store-flag
1498 we will be emitting.
1500 Therefore, emit into a temporary which will be copied to
1501 VAR immediately after TEMP. */
1506 VOIDmode,
1509 normalizep);
1511 {
1512 rtx seq;
1518 /* Put the store-flag insns in front of the first insn
1519 used to compute the condition to ensure that we
1520 use the same values of them as the current
1521 comparison. However, the remainder of the insns we
1522 generate will be placed directly in front of the
1523 jump insn, in case any of the pseudos we use
1524 are modified earlier. */
1530 /* Both CVAL and UVAL are non-zero. */
1532 {
1540 else
1541 {
1547 }
1549 /* If we usually make new pseudos, do so here. This
1550 turns out to help machines that have conditional
1551 move insns. */
1552 /* ??? Conditional moves have already been handled.
1553 This may be obsolete. */
1561 }
1563 {
1564 /* We know that either CVAL or UVAL is zero. If
1565 UVAL is zero, negate TARGET and `and' with CVAL.
1566 Otherwise, `and' with UVAL. */
1568 {
1572 }
1578 }
1583 #ifdef HAVE_cc0
1584 /* If INSN uses CC0, we must not separate it from the
1585 insn that sets cc0. */
1588 #endif
1596 {
1599 }
1603 }
1604 else
1606 }
1607 }
1610 /* Simplify if (...) x = 1; else {...} if (x) ...
1611 We recognize this case scanning backwards as well.
1613 TEMP is the assignment to x;
1614 TEMP1 is the label at the head of the second if. */
1615 /* ?? This should call get_condition to find the values being
1616 compared, instead of looking for a COMPARE insn when HAVE_cc0
1617 is not defined. This would allow it to work on the m88k. */
1618 /* ?? This optimization is only safe before cse is run if HAVE_cc0
1619 is not defined and the condition is tested by a separate compare
1620 insn. This is because the code below assumes that the result
1621 of the compare dies in the following branch.
1623 Not only that, but there might be other insns between the
1624 compare and branch whose results are live. Those insns need
1625 to be executed.
1627 A way to fix this is to move the insns at JUMP_LABEL (insn)
1628 to before INSN. If we are running before flow, they will
1629 be deleted if they aren't needed. But this doesn't work
1630 well after flow.
1632 This is really a special-case of jump threading, anyway. The
1633 right thing to do is to replace this and jump threading with
1634 much simpler code in cse.
1636 This code has been turned off in the non-cc0 case in the
1637 meantime. */
1639 #ifdef HAVE_cc0
1641 /* Safe to skip USE and CLOBBER insns here
1642 since they will not be deleted. */
1650 /* If we find that the next value tested is `x'
1651 (TEMP1 is the insn where this happens), win. */
1654 #ifdef HAVE_cc0
1655 /* Does temp1 `tst' the value of x? */
1659 #else
1660 /* Does temp1 compare the value of x against zero? */
1667 #endif
1669 {
1670 /* Get the if_then_else from the condjump. */
1673 {
1676 rtx cond
1679 rtx ultimate;
1685 else
1695 }
1696 }
1697 #endif
1699 #if 0
1700 /* @@ This needs a bit of work before it will be right.
1702 Any type of comparison can be accepted for the first and
1703 second compare. When rewriting the first jump, we must
1704 compute the what conditions can reach label3, and use the
1705 appropriate code. We can not simply reverse/swap the code
1706 of the first jump. In some cases, the second jump must be
1707 rewritten also.
1709 For example,
1710 < == converts to > ==
1711 < != converts to == >
1712 etc.
1714 If the code is written to only accept an '==' test for the second
1715 compare, then all that needs to be done is to swap the condition
1716 of the first branch.
1718 It is questionable whether we want this optimization anyways,
1719 since if the user wrote code like this because he/she knew that
1720 the jump to label1 is taken most of the time, then rewriting
1721 this gives slower code. */
1722 /* @@ This should call get_condition to find the values being
1723 compared, instead of looking for a COMPARE insn when HAVE_cc0
1724 is not defined. This would allow it to work on the m88k. */
1725 /* @@ This optimization is only safe before cse is run if HAVE_cc0
1726 is not defined and the condition is tested by a separate compare
1727 insn. This is because the code below assumes that the result
1728 of the compare dies in the following branch. */
1730 /* Simplify test a ~= b
1731 condjump label1;
1732 test a == b
1733 condjump label2;
1734 jump label3;
1735 label1:
1737 rewriting as
1738 test a ~~= b
1739 condjump label3
1740 test a == b
1741 condjump label2
1742 label1:
1744 where ~= is an inequality, e.g. >, and ~~= is the swapped
1745 inequality, e.g. <.
1747 We recognize this case scanning backwards.
1749 TEMP is the conditional jump to `label2';
1750 TEMP1 is the test for `a == b';
1751 TEMP2 is the conditional jump to `label1';
1752 TEMP3 is the test for `a ~= b'. */
1761 #ifdef HAVE_cc0
1763 #else
1767 #endif
1781 {
1786 {
1789 }
1793 }
1794 #endif
1795 /* Simplify if (...) {... x = 1;} if (x) ...
1797 We recognize this case backwards.
1799 TEMP is the test of `x';
1800 TEMP1 is the assignment to `x' at the end of the
1801 previous statement. */
1802 /* @@ This should call get_condition to find the values being
1803 compared, instead of looking for a COMPARE insn when HAVE_cc0
1804 is not defined. This would allow it to work on the m88k. */
1805 /* @@ This optimization is only safe before cse is run if HAVE_cc0
1806 is not defined and the condition is tested by a separate compare
1807 insn. This is because the code below assumes that the result
1808 of the compare dies in the following branch. */
1810 /* ??? This has to be turned off. The problem is that the
1811 unconditional jump might indirectly end up branching to the
1812 label between TEMP1 and TEMP. We can't detect this, in general,
1813 since it may become a jump to there after further optimizations.
1814 If that jump is done, it will be deleted, so we will retry
1815 this optimization in the next pass, thus an infinite loop.
1817 The present code prevents this by putting the jump after the
1818 label, but this is not logically correct. */
1819 #if 0
1821 /* Safe to skip USE and CLOBBER insns here
1822 since they will not be deleted. */
1827 #ifdef HAVE_cc0
1830 #else
1831 /* Temp must be a compare insn, we can not accept a register
1832 to register move here, since it may not be simply a
1833 tst insn. */
1839 #endif
1840 /* May skip USE or CLOBBER insns here
1841 for checking for opportunity, since we
1842 take care of them later. */
1846 #ifdef HAVE_cc0
1848 #else
1851 #endif
1853 /* If this isn't true, cse will do the job. */
1855 {
1856 /* Get the if_then_else from the condjump. */
1861 {
1863 rtx last_insn;
1864 rtx ultimate;
1865 rtx p;
1867 /* Get the place that condjump will jump to
1868 if it is reached from here. */
1872 else
1874 /* Get it as a CODE_LABEL. */
1877 else
1878 /* Get the label out of the LABEL_REF. */
1881 /* Insert the jump immediately before TEMP, specifically
1882 after the label that is between TEMP1 and TEMP. */
1885 /* If we would be branching to the next insn, the jump
1886 would immediately be deleted and the re-inserted in
1887 a subsequent pass over the code. So don't do anything
1888 in that case. */
1891 {
1894 last_insn);
1899 {
1903 }
1906 }
1907 }
1908 }
1909 #endif
1910 #ifdef HAVE_trap
1911 /* Detect a conditional jump jumping over an unconditional trap. */
1922 {
1928 {
1934 }
1935 }
1936 /* Detect a jump jumping to an unconditional trap. */
1941 && (this_is_simplejump
1943 {
1948 {
1950 /* Replace an unconditional jump to a trap with a trap. */
1952 {
1957 }
1962 {
1967 }
1968 }
1969 /* If the trap condition and jump condition are mutually
1970 exclusive, redirect the jump to the following insn. */
1972 && ! this_is_simplejump
1977 {
1980 }
1981 }
1982 #endif
1983 else
1984 {
1985 /* Now that the jump has been tensioned,
1986 try cross jumping: check for identical code
1987 before the jump and before its target label. */
1989 /* First, cross jumping of conditional jumps: */
1992 {
1996 /* A conditional jump may be crossjumped
1997 only if the place it jumps to follows
1998 an opposing jump that comes back here. */
2001 /* We have no opposing jump;
2002 cannot cross jump this insn. */
2006 /* TARGET is nonzero if it is ok to cross jump
2007 to code before TARGET. If so, see if matches. */
2013 {
2015 /* Make the old conditional jump
2016 into an unconditional one. */
2021 /* Add to jump_chain unless this is a new label
2022 whose UID is too large. */
2024 {
2028 }
2031 }
2032 }
2034 /* Cross jumping of unconditional jumps:
2035 a few differences. */
2038 {
2040 rtx target;
2044 /* TARGET is nonzero if it is ok to cross jump
2045 to code before TARGET. If so, see if matches. */
2049 /* If cannot cross jump to code before the label,
2050 see if we can cross jump to another jump to
2051 the same label. */
2052 /* Try each other jump to this label. */
2059 /* Ignore TARGET if it's deleted. */
2065 {
2069 }
2070 }
2072 /* This code was dead in the previous jump.c! */
2074 {
2075 /* Return insns all "jump to the same place"
2076 so we can cross-jump between any two of them. */
2082 /* If cannot cross jump to code before the label,
2083 see if we can cross jump to another jump to
2084 the same label. */
2085 /* Try each other jump to this label. */
2096 {
2100 }
2101 }
2102 }
2103 }
2106 }
2108 /* Delete extraneous line number notes.
2109 Note that two consecutive notes for different lines are not really
2110 extraneous. There should be some indication where that line belonged,
2111 even if it became empty. */
2113 {
2118 {
2119 /* Delete this note if it is identical to previous note. */
2123 {
2126 }
2129 }
2130 }
2132 /* CAN_REACH_END is persistent for each function. Once set it should
2133 not be cleared. This is especially true for the case where we
2134 delete the NOTE_FUNCTION_END note. CAN_REACH_END is cleared by
2135 the front-end before compiling each function. */
2139 end:
2140 /* Clean up. */
2143 }
2144 \f
2145 /* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
2146 notes whose labels don't occur in the insn any more. Returns the
2147 largest INSN_UID found. */
2148 static int
2150 rtx f;
2151 {
2153 rtx insn;
2156 {
2162 {
2166 {
2171 }
2172 }
2175 }
2178 }
2180 /* Delete insns following barriers, up to next label.
2182 Also delete no-op jumps created by gcse. */
2183 static void
2185 rtx f;
2186 {
2187 rtx insn;
2190 {
2192 {
2198 {
2202 else
2204 }
2205 /* INSN is now the code_label. */
2206 }
2207 /* Also remove (set (pc) (pc)) insns which can be created by
2208 gcse. We eliminate such insns now to avoid having them
2209 cause problems later. */
2216 else
2218 }
2219 }
2221 /* Mark the label each jump jumps to.
2222 Combine consecutive labels, and count uses of labels.
2224 For each label, make a chain (using `jump_chain')
2225 of all the *unconditional* jumps that jump to it;
2226 also make a chain of all returns.
2228 CROSS_JUMP indicates whether we are doing cross jumping
2229 and if we are whether we will be paying attention to
2230 death notes or not. */
2232 static void
2234 rtx f;
2236 {
2237 rtx insn;
2241 {
2244 {
2246 {
2250 }
2252 {
2255 }
2256 }
2257 }
2258 }
2260 /* Delete all labels already not referenced.
2261 Also find and return the last insn. */
2263 static rtx
2265 rtx f;
2266 {
2268 rtx insn;
2271 {
2276 else
2277 {
2280 }
2281 }
2284 }
2286 /* Delete various simple forms of moves which have no necessary
2287 side effect. */
2289 static void
2291 rtx f;
2292 {
2296 {
2300 {
2303 /* Combine stack_adjusts with following push_insns. */
2304 #ifdef PUSH_ROUNDING
2311 {
2312 rtx p;
2318 /* Find all successive push insns. */
2320 /* Don't convert more than three pushes;
2321 that starts adding too many displaced addresses
2322 and the whole thing starts becoming a losing
2323 proposition. */
2325 {
2334 /* Allow a no-op move between the adjust and the push. */
2343 pushes++;
2348 }
2350 /* Discard the amount pushed from the stack adjust;
2351 maybe eliminate it entirely. */
2353 {
2356 }
2357 else
2361 /* Change the appropriate push insns to ordinary stores. */
2364 {
2373 /* Allow a no-op move between the adjust and the push. */
2383 /* If this push doesn't fully fit in the space
2384 of the stack adjust that we deleted,
2385 make another stack adjust here for what we
2386 didn't use up. There should be peepholes
2387 to recognize the resulting sequence of insns. */
2389 {
2392 p);
2394 }
2397 }
2398 }
2399 #endif
2401 /* Detect and delete no-op move instructions
2402 resulting from not allocating a parameter in a register. */
2415 /* Detect and ignore no-op move instructions
2416 resulting from smart or fortuitous register allocation. */
2419 {
2426 {
2427 rtx trial;
2434 {
2435 /* DREG may have been the target of a REG_DEAD note in
2436 the insn which makes INSN redundant. If so, reorg
2437 would still think it is dead. So search for such a
2438 note and delete it if we find it. */
2444 {
2447 }
2449 /* Deleting insn could lose a death-note for SREG. */
2451 {
2452 /* Change this into a USE so that we won't emit
2453 code for it, but still can keep the note. */
2457 /* Remove all reg notes but the REG_DEAD one. */
2460 }
2461 else
2463 }
2464 }
2469 {
2470 /* This handles the case where we have two consecutive
2471 assignments of the same constant to pseudos that didn't
2472 get a hard reg. Each SET from the constant will be
2473 converted into a SET of the spill register and an
2474 output reload will be made following it. This produces
2475 two loads of the same constant into the same spill
2476 register. */
2480 /* Look back for a death note for the first reg.
2481 If there is one, it is no longer accurate. */
2483 {
2487 {
2490 }
2492 }
2494 /* Delete the second load of the value. */
2496 }
2497 }
2499 {
2500 /* If each part is a set between two identical registers or
2501 a USE or CLOBBER, delete the insn. */
2503 rtx tem;
2506 {
2516 }
2520 }
2521 /* Also delete insns to store bit fields if they are no-ops. */
2522 /* Not worth the hair to detect this in the big-endian case. */
2531 }
2533 }
2534 }
2536 /* See if there is still a NOTE_INSN_FUNCTION_END in this function.
2537 If so indicate that this function can drop off the end by returning
2538 1, else return 0.
2540 CHECK_DELETED indicates whether we must check if the note being
2541 searched for has the deleted flag set.
2543 DELETE_FINAL_NOTE indicates whether we should delete the note
2544 if we find it. */
2546 static int
2548 rtx last;
2550 {
2555 {
2558 /* One label can follow the end-note: the return label. */
2561 /* Ordinary insns can follow it if returning a structure. */
2564 /* If machine uses explicit RETURN insns, no epilogue,
2565 then one of them follows the note. */
2569 /* A barrier can follow the return insn. */
2572 /* Other kinds of notes can follow also. */
2581 }
2583 /* See if we backed up to the appropriate type of note. */
2587 {
2591 }
2594 }
2596 /* LOOP_START is a NOTE_INSN_LOOP_BEG note that is followed by an unconditional
2597 jump. Assume that this unconditional jump is to the exit test code. If
2598 the code is sufficiently simple, make a copy of it before INSN,
2599 followed by a jump to the exit of the loop. Then delete the unconditional
2600 jump after INSN.
2602 Return 1 if we made the change, else 0.
2604 This is only safe immediately after a regscan pass because it uses the
2605 values of regno_first_uid and regno_last_uid. */
2607 static int
2609 rtx loop_start;
2610 {
2615 rtx lastexit;
2619 /* Scan the exit code. We do not perform this optimization if any insn:
2621 is a CALL_INSN
2622 is a CODE_LABEL
2623 has a REG_RETVAL or REG_LIBCALL note (hard to adjust)
2624 is a NOTE_INSN_LOOP_BEG because this means we have a nested loop
2625 is a NOTE_INSN_BLOCK_{BEG,END} because duplicating these notes
2626 is not valid.
2628 We also do not do this if we find an insn with ASM_OPERANDS. While
2629 this restriction should not be necessary, copying an insn with
2630 ASM_OPERANDS can confuse asm_noperands in some cases.
2632 Also, don't do this if the exit code is more than 20 insns. */
2635 insn
2639 {
2641 {
2646 /* We could be in front of the wrong NOTE_INSN_LOOP_END if there is
2647 a jump immediately after the loop start that branches outside
2648 the loop but within an outer loop, near the exit test.
2649 If we copied this exit test and created a phony
2650 NOTE_INSN_LOOP_VTOP, this could make instructions immediately
2651 before the exit test look like these could be safely moved
2652 out of the loop even if they actually may be never executed.
2653 This can be avoided by checking here for NOTE_INSN_LOOP_CONT. */
2662 /* If we were to duplicate this code, we would not move
2663 the BLOCK notes, and so debugging the moved code would
2664 be difficult. Thus, we only move the code with -O2 or
2665 higher. */
2671 /* The code below would grossly mishandle REG_WAS_0 notes,
2672 so get rid of them here. */
2682 }
2683 }
2685 /* Unless INSN is zero, we can do the optimization. */
2691 /* See if any insn sets a register only used in the loop exit code and
2692 not a user variable. If so, replace it with a new register. */
2701 {
2707 {
2708 /* We can do the replacement. Allocate reg_map if this is the
2709 first replacement we found. */
2716 }
2717 }
2719 /* Now copy each insn. */
2721 {
2723 {
2728 /* Only copy line-number notes. */
2730 {
2733 }
2743 /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
2744 make them. */
2761 {
2765 }
2767 /* If this is a simple jump, add it to the jump chain. */
2771 {
2775 }
2780 }
2782 /* Record the first insn we copied. We need it so that we can
2783 scan the copied insns for new pseudo registers. */
2786 }
2788 /* Now clean up by emitting a jump to the end label and deleting the jump
2789 at the start of the loop. */
2791 {
2793 loop_start);
2795 /* Record the first insn we copied. We need it so that we can
2796 scan the copied insns for new pseudo registers. This may not
2797 be strictly necessary since we should have copied at least one
2798 insn above. But I am going to be safe. */
2805 {
2809 }
2811 }
2813 /* Now scan from the first insn we copied to the last insn we copied
2814 (copy) for new pseudo registers. Do this after the code to jump to
2815 the end label since that might create a new pseudo too. */
2818 /* Mark the exit code as the virtual top of the converted loop. */
2823 /* Clean up. */
2828 }
2829 \f
2830 /* Move all block-beg, block-end, loop-beg, loop-cont, loop-vtop, and
2831 loop-end notes between START and END out before START. Assume that
2832 END is not such a note. START may be such a note. Returns the value
2833 of the new starting insn, which may be different if the original start
2834 was such a note. */
2836 rtx
2839 {
2840 rtx insn;
2841 rtx next;
2844 {
2853 {
2856 else
2857 {
2865 }
2866 }
2867 }
2870 }
2871 \f
2872 /* Compare the instructions before insn E1 with those before E2
2873 to find an opportunity for cross jumping.
2874 (This means detecting identical sequences of insns followed by
2875 jumps to the same place, or followed by a label and a jump
2876 to that label, and replacing one with a jump to the other.)
2878 Assume E1 is a jump that jumps to label E2
2879 (that is not always true but it might as well be).
2880 Find the longest possible equivalent sequences
2881 and store the first insns of those sequences into *F1 and *F2.
2882 Store zero there if no equivalent preceding instructions are found.
2884 We give up if we find a label in stream 1.
2885 Actually we could transfer that label into stream 2. */
2887 static void
2892 {
2904 {
2914 /* Don't allow the range of insns preceding E1 or E2
2915 to include the other (E2 or E1). */
2919 /* If we will get to this code by jumping, those jumps will be
2920 tensioned to go directly to the new label (before I2),
2921 so this cross-jumping won't cost extra. So reduce the minimum. */
2923 {
2926 }
2931 /* Avoid moving insns across EH regions if either of the insns
2932 can throw. */
2941 /* If this is a CALL_INSN, compare register usage information.
2942 If we don't check this on stack register machines, the two
2943 CALL_INSNs might be merged leaving reg-stack.c with mismatching
2944 numbers of stack registers in the same basic block.
2945 If we don't check this on machines with delay slots, a delay slot may
2946 be filled that clobbers a parameter expected by the subroutine.
2948 ??? We take the simple route for now and assume that if they're
2949 equal, they were constructed identically. */
2956 #ifdef STACK_REGS
2957 /* If cross_jump_death_matters is not 0, the insn's mode
2958 indicates whether or not the insn contains any stack-like
2959 regs. */
2962 {
2963 /* If register stack conversion has already been done, then
2964 death notes must also be compared before it is certain that
2965 the two instruction streams match. */
2967 rtx note;
2987 done:
2988 ;
2989 }
2990 #endif
2992 /* Don't allow old-style asm or volatile extended asms to be accepted
2993 for cross jumping purposes. It is conceptually correct to allow
2994 them, since cross-jumping preserves the dynamic instruction order
2995 even though it is changing the static instruction order. However,
2996 if an asm is being used to emit an assembler pseudo-op, such as
2997 the MIPS `.set reorder' pseudo-op, then the static instruction order
2998 matters and it must be preserved. */
3006 {
3007 /* The following code helps take care of G++ cleanups. */
3008 rtx equiv1;
3009 rtx equiv2;
3016 /* If the equivalences are not to a constant, they may
3017 reference pseudos that no longer exist, so we can't
3018 use them. */
3021 {
3026 {
3033 }
3034 }
3036 /* Insns fail to match; cross jumping is limited to the following
3037 insns. */
3039 #ifdef HAVE_cc0
3040 /* Don't allow the insn after a compare to be shared by
3041 cross-jumping unless the compare is also shared.
3042 Here, if either of these non-matching insns is a compare,
3043 exclude the following insn from possible cross-jumping. */
3046 #endif
3048 /* If cross-jumping here will feed a jump-around-jump
3049 optimization, this jump won't cost extra, so reduce
3050 the minimum. */
3056 }
3058 win:
3060 {
3061 /* Ok, this insn is potentially includable in a cross-jump here. */
3064 }
3065 }
3069 }
3071 static void
3074 {
3075 /* Find an existing label at this point
3076 or make a new one if there is none. */
3079 /* Make the same jump insn jump to the new point. */
3081 {
3082 /* Remove from jump chain of returns. */
3084 /* Change the insn. */
3089 /* Add to new the jump chain. */
3092 {
3095 }
3096 }
3097 else
3100 /* Delete the matching insns before the jump. Also, remove any REG_EQUAL
3101 or REG_EQUIV note in the NEWLPOS stream that isn't also present in
3102 the NEWJPOS stream. */
3105 {
3106 rtx lnote;
3118 }
3119 }
3120 \f
3121 /* Return the label before INSN, or put a new label there. */
3123 rtx
3125 rtx insn;
3126 {
3127 rtx label;
3129 /* Find an existing label at this point
3130 or make a new one if there is none. */
3134 {
3140 }
3142 }
3144 /* Return the label after INSN, or put a new label there. */
3146 rtx
3148 rtx insn;
3149 {
3150 rtx label;
3152 /* Find an existing label at this point
3153 or make a new one if there is none. */
3157 {
3161 }
3163 }
3164 \f
3165 /* Return 1 if INSN is a jump that jumps to right after TARGET
3166 only on the condition that TARGET itself would drop through.
3167 Assumes that TARGET is a conditional jump. */
3169 static int
3172 {
3188 {
3192 }
3195 {
3199 }
3204 }
3205 \f
3206 /* Given a comparison, COMPARISON, inside a conditional jump insn, INSN,
3207 return non-zero if it is safe to reverse this comparison. It is if our
3208 floating-point is not IEEE, if this is an NE or EQ comparison, or if
3209 this is known to be an integer comparison. */
3211 int
3213 rtx comparison;
3214 rtx insn;
3215 {
3216 rtx arg0;
3218 /* If this is not actually a comparison, we can't reverse it. */
3223 /* If this is an NE comparison, it is safe to reverse it to an EQ
3224 comparison and vice versa, even for floating point. If no operands
3225 are NaNs, the reversal is valid. If some operand is a NaN, EQ is
3226 always false and NE is always true, so the reversal is also valid. */
3227 || flag_fast_math
3234 /* Make sure ARG0 is one of the actual objects being compared. If we
3235 can't do this, we can't be sure the comparison can be reversed.
3237 Handle cc0 and a MODE_CC register. */
3239 #ifdef HAVE_cc0
3241 #endif
3242 )
3243 {
3245 rtx set;
3247 /* First see if the condition code mode alone if enough to say we can
3248 reverse the condition. If not, then search backwards for a set of
3249 ARG0. We do not need to check for an insn clobbering it since valid
3250 code will contain set a set with no intervening clobber. But
3251 stop when we reach a label. */
3252 #ifdef REVERSIBLE_CC_MODE
3256 #endif
3263 {
3269 }
3270 }
3272 /* We can reverse this if ARG0 is a CONST_INT or if its mode is
3273 not VOIDmode and neither a MODE_CC nor MODE_FLOAT type. */
3278 }
3280 /* Given an rtx-code for a comparison, return the code for the negated
3281 comparison. If no such code exists, return UNKNOWN.
3283 WATCH OUT! reverse_condition is not safe to use on a jump that might
3284 be acting on the results of an IEEE floating point comparison, because
3285 of the special treatment of non-signaling nans in comparisons.
3286 Use can_reverse_comparison_p to be sure. */
3288 enum rtx_code
3291 {
3293 {
3329 }
3330 }
3332 /* Similar, but we're allowed to generate unordered comparisons, which
3333 makes it safe for IEEE floating-point. Of course, we have to recognize
3334 that the target will support them too... */
3336 enum rtx_code
3339 {
3340 /* Non-IEEE formats don't have unordered conditions. */
3345 {
3385 }
3386 }
3388 /* Similar, but return the code when two operands of a comparison are swapped.
3389 This IS safe for IEEE floating-point. */
3391 enum rtx_code
3394 {
3396 {
3432 }
3433 }
3435 /* Given a comparison CODE, return the corresponding unsigned comparison.
3436 If CODE is an equality comparison or already an unsigned comparison,
3437 CODE is returned. */
3439 enum rtx_code
3442 {
3444 {
3464 }
3465 }
3467 /* Similarly, return the signed version of a comparison. */
3469 enum rtx_code
3472 {
3474 {
3494 }
3495 }
3496 \f
3497 /* Return non-zero if CODE1 is more strict than CODE2, i.e., if the
3498 truth of CODE1 implies the truth of CODE2. */
3500 int
3503 {
3508 {
3553 }
3556 }
3557 \f
3558 /* Return 1 if INSN is an unconditional jump and nothing else. */
3560 int
3562 rtx insn;
3563 {
3568 }
3570 /* Return nonzero if INSN is a (possibly) conditional jump
3571 and nothing more. */
3573 int
3575 rtx insn;
3576 {
3595 }
3597 /* Return nonzero if INSN is a (possibly) conditional jump inside a
3598 PARALLEL. */
3600 int
3602 rtx insn;
3603 {
3608 else
3628 }
3630 /* Return the label of a conditional jump. */
3632 rtx
3634 rtx insn;
3635 {
3654 }
3656 /* Return true if INSN is a (possibly conditional) return insn. */
3658 static int
3662 {
3665 }
3667 int
3669 rtx insn;
3670 {
3672 }
3674 /* Return true if INSN is a jump that only transfers control and
3675 nothing more. */
3677 int
3679 rtx insn;
3680 {
3681 rtx set;
3695 }
3697 #ifdef HAVE_cc0
3699 /* Return 1 if X is an RTX that does nothing but set the condition codes
3700 and CLOBBER or USE registers.
3701 Return -1 if X does explicitly set the condition codes,
3702 but also does other things. */
3704 int
3706 rtx x ATTRIBUTE_UNUSED;
3707 {
3711 {
3716 {
3722 }
3724 }
3726 }
3727 #endif
3728 \f
3729 /* Follow any unconditional jump at LABEL;
3730 return the ultimate label reached by any such chain of jumps.
3731 If LABEL is not followed by a jump, return LABEL.
3732 If the chain loops or we can't find end, return LABEL,
3733 since that tells caller to avoid changing the insn.
3735 If RELOAD_COMPLETED is 0, we do not chain across a NOTE_INSN_LOOP_BEG or
3736 a USE or CLOBBER. */
3738 rtx
3740 rtx label;
3741 {
3755 depth++)
3756 {
3757 /* Don't chain through the insn that jumps into a loop
3758 from outside the loop,
3759 since that would create multiple loop entry jumps
3760 and prevent loop optimization. */
3761 rtx tem;
3766 /* ??? Optional. Disables some optimizations, but makes
3767 gcov output more accurate with -O. */
3771 /* If we have found a cycle, make the insn jump to itself. */
3781 }
3785 }
3787 /* Assuming that field IDX of X is a vector of label_refs,
3788 replace each of them by the ultimate label reached by it.
3789 Return nonzero if a change is made.
3790 If IGNORE_LOOPS is 0, we do not chain across a NOTE_INSN_LOOP_BEG. */
3792 static int
3796 {
3800 {
3804 {
3810 }
3811 }
3813 }
3814 \f
3815 /* Find all CODE_LABELs referred to in X, and increment their use counts.
3816 If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
3817 in INSN, then store one of them in JUMP_LABEL (INSN).
3818 If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
3819 referenced in INSN, add a REG_LABEL note containing that label to INSN.
3820 Also, when there are consecutive labels, canonicalize on the last of them.
3822 Note that two labels separated by a loop-beginning note
3823 must be kept distinct if we have not yet done loop-optimization,
3824 because the gap between them is where loop-optimize
3825 will want to move invariant code to. CROSS_JUMP tells us
3826 that loop-optimization is done with.
3828 Once reload has completed (CROSS_JUMP non-zero), we need not consider
3829 two labels distinct if they are separated by only USE or CLOBBER insns. */
3831 static void
3834 rtx insn;
3837 {
3843 {
3862 /* If this is a constant-pool reference, see if it is a label. */
3868 {
3871 rtx note;
3872 rtx next;
3877 /* Ignore references to labels of containing functions. */
3881 /* If there are other labels following this one,
3882 replace it with the last of the consecutive labels. */
3884 {
3896 /* ??? Optional. Disables some optimizations, but
3897 makes gcov output more accurate with -O. */
3900 }
3907 {
3911 /* If we've changed OLABEL and we had a REG_LABEL note
3912 for it, update it as well. */
3917 /* Otherwise, add a REG_LABEL note for LABEL unless there already
3918 is one. */
3920 {
3921 /* This code used to ignore labels which refered to dispatch
3922 tables to avoid flow.c generating worse code.
3924 However, in the presense of global optimizations like
3925 gcse which call find_basic_blocks without calling
3926 life_analysis, not recording such labels will lead
3927 to compiler aborts because of inconsistencies in the
3928 flow graph. So we go ahead and record the label.
3930 It may also be the case that the optimization argument
3931 is no longer valid because of the more accurate cfg
3932 we build in find_basic_blocks -- it no longer pessimizes
3933 code when it finds a REG_LABEL note. */
3936 }
3937 }
3939 }
3941 /* Do walk the labels in a vector, but not the first operand of an
3942 ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
3946 {
3952 }
3957 }
3961 {
3965 {
3969 }
3970 }
3971 }
3973 /* If all INSN does is set the pc, delete it,
3974 and delete the insn that set the condition codes for it
3975 if that's what the previous thing was. */
3977 void
3979 rtx insn;
3980 {
3985 }
3987 /* Verify INSN is a BARRIER and delete it. */
3989 void
3991 rtx insn;
3992 {
3997 }
3999 /* Recursively delete prior insns that compute the value (used only by INSN
4000 which the caller is deleting) stored in the register mentioned by NOTE
4001 which is a REG_DEAD note associated with INSN. */
4003 static void
4005 rtx note;
4006 rtx insn;
4007 {
4008 rtx our_prev;
4015 {
4018 /* If we reach a CALL which is not calling a const function
4019 or the callee pops the arguments, then give up. */
4025 /* If we reach a SEQUENCE, it is too complex to try to
4026 do anything with it, so give up. */
4032 /* reorg creates USEs that look like this. We leave them
4033 alone because reorg needs them for its own purposes. */
4037 {
4042 {
4043 /* If we find a SET of something else, we can't
4044 delete the insn. */
4049 {
4055 }
4059 }
4062 {
4064 int dest_endregno
4076 /* We may have a multi-word hard register and some, but not
4077 all, of the words of the register are needed in subsequent
4078 insns. Write REG_UNUSED notes for those parts that were not
4079 needed. */
4082 {
4094 }
4095 }
4098 }
4100 /* If PAT references the register that dies here, it is an
4101 additional use. Hence any prior SET isn't dead. However, this
4102 insn becomes the new place for the REG_DEAD note. */
4104 {
4108 }
4109 }
4110 }
4112 /* Delete INSN and recursively delete insns that compute values used only
4113 by INSN. This uses the REG_DEAD notes computed during flow analysis.
4114 If we are running before flow.c, we need do nothing since flow.c will
4115 delete dead code. We also can't know if the registers being used are
4116 dead or not at this point.
4118 Otherwise, look at all our REG_DEAD notes. If a previous insn does
4119 nothing other than set a register that dies in this insn, we can delete
4120 that insn as well.
4122 On machines with CC0, if CC0 is used in this insn, we may be able to
4123 delete the insn that set it. */
4125 static void
4127 rtx insn;
4128 {
4130 rtx set;
4132 #ifdef HAVE_cc0
4134 {
4136 /* We assume that at this stage
4137 CC's are always set explicitly
4138 and always immediately before the jump that
4139 will use them. So if the previous insn
4140 exists to set the CC's, delete it
4141 (unless it performs auto-increments, etc.). */
4144 {
4148 else
4149 /* Otherwise, show that cc0 won't be used. */
4152 }
4153 }
4154 #endif
4156 #ifdef INSN_SCHEDULING
4157 /* ?!? The schedulers do not keep REG_DEAD notes accurate after
4158 reload has completed. The schedulers need to be fixed. Until
4159 they are, we must not rely on the death notes here. */
4161 {
4164 }
4165 #endif
4167 /* The REG_DEAD note may have been omitted for a register
4168 which is both set and used by the insn. */
4171 {
4173 int dest_endregno
4180 {
4189 }
4190 }
4193 {
4197 /* Verify that the REG_NOTE is legitimate. */
4202 }
4205 }
4206 \f
4207 /* Delete insn INSN from the chain of insns and update label ref counts.
4208 May delete some following insns as a consequence; may even delete
4209 a label elsewhere and insns that follow it.
4211 Returns the first insn after INSN that was not deleted. */
4213 rtx
4216 {
4225 /* This insn is already deleted => return first following nondeleted. */
4232 /* Don't delete user-declared labels. When optimizing, convert them
4233 to special NOTEs instead. When not optimizing, leave them alone. */
4235 {
4239 {
4244 }
4245 }
4246 else
4247 /* Mark this insn as deleted. */
4250 /* If this is an unconditional jump, delete it from the jump chain. */
4254 /* If instruction is followed by a barrier,
4255 delete the barrier too. */
4258 {
4261 }
4263 /* Patch out INSN (and the barrier if any) */
4266 {
4268 {
4273 }
4276 {
4280 }
4284 }
4286 /* If deleting a jump, decrement the count of the label,
4287 and delete the label if it is now unused. */
4290 {
4294 {
4295 /* This can delete NEXT or PREV,
4296 either directly if NEXT is JUMP_LABEL (INSN),
4297 or indirectly through more levels of jumps. */
4300 /* I feel a little doubtful about this loop,
4301 but I see no clean and sure alternative way
4302 to find the first insn after INSN that is not now deleted.
4303 I hope this works. */
4307 }
4312 {
4313 /* If we're deleting the tablejump, delete the dispatch table.
4314 We may not be able to kill the label immediately preceeding
4315 just yet, as it might be referenced in code leading up to
4316 the tablejump. */
4318 }
4319 }
4321 /* Likewise if we're deleting a dispatch table. */
4326 {
4337 }
4342 /* If INSN was a label and a dispatch table follows it,
4343 delete the dispatch table. The tablejump must have gone already.
4344 It isn't useful to fall through into a table. */
4353 /* If INSN was a label, delete insns following it if now unreachable. */
4356 {
4362 {
4366 /* Keep going past other deleted labels to delete what follows. */
4369 else
4370 /* Note: if this deletes a jump, it can cause more
4371 deletion of unreachable code, after a different label.
4372 As long as the value from this recursive call is correct,
4373 this invocation functions correctly. */
4375 }
4376 }
4379 }
4381 /* Advance from INSN till reaching something not deleted
4382 then return that. May return INSN itself. */
4384 rtx
4386 rtx insn;
4387 {
4391 }
4392 \f
4393 /* Delete a range of insns from FROM to TO, inclusive.
4394 This is for the sake of peephole optimization, so assume
4395 that whatever these insns do will still be done by a new
4396 peephole insn that will replace them. */
4398 void
4401 {
4405 {
4410 {
4413 /* Patch this insn out of the chain. */
4414 /* We don't do this all at once, because we
4415 must preserve all NOTEs. */
4421 }
4426 }
4428 /* Note that if TO is an unconditional jump
4429 we *do not* delete the BARRIER that follows,
4430 since the peephole that replaces this sequence
4431 is also an unconditional jump in that case. */
4432 }
4433 \f
4434 /* We have determined that INSN is never reached, and are about to
4435 delete it. Print a warning if the user asked for one.
4437 To try to make this warning more useful, this should only be called
4438 once per basic block not reached, and it only warns when the basic
4439 block contains more than one line from the current function, and
4440 contains at least one operation. CSE and inlining can duplicate insns,
4441 so it's possible to get spurious warnings from this. */
4443 void
4445 rtx avoided_insn;
4446 {
4447 rtx insn;
4455 /* Scan forwards, looking at LINE_NUMBER notes, until
4456 we hit a LABEL or we run out of insns. */
4459 {
4464 {
4467 else
4470 }
4473 }
4478 }
4479 \f
4480 /* Invert the condition of the jump JUMP, and make it jump
4481 to label NLABEL instead of where it jumps now. */
4483 int
4486 {
4487 /* We have to either invert the condition and change the label or
4488 do neither. Either operation could fail. We first try to invert
4489 the jump. If that succeeds, we try changing the label. If that fails,
4490 we invert the jump back to what it was. */
4496 {
4498 {
4501 /* An inverted jump means that a probability taken becomes a
4502 probability not taken. Subtract the branch probability from the
4503 probability base to convert it back to a taken probability.
4504 (We don't flip the probability on a branch that's never taken. */
4507 }
4510 }
4513 /* This should just be putting it back the way it was. */
4517 }
4519 /* Invert the jump condition of rtx X contained in jump insn, INSN.
4521 Return 1 if we can do so, 0 if we cannot find a way to do so that
4522 matches a pattern. */
4524 int
4526 rtx x;
4527 rtx insn;
4528 {
4536 {
4540 /* We can do this in two ways: The preferable way, which can only
4541 be done if this is not an integer comparison, is to reverse
4542 the comparison code. Otherwise, swap the THEN-part and ELSE-part
4543 of the IF_THEN_ELSE. If we can't do either, fail. */
4556 }
4560 {
4562 {
4565 }
4567 {
4572 }
4573 }
4576 }
4577 \f
4578 /* Make jump JUMP jump to label NLABEL instead of where it jumps now.
4579 If the old jump target label is unused as a result,
4580 it and the code following it may be deleted.
4582 If NLABEL is zero, we are to turn the jump into a (possibly conditional)
4583 RETURN insn.
4585 The return value will be 1 if the change was made, 0 if it wasn't (this
4586 can only occur for NLABEL == 0). */
4588 int
4591 {
4600 /* If this is an unconditional branch, delete it from the jump_chain of
4601 OLABEL and add it to the jump_chain of NLABEL (assuming both labels
4602 have UID's in range and JUMP_CHAIN is valid). */
4605 {
4611 {
4614 }
4615 }
4621 /* If we're eliding the jump over exception cleanups at the end of a
4622 function, move the function end note so that -Wreturn-type works. */
4632 }
4634 /* Delete the instruction JUMP from any jump chain it might be on. */
4636 static void
4638 rtx jump;
4639 {
4643 /* Handle unconditional jumps. */
4648 /* Handle return insns. */
4655 else
4656 {
4657 rtx insn;
4663 {
4666 }
4667 }
4668 }
4670 /* If NLABEL is nonzero, throughout the rtx at LOC,
4671 alter (LABEL_REF OLABEL) to (LABEL_REF NLABEL). If OLABEL is
4672 zero, alter (RETURN) to (LABEL_REF NLABEL).
4674 If NLABEL is zero, alter (LABEL_REF OLABEL) to (RETURN) and check
4675 validity with validate_change. Convert (set (pc) (label_ref olabel))
4676 to (return).
4678 Return 0 if we found a change we would like to make but it is invalid.
4679 Otherwise, return 1. */
4681 int
4685 rtx insn;
4686 {
4693 {
4695 {
4698 else
4701 }
4702 }
4704 {
4709 }
4718 {
4720 {
4723 }
4725 {
4730 }
4731 }
4734 }
4735 \f
4736 /* Make jump JUMP jump to label NLABEL, assuming it used to be a tablejump.
4738 If the old jump target label (before the dispatch table) becomes unused,
4739 it and the dispatch table may be deleted. In that case, find the insn
4740 before the jump references that label and delete it and logical successors
4741 too. */
4743 static void
4746 {
4749 /* Add this jump to the jump_chain of NLABEL. */
4752 {
4755 }
4763 {
4766 }
4767 }
4769 /* Find the insn referencing LABEL that is a logical predecessor of INSN.
4770 If we found one, delete it and then delete this insn if DELETE_THIS is
4771 non-zero. Return non-zero if INSN or a predecessor references LABEL. */
4773 static int
4777 {
4779 rtx link;
4783 {
4785 {
4788 }
4789 else
4791 }
4795 {
4797 {
4800 }
4801 else
4803 }
4806 }
4807 \f
4808 /* Like rtx_equal_p except that it considers two REGs as equal
4809 if they renumber to the same value and considers two commutative
4810 operations to be the same if the order of the operands has been
4811 reversed.
4813 ??? Addition is not commutative on the PA due to the weird implicit
4814 space register selection rules for memory addresses. Therefore, we
4815 don't consider a + b == b + a.
4817 We could/should make this test a little tighter. Possibly only
4818 disabling it on the PA via some backend macro or only disabling this
4819 case when the PLUS is inside a MEM. */
4821 int
4824 {
4835 {
4842 /* If we haven't done any renumbering, don't
4843 make any assumptions. */
4848 {
4853 {
4856 }
4857 }
4859 else
4860 {
4864 }
4867 {
4872 {
4875 }
4876 }
4878 else
4879 {
4883 }
4886 }
4888 /* Now we have disposed of all the cases
4889 in which different rtx codes can match. */
4894 {
4905 /* We can't assume nonlocal labels have their following insns yet. */
4909 /* Two label-refs are equivalent if they point at labels
4910 in the same position in the instruction stream. */
4918 /* If we didn't match EQ equality above, they aren't the same. */
4923 }
4925 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
4930 /* For commutative operations, the RTX match if the operand match in any
4931 order. Also handle the simple binary and unary cases without a loop.
4933 ??? Don't consider PLUS a commutative operator; see comments above. */
4946 /* Compare the elements. If any pair of corresponding elements
4947 fail to match, return 0 for the whole things. */
4951 {
4954 {
4978 /* fall through. */
4992 }
4993 }
4995 }
4996 \f
4997 /* If X is a hard register or equivalent to one or a subregister of one,
4998 return the hard register number. If X is a pseudo register that was not
4999 assigned a hard register, return the pseudo register number. Otherwise,
5000 return -1. Any rtx is valid for X. */
5002 int
5004 rtx x;
5005 {
5007 {
5011 }
5013 {
5017 }
5019 }
5020 \f
5021 /* Optimize code of the form:
5023 for (x = a[i]; x; ...)
5024 ...
5025 for (x = a[i]; x; ...)
5026 ...
5027 foo:
5029 Loop optimize will change the above code into
5031 if (x = a[i])
5032 for (;;)
5033 { ...; if (! (x = ...)) break; }
5034 if (x = a[i])
5035 for (;;)
5036 { ...; if (! (x = ...)) break; }
5037 foo:
5039 In general, if the first test fails, the program can branch
5040 directly to `foo' and skip the second try which is doomed to fail.
5041 We run this after loop optimization and before flow analysis. */
5043 /* When comparing the insn patterns, we track the fact that different
5044 pseudo-register numbers may have been used in each computation.
5045 The following array stores an equivalence -- same_regs[I] == J means
5046 that pseudo register I was used in the first set of tests in a context
5047 where J was used in the second set. We also count the number of such
5048 pending equivalences. If nonzero, the expressions really aren't the
5049 same. */
5055 /* Track any registers modified between the target of the first jump and
5056 the second jump. They never compare equal. */
5060 /* Record if memory was modified. */
5064 /* Called via note_stores on each insn between the target of the first
5065 branch and the second branch. It marks any changed registers. */
5067 static void
5069 rtx dest;
5070 rtx x ATTRIBUTE_UNUSED;
5072 {
5087 else
5090 }
5092 /* F is the first insn in the chain of insns. */
5094 void
5096 rtx f;
5099 {
5100 /* Basic algorithm is to find a conditional branch,
5101 the label it may branch to, and the branch after
5102 that label. If the two branches test the same condition,
5103 walk back from both branch paths until the insn patterns
5104 differ, or code labels are hit. If we make it back to
5105 the target of the first branch, then we know that the first branch
5106 will either always succeed or always fail depending on the relative
5107 senses of the two branches. So adjust the first branch accordingly
5108 in this case. */
5117 /* Allocate register tables and quick-reset table. */
5125 {
5129 {
5130 /* Get to a candidate branch insn. */
5145 /* Look for a branch after the target. Record any registers and
5146 memory modified between the target and the branch. Stop when we
5147 get to a label since we can't know what was changed there. */
5149 {
5154 {
5155 /* If this is an unconditional jump and is the only use of
5156 its target label, we can follow it. */
5160 {
5163 }
5164 else
5166 }
5172 {
5181 }
5184 }
5186 /* Check the next candidate branch insn from the label
5187 of the first. */
5195 /* Get the comparison codes and operands, reversing the
5196 codes if appropriate. If we don't have comparison codes,
5197 we can't do anything. */
5210 /* If they test the same things and knowing that B1 branches
5211 tells us whether or not B2 branches, check if we
5212 can thread the branch. */
5218 b1)
5221 {
5226 {
5228 {
5229 /* We have reached the target of the first branch.
5230 If there are no pending register equivalents,
5231 we know that this branch will either always
5232 succeed (if the senses of the two branches are
5233 the same) or always fail (if not). */
5234 rtx new_label;
5241 else
5245 {
5251 {
5252 /* Don't thread to the loop label. If a loop
5253 label is reused, loop optimization will
5254 be disabled for that loop. */
5257 }
5259 }
5261 }
5263 /* If either of these is not a normal insn (it might be
5264 a JUMP_INSN, CALL_INSN, or CODE_LABEL) we fail. (NOTEs
5265 have already been skipped above.) Similarly, fail
5266 if the insns are different. */
5275 }
5276 }
5277 }
5278 }
5280 /* Clean up. */
5284 }
5285 \f
5286 /* This is like RTX_EQUAL_P except that it knows about our handling of
5287 possibly equivalent registers and knows to consider volatile and
5288 modified objects as not equal.
5290 YINSN is the insn containing Y. */
5292 int
5295 rtx yinsn;
5296 {
5303 /* Rtx's of different codes cannot be equal. */
5307 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
5308 (REG:SI x) and (REG:HI x) are NOT equivalent. */
5313 /* For floating-point, consider everything unequal. This is a bit
5314 pessimistic, but this pass would only rarely do anything for FP
5315 anyway. */
5320 /* For commutative operations, the RTX match if the operand match in any
5321 order. Also handle the simple binary and unary cases without a loop. */
5333 /* Handle special-cases first. */
5335 {
5340 /* If neither is user variable or hard register, check for possible
5341 equivalence. */
5348 {
5350 num_same_regs++;
5352 /* If this is the first time we are seeing a register on the `Y'
5353 side, see if it is the last use. If not, we can't thread the
5354 jump, so mark it as not equivalent. */
5359 }
5360 else
5366 /* If memory modified or either volatile, not equivalent.
5367 Else, check address. */
5380 /* Cancel a pending `same_regs' if setting equivalenced registers.
5381 Then process source. */
5384 {
5386 {
5388 num_same_regs--;
5389 }
5392 }
5393 else
5407 }
5414 {
5416 {
5430 /* Two vectors must have the same length. */
5434 /* And the corresponding elements must match. */
5453 /* These are just backpointers, so they don't matter. */
5460 /* It is believed that rtx's at this level will never
5461 contain anything but integers and other rtx's,
5462 except for within LABEL_REFs and SYMBOL_REFs. */
5465 }
5466 }
5468 }
5469 \f
5471 #if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
5472 /* Return the insn that NEW can be safely inserted in front of starting at
5473 the jump insn INSN. Return 0 if it is not safe to do this jump
5474 optimization. Note that NEW must contain a single set. */
5476 static rtx
5478 rtx insn;
5480 {
5482 rtx prev;
5484 /* If NEW does not clobber, it is safe to insert NEW before INSN. */
5491 insn))
5497 /* There is a good chance that the previous insn PREV sets the thing
5498 being clobbered (often the CC in a hard reg). If PREV does not
5499 use what NEW sets, we can insert NEW before PREV. */
5505 insn)
5507 prev))
5511 }