1 /* Perform instruction reorganizations for delay slot filling.
2 Copyright (C) 1992, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
3 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu).
4 Hacked by Michael Tiemann (tiemann@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Instruction reorganization pass.
25 This pass runs after register allocation and final jump
26 optimization. It should be the last pass to run before peephole.
27 It serves primarily to fill delay slots of insns, typically branch
28 and call insns. Other insns typically involve more complicated
29 interactions of data dependencies and resource constraints, and
30 are better handled by scheduling before register allocation (by the
31 function `schedule_insns').
33 The Branch Penalty is the number of extra cycles that are needed to
34 execute a branch insn. On an ideal machine, branches take a single
35 cycle, and the Branch Penalty is 0. Several RISC machines approach
36 branch delays differently:
38 The MIPS and AMD 29000 have a single branch delay slot. Most insns
39 (except other branches) can be used to fill this slot. When the
40 slot is filled, two insns execute in two cycles, reducing the
41 branch penalty to zero.
43 The Motorola 88000 conditionally exposes its branch delay slot,
44 so code is shorter when it is turned off, but will run faster
45 when useful insns are scheduled there.
47 The IBM ROMP has two forms of branch and call insns, both with and
48 without a delay slot. Much like the 88k, insns not using the delay
49 slot can be shorted (2 bytes vs. 4 bytes), but will run slowed.
51 The SPARC always has a branch delay slot, but its effects can be
52 annulled when the branch is not taken. This means that failing to
53 find other sources of insns, we can hoist an insn from the branch
54 target that would only be safe to execute knowing that the branch
57 The HP-PA always has a branch delay slot. For unconditional branches
58 its effects can be annulled when the branch is taken. The effects
59 of the delay slot in a conditional branch can be nullified for forward
60 taken branches, or for untaken backward branches. This means
61 we can hoist insns from the fall-through path for forward branches or
62 steal insns from the target of backward branches.
64 Three techniques for filling delay slots have been implemented so far:
66 (1) `fill_simple_delay_slots' is the simplest, most efficient way
67 to fill delay slots. This pass first looks for insns which come
68 from before the branch and which are safe to execute after the
69 branch. Then it searches after the insn requiring delay slots or,
70 in the case of a branch, for insns that are after the point at
71 which the branch merges into the fallthrough code, if such a point
72 exists. When such insns are found, the branch penalty decreases
73 and no code expansion takes place.
75 (2) `fill_eager_delay_slots' is more complicated: it is used for
76 scheduling conditional jumps, or for scheduling jumps which cannot
77 be filled using (1). A machine need not have annulled jumps to use
78 this strategy, but it helps (by keeping more options open).
79 `fill_eager_delay_slots' tries to guess the direction the branch
80 will go; if it guesses right 100% of the time, it can reduce the
81 branch penalty as much as `fill_simple_delay_slots' does. If it
82 guesses wrong 100% of the time, it might as well schedule nops (or
83 on the m88k, unexpose the branch slot). When
84 `fill_eager_delay_slots' takes insns from the fall-through path of
85 the jump, usually there is no code expansion; when it takes insns
86 from the branch target, there is code expansion if it is not the
87 only way to reach that target.
89 (3) `relax_delay_slots' uses a set of rules to simplify code that
90 has been reorganized by (1) and (2). It finds cases where
91 conditional test can be eliminated, jumps can be threaded, extra
92 insns can be eliminated, etc. It is the job of (1) and (2) to do a
93 good job of scheduling locally; `relax_delay_slots' takes care of
94 making the various individual schedules work well together. It is
95 especially tuned to handle the control flow interactions of branch
96 insns. It does nothing for insns with delay slots that do not
99 On machines that use CC0, we are very conservative. We will not make
100 a copy of an insn involving CC0 since we want to maintain a 1-1
101 correspondence between the insn that sets and uses CC0. The insns are
102 allowed to be separated by placing an insn that sets CC0 (but not an insn
103 that uses CC0; we could do this, but it doesn't seem worthwhile) in a
104 delay slot. In that case, we point each insn at the other with REG_CC_USER
105 and REG_CC_SETTER notes. Note that these restrictions affect very few
106 machines because most RISC machines with delay slots will not use CC0
107 (the RT is the only known exception at this point).
111 The Acorn Risc Machine can conditionally execute most insns, so
112 it is profitable to move single insns into a position to execute
113 based on the condition code of the previous insn.
115 The HP-PA can conditionally nullify insns, providing a similar
116 effect to the ARM, differing mostly in which insn is "in charge". */
122 #include "insn-config.h"
123 #include "conditions.h"
124 #include "hard-reg-set.h"
125 #include "basic-block.h"
127 #include "insn-flags.h"
132 #include "insn-attr.h"
134 /* Import list of registers used as spill regs from reload. */
135 extern HARD_REG_SET used_spill_regs;
137 /* Import highest label used in function at end of reload. */
138 extern int max_label_num_after_reload;
143 #define obstack_chunk_alloc xmalloc
144 #define obstack_chunk_free free
146 #ifndef ANNUL_IFTRUE_SLOTS
147 #define eligible_for_annul_true(INSN, SLOTS, TRIAL, FLAGS) 0
149 #ifndef ANNUL_IFFALSE_SLOTS
150 #define eligible_for_annul_false(INSN, SLOTS, TRIAL, FLAGS) 0
153 /* Insns which have delay slots that have not yet been filled. */
155 static struct obstack unfilled_slots_obstack;
156 static rtx *unfilled_firstobj;
158 /* Define macros to refer to the first and last slot containing unfilled
159 insns. These are used because the list may move and its address
160 should be recomputed at each use. */
162 #define unfilled_slots_base \
163 ((rtx *) obstack_base (&unfilled_slots_obstack))
165 #define unfilled_slots_next \
166 ((rtx *) obstack_next_free (&unfilled_slots_obstack))
168 /* This structure is used to indicate which hardware resources are set or
169 needed by insns so far. */
173 char memory; /* Insn sets or needs a memory location. */
174 char unch_memory; /* Insn sets of needs a "unchanging" MEM. */
175 char volatil; /* Insn sets or needs a volatile memory loc. */
176 char cc; /* Insn sets or needs the condition codes. */
177 HARD_REG_SET regs; /* Which registers are set or needed. */
180 /* Macro to clear all resources. */
181 #define CLEAR_RESOURCE(RES) \
182 do { (RES)->memory = (RES)->unch_memory = (RES)->volatil = (RES)->cc = 0; \
183 CLEAR_HARD_REG_SET ((RES)->regs); } while (0)
185 /* Indicates what resources are required at the beginning of the epilogue. */
186 static struct resources start_of_epilogue_needs;
188 /* Indicates what resources are required at function end. */
189 static struct resources end_of_function_needs;
191 /* Points to the label before the end of the function. */
192 static rtx end_of_function_label;
194 /* This structure is used to record liveness information at the targets or
195 fallthrough insns of branches. We will most likely need the information
196 at targets again, so save them in a hash table rather than recomputing them
201 int uid; /* INSN_UID of target. */
202 struct target_info *next; /* Next info for same hash bucket. */
203 HARD_REG_SET live_regs; /* Registers live at target. */
204 int block; /* Basic block number containing target. */
205 int bb_tick; /* Generation count of basic block info. */
208 #define TARGET_HASH_PRIME 257
210 /* Define the hash table itself. */
211 static struct target_info **target_hash_table;
213 /* For each basic block, we maintain a generation number of its basic
214 block info, which is updated each time we move an insn from the
215 target of a jump. This is the generation number indexed by block
218 static int *bb_ticks;
220 /* Mapping between INSN_UID's and position in the code since INSN_UID's do
221 not always monotonically increase. */
222 static int *uid_to_ruid;
224 /* Highest valid index in `uid_to_ruid'. */
227 static void mark_referenced_resources PROTO((rtx, struct resources *, int));
228 static void mark_set_resources PROTO((rtx, struct resources *, int, int));
229 static int stop_search_p PROTO((rtx, int));
230 static int resource_conflicts_p PROTO((struct resources *,
231 struct resources *));
232 static int insn_references_resource_p PROTO((rtx, struct resources *, int));
233 static int insn_sets_resource_p PROTO((rtx, struct resources *, int));
234 static rtx find_end_label PROTO((void));
235 static rtx emit_delay_sequence PROTO((rtx, rtx, int));
236 static rtx add_to_delay_list PROTO((rtx, rtx));
237 static rtx delete_from_delay_slot PROTO((rtx));
238 static void delete_scheduled_jump PROTO((rtx));
239 static void note_delay_statistics PROTO((int, int));
240 static rtx optimize_skip PROTO((rtx));
241 static int get_jump_flags PROTO((rtx, rtx));
242 static int rare_destination PROTO((rtx));
243 static int mostly_true_jump PROTO((rtx, rtx));
244 static rtx get_branch_condition PROTO((rtx, rtx));
245 static int condition_dominates_p PROTO((rtx, rtx));
246 static rtx steal_delay_list_from_target PROTO((rtx, rtx, rtx, rtx,
250 int, int *, int *, rtx *));
251 static rtx steal_delay_list_from_fallthrough PROTO((rtx, rtx, rtx, rtx,
256 static void try_merge_delay_insns PROTO((rtx, rtx));
257 static rtx redundant_insn PROTO((rtx, rtx, rtx));
258 static int own_thread_p PROTO((rtx, rtx, int));
259 static int find_basic_block PROTO((rtx));
260 static void update_block PROTO((rtx, rtx));
261 static int reorg_redirect_jump PROTO((rtx, rtx));
262 static void update_reg_dead_notes PROTO((rtx, rtx));
263 static void fix_reg_dead_note PROTO((rtx, rtx));
264 static void update_reg_unused_notes PROTO((rtx, rtx));
265 static void update_live_status PROTO((rtx, rtx));
266 static rtx next_insn_no_annul PROTO((rtx));
267 static rtx find_dead_or_set_registers PROTO ((rtx, struct resources *, rtx *,
268 int, struct resources,
270 static void mark_target_live_regs PROTO((rtx, struct resources *));
271 static void fill_simple_delay_slots PROTO((int));
272 static rtx fill_slots_from_thread PROTO((rtx, rtx, rtx, rtx, int, int,
273 int, int, int *, rtx));
274 static void fill_eager_delay_slots PROTO((void));
275 static void relax_delay_slots PROTO((rtx));
276 static void make_return_insns PROTO((rtx));
277 static int redirect_with_delay_slots_safe_p PROTO ((rtx, rtx, rtx));
278 static int redirect_with_delay_list_safe_p PROTO ((rtx, rtx, rtx));
280 /* Given X, some rtl, and RES, a pointer to a `struct resource', mark
281 which resources are references by the insn. If INCLUDE_DELAYED_EFFECTS
282 is TRUE, resources used by the called routine will be included for
286 mark_referenced_resources (x, res, include_delayed_effects)
288 register struct resources *res;
289 register int include_delayed_effects;
291 register enum rtx_code code = GET_CODE (x);
293 register char *format_ptr;
295 /* Handle leaf items for which we set resource flags. Also, special-case
296 CALL, SET and CLOBBER operators. */
308 if (GET_CODE (SUBREG_REG (x)) != REG)
309 mark_referenced_resources (SUBREG_REG (x), res, 0);
312 int regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
313 int last_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
314 for (i = regno; i < last_regno; i++)
315 SET_HARD_REG_BIT (res->regs, i);
320 for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
321 SET_HARD_REG_BIT (res->regs, REGNO (x) + i);
325 /* If this memory shouldn't change, it really isn't referencing
327 if (RTX_UNCHANGING_P (x))
328 res->unch_memory = 1;
331 res->volatil = MEM_VOLATILE_P (x);
333 /* Mark registers used to access memory. */
334 mark_referenced_resources (XEXP (x, 0), res, 0);
341 case UNSPEC_VOLATILE:
343 /* Traditional asm's are always volatile. */
352 res->volatil = MEM_VOLATILE_P (x);
354 /* For all ASM_OPERANDS, we must traverse the vector of input operands.
355 We can not just fall through here since then we would be confused
356 by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
357 traditional asms unlike their normal usage. */
359 for (i = 0; i < ASM_OPERANDS_INPUT_LENGTH (x); i++)
360 mark_referenced_resources (ASM_OPERANDS_INPUT (x, i), res, 0);
364 /* The first operand will be a (MEM (xxx)) but doesn't really reference
365 memory. The second operand may be referenced, though. */
366 mark_referenced_resources (XEXP (XEXP (x, 0), 0), res, 0);
367 mark_referenced_resources (XEXP (x, 1), res, 0);
371 /* Usually, the first operand of SET is set, not referenced. But
372 registers used to access memory are referenced. SET_DEST is
373 also referenced if it is a ZERO_EXTRACT or SIGN_EXTRACT. */
375 mark_referenced_resources (SET_SRC (x), res, 0);
378 if (GET_CODE (x) == SIGN_EXTRACT || GET_CODE (x) == ZERO_EXTRACT)
379 mark_referenced_resources (x, res, 0);
380 else if (GET_CODE (x) == SUBREG)
382 if (GET_CODE (x) == MEM)
383 mark_referenced_resources (XEXP (x, 0), res, 0);
390 if (include_delayed_effects)
392 /* A CALL references memory, the frame pointer if it exists, the
393 stack pointer, any global registers and any registers given in
394 USE insns immediately in front of the CALL.
396 However, we may have moved some of the parameter loading insns
397 into the delay slot of this CALL. If so, the USE's for them
398 don't count and should be skipped. */
399 rtx insn = PREV_INSN (x);
402 rtx next = NEXT_INSN (x);
405 /* If we are part of a delay slot sequence, point at the SEQUENCE. */
406 if (NEXT_INSN (insn) != x)
408 next = NEXT_INSN (NEXT_INSN (insn));
409 sequence = PATTERN (NEXT_INSN (insn));
410 seq_size = XVECLEN (sequence, 0);
411 if (GET_CODE (sequence) != SEQUENCE)
416 SET_HARD_REG_BIT (res->regs, STACK_POINTER_REGNUM);
417 if (frame_pointer_needed)
419 SET_HARD_REG_BIT (res->regs, FRAME_POINTER_REGNUM);
420 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
421 SET_HARD_REG_BIT (res->regs, HARD_FRAME_POINTER_REGNUM);
425 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
427 SET_HARD_REG_BIT (res->regs, i);
429 /* Check for a NOTE_INSN_SETJMP. If it exists, then we must
430 assume that this call can need any register.
432 This is done to be more conservative about how we handle setjmp.
433 We assume that they both use and set all registers. Using all
434 registers ensures that a register will not be considered dead
435 just because it crosses a setjmp call. A register should be
436 considered dead only if the setjmp call returns non-zero. */
437 if (next && GET_CODE (next) == NOTE
438 && NOTE_LINE_NUMBER (next) == NOTE_INSN_SETJMP)
439 SET_HARD_REG_SET (res->regs);
444 for (link = CALL_INSN_FUNCTION_USAGE (x);
446 link = XEXP (link, 1))
447 if (GET_CODE (XEXP (link, 0)) == USE)
449 for (i = 1; i < seq_size; i++)
451 rtx slot_pat = PATTERN (XVECEXP (sequence, 0, i));
452 if (GET_CODE (slot_pat) == SET
453 && rtx_equal_p (SET_DEST (slot_pat),
454 SET_DEST (XEXP (link, 0))))
458 mark_referenced_resources (SET_DEST (XEXP (link, 0)),
464 /* ... fall through to other INSN processing ... */
469 #ifdef INSN_REFERENCES_ARE_DELAYED
470 if (! include_delayed_effects
471 && INSN_REFERENCES_ARE_DELAYED (x))
475 /* No special processing, just speed up. */
476 mark_referenced_resources (PATTERN (x), res, include_delayed_effects);
483 /* Process each sub-expression and flag what it needs. */
484 format_ptr = GET_RTX_FORMAT (code);
485 for (i = 0; i < GET_RTX_LENGTH (code); i++)
486 switch (*format_ptr++)
489 mark_referenced_resources (XEXP (x, i), res, include_delayed_effects);
493 for (j = 0; j < XVECLEN (x, i); j++)
494 mark_referenced_resources (XVECEXP (x, i, j), res,
495 include_delayed_effects);
500 /* Given X, a part of an insn, and a pointer to a `struct resource',
501 RES, indicate which resources are modified by the insn. If
502 INCLUDE_DELAYED_EFFECTS is nonzero, also mark resources potentially
503 set by the called routine.
505 If IN_DEST is nonzero, it means we are inside a SET. Otherwise,
506 objects are being referenced instead of set.
508 We never mark the insn as modifying the condition code unless it explicitly
509 SETs CC0 even though this is not totally correct. The reason for this is
510 that we require a SET of CC0 to immediately precede the reference to CC0.
511 So if some other insn sets CC0 as a side-effect, we know it cannot affect
512 our computation and thus may be placed in a delay slot. */
515 mark_set_resources (x, res, in_dest, include_delayed_effects)
517 register struct resources *res;
519 int include_delayed_effects;
521 register enum rtx_code code;
523 register char *format_ptr;
541 /* These don't set any resources. */
550 /* Called routine modifies the condition code, memory, any registers
551 that aren't saved across calls, global registers and anything
552 explicitly CLOBBERed immediately after the CALL_INSN. */
554 if (include_delayed_effects)
556 rtx next = NEXT_INSN (x);
557 rtx prev = PREV_INSN (x);
560 res->cc = res->memory = 1;
561 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
562 if (call_used_regs[i] || global_regs[i])
563 SET_HARD_REG_BIT (res->regs, i);
565 /* If X is part of a delay slot sequence, then NEXT should be
566 the first insn after the sequence. */
567 if (NEXT_INSN (prev) != x)
568 next = NEXT_INSN (NEXT_INSN (prev));
570 for (link = CALL_INSN_FUNCTION_USAGE (x);
571 link; link = XEXP (link, 1))
572 if (GET_CODE (XEXP (link, 0)) == CLOBBER)
573 mark_set_resources (SET_DEST (XEXP (link, 0)), res, 1, 0);
575 /* Check for a NOTE_INSN_SETJMP. If it exists, then we must
576 assume that this call can clobber any register. */
577 if (next && GET_CODE (next) == NOTE
578 && NOTE_LINE_NUMBER (next) == NOTE_INSN_SETJMP)
579 SET_HARD_REG_SET (res->regs);
582 /* ... and also what its RTL says it modifies, if anything. */
587 /* An insn consisting of just a CLOBBER (or USE) is just for flow
588 and doesn't actually do anything, so we ignore it. */
590 #ifdef INSN_SETS_ARE_DELAYED
591 if (! include_delayed_effects
592 && INSN_SETS_ARE_DELAYED (x))
597 if (GET_CODE (x) != USE && GET_CODE (x) != CLOBBER)
602 /* If the source of a SET is a CALL, this is actually done by
603 the called routine. So only include it if we are to include the
604 effects of the calling routine. */
606 mark_set_resources (SET_DEST (x), res,
607 (include_delayed_effects
608 || GET_CODE (SET_SRC (x)) != CALL),
611 mark_set_resources (SET_SRC (x), res, 0, 0);
615 mark_set_resources (XEXP (x, 0), res, 1, 0);
619 for (i = 0; i < XVECLEN (x, 0); i++)
620 if (! (INSN_ANNULLED_BRANCH_P (XVECEXP (x, 0, 0))
621 && INSN_FROM_TARGET_P (XVECEXP (x, 0, i))))
622 mark_set_resources (XVECEXP (x, 0, i), res, 0,
623 include_delayed_effects);
630 mark_set_resources (XEXP (x, 0), res, 1, 0);
634 mark_set_resources (XEXP (x, 0), res, in_dest, 0);
635 mark_set_resources (XEXP (x, 1), res, 0, 0);
636 mark_set_resources (XEXP (x, 2), res, 0, 0);
643 res->unch_memory = RTX_UNCHANGING_P (x);
644 res->volatil = MEM_VOLATILE_P (x);
647 mark_set_resources (XEXP (x, 0), res, 0, 0);
653 if (GET_CODE (SUBREG_REG (x)) != REG)
654 mark_set_resources (SUBREG_REG (x), res,
655 in_dest, include_delayed_effects);
658 int regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
659 int last_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
660 for (i = regno; i < last_regno; i++)
661 SET_HARD_REG_BIT (res->regs, i);
668 for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
669 SET_HARD_REG_BIT (res->regs, REGNO (x) + i);
676 /* Process each sub-expression and flag what it needs. */
677 format_ptr = GET_RTX_FORMAT (code);
678 for (i = 0; i < GET_RTX_LENGTH (code); i++)
679 switch (*format_ptr++)
682 mark_set_resources (XEXP (x, i), res, in_dest, include_delayed_effects);
686 for (j = 0; j < XVECLEN (x, i); j++)
687 mark_set_resources (XVECEXP (x, i, j), res, in_dest,
688 include_delayed_effects);
693 /* Return TRUE if this insn should stop the search for insn to fill delay
694 slots. LABELS_P indicates that labels should terminate the search.
695 In all cases, jumps terminate the search. */
698 stop_search_p (insn, labels_p)
705 switch (GET_CODE (insn))
719 /* OK unless it contains a delay slot or is an `asm' insn of some type.
720 We don't know anything about these. */
721 return (GET_CODE (PATTERN (insn)) == SEQUENCE
722 || GET_CODE (PATTERN (insn)) == ASM_INPUT
723 || asm_noperands (PATTERN (insn)) >= 0);
730 /* Return TRUE if any resources are marked in both RES1 and RES2 or if either
731 resource set contains a volatile memory reference. Otherwise, return FALSE. */
734 resource_conflicts_p (res1, res2)
735 struct resources *res1, *res2;
737 if ((res1->cc && res2->cc) || (res1->memory && res2->memory)
738 || (res1->unch_memory && res2->unch_memory)
739 || res1->volatil || res2->volatil)
743 return (res1->regs & res2->regs) != HARD_CONST (0);
748 for (i = 0; i < HARD_REG_SET_LONGS; i++)
749 if ((res1->regs[i] & res2->regs[i]) != 0)
756 /* Return TRUE if any resource marked in RES, a `struct resources', is
757 referenced by INSN. If INCLUDE_DELAYED_EFFECTS is set, return if the called
758 routine is using those resources.
760 We compute this by computing all the resources referenced by INSN and
761 seeing if this conflicts with RES. It might be faster to directly check
762 ourselves, and this is the way it used to work, but it means duplicating
763 a large block of complex code. */
766 insn_references_resource_p (insn, res, include_delayed_effects)
768 register struct resources *res;
769 int include_delayed_effects;
771 struct resources insn_res;
773 CLEAR_RESOURCE (&insn_res);
774 mark_referenced_resources (insn, &insn_res, include_delayed_effects);
775 return resource_conflicts_p (&insn_res, res);
778 /* Return TRUE if INSN modifies resources that are marked in RES.
779 INCLUDE_DELAYED_EFFECTS is set if the actions of that routine should be
780 included. CC0 is only modified if it is explicitly set; see comments
781 in front of mark_set_resources for details. */
784 insn_sets_resource_p (insn, res, include_delayed_effects)
786 register struct resources *res;
787 int include_delayed_effects;
789 struct resources insn_sets;
791 CLEAR_RESOURCE (&insn_sets);
792 mark_set_resources (insn, &insn_sets, 0, include_delayed_effects);
793 return resource_conflicts_p (&insn_sets, res);
796 /* Find a label at the end of the function or before a RETURN. If there is
804 /* If we found one previously, return it. */
805 if (end_of_function_label)
806 return end_of_function_label;
808 /* Otherwise, see if there is a label at the end of the function. If there
809 is, it must be that RETURN insns aren't needed, so that is our return
810 label and we don't have to do anything else. */
812 insn = get_last_insn ();
813 while (GET_CODE (insn) == NOTE
814 || (GET_CODE (insn) == INSN
815 && (GET_CODE (PATTERN (insn)) == USE
816 || GET_CODE (PATTERN (insn)) == CLOBBER)))
817 insn = PREV_INSN (insn);
819 /* When a target threads its epilogue we might already have a
820 suitable return insn. If so put a label before it for the
821 end_of_function_label. */
822 if (GET_CODE (insn) == BARRIER
823 && GET_CODE (PREV_INSN (insn)) == JUMP_INSN
824 && GET_CODE (PATTERN (PREV_INSN (insn))) == RETURN)
826 rtx temp = PREV_INSN (PREV_INSN (insn));
827 end_of_function_label = gen_label_rtx ();
828 LABEL_NUSES (end_of_function_label) = 0;
830 /* Put the label before an USE insns that may proceed the RETURN insn. */
831 while (GET_CODE (temp) == USE)
832 temp = PREV_INSN (temp);
834 emit_label_after (end_of_function_label, temp);
837 else if (GET_CODE (insn) == CODE_LABEL)
838 end_of_function_label = insn;
841 /* Otherwise, make a new label and emit a RETURN and BARRIER,
843 end_of_function_label = gen_label_rtx ();
844 LABEL_NUSES (end_of_function_label) = 0;
845 emit_label (end_of_function_label);
849 /* The return we make may have delay slots too. */
850 rtx insn = gen_return ();
851 insn = emit_jump_insn (insn);
853 if (num_delay_slots (insn) > 0)
854 obstack_ptr_grow (&unfilled_slots_obstack, insn);
859 /* Show one additional use for this label so it won't go away until
861 ++LABEL_NUSES (end_of_function_label);
863 return end_of_function_label;
866 /* Put INSN and LIST together in a SEQUENCE rtx of LENGTH, and replace
867 the pattern of INSN with the SEQUENCE.
869 Chain the insns so that NEXT_INSN of each insn in the sequence points to
870 the next and NEXT_INSN of the last insn in the sequence points to
871 the first insn after the sequence. Similarly for PREV_INSN. This makes
872 it easier to scan all insns.
874 Returns the SEQUENCE that replaces INSN. */
877 emit_delay_sequence (insn, list, length)
886 /* Allocate the rtvec to hold the insns and the SEQUENCE. */
887 rtvec seqv = rtvec_alloc (length + 1);
888 rtx seq = gen_rtx_SEQUENCE (VOIDmode, seqv);
889 rtx seq_insn = make_insn_raw (seq);
890 rtx first = get_insns ();
891 rtx last = get_last_insn ();
893 /* Make a copy of the insn having delay slots. */
894 rtx delay_insn = copy_rtx (insn);
896 /* If INSN is followed by a BARRIER, delete the BARRIER since it will only
897 confuse further processing. Update LAST in case it was the last insn.
898 We will put the BARRIER back in later. */
899 if (NEXT_INSN (insn) && GET_CODE (NEXT_INSN (insn)) == BARRIER)
901 delete_insn (NEXT_INSN (insn));
902 last = get_last_insn ();
906 /* Splice our SEQUENCE into the insn stream where INSN used to be. */
907 NEXT_INSN (seq_insn) = NEXT_INSN (insn);
908 PREV_INSN (seq_insn) = PREV_INSN (insn);
911 PREV_INSN (NEXT_INSN (seq_insn)) = seq_insn;
914 NEXT_INSN (PREV_INSN (seq_insn)) = seq_insn;
916 /* Note the calls to set_new_first_and_last_insn must occur after
917 SEQ_INSN has been completely spliced into the insn stream.
919 Otherwise CUR_INSN_UID will get set to an incorrect value because
920 set_new_first_and_last_insn will not find SEQ_INSN in the chain. */
922 set_new_first_and_last_insn (first, seq_insn);
925 set_new_first_and_last_insn (seq_insn, last);
927 /* Build our SEQUENCE and rebuild the insn chain. */
928 XVECEXP (seq, 0, 0) = delay_insn;
929 INSN_DELETED_P (delay_insn) = 0;
930 PREV_INSN (delay_insn) = PREV_INSN (seq_insn);
932 for (li = list; li; li = XEXP (li, 1), i++)
934 rtx tem = XEXP (li, 0);
937 /* Show that this copy of the insn isn't deleted. */
938 INSN_DELETED_P (tem) = 0;
940 XVECEXP (seq, 0, i) = tem;
941 PREV_INSN (tem) = XVECEXP (seq, 0, i - 1);
942 NEXT_INSN (XVECEXP (seq, 0, i - 1)) = tem;
944 /* Remove any REG_DEAD notes because we can't rely on them now
945 that the insn has been moved. */
946 for (note = REG_NOTES (tem); note; note = XEXP (note, 1))
947 if (REG_NOTE_KIND (note) == REG_DEAD)
948 XEXP (note, 0) = const0_rtx;
951 NEXT_INSN (XVECEXP (seq, 0, length)) = NEXT_INSN (seq_insn);
953 /* If the previous insn is a SEQUENCE, update the NEXT_INSN pointer on the
954 last insn in that SEQUENCE to point to us. Similarly for the first
955 insn in the following insn if it is a SEQUENCE. */
957 if (PREV_INSN (seq_insn) && GET_CODE (PREV_INSN (seq_insn)) == INSN
958 && GET_CODE (PATTERN (PREV_INSN (seq_insn))) == SEQUENCE)
959 NEXT_INSN (XVECEXP (PATTERN (PREV_INSN (seq_insn)), 0,
960 XVECLEN (PATTERN (PREV_INSN (seq_insn)), 0) - 1))
963 if (NEXT_INSN (seq_insn) && GET_CODE (NEXT_INSN (seq_insn)) == INSN
964 && GET_CODE (PATTERN (NEXT_INSN (seq_insn))) == SEQUENCE)
965 PREV_INSN (XVECEXP (PATTERN (NEXT_INSN (seq_insn)), 0, 0)) = seq_insn;
967 /* If there used to be a BARRIER, put it back. */
969 emit_barrier_after (seq_insn);
977 /* Add INSN to DELAY_LIST and return the head of the new list. The list must
978 be in the order in which the insns are to be executed. */
981 add_to_delay_list (insn, delay_list)
985 /* If we have an empty list, just make a new list element. If
986 INSN has its block number recorded, clear it since we may
987 be moving the insn to a new block. */
991 struct target_info *tinfo;
993 for (tinfo = target_hash_table[INSN_UID (insn) % TARGET_HASH_PRIME];
994 tinfo; tinfo = tinfo->next)
995 if (tinfo->uid == INSN_UID (insn))
1001 return gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX);
1004 /* Otherwise this must be an INSN_LIST. Add INSN to the end of the
1006 XEXP (delay_list, 1) = add_to_delay_list (insn, XEXP (delay_list, 1));
1011 /* Delete INSN from the delay slot of the insn that it is in. This may
1012 produce an insn without anything in its delay slots. */
1015 delete_from_delay_slot (insn)
1018 rtx trial, seq_insn, seq, prev;
1022 /* We first must find the insn containing the SEQUENCE with INSN in its
1023 delay slot. Do this by finding an insn, TRIAL, where
1024 PREV_INSN (NEXT_INSN (TRIAL)) != TRIAL. */
1027 PREV_INSN (NEXT_INSN (trial)) == trial;
1028 trial = NEXT_INSN (trial))
1031 seq_insn = PREV_INSN (NEXT_INSN (trial));
1032 seq = PATTERN (seq_insn);
1034 /* Create a delay list consisting of all the insns other than the one
1035 we are deleting (unless we were the only one). */
1036 if (XVECLEN (seq, 0) > 2)
1037 for (i = 1; i < XVECLEN (seq, 0); i++)
1038 if (XVECEXP (seq, 0, i) != insn)
1039 delay_list = add_to_delay_list (XVECEXP (seq, 0, i), delay_list);
1041 /* Delete the old SEQUENCE, re-emit the insn that used to have the delay
1042 list, and rebuild the delay list if non-empty. */
1043 prev = PREV_INSN (seq_insn);
1044 trial = XVECEXP (seq, 0, 0);
1045 delete_insn (seq_insn);
1046 add_insn_after (trial, prev);
1048 if (GET_CODE (trial) == JUMP_INSN
1049 && (simplejump_p (trial) || GET_CODE (PATTERN (trial)) == RETURN))
1050 emit_barrier_after (trial);
1052 /* If there are any delay insns, remit them. Otherwise clear the
1055 trial = emit_delay_sequence (trial, delay_list, XVECLEN (seq, 0) - 2);
1057 INSN_ANNULLED_BRANCH_P (trial) = 0;
1059 INSN_FROM_TARGET_P (insn) = 0;
1061 /* Show we need to fill this insn again. */
1062 obstack_ptr_grow (&unfilled_slots_obstack, trial);
1067 /* Delete INSN, a JUMP_INSN. If it is a conditional jump, we must track down
1068 the insn that sets CC0 for it and delete it too. */
1071 delete_scheduled_jump (insn)
1074 /* Delete the insn that sets cc0 for us. On machines without cc0, we could
1075 delete the insn that sets the condition code, but it is hard to find it.
1076 Since this case is rare anyway, don't bother trying; there would likely
1077 be other insns that became dead anyway, which we wouldn't know to
1081 if (reg_mentioned_p (cc0_rtx, insn))
1083 rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
1085 /* If a reg-note was found, it points to an insn to set CC0. This
1086 insn is in the delay list of some other insn. So delete it from
1087 the delay list it was in. */
1090 if (! FIND_REG_INC_NOTE (XEXP (note, 0), NULL_RTX)
1091 && sets_cc0_p (PATTERN (XEXP (note, 0))) == 1)
1092 delete_from_delay_slot (XEXP (note, 0));
1096 /* The insn setting CC0 is our previous insn, but it may be in
1097 a delay slot. It will be the last insn in the delay slot, if
1099 rtx trial = previous_insn (insn);
1100 if (GET_CODE (trial) == NOTE)
1101 trial = prev_nonnote_insn (trial);
1102 if (sets_cc0_p (PATTERN (trial)) != 1
1103 || FIND_REG_INC_NOTE (trial, 0))
1105 if (PREV_INSN (NEXT_INSN (trial)) == trial)
1106 delete_insn (trial);
1108 delete_from_delay_slot (trial);
1116 /* Counters for delay-slot filling. */
1118 #define NUM_REORG_FUNCTIONS 2
1119 #define MAX_DELAY_HISTOGRAM 3
1120 #define MAX_REORG_PASSES 2
1122 static int num_insns_needing_delays[NUM_REORG_FUNCTIONS][MAX_REORG_PASSES];
1124 static int num_filled_delays[NUM_REORG_FUNCTIONS][MAX_DELAY_HISTOGRAM+1][MAX_REORG_PASSES];
1126 static int reorg_pass_number;
1129 note_delay_statistics (slots_filled, index)
1130 int slots_filled, index;
1132 num_insns_needing_delays[index][reorg_pass_number]++;
1133 if (slots_filled > MAX_DELAY_HISTOGRAM)
1134 slots_filled = MAX_DELAY_HISTOGRAM;
1135 num_filled_delays[index][slots_filled][reorg_pass_number]++;
1138 #if defined(ANNUL_IFFALSE_SLOTS) || defined(ANNUL_IFTRUE_SLOTS)
1140 /* Optimize the following cases:
1142 1. When a conditional branch skips over only one instruction,
1143 use an annulling branch and put that insn in the delay slot.
1144 Use either a branch that annuls when the condition if true or
1145 invert the test with a branch that annuls when the condition is
1146 false. This saves insns, since otherwise we must copy an insn
1149 (orig) (skip) (otherwise)
1150 Bcc.n L1 Bcc',a L1 Bcc,a L1'
1157 2. When a conditional branch skips over only one instruction,
1158 and after that, it unconditionally branches somewhere else,
1159 perform the similar optimization. This saves executing the
1160 second branch in the case where the inverted condition is true.
1167 INSN is a JUMP_INSN.
1169 This should be expanded to skip over N insns, where N is the number
1170 of delay slots required. */
1173 optimize_skip (insn)
1176 register rtx trial = next_nonnote_insn (insn);
1177 rtx next_trial = next_active_insn (trial);
1182 flags = get_jump_flags (insn, JUMP_LABEL (insn));
1185 || GET_CODE (trial) != INSN
1186 || GET_CODE (PATTERN (trial)) == SEQUENCE
1187 || recog_memoized (trial) < 0
1188 || (! eligible_for_annul_false (insn, 0, trial, flags)
1189 && ! eligible_for_annul_true (insn, 0, trial, flags)))
1192 /* There are two cases where we are just executing one insn (we assume
1193 here that a branch requires only one insn; this should be generalized
1194 at some point): Where the branch goes around a single insn or where
1195 we have one insn followed by a branch to the same label we branch to.
1196 In both of these cases, inverting the jump and annulling the delay
1197 slot give the same effect in fewer insns. */
1198 if ((next_trial == next_active_insn (JUMP_LABEL (insn)))
1200 && GET_CODE (next_trial) == JUMP_INSN
1201 && JUMP_LABEL (insn) == JUMP_LABEL (next_trial)
1202 && (simplejump_p (next_trial)
1203 || GET_CODE (PATTERN (next_trial)) == RETURN)))
1205 if (eligible_for_annul_false (insn, 0, trial, flags))
1207 if (invert_jump (insn, JUMP_LABEL (insn)))
1208 INSN_FROM_TARGET_P (trial) = 1;
1209 else if (! eligible_for_annul_true (insn, 0, trial, flags))
1213 delay_list = add_to_delay_list (trial, NULL_RTX);
1214 next_trial = next_active_insn (trial);
1215 update_block (trial, trial);
1216 delete_insn (trial);
1218 /* Also, if we are targeting an unconditional
1219 branch, thread our jump to the target of that branch. Don't
1220 change this into a RETURN here, because it may not accept what
1221 we have in the delay slot. We'll fix this up later. */
1222 if (next_trial && GET_CODE (next_trial) == JUMP_INSN
1223 && (simplejump_p (next_trial)
1224 || GET_CODE (PATTERN (next_trial)) == RETURN))
1226 target_label = JUMP_LABEL (next_trial);
1227 if (target_label == 0)
1228 target_label = find_end_label ();
1230 /* Recompute the flags based on TARGET_LABEL since threading
1231 the jump to TARGET_LABEL may change the direction of the
1232 jump (which may change the circumstances in which the
1233 delay slot is nullified). */
1234 flags = get_jump_flags (insn, target_label);
1235 if (eligible_for_annul_true (insn, 0, trial, flags))
1236 reorg_redirect_jump (insn, target_label);
1239 INSN_ANNULLED_BRANCH_P (insn) = 1;
1247 /* Encode and return branch direction and prediction information for
1248 INSN assuming it will jump to LABEL.
1250 Non conditional branches return no direction information and
1251 are predicted as very likely taken. */
1254 get_jump_flags (insn, label)
1259 /* get_jump_flags can be passed any insn with delay slots, these may
1260 be INSNs, CALL_INSNs, or JUMP_INSNs. Only JUMP_INSNs have branch
1261 direction information, and only if they are conditional jumps.
1263 If LABEL is zero, then there is no way to determine the branch
1265 if (GET_CODE (insn) == JUMP_INSN
1266 && (condjump_p (insn) || condjump_in_parallel_p (insn))
1267 && INSN_UID (insn) <= max_uid
1269 && INSN_UID (label) <= max_uid)
1271 = (uid_to_ruid[INSN_UID (label)] > uid_to_ruid[INSN_UID (insn)])
1272 ? ATTR_FLAG_forward : ATTR_FLAG_backward;
1273 /* No valid direction information. */
1277 /* If insn is a conditional branch call mostly_true_jump to get
1278 determine the branch prediction.
1280 Non conditional branches are predicted as very likely taken. */
1281 if (GET_CODE (insn) == JUMP_INSN
1282 && (condjump_p (insn) || condjump_in_parallel_p (insn)))
1286 prediction = mostly_true_jump (insn, get_branch_condition (insn, label));
1290 flags |= (ATTR_FLAG_very_likely | ATTR_FLAG_likely);
1293 flags |= ATTR_FLAG_likely;
1296 flags |= ATTR_FLAG_unlikely;
1299 flags |= (ATTR_FLAG_very_unlikely | ATTR_FLAG_unlikely);
1307 flags |= (ATTR_FLAG_very_likely | ATTR_FLAG_likely);
1312 /* Return 1 if INSN is a destination that will be branched to rarely (the
1313 return point of a function); return 2 if DEST will be branched to very
1314 rarely (a call to a function that doesn't return). Otherwise,
1318 rare_destination (insn)
1324 for (; insn; insn = next)
1326 if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
1327 insn = XVECEXP (PATTERN (insn), 0, 0);
1329 next = NEXT_INSN (insn);
1331 switch (GET_CODE (insn))
1336 /* A BARRIER can either be after a JUMP_INSN or a CALL_INSN. We
1337 don't scan past JUMP_INSNs, so any barrier we find here must
1338 have been after a CALL_INSN and hence mean the call doesn't
1342 if (GET_CODE (PATTERN (insn)) == RETURN)
1344 else if (simplejump_p (insn)
1345 && jump_count++ < 10)
1346 next = JUMP_LABEL (insn);
1355 /* If we got here it means we hit the end of the function. So this
1356 is an unlikely destination. */
1361 /* Return truth value of the statement that this branch
1362 is mostly taken. If we think that the branch is extremely likely
1363 to be taken, we return 2. If the branch is slightly more likely to be
1364 taken, return 1. If the branch is slightly less likely to be taken,
1365 return 0 and if the branch is highly unlikely to be taken, return -1.
1367 CONDITION, if non-zero, is the condition that JUMP_INSN is testing. */
1370 mostly_true_jump (jump_insn, condition)
1371 rtx jump_insn, condition;
1373 rtx target_label = JUMP_LABEL (jump_insn);
1375 int rare_dest = rare_destination (target_label);
1376 int rare_fallthrough = rare_destination (NEXT_INSN (jump_insn));
1378 /* If branch probabilities are available, then use that number since it
1379 always gives a correct answer. */
1380 if (flag_branch_probabilities)
1382 rtx note = find_reg_note (jump_insn, REG_BR_PROB, 0);;
1385 int prob = XINT (note, 0);
1387 if (prob >= REG_BR_PROB_BASE * 9 / 10)
1389 else if (prob >= REG_BR_PROB_BASE / 2)
1391 else if (prob >= REG_BR_PROB_BASE / 10)
1398 /* If this is a branch outside a loop, it is highly unlikely. */
1399 if (GET_CODE (PATTERN (jump_insn)) == SET
1400 && GET_CODE (SET_SRC (PATTERN (jump_insn))) == IF_THEN_ELSE
1401 && ((GET_CODE (XEXP (SET_SRC (PATTERN (jump_insn)), 1)) == LABEL_REF
1402 && LABEL_OUTSIDE_LOOP_P (XEXP (SET_SRC (PATTERN (jump_insn)), 1)))
1403 || (GET_CODE (XEXP (SET_SRC (PATTERN (jump_insn)), 2)) == LABEL_REF
1404 && LABEL_OUTSIDE_LOOP_P (XEXP (SET_SRC (PATTERN (jump_insn)), 2)))))
1409 /* If this is the test of a loop, it is very likely true. We scan
1410 backwards from the target label. If we find a NOTE_INSN_LOOP_BEG
1411 before the next real insn, we assume the branch is to the top of
1413 for (insn = PREV_INSN (target_label);
1414 insn && GET_CODE (insn) == NOTE;
1415 insn = PREV_INSN (insn))
1416 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
1419 /* If this is a jump to the test of a loop, it is likely true. We scan
1420 forwards from the target label. If we find a NOTE_INSN_LOOP_VTOP
1421 before the next real insn, we assume the branch is to the loop branch
1423 for (insn = NEXT_INSN (target_label);
1424 insn && GET_CODE (insn) == NOTE;
1425 insn = PREV_INSN (insn))
1426 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_VTOP)
1430 /* Look at the relative rarities of the fallthrough and destination. If
1431 they differ, we can predict the branch that way. */
1433 switch (rare_fallthrough - rare_dest)
1447 /* If we couldn't figure out what this jump was, assume it won't be
1448 taken. This should be rare. */
1452 /* EQ tests are usually false and NE tests are usually true. Also,
1453 most quantities are positive, so we can make the appropriate guesses
1454 about signed comparisons against zero. */
1455 switch (GET_CODE (condition))
1458 /* Unconditional branch. */
1466 if (XEXP (condition, 1) == const0_rtx)
1471 if (XEXP (condition, 1) == const0_rtx)
1479 /* Predict backward branches usually take, forward branches usually not. If
1480 we don't know whether this is forward or backward, assume the branch
1481 will be taken, since most are. */
1482 return (target_label == 0 || INSN_UID (jump_insn) > max_uid
1483 || INSN_UID (target_label) > max_uid
1484 || (uid_to_ruid[INSN_UID (jump_insn)]
1485 > uid_to_ruid[INSN_UID (target_label)]));;
1488 /* Return the condition under which INSN will branch to TARGET. If TARGET
1489 is zero, return the condition under which INSN will return. If INSN is
1490 an unconditional branch, return const_true_rtx. If INSN isn't a simple
1491 type of jump, or it doesn't go to TARGET, return 0. */
1494 get_branch_condition (insn, target)
1498 rtx pat = PATTERN (insn);
1501 if (condjump_in_parallel_p (insn))
1502 pat = XVECEXP (pat, 0, 0);
1504 if (GET_CODE (pat) == RETURN)
1505 return target == 0 ? const_true_rtx : 0;
1507 else if (GET_CODE (pat) != SET || SET_DEST (pat) != pc_rtx)
1510 src = SET_SRC (pat);
1511 if (GET_CODE (src) == LABEL_REF && XEXP (src, 0) == target)
1512 return const_true_rtx;
1514 else if (GET_CODE (src) == IF_THEN_ELSE
1515 && ((target == 0 && GET_CODE (XEXP (src, 1)) == RETURN)
1516 || (GET_CODE (XEXP (src, 1)) == LABEL_REF
1517 && XEXP (XEXP (src, 1), 0) == target))
1518 && XEXP (src, 2) == pc_rtx)
1519 return XEXP (src, 0);
1521 else if (GET_CODE (src) == IF_THEN_ELSE
1522 && ((target == 0 && GET_CODE (XEXP (src, 2)) == RETURN)
1523 || (GET_CODE (XEXP (src, 2)) == LABEL_REF
1524 && XEXP (XEXP (src, 2), 0) == target))
1525 && XEXP (src, 1) == pc_rtx)
1526 return gen_rtx_fmt_ee (reverse_condition (GET_CODE (XEXP (src, 0))),
1527 GET_MODE (XEXP (src, 0)),
1528 XEXP (XEXP (src, 0), 0), XEXP (XEXP (src, 0), 1));
1533 /* Return non-zero if CONDITION is more strict than the condition of
1534 INSN, i.e., if INSN will always branch if CONDITION is true. */
1537 condition_dominates_p (condition, insn)
1541 rtx other_condition = get_branch_condition (insn, JUMP_LABEL (insn));
1542 enum rtx_code code = GET_CODE (condition);
1543 enum rtx_code other_code;
1545 if (rtx_equal_p (condition, other_condition)
1546 || other_condition == const_true_rtx)
1549 else if (condition == const_true_rtx || other_condition == 0)
1552 other_code = GET_CODE (other_condition);
1553 if (GET_RTX_LENGTH (code) != 2 || GET_RTX_LENGTH (other_code) != 2
1554 || ! rtx_equal_p (XEXP (condition, 0), XEXP (other_condition, 0))
1555 || ! rtx_equal_p (XEXP (condition, 1), XEXP (other_condition, 1)))
1558 return comparison_dominates_p (code, other_code);
1561 /* Return non-zero if redirecting JUMP to NEWLABEL does not invalidate
1562 any insns already in the delay slot of JUMP. */
1565 redirect_with_delay_slots_safe_p (jump, newlabel, seq)
1566 rtx jump, newlabel, seq;
1569 rtx pat = PATTERN (seq);
1571 /* Make sure all the delay slots of this jump would still
1572 be valid after threading the jump. If they are still
1573 valid, then return non-zero. */
1575 flags = get_jump_flags (jump, newlabel);
1576 for (i = 1; i < XVECLEN (pat, 0); i++)
1578 #ifdef ANNUL_IFFALSE_SLOTS
1579 (INSN_ANNULLED_BRANCH_P (jump)
1580 && INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
1581 ? eligible_for_annul_false (jump, i - 1,
1582 XVECEXP (pat, 0, i), flags) :
1584 #ifdef ANNUL_IFTRUE_SLOTS
1585 (INSN_ANNULLED_BRANCH_P (jump)
1586 && ! INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
1587 ? eligible_for_annul_true (jump, i - 1,
1588 XVECEXP (pat, 0, i), flags) :
1590 eligible_for_delay (jump, i -1, XVECEXP (pat, 0, i), flags)))
1593 return (i == XVECLEN (pat, 0));
1596 /* Return non-zero if redirecting JUMP to NEWLABEL does not invalidate
1597 any insns we wish to place in the delay slot of JUMP. */
1600 redirect_with_delay_list_safe_p (jump, newlabel, delay_list)
1601 rtx jump, newlabel, delay_list;
1606 /* Make sure all the insns in DELAY_LIST would still be
1607 valid after threading the jump. If they are still
1608 valid, then return non-zero. */
1610 flags = get_jump_flags (jump, newlabel);
1611 for (li = delay_list, i = 0; li; li = XEXP (li, 1), i++)
1613 #ifdef ANNUL_IFFALSE_SLOTS
1614 (INSN_ANNULLED_BRANCH_P (jump)
1615 && INSN_FROM_TARGET_P (XEXP (li, 0)))
1616 ? eligible_for_annul_false (jump, i, XEXP (li, 0), flags) :
1618 #ifdef ANNUL_IFTRUE_SLOTS
1619 (INSN_ANNULLED_BRANCH_P (jump)
1620 && ! INSN_FROM_TARGET_P (XEXP (li, 0)))
1621 ? eligible_for_annul_true (jump, i, XEXP (li, 0), flags) :
1623 eligible_for_delay (jump, i, XEXP (li, 0), flags)))
1626 return (li == NULL);
1629 /* DELAY_LIST is a list of insns that have already been placed into delay
1630 slots. See if all of them have the same annulling status as ANNUL_TRUE_P.
1631 If not, return 0; otherwise return 1. */
1634 check_annul_list_true_false (annul_true_p, delay_list)
1642 for (temp = delay_list; temp; temp = XEXP (temp, 1))
1644 rtx trial = XEXP (temp, 0);
1646 if ((annul_true_p && INSN_FROM_TARGET_P (trial))
1647 || (!annul_true_p && !INSN_FROM_TARGET_P (trial)))
1655 /* INSN branches to an insn whose pattern SEQ is a SEQUENCE. Given that
1656 the condition tested by INSN is CONDITION and the resources shown in
1657 OTHER_NEEDED are needed after INSN, see whether INSN can take all the insns
1658 from SEQ's delay list, in addition to whatever insns it may execute
1659 (in DELAY_LIST). SETS and NEEDED are denote resources already set and
1660 needed while searching for delay slot insns. Return the concatenated
1661 delay list if possible, otherwise, return 0.
1663 SLOTS_TO_FILL is the total number of slots required by INSN, and
1664 PSLOTS_FILLED points to the number filled so far (also the number of
1665 insns in DELAY_LIST). It is updated with the number that have been
1666 filled from the SEQUENCE, if any.
1668 PANNUL_P points to a non-zero value if we already know that we need
1669 to annul INSN. If this routine determines that annulling is needed,
1670 it may set that value non-zero.
1672 PNEW_THREAD points to a location that is to receive the place at which
1673 execution should continue. */
1676 steal_delay_list_from_target (insn, condition, seq, delay_list,
1677 sets, needed, other_needed,
1678 slots_to_fill, pslots_filled, pannul_p,
1680 rtx insn, condition;
1683 struct resources *sets, *needed, *other_needed;
1690 int slots_remaining = slots_to_fill - *pslots_filled;
1691 int total_slots_filled = *pslots_filled;
1692 rtx new_delay_list = 0;
1693 int must_annul = *pannul_p;
1697 /* We can't do anything if there are more delay slots in SEQ than we
1698 can handle, or if we don't know that it will be a taken branch.
1699 We know that it will be a taken branch if it is either an unconditional
1700 branch or a conditional branch with a stricter branch condition.
1702 Also, exit if the branch has more than one set, since then it is computing
1703 other results that can't be ignored, e.g. the HPPA mov&branch instruction.
1704 ??? It may be possible to move other sets into INSN in addition to
1705 moving the instructions in the delay slots. */
1707 if (XVECLEN (seq, 0) - 1 > slots_remaining
1708 || ! condition_dominates_p (condition, XVECEXP (seq, 0, 0))
1709 || ! single_set (XVECEXP (seq, 0, 0)))
1712 for (i = 1; i < XVECLEN (seq, 0); i++)
1714 rtx trial = XVECEXP (seq, 0, i);
1717 if (insn_references_resource_p (trial, sets, 0)
1718 || insn_sets_resource_p (trial, needed, 0)
1719 || insn_sets_resource_p (trial, sets, 0)
1721 /* If TRIAL sets CC0, we can't copy it, so we can't steal this
1723 || find_reg_note (trial, REG_CC_USER, NULL_RTX)
1725 /* If TRIAL is from the fallthrough code of an annulled branch insn
1726 in SEQ, we cannot use it. */
1727 || (INSN_ANNULLED_BRANCH_P (XVECEXP (seq, 0, 0))
1728 && ! INSN_FROM_TARGET_P (trial)))
1731 /* If this insn was already done (usually in a previous delay slot),
1732 pretend we put it in our delay slot. */
1733 if (redundant_insn (trial, insn, new_delay_list))
1736 /* We will end up re-vectoring this branch, so compute flags
1737 based on jumping to the new label. */
1738 flags = get_jump_flags (insn, JUMP_LABEL (XVECEXP (seq, 0, 0)));
1741 && ((condition == const_true_rtx
1742 || (! insn_sets_resource_p (trial, other_needed, 0)
1743 && ! may_trap_p (PATTERN (trial)))))
1744 ? eligible_for_delay (insn, total_slots_filled, trial, flags)
1745 : (must_annul || (delay_list == NULL && new_delay_list == NULL))
1747 check_annul_list_true_false (0, delay_list)
1748 && check_annul_list_true_false (0, new_delay_list)
1749 && eligible_for_annul_false (insn, total_slots_filled,
1754 temp = copy_rtx (trial);
1755 INSN_FROM_TARGET_P (temp) = 1;
1756 new_delay_list = add_to_delay_list (temp, new_delay_list);
1757 total_slots_filled++;
1759 if (--slots_remaining == 0)
1766 /* Show the place to which we will be branching. */
1767 *pnew_thread = next_active_insn (JUMP_LABEL (XVECEXP (seq, 0, 0)));
1769 /* Add any new insns to the delay list and update the count of the
1770 number of slots filled. */
1771 *pslots_filled = total_slots_filled;
1775 if (delay_list == 0)
1776 return new_delay_list;
1778 for (temp = new_delay_list; temp; temp = XEXP (temp, 1))
1779 delay_list = add_to_delay_list (XEXP (temp, 0), delay_list);
1784 /* Similar to steal_delay_list_from_target except that SEQ is on the
1785 fallthrough path of INSN. Here we only do something if the delay insn
1786 of SEQ is an unconditional branch. In that case we steal its delay slot
1787 for INSN since unconditional branches are much easier to fill. */
1790 steal_delay_list_from_fallthrough (insn, condition, seq,
1791 delay_list, sets, needed, other_needed,
1792 slots_to_fill, pslots_filled, pannul_p)
1793 rtx insn, condition;
1796 struct resources *sets, *needed, *other_needed;
1803 int must_annul = *pannul_p;
1806 flags = get_jump_flags (insn, JUMP_LABEL (insn));
1808 /* We can't do anything if SEQ's delay insn isn't an
1809 unconditional branch. */
1811 if (! simplejump_p (XVECEXP (seq, 0, 0))
1812 && GET_CODE (PATTERN (XVECEXP (seq, 0, 0))) != RETURN)
1815 for (i = 1; i < XVECLEN (seq, 0); i++)
1817 rtx trial = XVECEXP (seq, 0, i);
1819 /* If TRIAL sets CC0, stealing it will move it too far from the use
1821 if (insn_references_resource_p (trial, sets, 0)
1822 || insn_sets_resource_p (trial, needed, 0)
1823 || insn_sets_resource_p (trial, sets, 0)
1825 || sets_cc0_p (PATTERN (trial))
1831 /* If this insn was already done, we don't need it. */
1832 if (redundant_insn (trial, insn, delay_list))
1834 delete_from_delay_slot (trial);
1839 && ((condition == const_true_rtx
1840 || (! insn_sets_resource_p (trial, other_needed, 0)
1841 && ! may_trap_p (PATTERN (trial)))))
1842 ? eligible_for_delay (insn, *pslots_filled, trial, flags)
1843 : (must_annul || delay_list == NULL) && (must_annul = 1,
1844 check_annul_list_true_false (1, delay_list)
1845 && eligible_for_annul_true (insn, *pslots_filled, trial, flags)))
1849 delete_from_delay_slot (trial);
1850 delay_list = add_to_delay_list (trial, delay_list);
1852 if (++(*pslots_filled) == slots_to_fill)
1865 /* Try merging insns starting at THREAD which match exactly the insns in
1868 If all insns were matched and the insn was previously annulling, the
1869 annul bit will be cleared.
1871 For each insn that is merged, if the branch is or will be non-annulling,
1872 we delete the merged insn. */
1875 try_merge_delay_insns (insn, thread)
1878 rtx trial, next_trial;
1879 rtx delay_insn = XVECEXP (PATTERN (insn), 0, 0);
1880 int annul_p = INSN_ANNULLED_BRANCH_P (delay_insn);
1881 int slot_number = 1;
1882 int num_slots = XVECLEN (PATTERN (insn), 0);
1883 rtx next_to_match = XVECEXP (PATTERN (insn), 0, slot_number);
1884 struct resources set, needed;
1885 rtx merged_insns = 0;
1889 flags = get_jump_flags (delay_insn, JUMP_LABEL (delay_insn));
1891 CLEAR_RESOURCE (&needed);
1892 CLEAR_RESOURCE (&set);
1894 /* If this is not an annulling branch, take into account anything needed in
1895 INSN's delay slot. This prevents two increments from being incorrectly
1896 folded into one. If we are annulling, this would be the correct
1897 thing to do. (The alternative, looking at things set in NEXT_TO_MATCH
1898 will essentially disable this optimization. This method is somewhat of
1899 a kludge, but I don't see a better way.) */
1901 for (i = 1 ; i < num_slots ; i++)
1902 if (XVECEXP (PATTERN (insn), 0, i))
1903 mark_referenced_resources (XVECEXP (PATTERN (insn), 0, i), &needed, 1);
1905 for (trial = thread; !stop_search_p (trial, 1); trial = next_trial)
1907 rtx pat = PATTERN (trial);
1908 rtx oldtrial = trial;
1910 next_trial = next_nonnote_insn (trial);
1912 /* TRIAL must be a CALL_INSN or INSN. Skip USE and CLOBBER. */
1913 if (GET_CODE (trial) == INSN
1914 && (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER))
1917 if (GET_CODE (next_to_match) == GET_CODE (trial)
1919 /* We can't share an insn that sets cc0. */
1920 && ! sets_cc0_p (pat)
1922 && ! insn_references_resource_p (trial, &set, 1)
1923 && ! insn_sets_resource_p (trial, &set, 1)
1924 && ! insn_sets_resource_p (trial, &needed, 1)
1925 && (trial = try_split (pat, trial, 0)) != 0
1926 /* Update next_trial, in case try_split succeeded. */
1927 && (next_trial = next_nonnote_insn (trial))
1928 /* Likewise THREAD. */
1929 && (thread = oldtrial == thread ? trial : thread)
1930 && rtx_equal_p (PATTERN (next_to_match), PATTERN (trial))
1931 /* Have to test this condition if annul condition is different
1932 from (and less restrictive than) non-annulling one. */
1933 && eligible_for_delay (delay_insn, slot_number - 1, trial, flags))
1938 update_block (trial, thread);
1939 if (trial == thread)
1940 thread = next_active_insn (thread);
1942 delete_insn (trial);
1943 INSN_FROM_TARGET_P (next_to_match) = 0;
1946 merged_insns = gen_rtx_INSN_LIST (VOIDmode, trial, merged_insns);
1948 if (++slot_number == num_slots)
1951 next_to_match = XVECEXP (PATTERN (insn), 0, slot_number);
1954 mark_set_resources (trial, &set, 0, 1);
1955 mark_referenced_resources (trial, &needed, 1);
1958 /* See if we stopped on a filled insn. If we did, try to see if its
1959 delay slots match. */
1960 if (slot_number != num_slots
1961 && trial && GET_CODE (trial) == INSN
1962 && GET_CODE (PATTERN (trial)) == SEQUENCE
1963 && ! INSN_ANNULLED_BRANCH_P (XVECEXP (PATTERN (trial), 0, 0)))
1965 rtx pat = PATTERN (trial);
1966 rtx filled_insn = XVECEXP (pat, 0, 0);
1968 /* Account for resources set/needed by the filled insn. */
1969 mark_set_resources (filled_insn, &set, 0, 1);
1970 mark_referenced_resources (filled_insn, &needed, 1);
1972 for (i = 1; i < XVECLEN (pat, 0); i++)
1974 rtx dtrial = XVECEXP (pat, 0, i);
1976 if (! insn_references_resource_p (dtrial, &set, 1)
1977 && ! insn_sets_resource_p (dtrial, &set, 1)
1978 && ! insn_sets_resource_p (dtrial, &needed, 1)
1980 && ! sets_cc0_p (PATTERN (dtrial))
1982 && rtx_equal_p (PATTERN (next_to_match), PATTERN (dtrial))
1983 && eligible_for_delay (delay_insn, slot_number - 1, dtrial, flags))
1989 update_block (dtrial, thread);
1990 new = delete_from_delay_slot (dtrial);
1991 if (INSN_DELETED_P (thread))
1993 INSN_FROM_TARGET_P (next_to_match) = 0;
1996 merged_insns = gen_rtx_INSN_LIST (SImode, dtrial,
1999 if (++slot_number == num_slots)
2002 next_to_match = XVECEXP (PATTERN (insn), 0, slot_number);
2006 /* Keep track of the set/referenced resources for the delay
2007 slots of any trial insns we encounter. */
2008 mark_set_resources (dtrial, &set, 0, 1);
2009 mark_referenced_resources (dtrial, &needed, 1);
2014 /* If all insns in the delay slot have been matched and we were previously
2015 annulling the branch, we need not any more. In that case delete all the
2016 merged insns. Also clear the INSN_FROM_TARGET_P bit of each insn in
2017 the delay list so that we know that it isn't only being used at the
2019 if (slot_number == num_slots && annul_p)
2021 for (; merged_insns; merged_insns = XEXP (merged_insns, 1))
2023 if (GET_MODE (merged_insns) == SImode)
2027 update_block (XEXP (merged_insns, 0), thread);
2028 new = delete_from_delay_slot (XEXP (merged_insns, 0));
2029 if (INSN_DELETED_P (thread))
2034 update_block (XEXP (merged_insns, 0), thread);
2035 delete_insn (XEXP (merged_insns, 0));
2039 INSN_ANNULLED_BRANCH_P (delay_insn) = 0;
2041 for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
2042 INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i)) = 0;
2046 /* See if INSN is redundant with an insn in front of TARGET. Often this
2047 is called when INSN is a candidate for a delay slot of TARGET.
2048 DELAY_LIST are insns that will be placed in delay slots of TARGET in front
2049 of INSN. Often INSN will be redundant with an insn in a delay slot of
2050 some previous insn. This happens when we have a series of branches to the
2051 same label; in that case the first insn at the target might want to go
2052 into each of the delay slots.
2054 If we are not careful, this routine can take up a significant fraction
2055 of the total compilation time (4%), but only wins rarely. Hence we
2056 speed this routine up by making two passes. The first pass goes back
2057 until it hits a label and sees if it find an insn with an identical
2058 pattern. Only in this (relatively rare) event does it check for
2061 We do not split insns we encounter. This could cause us not to find a
2062 redundant insn, but the cost of splitting seems greater than the possible
2063 gain in rare cases. */
2066 redundant_insn (insn, target, delay_list)
2071 rtx target_main = target;
2072 rtx ipat = PATTERN (insn);
2074 struct resources needed, set;
2077 /* If INSN has any REG_UNUSED notes, it can't match anything since we
2078 are allowed to not actually assign to such a register. */
2079 if (find_reg_note (insn, REG_UNUSED, NULL_RTX) != 0)
2082 /* Scan backwards looking for a match. */
2083 for (trial = PREV_INSN (target); trial; trial = PREV_INSN (trial))
2085 if (GET_CODE (trial) == CODE_LABEL)
2088 if (GET_RTX_CLASS (GET_CODE (trial)) != 'i')
2091 pat = PATTERN (trial);
2092 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
2095 if (GET_CODE (pat) == SEQUENCE)
2097 /* Stop for a CALL and its delay slots because it is difficult to
2098 track its resource needs correctly. */
2099 if (GET_CODE (XVECEXP (pat, 0, 0)) == CALL_INSN)
2102 /* Stop for an INSN or JUMP_INSN with delayed effects and its delay
2103 slots because it is difficult to track its resource needs
2106 #ifdef INSN_SETS_ARE_DELAYED
2107 if (INSN_SETS_ARE_DELAYED (XVECEXP (pat, 0, 0)))
2111 #ifdef INSN_REFERENCES_ARE_DELAYED
2112 if (INSN_REFERENCES_ARE_DELAYED (XVECEXP (pat, 0, 0)))
2116 /* See if any of the insns in the delay slot match, updating
2117 resource requirements as we go. */
2118 for (i = XVECLEN (pat, 0) - 1; i > 0; i--)
2119 if (GET_CODE (XVECEXP (pat, 0, i)) == GET_CODE (insn)
2120 && rtx_equal_p (PATTERN (XVECEXP (pat, 0, i)), ipat)
2121 && ! find_reg_note (XVECEXP (pat, 0, i), REG_UNUSED, NULL_RTX))
2124 /* If found a match, exit this loop early. */
2129 else if (GET_CODE (trial) == GET_CODE (insn) && rtx_equal_p (pat, ipat)
2130 && ! find_reg_note (trial, REG_UNUSED, NULL_RTX))
2134 /* If we didn't find an insn that matches, return 0. */
2138 /* See what resources this insn sets and needs. If they overlap, or
2139 if this insn references CC0, it can't be redundant. */
2141 CLEAR_RESOURCE (&needed);
2142 CLEAR_RESOURCE (&set);
2143 mark_set_resources (insn, &set, 0, 1);
2144 mark_referenced_resources (insn, &needed, 1);
2146 /* If TARGET is a SEQUENCE, get the main insn. */
2147 if (GET_CODE (target) == INSN && GET_CODE (PATTERN (target)) == SEQUENCE)
2148 target_main = XVECEXP (PATTERN (target), 0, 0);
2150 if (resource_conflicts_p (&needed, &set)
2152 || reg_mentioned_p (cc0_rtx, ipat)
2154 /* The insn requiring the delay may not set anything needed or set by
2156 || insn_sets_resource_p (target_main, &needed, 1)
2157 || insn_sets_resource_p (target_main, &set, 1))
2160 /* Insns we pass may not set either NEEDED or SET, so merge them for
2162 needed.memory |= set.memory;
2163 needed.unch_memory |= set.unch_memory;
2164 IOR_HARD_REG_SET (needed.regs, set.regs);
2166 /* This insn isn't redundant if it conflicts with an insn that either is
2167 or will be in a delay slot of TARGET. */
2171 if (insn_sets_resource_p (XEXP (delay_list, 0), &needed, 1))
2173 delay_list = XEXP (delay_list, 1);
2176 if (GET_CODE (target) == INSN && GET_CODE (PATTERN (target)) == SEQUENCE)
2177 for (i = 1; i < XVECLEN (PATTERN (target), 0); i++)
2178 if (insn_sets_resource_p (XVECEXP (PATTERN (target), 0, i), &needed, 1))
2181 /* Scan backwards until we reach a label or an insn that uses something
2182 INSN sets or sets something insn uses or sets. */
2184 for (trial = PREV_INSN (target);
2185 trial && GET_CODE (trial) != CODE_LABEL;
2186 trial = PREV_INSN (trial))
2188 if (GET_CODE (trial) != INSN && GET_CODE (trial) != CALL_INSN
2189 && GET_CODE (trial) != JUMP_INSN)
2192 pat = PATTERN (trial);
2193 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
2196 if (GET_CODE (pat) == SEQUENCE)
2198 /* If this is a CALL_INSN and its delay slots, it is hard to track
2199 the resource needs properly, so give up. */
2200 if (GET_CODE (XVECEXP (pat, 0, 0)) == CALL_INSN)
2203 /* If this is an INSN or JUMP_INSN with delayed effects, it
2204 is hard to track the resource needs properly, so give up. */
2206 #ifdef INSN_SETS_ARE_DELAYED
2207 if (INSN_SETS_ARE_DELAYED (XVECEXP (pat, 0, 0)))
2211 #ifdef INSN_REFERENCES_ARE_DELAYED
2212 if (INSN_REFERENCES_ARE_DELAYED (XVECEXP (pat, 0, 0)))
2216 /* See if any of the insns in the delay slot match, updating
2217 resource requirements as we go. */
2218 for (i = XVECLEN (pat, 0) - 1; i > 0; i--)
2220 rtx candidate = XVECEXP (pat, 0, i);
2222 /* If an insn will be annulled if the branch is false, it isn't
2223 considered as a possible duplicate insn. */
2224 if (rtx_equal_p (PATTERN (candidate), ipat)
2225 && ! (INSN_ANNULLED_BRANCH_P (XVECEXP (pat, 0, 0))
2226 && INSN_FROM_TARGET_P (candidate)))
2228 /* Show that this insn will be used in the sequel. */
2229 INSN_FROM_TARGET_P (candidate) = 0;
2233 /* Unless this is an annulled insn from the target of a branch,
2234 we must stop if it sets anything needed or set by INSN. */
2235 if ((! INSN_ANNULLED_BRANCH_P (XVECEXP (pat, 0, 0))
2236 || ! INSN_FROM_TARGET_P (candidate))
2237 && insn_sets_resource_p (candidate, &needed, 1))
2242 /* If the insn requiring the delay slot conflicts with INSN, we
2244 if (insn_sets_resource_p (XVECEXP (pat, 0, 0), &needed, 1))
2249 /* See if TRIAL is the same as INSN. */
2250 pat = PATTERN (trial);
2251 if (rtx_equal_p (pat, ipat))
2254 /* Can't go any further if TRIAL conflicts with INSN. */
2255 if (insn_sets_resource_p (trial, &needed, 1))
2263 /* Return 1 if THREAD can only be executed in one way. If LABEL is non-zero,
2264 it is the target of the branch insn being scanned. If ALLOW_FALLTHROUGH
2265 is non-zero, we are allowed to fall into this thread; otherwise, we are
2268 If LABEL is used more than one or we pass a label other than LABEL before
2269 finding an active insn, we do not own this thread. */
2272 own_thread_p (thread, label, allow_fallthrough)
2275 int allow_fallthrough;
2280 /* We don't own the function end. */
2284 /* Get the first active insn, or THREAD, if it is an active insn. */
2285 active_insn = next_active_insn (PREV_INSN (thread));
2287 for (insn = thread; insn != active_insn; insn = NEXT_INSN (insn))
2288 if (GET_CODE (insn) == CODE_LABEL
2289 && (insn != label || LABEL_NUSES (insn) != 1))
2292 if (allow_fallthrough)
2295 /* Ensure that we reach a BARRIER before any insn or label. */
2296 for (insn = prev_nonnote_insn (thread);
2297 insn == 0 || GET_CODE (insn) != BARRIER;
2298 insn = prev_nonnote_insn (insn))
2300 || GET_CODE (insn) == CODE_LABEL
2301 || (GET_CODE (insn) == INSN
2302 && GET_CODE (PATTERN (insn)) != USE
2303 && GET_CODE (PATTERN (insn)) != CLOBBER))
2309 /* Find the number of the basic block that starts closest to INSN. Return -1
2310 if we couldn't find such a basic block. */
2313 find_basic_block (insn)
2318 /* Scan backwards to the previous BARRIER. Then see if we can find a
2319 label that starts a basic block. Return the basic block number. */
2321 for (insn = prev_nonnote_insn (insn);
2322 insn && GET_CODE (insn) != BARRIER;
2323 insn = prev_nonnote_insn (insn))
2326 /* The start of the function is basic block zero. */
2330 /* See if any of the upcoming CODE_LABELs start a basic block. If we reach
2331 anything other than a CODE_LABEL or note, we can't find this code. */
2332 for (insn = next_nonnote_insn (insn);
2333 insn && GET_CODE (insn) == CODE_LABEL;
2334 insn = next_nonnote_insn (insn))
2336 for (i = 0; i < n_basic_blocks; i++)
2337 if (insn == basic_block_head[i])
2344 /* Called when INSN is being moved from a location near the target of a jump.
2345 We leave a marker of the form (use (INSN)) immediately in front
2346 of WHERE for mark_target_live_regs. These markers will be deleted when
2349 We used to try to update the live status of registers if WHERE is at
2350 the start of a basic block, but that can't work since we may remove a
2351 BARRIER in relax_delay_slots. */
2354 update_block (insn, where)
2360 /* Ignore if this was in a delay slot and it came from the target of
2362 if (INSN_FROM_TARGET_P (insn))
2365 emit_insn_before (gen_rtx_USE (VOIDmode, insn), where);
2367 /* INSN might be making a value live in a block where it didn't use to
2368 be. So recompute liveness information for this block. */
2370 b = find_basic_block (insn);
2375 /* Similar to REDIRECT_JUMP except that we update the BB_TICKS entry for
2376 the basic block containing the jump. */
2379 reorg_redirect_jump (jump, nlabel)
2383 int b = find_basic_block (jump);
2388 return redirect_jump (jump, nlabel);
2391 /* Called when INSN is being moved forward into a delay slot of DELAYED_INSN.
2392 We check every instruction between INSN and DELAYED_INSN for REG_DEAD notes
2393 that reference values used in INSN. If we find one, then we move the
2394 REG_DEAD note to INSN.
2396 This is needed to handle the case where an later insn (after INSN) has a
2397 REG_DEAD note for a register used by INSN, and this later insn subsequently
2398 gets moved before a CODE_LABEL because it is a redundant insn. In this
2399 case, mark_target_live_regs may be confused into thinking the register
2400 is dead because it sees a REG_DEAD note immediately before a CODE_LABEL. */
2403 update_reg_dead_notes (insn, delayed_insn)
2404 rtx insn, delayed_insn;
2408 for (p = next_nonnote_insn (insn); p != delayed_insn;
2409 p = next_nonnote_insn (p))
2410 for (link = REG_NOTES (p); link; link = next)
2412 next = XEXP (link, 1);
2414 if (REG_NOTE_KIND (link) != REG_DEAD
2415 || GET_CODE (XEXP (link, 0)) != REG)
2418 if (reg_referenced_p (XEXP (link, 0), PATTERN (insn)))
2420 /* Move the REG_DEAD note from P to INSN. */
2421 remove_note (p, link);
2422 XEXP (link, 1) = REG_NOTES (insn);
2423 REG_NOTES (insn) = link;
2428 /* Called when an insn redundant with start_insn is deleted. If there
2429 is a REG_DEAD note for the target of start_insn between start_insn
2430 and stop_insn, then the REG_DEAD note needs to be deleted since the
2431 value no longer dies there.
2433 If the REG_DEAD note isn't deleted, then mark_target_live_regs may be
2434 confused into thinking the register is dead. */
2437 fix_reg_dead_note (start_insn, stop_insn)
2438 rtx start_insn, stop_insn;
2442 for (p = next_nonnote_insn (start_insn); p != stop_insn;
2443 p = next_nonnote_insn (p))
2444 for (link = REG_NOTES (p); link; link = next)
2446 next = XEXP (link, 1);
2448 if (REG_NOTE_KIND (link) != REG_DEAD
2449 || GET_CODE (XEXP (link, 0)) != REG)
2452 if (reg_set_p (XEXP (link, 0), PATTERN (start_insn)))
2454 remove_note (p, link);
2460 /* Delete any REG_UNUSED notes that exist on INSN but not on REDUNDANT_INSN.
2462 This handles the case of udivmodXi4 instructions which optimize their
2463 output depending on whether any REG_UNUSED notes are present.
2464 we must make sure that INSN calculates as many results as REDUNDANT_INSN
2468 update_reg_unused_notes (insn, redundant_insn)
2469 rtx insn, redundant_insn;
2473 for (link = REG_NOTES (insn); link; link = next)
2475 next = XEXP (link, 1);
2477 if (REG_NOTE_KIND (link) != REG_UNUSED
2478 || GET_CODE (XEXP (link, 0)) != REG)
2481 if (! find_regno_note (redundant_insn, REG_UNUSED,
2482 REGNO (XEXP (link, 0))))
2483 remove_note (insn, link);
2487 /* Marks registers possibly live at the current place being scanned by
2488 mark_target_live_regs. Used only by next two function. */
2490 static HARD_REG_SET current_live_regs;
2492 /* Marks registers for which we have seen a REG_DEAD note but no assignment.
2493 Also only used by the next two functions. */
2495 static HARD_REG_SET pending_dead_regs;
2497 /* Utility function called from mark_target_live_regs via note_stores.
2498 It deadens any CLOBBERed registers and livens any SET registers. */
2501 update_live_status (dest, x)
2505 int first_regno, last_regno;
2508 if (GET_CODE (dest) != REG
2509 && (GET_CODE (dest) != SUBREG || GET_CODE (SUBREG_REG (dest)) != REG))
2512 if (GET_CODE (dest) == SUBREG)
2513 first_regno = REGNO (SUBREG_REG (dest)) + SUBREG_WORD (dest);
2515 first_regno = REGNO (dest);
2517 last_regno = first_regno + HARD_REGNO_NREGS (first_regno, GET_MODE (dest));
2519 if (GET_CODE (x) == CLOBBER)
2520 for (i = first_regno; i < last_regno; i++)
2521 CLEAR_HARD_REG_BIT (current_live_regs, i);
2523 for (i = first_regno; i < last_regno; i++)
2525 SET_HARD_REG_BIT (current_live_regs, i);
2526 CLEAR_HARD_REG_BIT (pending_dead_regs, i);
2530 /* Similar to next_insn, but ignores insns in the delay slots of
2531 an annulled branch. */
2534 next_insn_no_annul (insn)
2539 /* If INSN is an annulled branch, skip any insns from the target
2541 if (INSN_ANNULLED_BRANCH_P (insn)
2542 && NEXT_INSN (PREV_INSN (insn)) != insn)
2543 while (INSN_FROM_TARGET_P (NEXT_INSN (insn)))
2544 insn = NEXT_INSN (insn);
2546 insn = NEXT_INSN (insn);
2547 if (insn && GET_CODE (insn) == INSN
2548 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2549 insn = XVECEXP (PATTERN (insn), 0, 0);
2555 /* A subroutine of mark_target_live_regs. Search forward from TARGET
2556 looking for registers that are set before they are used. These are dead.
2557 Stop after passing a few conditional jumps, and/or a small
2558 number of unconditional branches. */
2561 find_dead_or_set_registers (target, res, jump_target, jump_count, set, needed)
2563 struct resources *res;
2566 struct resources set, needed;
2568 HARD_REG_SET scratch;
2573 for (insn = target; insn; insn = next)
2575 rtx this_jump_insn = insn;
2577 next = NEXT_INSN (insn);
2578 switch (GET_CODE (insn))
2581 /* After a label, any pending dead registers that weren't yet
2582 used can be made dead. */
2583 AND_COMPL_HARD_REG_SET (pending_dead_regs, needed.regs);
2584 AND_COMPL_HARD_REG_SET (res->regs, pending_dead_regs);
2585 CLEAR_HARD_REG_SET (pending_dead_regs);
2587 if (CODE_LABEL_NUMBER (insn) < max_label_num_after_reload)
2589 /* All spill registers are dead at a label, so kill all of the
2590 ones that aren't needed also. */
2591 COPY_HARD_REG_SET (scratch, used_spill_regs);
2592 AND_COMPL_HARD_REG_SET (scratch, needed.regs);
2593 AND_COMPL_HARD_REG_SET (res->regs, scratch);
2602 if (GET_CODE (PATTERN (insn)) == USE)
2604 /* If INSN is a USE made by update_block, we care about the
2605 underlying insn. Any registers set by the underlying insn
2606 are live since the insn is being done somewhere else. */
2607 if (GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
2608 mark_set_resources (XEXP (PATTERN (insn), 0), res, 0, 1);
2610 /* All other USE insns are to be ignored. */
2613 else if (GET_CODE (PATTERN (insn)) == CLOBBER)
2615 else if (GET_CODE (PATTERN (insn)) == SEQUENCE)
2617 /* An unconditional jump can be used to fill the delay slot
2618 of a call, so search for a JUMP_INSN in any position. */
2619 for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
2621 this_jump_insn = XVECEXP (PATTERN (insn), 0, i);
2622 if (GET_CODE (this_jump_insn) == JUMP_INSN)
2631 if (GET_CODE (this_jump_insn) == JUMP_INSN)
2633 if (jump_count++ < 10)
2635 if (simplejump_p (this_jump_insn)
2636 || GET_CODE (PATTERN (this_jump_insn)) == RETURN)
2638 next = JUMP_LABEL (this_jump_insn);
2643 *jump_target = JUMP_LABEL (this_jump_insn);
2646 else if (condjump_p (this_jump_insn)
2647 || condjump_in_parallel_p (this_jump_insn))
2649 struct resources target_set, target_res;
2650 struct resources fallthrough_res;
2652 /* We can handle conditional branches here by following
2653 both paths, and then IOR the results of the two paths
2654 together, which will give us registers that are dead
2655 on both paths. Since this is expensive, we give it
2656 a much higher cost than unconditional branches. The
2657 cost was chosen so that we will follow at most 1
2658 conditional branch. */
2661 if (jump_count >= 10)
2664 mark_referenced_resources (insn, &needed, 1);
2666 /* For an annulled branch, mark_set_resources ignores slots
2667 filled by instructions from the target. This is correct
2668 if the branch is not taken. Since we are following both
2669 paths from the branch, we must also compute correct info
2670 if the branch is taken. We do this by inverting all of
2671 the INSN_FROM_TARGET_P bits, calling mark_set_resources,
2672 and then inverting the INSN_FROM_TARGET_P bits again. */
2674 if (GET_CODE (PATTERN (insn)) == SEQUENCE
2675 && INSN_ANNULLED_BRANCH_P (this_jump_insn))
2677 for (i = 1; i < XVECLEN (PATTERN (insn), 0); i++)
2678 INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i))
2679 = ! INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i));
2682 mark_set_resources (insn, &target_set, 0, 1);
2684 for (i = 1; i < XVECLEN (PATTERN (insn), 0); i++)
2685 INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i))
2686 = ! INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i));
2688 mark_set_resources (insn, &set, 0, 1);
2692 mark_set_resources (insn, &set, 0, 1);
2697 COPY_HARD_REG_SET (scratch, target_set.regs);
2698 AND_COMPL_HARD_REG_SET (scratch, needed.regs);
2699 AND_COMPL_HARD_REG_SET (target_res.regs, scratch);
2701 fallthrough_res = *res;
2702 COPY_HARD_REG_SET (scratch, set.regs);
2703 AND_COMPL_HARD_REG_SET (scratch, needed.regs);
2704 AND_COMPL_HARD_REG_SET (fallthrough_res.regs, scratch);
2706 find_dead_or_set_registers (JUMP_LABEL (this_jump_insn),
2707 &target_res, 0, jump_count,
2708 target_set, needed);
2709 find_dead_or_set_registers (next,
2710 &fallthrough_res, 0, jump_count,
2712 IOR_HARD_REG_SET (fallthrough_res.regs, target_res.regs);
2713 AND_HARD_REG_SET (res->regs, fallthrough_res.regs);
2721 /* Don't try this optimization if we expired our jump count
2722 above, since that would mean there may be an infinite loop
2723 in the function being compiled. */
2729 mark_referenced_resources (insn, &needed, 1);
2730 mark_set_resources (insn, &set, 0, 1);
2732 COPY_HARD_REG_SET (scratch, set.regs);
2733 AND_COMPL_HARD_REG_SET (scratch, needed.regs);
2734 AND_COMPL_HARD_REG_SET (res->regs, scratch);
2740 /* Set the resources that are live at TARGET.
2742 If TARGET is zero, we refer to the end of the current function and can
2743 return our precomputed value.
2745 Otherwise, we try to find out what is live by consulting the basic block
2746 information. This is tricky, because we must consider the actions of
2747 reload and jump optimization, which occur after the basic block information
2750 Accordingly, we proceed as follows::
2752 We find the previous BARRIER and look at all immediately following labels
2753 (with no intervening active insns) to see if any of them start a basic
2754 block. If we hit the start of the function first, we use block 0.
2756 Once we have found a basic block and a corresponding first insns, we can
2757 accurately compute the live status from basic_block_live_regs and
2758 reg_renumber. (By starting at a label following a BARRIER, we are immune
2759 to actions taken by reload and jump.) Then we scan all insns between
2760 that point and our target. For each CLOBBER (or for call-clobbered regs
2761 when we pass a CALL_INSN), mark the appropriate registers are dead. For
2762 a SET, mark them as live.
2764 We have to be careful when using REG_DEAD notes because they are not
2765 updated by such things as find_equiv_reg. So keep track of registers
2766 marked as dead that haven't been assigned to, and mark them dead at the
2767 next CODE_LABEL since reload and jump won't propagate values across labels.
2769 If we cannot find the start of a basic block (should be a very rare
2770 case, if it can happen at all), mark everything as potentially live.
2772 Next, scan forward from TARGET looking for things set or clobbered
2773 before they are used. These are not live.
2775 Because we can be called many times on the same target, save our results
2776 in a hash table indexed by INSN_UID. */
2779 mark_target_live_regs (target, res)
2781 struct resources *res;
2785 struct target_info *tinfo;
2789 HARD_REG_SET scratch;
2790 struct resources set, needed;
2792 /* Handle end of function. */
2795 *res = end_of_function_needs;
2799 /* We have to assume memory is needed, but the CC isn't. */
2801 res->volatil = res->unch_memory = 0;
2804 /* See if we have computed this value already. */
2805 for (tinfo = target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME];
2806 tinfo; tinfo = tinfo->next)
2807 if (tinfo->uid == INSN_UID (target))
2810 /* Start by getting the basic block number. If we have saved information,
2811 we can get it from there unless the insn at the start of the basic block
2812 has been deleted. */
2813 if (tinfo && tinfo->block != -1
2814 && ! INSN_DELETED_P (basic_block_head[tinfo->block]))
2818 b = find_basic_block (target);
2822 /* If the information is up-to-date, use it. Otherwise, we will
2824 if (b == tinfo->block && b != -1 && tinfo->bb_tick == bb_ticks[b])
2826 COPY_HARD_REG_SET (res->regs, tinfo->live_regs);
2832 /* Allocate a place to put our results and chain it into the
2834 tinfo = (struct target_info *) oballoc (sizeof (struct target_info));
2835 tinfo->uid = INSN_UID (target);
2837 tinfo->next = target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME];
2838 target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME] = tinfo;
2841 CLEAR_HARD_REG_SET (pending_dead_regs);
2843 /* If we found a basic block, get the live registers from it and update
2844 them with anything set or killed between its start and the insn before
2845 TARGET. Otherwise, we must assume everything is live. */
2848 regset regs_live = basic_block_live_at_start[b];
2851 rtx start_insn, stop_insn;
2853 /* Compute hard regs live at start of block -- this is the real hard regs
2854 marked live, plus live pseudo regs that have been renumbered to
2857 REG_SET_TO_HARD_REG_SET (current_live_regs, regs_live);
2859 EXECUTE_IF_SET_IN_REG_SET
2860 (regs_live, FIRST_PSEUDO_REGISTER, i,
2862 if ((regno = reg_renumber[i]) >= 0)
2864 j < regno + HARD_REGNO_NREGS (regno,
2865 PSEUDO_REGNO_MODE (i));
2867 SET_HARD_REG_BIT (current_live_regs, j);
2870 /* Get starting and ending insn, handling the case where each might
2872 start_insn = (b == 0 ? get_insns () : basic_block_head[b]);
2875 if (GET_CODE (start_insn) == INSN
2876 && GET_CODE (PATTERN (start_insn)) == SEQUENCE)
2877 start_insn = XVECEXP (PATTERN (start_insn), 0, 0);
2879 if (GET_CODE (stop_insn) == INSN
2880 && GET_CODE (PATTERN (stop_insn)) == SEQUENCE)
2881 stop_insn = next_insn (PREV_INSN (stop_insn));
2883 for (insn = start_insn; insn != stop_insn;
2884 insn = next_insn_no_annul (insn))
2887 rtx real_insn = insn;
2889 /* If this insn is from the target of a branch, it isn't going to
2890 be used in the sequel. If it is used in both cases, this
2891 test will not be true. */
2892 if (INSN_FROM_TARGET_P (insn))
2895 /* If this insn is a USE made by update_block, we care about the
2897 if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE
2898 && GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
2899 real_insn = XEXP (PATTERN (insn), 0);
2901 if (GET_CODE (real_insn) == CALL_INSN)
2903 /* CALL clobbers all call-used regs that aren't fixed except
2904 sp, ap, and fp. Do this before setting the result of the
2906 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2907 if (call_used_regs[i]
2908 && i != STACK_POINTER_REGNUM && i != FRAME_POINTER_REGNUM
2909 && i != ARG_POINTER_REGNUM
2910 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2911 && i != HARD_FRAME_POINTER_REGNUM
2913 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
2914 && ! (i == ARG_POINTER_REGNUM && fixed_regs[i])
2916 #ifdef PIC_OFFSET_TABLE_REGNUM
2917 && ! (i == PIC_OFFSET_TABLE_REGNUM && flag_pic)
2920 CLEAR_HARD_REG_BIT (current_live_regs, i);
2922 /* A CALL_INSN sets any global register live, since it may
2923 have been modified by the call. */
2924 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2926 SET_HARD_REG_BIT (current_live_regs, i);
2929 /* Mark anything killed in an insn to be deadened at the next
2930 label. Ignore USE insns; the only REG_DEAD notes will be for
2931 parameters. But they might be early. A CALL_INSN will usually
2932 clobber registers used for parameters. It isn't worth bothering
2933 with the unlikely case when it won't. */
2934 if ((GET_CODE (real_insn) == INSN
2935 && GET_CODE (PATTERN (real_insn)) != USE
2936 && GET_CODE (PATTERN (real_insn)) != CLOBBER)
2937 || GET_CODE (real_insn) == JUMP_INSN
2938 || GET_CODE (real_insn) == CALL_INSN)
2940 for (link = REG_NOTES (real_insn); link; link = XEXP (link, 1))
2941 if (REG_NOTE_KIND (link) == REG_DEAD
2942 && GET_CODE (XEXP (link, 0)) == REG
2943 && REGNO (XEXP (link, 0)) < FIRST_PSEUDO_REGISTER)
2945 int first_regno = REGNO (XEXP (link, 0));
2948 + HARD_REGNO_NREGS (first_regno,
2949 GET_MODE (XEXP (link, 0))));
2951 for (i = first_regno; i < last_regno; i++)
2952 SET_HARD_REG_BIT (pending_dead_regs, i);
2955 note_stores (PATTERN (real_insn), update_live_status);
2957 /* If any registers were unused after this insn, kill them.
2958 These notes will always be accurate. */
2959 for (link = REG_NOTES (real_insn); link; link = XEXP (link, 1))
2960 if (REG_NOTE_KIND (link) == REG_UNUSED
2961 && GET_CODE (XEXP (link, 0)) == REG
2962 && REGNO (XEXP (link, 0)) < FIRST_PSEUDO_REGISTER)
2964 int first_regno = REGNO (XEXP (link, 0));
2967 + HARD_REGNO_NREGS (first_regno,
2968 GET_MODE (XEXP (link, 0))));
2970 for (i = first_regno; i < last_regno; i++)
2971 CLEAR_HARD_REG_BIT (current_live_regs, i);
2975 else if (GET_CODE (real_insn) == CODE_LABEL)
2977 /* A label clobbers the pending dead registers since neither
2978 reload nor jump will propagate a value across a label. */
2979 AND_COMPL_HARD_REG_SET (current_live_regs, pending_dead_regs);
2980 CLEAR_HARD_REG_SET (pending_dead_regs);
2983 /* The beginning of the epilogue corresponds to the end of the
2984 RTL chain when there are no epilogue insns. Certain resources
2985 are implicitly required at that point. */
2986 else if (GET_CODE (real_insn) == NOTE
2987 && NOTE_LINE_NUMBER (real_insn) == NOTE_INSN_EPILOGUE_BEG)
2988 IOR_HARD_REG_SET (current_live_regs, start_of_epilogue_needs.regs);
2991 COPY_HARD_REG_SET (res->regs, current_live_regs);
2993 tinfo->bb_tick = bb_ticks[b];
2996 /* We didn't find the start of a basic block. Assume everything
2997 in use. This should happen only extremely rarely. */
2998 SET_HARD_REG_SET (res->regs);
3000 CLEAR_RESOURCE (&set);
3001 CLEAR_RESOURCE (&needed);
3003 jump_insn = find_dead_or_set_registers (target, res, &jump_target, 0,
3006 /* If we hit an unconditional branch, we have another way of finding out
3007 what is live: we can see what is live at the branch target and include
3008 anything used but not set before the branch. The only things that are
3009 live are those that are live using the above test and the test below. */
3013 struct resources new_resources;
3014 rtx stop_insn = next_active_insn (jump_insn);
3016 mark_target_live_regs (next_active_insn (jump_target), &new_resources);
3017 CLEAR_RESOURCE (&set);
3018 CLEAR_RESOURCE (&needed);
3020 /* Include JUMP_INSN in the needed registers. */
3021 for (insn = target; insn != stop_insn; insn = next_active_insn (insn))
3023 mark_referenced_resources (insn, &needed, 1);
3025 COPY_HARD_REG_SET (scratch, needed.regs);
3026 AND_COMPL_HARD_REG_SET (scratch, set.regs);
3027 IOR_HARD_REG_SET (new_resources.regs, scratch);
3029 mark_set_resources (insn, &set, 0, 1);
3032 AND_HARD_REG_SET (res->regs, new_resources.regs);
3035 COPY_HARD_REG_SET (tinfo->live_regs, res->regs);
3038 /* Scan a function looking for insns that need a delay slot and find insns to
3039 put into the delay slot.
3041 NON_JUMPS_P is non-zero if we are to only try to fill non-jump insns (such
3042 as calls). We do these first since we don't want jump insns (that are
3043 easier to fill) to get the only insns that could be used for non-jump insns.
3044 When it is zero, only try to fill JUMP_INSNs.
3046 When slots are filled in this manner, the insns (including the
3047 delay_insn) are put together in a SEQUENCE rtx. In this fashion,
3048 it is possible to tell whether a delay slot has really been filled
3049 or not. `final' knows how to deal with this, by communicating
3050 through FINAL_SEQUENCE. */
3053 fill_simple_delay_slots (non_jumps_p)
3056 register rtx insn, pat, trial, next_trial;
3058 int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
3059 struct resources needed, set;
3060 int slots_to_fill, slots_filled;
3063 for (i = 0; i < num_unfilled_slots; i++)
3066 /* Get the next insn to fill. If it has already had any slots assigned,
3067 we can't do anything with it. Maybe we'll improve this later. */
3069 insn = unfilled_slots_base[i];
3071 || INSN_DELETED_P (insn)
3072 || (GET_CODE (insn) == INSN
3073 && GET_CODE (PATTERN (insn)) == SEQUENCE)
3074 || (GET_CODE (insn) == JUMP_INSN && non_jumps_p)
3075 || (GET_CODE (insn) != JUMP_INSN && ! non_jumps_p))
3078 if (GET_CODE (insn) == JUMP_INSN)
3079 flags = get_jump_flags (insn, JUMP_LABEL (insn));
3081 flags = get_jump_flags (insn, NULL_RTX);
3082 slots_to_fill = num_delay_slots (insn);
3084 /* Some machine description have defined instructions to have
3085 delay slots only in certain circumstances which may depend on
3086 nearby insns (which change due to reorg's actions).
3088 For example, the PA port normally has delay slots for unconditional
3091 However, the PA port claims such jumps do not have a delay slot
3092 if they are immediate successors of certain CALL_INSNs. This
3093 allows the port to favor filling the delay slot of the call with
3094 the unconditional jump. */
3095 if (slots_to_fill == 0)
3098 /* This insn needs, or can use, some delay slots. SLOTS_TO_FILL
3099 says how many. After initialization, first try optimizing
3102 nop add %o7,.-L1,%o7
3106 If this case applies, the delay slot of the call is filled with
3107 the unconditional jump. This is done first to avoid having the
3108 delay slot of the call filled in the backward scan. Also, since
3109 the unconditional jump is likely to also have a delay slot, that
3110 insn must exist when it is subsequently scanned.
3112 This is tried on each insn with delay slots as some machines
3113 have insns which perform calls, but are not represented as
3119 if ((trial = next_active_insn (insn))
3120 && GET_CODE (trial) == JUMP_INSN
3121 && simplejump_p (trial)
3122 && eligible_for_delay (insn, slots_filled, trial, flags)
3123 && no_labels_between_p (insn, trial))
3127 delay_list = add_to_delay_list (trial, delay_list);
3129 /* TRIAL may have had its delay slot filled, then unfilled. When
3130 the delay slot is unfilled, TRIAL is placed back on the unfilled
3131 slots obstack. Unfortunately, it is placed on the end of the
3132 obstack, not in its original location. Therefore, we must search
3133 from entry i + 1 to the end of the unfilled slots obstack to
3134 try and find TRIAL. */
3135 tmp = &unfilled_slots_base[i + 1];
3136 while (*tmp != trial && tmp != unfilled_slots_next)
3139 /* Remove the unconditional jump from consideration for delay slot
3140 filling and unthread it. */
3144 rtx next = NEXT_INSN (trial);
3145 rtx prev = PREV_INSN (trial);
3147 NEXT_INSN (prev) = next;
3149 PREV_INSN (next) = prev;
3153 /* Now, scan backwards from the insn to search for a potential
3154 delay-slot candidate. Stop searching when a label or jump is hit.
3156 For each candidate, if it is to go into the delay slot (moved
3157 forward in execution sequence), it must not need or set any resources
3158 that were set by later insns and must not set any resources that
3159 are needed for those insns.
3161 The delay slot insn itself sets resources unless it is a call
3162 (in which case the called routine, not the insn itself, is doing
3165 if (slots_filled < slots_to_fill)
3167 CLEAR_RESOURCE (&needed);
3168 CLEAR_RESOURCE (&set);
3169 mark_set_resources (insn, &set, 0, 0);
3170 mark_referenced_resources (insn, &needed, 0);
3172 for (trial = prev_nonnote_insn (insn); ! stop_search_p (trial, 1);
3175 next_trial = prev_nonnote_insn (trial);
3177 /* This must be an INSN or CALL_INSN. */
3178 pat = PATTERN (trial);
3180 /* USE and CLOBBER at this level was just for flow; ignore it. */
3181 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
3184 /* Check for resource conflict first, to avoid unnecessary
3186 if (! insn_references_resource_p (trial, &set, 1)
3187 && ! insn_sets_resource_p (trial, &set, 1)
3188 && ! insn_sets_resource_p (trial, &needed, 1)
3190 /* Can't separate set of cc0 from its use. */
3191 && ! (reg_mentioned_p (cc0_rtx, pat)
3192 && ! sets_cc0_p (cc0_rtx, pat))
3196 trial = try_split (pat, trial, 1);
3197 next_trial = prev_nonnote_insn (trial);
3198 if (eligible_for_delay (insn, slots_filled, trial, flags))
3200 /* In this case, we are searching backward, so if we
3201 find insns to put on the delay list, we want
3202 to put them at the head, rather than the
3203 tail, of the list. */
3205 update_reg_dead_notes (trial, insn);
3206 delay_list = gen_rtx_INSN_LIST (VOIDmode,
3208 update_block (trial, trial);
3209 delete_insn (trial);
3210 if (slots_to_fill == ++slots_filled)
3216 mark_set_resources (trial, &set, 0, 1);
3217 mark_referenced_resources (trial, &needed, 1);
3221 /* If all needed slots haven't been filled, we come here. */
3223 /* Try to optimize case of jumping around a single insn. */
3224 #if defined(ANNUL_IFFALSE_SLOTS) || defined(ANNUL_IFTRUE_SLOTS)
3225 if (slots_filled != slots_to_fill
3227 && GET_CODE (insn) == JUMP_INSN
3228 && (condjump_p (insn) || condjump_in_parallel_p (insn)))
3230 delay_list = optimize_skip (insn);
3236 /* Try to get insns from beyond the insn needing the delay slot.
3237 These insns can neither set or reference resources set in insns being
3238 skipped, cannot set resources in the insn being skipped, and, if this
3239 is a CALL_INSN (or a CALL_INSN is passed), cannot trap (because the
3240 call might not return).
3242 There used to be code which continued past the target label if
3243 we saw all uses of the target label. This code did not work,
3244 because it failed to account for some instructions which were
3245 both annulled and marked as from the target. This can happen as a
3246 result of optimize_skip. Since this code was redundant with
3247 fill_eager_delay_slots anyways, it was just deleted. */
3249 if (slots_filled != slots_to_fill
3250 && (GET_CODE (insn) != JUMP_INSN
3251 || ((condjump_p (insn) || condjump_in_parallel_p (insn))
3252 && ! simplejump_p (insn)
3253 && JUMP_LABEL (insn) != 0)))
3256 int maybe_never = 0;
3257 struct resources needed_at_jump;
3259 CLEAR_RESOURCE (&needed);
3260 CLEAR_RESOURCE (&set);
3262 if (GET_CODE (insn) == CALL_INSN)
3264 mark_set_resources (insn, &set, 0, 1);
3265 mark_referenced_resources (insn, &needed, 1);
3270 mark_set_resources (insn, &set, 0, 1);
3271 mark_referenced_resources (insn, &needed, 1);
3272 if (GET_CODE (insn) == JUMP_INSN)
3273 target = JUMP_LABEL (insn);
3276 for (trial = next_nonnote_insn (insn); trial; trial = next_trial)
3278 rtx pat, trial_delay;
3280 next_trial = next_nonnote_insn (trial);
3282 if (GET_CODE (trial) == CODE_LABEL
3283 || GET_CODE (trial) == BARRIER)
3286 /* We must have an INSN, JUMP_INSN, or CALL_INSN. */
3287 pat = PATTERN (trial);
3289 /* Stand-alone USE and CLOBBER are just for flow. */
3290 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
3293 /* If this already has filled delay slots, get the insn needing
3295 if (GET_CODE (pat) == SEQUENCE)
3296 trial_delay = XVECEXP (pat, 0, 0);
3298 trial_delay = trial;
3300 /* If this is a jump insn to our target, indicate that we have
3301 seen another jump to it. If we aren't handling a conditional
3302 jump, stop our search. Otherwise, compute the needs at its
3303 target and add them to NEEDED. */
3304 if (GET_CODE (trial_delay) == JUMP_INSN)
3308 else if (JUMP_LABEL (trial_delay) != target)
3310 mark_target_live_regs
3311 (next_active_insn (JUMP_LABEL (trial_delay)),
3313 needed.memory |= needed_at_jump.memory;
3314 needed.unch_memory |= needed_at_jump.unch_memory;
3315 IOR_HARD_REG_SET (needed.regs, needed_at_jump.regs);
3319 /* See if we have a resource problem before we try to
3322 && GET_CODE (pat) != SEQUENCE
3323 && ! insn_references_resource_p (trial, &set, 1)
3324 && ! insn_sets_resource_p (trial, &set, 1)
3325 && ! insn_sets_resource_p (trial, &needed, 1)
3327 && ! (reg_mentioned_p (cc0_rtx, pat) && ! sets_cc0_p (pat))
3329 && ! (maybe_never && may_trap_p (pat))
3330 && (trial = try_split (pat, trial, 0))
3331 && eligible_for_delay (insn, slots_filled, trial, flags))
3333 next_trial = next_nonnote_insn (trial);
3334 delay_list = add_to_delay_list (trial, delay_list);
3337 if (reg_mentioned_p (cc0_rtx, pat))
3338 link_cc0_insns (trial);
3341 delete_insn (trial);
3342 if (slots_to_fill == ++slots_filled)
3347 mark_set_resources (trial, &set, 0, 1);
3348 mark_referenced_resources (trial, &needed, 1);
3350 /* Ensure we don't put insns between the setting of cc and the
3351 comparison by moving a setting of cc into an earlier delay
3352 slot since these insns could clobber the condition code. */
3355 /* If this is a call or jump, we might not get here. */
3356 if (GET_CODE (trial_delay) == CALL_INSN
3357 || GET_CODE (trial_delay) == JUMP_INSN)
3361 /* If there are slots left to fill and our search was stopped by an
3362 unconditional branch, try the insn at the branch target. We can
3363 redirect the branch if it works.
3365 Don't do this if the insn at the branch target is a branch. */
3366 if (slots_to_fill != slots_filled
3368 && GET_CODE (trial) == JUMP_INSN
3369 && simplejump_p (trial)
3370 && (target == 0 || JUMP_LABEL (trial) == target)
3371 && (next_trial = next_active_insn (JUMP_LABEL (trial))) != 0
3372 && ! (GET_CODE (next_trial) == INSN
3373 && GET_CODE (PATTERN (next_trial)) == SEQUENCE)
3374 && GET_CODE (next_trial) != JUMP_INSN
3375 && ! insn_references_resource_p (next_trial, &set, 1)
3376 && ! insn_sets_resource_p (next_trial, &set, 1)
3377 && ! insn_sets_resource_p (next_trial, &needed, 1)
3379 && ! reg_mentioned_p (cc0_rtx, PATTERN (next_trial))
3381 && ! (maybe_never && may_trap_p (PATTERN (next_trial)))
3382 && (next_trial = try_split (PATTERN (next_trial), next_trial, 0))
3383 && eligible_for_delay (insn, slots_filled, next_trial, flags))
3385 rtx new_label = next_active_insn (next_trial);
3388 new_label = get_label_before (new_label);
3390 new_label = find_end_label ();
3393 = add_to_delay_list (copy_rtx (next_trial), delay_list);
3395 reorg_redirect_jump (trial, new_label);
3397 /* If we merged because we both jumped to the same place,
3398 redirect the original insn also. */
3400 reorg_redirect_jump (insn, new_label);
3404 /* If this is an unconditional jump, then try to get insns from the
3405 target of the jump. */
3406 if (GET_CODE (insn) == JUMP_INSN
3407 && simplejump_p (insn)
3408 && slots_filled != slots_to_fill)
3410 = fill_slots_from_thread (insn, const_true_rtx,
3411 next_active_insn (JUMP_LABEL (insn)),
3413 own_thread_p (JUMP_LABEL (insn),
3414 JUMP_LABEL (insn), 0),
3415 slots_to_fill, &slots_filled,
3419 unfilled_slots_base[i]
3420 = emit_delay_sequence (insn, delay_list, slots_filled);
3422 if (slots_to_fill == slots_filled)
3423 unfilled_slots_base[i] = 0;
3425 note_delay_statistics (slots_filled, 0);
3428 #ifdef DELAY_SLOTS_FOR_EPILOGUE
3429 /* See if the epilogue needs any delay slots. Try to fill them if so.
3430 The only thing we can do is scan backwards from the end of the
3431 function. If we did this in a previous pass, it is incorrect to do it
3433 if (current_function_epilogue_delay_list)
3436 slots_to_fill = DELAY_SLOTS_FOR_EPILOGUE;
3437 if (slots_to_fill == 0)
3441 CLEAR_RESOURCE (&set);
3443 /* The frame pointer and stack pointer are needed at the beginning of
3444 the epilogue, so instructions setting them can not be put in the
3445 epilogue delay slot. However, everything else needed at function
3446 end is safe, so we don't want to use end_of_function_needs here. */
3447 CLEAR_RESOURCE (&needed);
3448 if (frame_pointer_needed)
3450 SET_HARD_REG_BIT (needed.regs, FRAME_POINTER_REGNUM);
3451 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3452 SET_HARD_REG_BIT (needed.regs, HARD_FRAME_POINTER_REGNUM);
3454 #ifdef EXIT_IGNORE_STACK
3455 if (! EXIT_IGNORE_STACK)
3457 SET_HARD_REG_BIT (needed.regs, STACK_POINTER_REGNUM);
3460 SET_HARD_REG_BIT (needed.regs, STACK_POINTER_REGNUM);
3462 #ifdef EPILOGUE_USES
3463 for (i = 0; i <FIRST_PSEUDO_REGISTER; i++)
3465 if (EPILOGUE_USES (i))
3466 SET_HARD_REG_BIT (needed.regs, i);
3470 for (trial = get_last_insn (); ! stop_search_p (trial, 1);
3471 trial = PREV_INSN (trial))
3473 if (GET_CODE (trial) == NOTE)
3475 pat = PATTERN (trial);
3476 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
3479 if (! insn_references_resource_p (trial, &set, 1)
3480 && ! insn_sets_resource_p (trial, &needed, 1)
3481 && ! insn_sets_resource_p (trial, &set, 1)
3483 /* Don't want to mess with cc0 here. */
3484 && ! reg_mentioned_p (cc0_rtx, pat)
3488 trial = try_split (pat, trial, 1);
3489 if (ELIGIBLE_FOR_EPILOGUE_DELAY (trial, slots_filled))
3491 /* Here as well we are searching backward, so put the
3492 insns we find on the head of the list. */
3494 current_function_epilogue_delay_list
3495 = gen_rtx_INSN_LIST (VOIDmode, trial,
3496 current_function_epilogue_delay_list);
3497 mark_referenced_resources (trial, &end_of_function_needs, 1);
3498 update_block (trial, trial);
3499 delete_insn (trial);
3501 /* Clear deleted bit so final.c will output the insn. */
3502 INSN_DELETED_P (trial) = 0;
3504 if (slots_to_fill == ++slots_filled)
3510 mark_set_resources (trial, &set, 0, 1);
3511 mark_referenced_resources (trial, &needed, 1);
3514 note_delay_statistics (slots_filled, 0);
3518 /* Try to find insns to place in delay slots.
3520 INSN is the jump needing SLOTS_TO_FILL delay slots. It tests CONDITION
3521 or is an unconditional branch if CONDITION is const_true_rtx.
3522 *PSLOTS_FILLED is updated with the number of slots that we have filled.
3524 THREAD is a flow-of-control, either the insns to be executed if the
3525 branch is true or if the branch is false, THREAD_IF_TRUE says which.
3527 OPPOSITE_THREAD is the thread in the opposite direction. It is used
3528 to see if any potential delay slot insns set things needed there.
3530 LIKELY is non-zero if it is extremely likely that the branch will be
3531 taken and THREAD_IF_TRUE is set. This is used for the branch at the
3532 end of a loop back up to the top.
3534 OWN_THREAD and OWN_OPPOSITE_THREAD are true if we are the only user of the
3535 thread. I.e., it is the fallthrough code of our jump or the target of the
3536 jump when we are the only jump going there.
3538 If OWN_THREAD is false, it must be the "true" thread of a jump. In that
3539 case, we can only take insns from the head of the thread for our delay
3540 slot. We then adjust the jump to point after the insns we have taken. */
3543 fill_slots_from_thread (insn, condition, thread, opposite_thread, likely,
3544 thread_if_true, own_thread,
3545 slots_to_fill, pslots_filled, delay_list)
3548 rtx thread, opposite_thread;
3552 int slots_to_fill, *pslots_filled;
3556 struct resources opposite_needed, set, needed;
3562 /* Validate our arguments. */
3563 if ((condition == const_true_rtx && ! thread_if_true)
3564 || (! own_thread && ! thread_if_true))
3567 flags = get_jump_flags (insn, JUMP_LABEL (insn));
3569 /* If our thread is the end of subroutine, we can't get any delay
3574 /* If this is an unconditional branch, nothing is needed at the
3575 opposite thread. Otherwise, compute what is needed there. */
3576 if (condition == const_true_rtx)
3577 CLEAR_RESOURCE (&opposite_needed);
3579 mark_target_live_regs (opposite_thread, &opposite_needed);
3581 /* If the insn at THREAD can be split, do it here to avoid having to
3582 update THREAD and NEW_THREAD if it is done in the loop below. Also
3583 initialize NEW_THREAD. */
3585 new_thread = thread = try_split (PATTERN (thread), thread, 0);
3587 /* Scan insns at THREAD. We are looking for an insn that can be removed
3588 from THREAD (it neither sets nor references resources that were set
3589 ahead of it and it doesn't set anything needs by the insns ahead of
3590 it) and that either can be placed in an annulling insn or aren't
3591 needed at OPPOSITE_THREAD. */
3593 CLEAR_RESOURCE (&needed);
3594 CLEAR_RESOURCE (&set);
3596 /* If we do not own this thread, we must stop as soon as we find
3597 something that we can't put in a delay slot, since all we can do
3598 is branch into THREAD at a later point. Therefore, labels stop
3599 the search if this is not the `true' thread. */
3601 for (trial = thread;
3602 ! stop_search_p (trial, ! thread_if_true) && (! lose || own_thread);
3603 trial = next_nonnote_insn (trial))
3607 /* If we have passed a label, we no longer own this thread. */
3608 if (GET_CODE (trial) == CODE_LABEL)
3614 pat = PATTERN (trial);
3615 if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
3618 /* If TRIAL conflicts with the insns ahead of it, we lose. Also,
3619 don't separate or copy insns that set and use CC0. */
3620 if (! insn_references_resource_p (trial, &set, 1)
3621 && ! insn_sets_resource_p (trial, &set, 1)
3622 && ! insn_sets_resource_p (trial, &needed, 1)
3624 && ! (reg_mentioned_p (cc0_rtx, pat)
3625 && (! own_thread || ! sets_cc0_p (pat)))
3631 /* If TRIAL is redundant with some insn before INSN, we don't
3632 actually need to add it to the delay list; we can merely pretend
3634 if ((prior_insn = redundant_insn (trial, insn, delay_list)))
3636 fix_reg_dead_note (prior_insn, insn);
3639 update_block (trial, thread);
3640 if (trial == thread)
3642 thread = next_active_insn (thread);
3643 if (new_thread == trial)
3644 new_thread = thread;
3647 delete_insn (trial);
3651 update_reg_unused_notes (prior_insn, trial);
3652 new_thread = next_active_insn (trial);
3658 /* There are two ways we can win: If TRIAL doesn't set anything
3659 needed at the opposite thread and can't trap, or if it can
3660 go into an annulled delay slot. */
3662 && (condition == const_true_rtx
3663 || (! insn_sets_resource_p (trial, &opposite_needed, 1)
3664 && ! may_trap_p (pat))))
3667 trial = try_split (pat, trial, 0);
3668 if (new_thread == old_trial)
3670 if (thread == old_trial)
3672 pat = PATTERN (trial);
3673 if (eligible_for_delay (insn, *pslots_filled, trial, flags))
3677 #ifdef ANNUL_IFTRUE_SLOTS
3680 #ifdef ANNUL_IFFALSE_SLOTS
3686 trial = try_split (pat, trial, 0);
3687 if (new_thread == old_trial)
3689 if (thread == old_trial)
3691 pat = PATTERN (trial);
3692 if ((must_annul || delay_list == NULL) && (thread_if_true
3693 ? check_annul_list_true_false (0, delay_list)
3694 && eligible_for_annul_false (insn, *pslots_filled, trial, flags)
3695 : check_annul_list_true_false (1, delay_list)
3696 && eligible_for_annul_true (insn, *pslots_filled, trial, flags)))
3704 if (reg_mentioned_p (cc0_rtx, pat))
3705 link_cc0_insns (trial);
3708 /* If we own this thread, delete the insn. If this is the
3709 destination of a branch, show that a basic block status
3710 may have been updated. In any case, mark the new
3711 starting point of this thread. */
3714 update_block (trial, thread);
3715 if (trial == thread)
3717 thread = next_active_insn (thread);
3718 if (new_thread == trial)
3719 new_thread = thread;
3721 delete_insn (trial);
3724 new_thread = next_active_insn (trial);
3726 temp = own_thread ? trial : copy_rtx (trial);
3728 INSN_FROM_TARGET_P (temp) = 1;
3730 delay_list = add_to_delay_list (temp, delay_list);
3732 mark_set_resources (trial, &opposite_needed, 0, 1);
3734 if (slots_to_fill == ++(*pslots_filled))
3736 /* Even though we have filled all the slots, we
3737 may be branching to a location that has a
3738 redundant insn. Skip any if so. */
3739 while (new_thread && ! own_thread
3740 && ! insn_sets_resource_p (new_thread, &set, 1)
3741 && ! insn_sets_resource_p (new_thread, &needed, 1)
3742 && ! insn_references_resource_p (new_thread,
3745 = redundant_insn (new_thread, insn,
3748 /* We know we do not own the thread, so no need
3749 to call update_block and delete_insn. */
3750 fix_reg_dead_note (prior_insn, insn);
3751 update_reg_unused_notes (prior_insn, new_thread);
3752 new_thread = next_active_insn (new_thread);
3762 /* This insn can't go into a delay slot. */
3764 mark_set_resources (trial, &set, 0, 1);
3765 mark_referenced_resources (trial, &needed, 1);
3767 /* Ensure we don't put insns between the setting of cc and the comparison
3768 by moving a setting of cc into an earlier delay slot since these insns
3769 could clobber the condition code. */
3772 /* If this insn is a register-register copy and the next insn has
3773 a use of our destination, change it to use our source. That way,
3774 it will become a candidate for our delay slot the next time
3775 through this loop. This case occurs commonly in loops that
3778 We could check for more complex cases than those tested below,
3779 but it doesn't seem worth it. It might also be a good idea to try
3780 to swap the two insns. That might do better.
3782 We can't do this if the next insn modifies our destination, because
3783 that would make the replacement into the insn invalid. We also can't
3784 do this if it modifies our source, because it might be an earlyclobber
3785 operand. This latter test also prevents updating the contents of
3788 if (GET_CODE (trial) == INSN && GET_CODE (pat) == SET
3789 && GET_CODE (SET_SRC (pat)) == REG
3790 && GET_CODE (SET_DEST (pat)) == REG)
3792 rtx next = next_nonnote_insn (trial);
3794 if (next && GET_CODE (next) == INSN
3795 && GET_CODE (PATTERN (next)) != USE
3796 && ! reg_set_p (SET_DEST (pat), next)
3797 && ! reg_set_p (SET_SRC (pat), next)
3798 && reg_referenced_p (SET_DEST (pat), PATTERN (next)))
3799 validate_replace_rtx (SET_DEST (pat), SET_SRC (pat), next);
3803 /* If we stopped on a branch insn that has delay slots, see if we can
3804 steal some of the insns in those slots. */
3805 if (trial && GET_CODE (trial) == INSN
3806 && GET_CODE (PATTERN (trial)) == SEQUENCE
3807 && GET_CODE (XVECEXP (PATTERN (trial), 0, 0)) == JUMP_INSN)
3809 /* If this is the `true' thread, we will want to follow the jump,
3810 so we can only do this if we have taken everything up to here. */
3811 if (thread_if_true && trial == new_thread
3812 && ! insn_references_resource_p (XVECEXP (PATTERN (trial), 0, 0),
3813 &opposite_needed, 0))
3815 = steal_delay_list_from_target (insn, condition, PATTERN (trial),
3816 delay_list, &set, &needed,
3817 &opposite_needed, slots_to_fill,
3818 pslots_filled, &must_annul,
3820 else if (! thread_if_true)
3822 = steal_delay_list_from_fallthrough (insn, condition,
3824 delay_list, &set, &needed,
3825 &opposite_needed, slots_to_fill,
3826 pslots_filled, &must_annul);
3829 /* If we haven't found anything for this delay slot and it is very
3830 likely that the branch will be taken, see if the insn at our target
3831 increments or decrements a register with an increment that does not
3832 depend on the destination register. If so, try to place the opposite
3833 arithmetic insn after the jump insn and put the arithmetic insn in the
3834 delay slot. If we can't do this, return. */
3835 if (delay_list == 0 && likely && new_thread
3836 && GET_CODE (new_thread) == INSN
3837 && GET_CODE (PATTERN (new_thread)) != ASM_INPUT
3838 && asm_noperands (PATTERN (new_thread)) < 0)
3840 rtx pat = PATTERN (new_thread);
3845 pat = PATTERN (trial);
3847 if (GET_CODE (trial) != INSN || GET_CODE (pat) != SET
3848 || ! eligible_for_delay (insn, 0, trial, flags))
3851 dest = SET_DEST (pat), src = SET_SRC (pat);
3852 if ((GET_CODE (src) == PLUS || GET_CODE (src) == MINUS)
3853 && rtx_equal_p (XEXP (src, 0), dest)
3854 && ! reg_overlap_mentioned_p (dest, XEXP (src, 1)))
3856 rtx other = XEXP (src, 1);
3860 /* If this is a constant adjustment, use the same code with
3861 the negated constant. Otherwise, reverse the sense of the
3863 if (GET_CODE (other) == CONST_INT)
3864 new_arith = gen_rtx_fmt_ee (GET_CODE (src), GET_MODE (src), dest,
3865 negate_rtx (GET_MODE (src), other));
3867 new_arith = gen_rtx_fmt_ee (GET_CODE (src) == PLUS ? MINUS : PLUS,
3868 GET_MODE (src), dest, other);
3870 ninsn = emit_insn_after (gen_rtx_SET (VOIDmode, dest, new_arith),
3873 if (recog_memoized (ninsn) < 0
3874 || (insn_extract (ninsn),
3875 ! constrain_operands (INSN_CODE (ninsn), 1)))
3877 delete_insn (ninsn);
3883 update_block (trial, thread);
3884 if (trial == thread)
3886 thread = next_active_insn (thread);
3887 if (new_thread == trial)
3888 new_thread = thread;
3890 delete_insn (trial);
3893 new_thread = next_active_insn (trial);
3895 ninsn = own_thread ? trial : copy_rtx (trial);
3897 INSN_FROM_TARGET_P (ninsn) = 1;
3899 delay_list = add_to_delay_list (ninsn, NULL_RTX);
3904 if (delay_list && must_annul)
3905 INSN_ANNULLED_BRANCH_P (insn) = 1;
3907 /* If we are to branch into the middle of this thread, find an appropriate
3908 label or make a new one if none, and redirect INSN to it. If we hit the
3909 end of the function, use the end-of-function label. */
3910 if (new_thread != thread)
3914 if (! thread_if_true)
3917 if (new_thread && GET_CODE (new_thread) == JUMP_INSN
3918 && (simplejump_p (new_thread)
3919 || GET_CODE (PATTERN (new_thread)) == RETURN)
3920 && redirect_with_delay_list_safe_p (insn,
3921 JUMP_LABEL (new_thread),
3923 new_thread = follow_jumps (JUMP_LABEL (new_thread));
3925 if (new_thread == 0)
3926 label = find_end_label ();
3927 else if (GET_CODE (new_thread) == CODE_LABEL)
3930 label = get_label_before (new_thread);
3932 reorg_redirect_jump (insn, label);
3938 /* Make another attempt to find insns to place in delay slots.
3940 We previously looked for insns located in front of the delay insn
3941 and, for non-jump delay insns, located behind the delay insn.
3943 Here only try to schedule jump insns and try to move insns from either
3944 the target or the following insns into the delay slot. If annulling is
3945 supported, we will be likely to do this. Otherwise, we can do this only
3949 fill_eager_delay_slots ()
3953 int num_unfilled_slots = unfilled_slots_next - unfilled_slots_base;
3955 for (i = 0; i < num_unfilled_slots; i++)
3958 rtx target_label, insn_at_target, fallthrough_insn;
3961 int own_fallthrough;
3962 int prediction, slots_to_fill, slots_filled;
3964 insn = unfilled_slots_base[i];
3966 || INSN_DELETED_P (insn)
3967 || GET_CODE (insn) != JUMP_INSN
3968 || ! (condjump_p (insn) || condjump_in_parallel_p (insn)))
3971 slots_to_fill = num_delay_slots (insn);
3972 /* Some machine description have defined instructions to have
3973 delay slots only in certain circumstances which may depend on
3974 nearby insns (which change due to reorg's actions).
3976 For example, the PA port normally has delay slots for unconditional
3979 However, the PA port claims such jumps do not have a delay slot
3980 if they are immediate successors of certain CALL_INSNs. This
3981 allows the port to favor filling the delay slot of the call with
3982 the unconditional jump. */
3983 if (slots_to_fill == 0)
3987 target_label = JUMP_LABEL (insn);
3988 condition = get_branch_condition (insn, target_label);
3993 /* Get the next active fallthrough and target insns and see if we own
3994 them. Then see whether the branch is likely true. We don't need
3995 to do a lot of this for unconditional branches. */
3997 insn_at_target = next_active_insn (target_label);
3998 own_target = own_thread_p (target_label, target_label, 0);
4000 if (condition == const_true_rtx)
4002 own_fallthrough = 0;
4003 fallthrough_insn = 0;
4008 fallthrough_insn = next_active_insn (insn);
4009 own_fallthrough = own_thread_p (NEXT_INSN (insn), NULL_RTX, 1);
4010 prediction = mostly_true_jump (insn, condition);
4013 /* If this insn is expected to branch, first try to get insns from our
4014 target, then our fallthrough insns. If it is not, expected to branch,
4015 try the other order. */
4020 = fill_slots_from_thread (insn, condition, insn_at_target,
4021 fallthrough_insn, prediction == 2, 1,
4023 slots_to_fill, &slots_filled, delay_list);
4025 if (delay_list == 0 && own_fallthrough)
4027 /* Even though we didn't find anything for delay slots,
4028 we might have found a redundant insn which we deleted
4029 from the thread that was filled. So we have to recompute
4030 the next insn at the target. */
4031 target_label = JUMP_LABEL (insn);
4032 insn_at_target = next_active_insn (target_label);
4035 = fill_slots_from_thread (insn, condition, fallthrough_insn,
4036 insn_at_target, 0, 0,
4038 slots_to_fill, &slots_filled,
4044 if (own_fallthrough)
4046 = fill_slots_from_thread (insn, condition, fallthrough_insn,
4047 insn_at_target, 0, 0,
4049 slots_to_fill, &slots_filled,
4052 if (delay_list == 0)
4054 = fill_slots_from_thread (insn, condition, insn_at_target,
4055 next_active_insn (insn), 0, 1,
4057 slots_to_fill, &slots_filled,
4062 unfilled_slots_base[i]
4063 = emit_delay_sequence (insn, delay_list, slots_filled);
4065 if (slots_to_fill == slots_filled)
4066 unfilled_slots_base[i] = 0;
4068 note_delay_statistics (slots_filled, 1);
4072 /* Once we have tried two ways to fill a delay slot, make a pass over the
4073 code to try to improve the results and to do such things as more jump
4077 relax_delay_slots (first)
4080 register rtx insn, next, pat;
4081 register rtx trial, delay_insn, target_label;
4083 /* Look at every JUMP_INSN and see if we can improve it. */
4084 for (insn = first; insn; insn = next)
4088 next = next_active_insn (insn);
4090 /* If this is a jump insn, see if it now jumps to a jump, jumps to
4091 the next insn, or jumps to a label that is not the last of a
4092 group of consecutive labels. */
4093 if (GET_CODE (insn) == JUMP_INSN
4094 && (condjump_p (insn) || condjump_in_parallel_p (insn))
4095 && (target_label = JUMP_LABEL (insn)) != 0)
4097 target_label = follow_jumps (target_label);
4098 target_label = prev_label (next_active_insn (target_label));
4100 if (target_label == 0)
4101 target_label = find_end_label ();
4103 if (next_active_insn (target_label) == next
4104 && ! condjump_in_parallel_p (insn))
4110 if (target_label != JUMP_LABEL (insn))
4111 reorg_redirect_jump (insn, target_label);
4113 /* See if this jump branches around a unconditional jump.
4114 If so, invert this jump and point it to the target of the
4116 if (next && GET_CODE (next) == JUMP_INSN
4117 && (simplejump_p (next) || GET_CODE (PATTERN (next)) == RETURN)
4118 && next_active_insn (target_label) == next_active_insn (next)
4119 && no_labels_between_p (insn, next))
4121 rtx label = JUMP_LABEL (next);
4123 /* Be careful how we do this to avoid deleting code or
4124 labels that are momentarily dead. See similar optimization
4127 We also need to ensure we properly handle the case when
4128 invert_jump fails. */
4130 ++LABEL_NUSES (target_label);
4132 ++LABEL_NUSES (label);
4134 if (invert_jump (insn, label))
4141 --LABEL_NUSES (label);
4143 if (--LABEL_NUSES (target_label) == 0)
4144 delete_insn (target_label);
4150 /* If this is an unconditional jump and the previous insn is a
4151 conditional jump, try reversing the condition of the previous
4152 insn and swapping our targets. The next pass might be able to
4155 Don't do this if we expect the conditional branch to be true, because
4156 we would then be making the more common case longer. */
4158 if (GET_CODE (insn) == JUMP_INSN
4159 && (simplejump_p (insn) || GET_CODE (PATTERN (insn)) == RETURN)
4160 && (other = prev_active_insn (insn)) != 0
4161 && (condjump_p (other) || condjump_in_parallel_p (other))
4162 && no_labels_between_p (other, insn)
4163 && 0 < mostly_true_jump (other,
4164 get_branch_condition (other,
4165 JUMP_LABEL (other))))
4167 rtx other_target = JUMP_LABEL (other);
4168 target_label = JUMP_LABEL (insn);
4170 /* Increment the count of OTHER_TARGET, so it doesn't get deleted
4171 as we move the label. */
4173 ++LABEL_NUSES (other_target);
4175 if (invert_jump (other, target_label))
4176 reorg_redirect_jump (insn, other_target);
4179 --LABEL_NUSES (other_target);
4182 /* Now look only at cases where we have filled a delay slot. */
4183 if (GET_CODE (insn) != INSN
4184 || GET_CODE (PATTERN (insn)) != SEQUENCE)
4187 pat = PATTERN (insn);
4188 delay_insn = XVECEXP (pat, 0, 0);
4190 /* See if the first insn in the delay slot is redundant with some
4191 previous insn. Remove it from the delay slot if so; then set up
4192 to reprocess this insn. */
4193 if (redundant_insn (XVECEXP (pat, 0, 1), delay_insn, 0))
4195 delete_from_delay_slot (XVECEXP (pat, 0, 1));
4196 next = prev_active_insn (next);
4200 /* Now look only at the cases where we have a filled JUMP_INSN. */
4201 if (GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) != JUMP_INSN
4202 || ! (condjump_p (XVECEXP (PATTERN (insn), 0, 0))
4203 || condjump_in_parallel_p (XVECEXP (PATTERN (insn), 0, 0))))
4206 target_label = JUMP_LABEL (delay_insn);
4210 /* If this jump goes to another unconditional jump, thread it, but
4211 don't convert a jump into a RETURN here. */
4212 trial = follow_jumps (target_label);
4213 /* We use next_real_insn instead of next_active_insn, so that
4214 the special USE insns emitted by reorg won't be ignored.
4215 If they are ignored, then they will get deleted if target_label
4216 is now unreachable, and that would cause mark_target_live_regs
4218 trial = prev_label (next_real_insn (trial));
4219 if (trial == 0 && target_label != 0)
4220 trial = find_end_label ();
4222 if (trial != target_label
4223 && redirect_with_delay_slots_safe_p (delay_insn, trial, insn))
4225 reorg_redirect_jump (delay_insn, trial);
4226 target_label = trial;
4229 /* If the first insn at TARGET_LABEL is redundant with a previous
4230 insn, redirect the jump to the following insn process again. */
4231 trial = next_active_insn (target_label);
4232 if (trial && GET_CODE (PATTERN (trial)) != SEQUENCE
4233 && redundant_insn (trial, insn, 0))
4237 /* Figure out where to emit the special USE insn so we don't
4238 later incorrectly compute register live/death info. */
4239 tmp = next_active_insn (trial);
4241 tmp = find_end_label ();
4243 /* Insert the special USE insn and update dataflow info. */
4244 update_block (trial, tmp);
4246 /* Now emit a label before the special USE insn, and
4247 redirect our jump to the new label. */
4248 target_label = get_label_before (PREV_INSN (tmp));
4249 reorg_redirect_jump (delay_insn, target_label);
4254 /* Similarly, if it is an unconditional jump with one insn in its
4255 delay list and that insn is redundant, thread the jump. */
4256 if (trial && GET_CODE (PATTERN (trial)) == SEQUENCE
4257 && XVECLEN (PATTERN (trial), 0) == 2
4258 && GET_CODE (XVECEXP (PATTERN (trial), 0, 0)) == JUMP_INSN
4259 && (simplejump_p (XVECEXP (PATTERN (trial), 0, 0))
4260 || GET_CODE (PATTERN (XVECEXP (PATTERN (trial), 0, 0))) == RETURN)
4261 && redundant_insn (XVECEXP (PATTERN (trial), 0, 1), insn, 0))
4263 target_label = JUMP_LABEL (XVECEXP (PATTERN (trial), 0, 0));
4264 if (target_label == 0)
4265 target_label = find_end_label ();
4267 if (redirect_with_delay_slots_safe_p (delay_insn, target_label,
4270 reorg_redirect_jump (delay_insn, target_label);
4277 if (! INSN_ANNULLED_BRANCH_P (delay_insn)
4278 && prev_active_insn (target_label) == insn
4279 && ! condjump_in_parallel_p (delay_insn)
4281 /* If the last insn in the delay slot sets CC0 for some insn,
4282 various code assumes that it is in a delay slot. We could
4283 put it back where it belonged and delete the register notes,
4284 but it doesn't seem worthwhile in this uncommon case. */
4285 && ! find_reg_note (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1),
4286 REG_CC_USER, NULL_RTX)
4292 /* All this insn does is execute its delay list and jump to the
4293 following insn. So delete the jump and just execute the delay
4296 We do this by deleting the INSN containing the SEQUENCE, then
4297 re-emitting the insns separately, and then deleting the jump.
4298 This allows the count of the jump target to be properly
4301 /* Clear the from target bit, since these insns are no longer
4303 for (i = 0; i < XVECLEN (pat, 0); i++)
4304 INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)) = 0;
4306 trial = PREV_INSN (insn);
4308 emit_insn_after (pat, trial);
4309 delete_scheduled_jump (delay_insn);
4313 /* See if this is an unconditional jump around a single insn which is
4314 identical to the one in its delay slot. In this case, we can just
4315 delete the branch and the insn in its delay slot. */
4316 if (next && GET_CODE (next) == INSN
4317 && prev_label (next_active_insn (next)) == target_label
4318 && simplejump_p (insn)
4319 && XVECLEN (pat, 0) == 2
4320 && rtx_equal_p (PATTERN (next), PATTERN (XVECEXP (pat, 0, 1))))
4326 /* See if this jump (with its delay slots) branches around another
4327 jump (without delay slots). If so, invert this jump and point
4328 it to the target of the second jump. We cannot do this for
4329 annulled jumps, though. Again, don't convert a jump to a RETURN
4331 if (! INSN_ANNULLED_BRANCH_P (delay_insn)
4332 && next && GET_CODE (next) == JUMP_INSN
4333 && (simplejump_p (next) || GET_CODE (PATTERN (next)) == RETURN)
4334 && next_active_insn (target_label) == next_active_insn (next)
4335 && no_labels_between_p (insn, next))
4337 rtx label = JUMP_LABEL (next);
4338 rtx old_label = JUMP_LABEL (delay_insn);
4341 label = find_end_label ();
4343 if (redirect_with_delay_slots_safe_p (delay_insn, label, insn))
4345 /* Be careful how we do this to avoid deleting code or labels
4346 that are momentarily dead. See similar optimization in
4349 ++LABEL_NUSES (old_label);
4351 if (invert_jump (delay_insn, label))
4355 /* Must update the INSN_FROM_TARGET_P bits now that
4356 the branch is reversed, so that mark_target_live_regs
4357 will handle the delay slot insn correctly. */
4358 for (i = 1; i < XVECLEN (PATTERN (insn), 0); i++)
4360 rtx slot = XVECEXP (PATTERN (insn), 0, i);
4361 INSN_FROM_TARGET_P (slot) = ! INSN_FROM_TARGET_P (slot);
4368 if (old_label && --LABEL_NUSES (old_label) == 0)
4369 delete_insn (old_label);
4374 /* If we own the thread opposite the way this insn branches, see if we
4375 can merge its delay slots with following insns. */
4376 if (INSN_FROM_TARGET_P (XVECEXP (pat, 0, 1))
4377 && own_thread_p (NEXT_INSN (insn), 0, 1))
4378 try_merge_delay_insns (insn, next);
4379 else if (! INSN_FROM_TARGET_P (XVECEXP (pat, 0, 1))
4380 && own_thread_p (target_label, target_label, 0))
4381 try_merge_delay_insns (insn, next_active_insn (target_label));
4383 /* If we get here, we haven't deleted INSN. But we may have deleted
4384 NEXT, so recompute it. */
4385 next = next_active_insn (insn);
4391 /* Look for filled jumps to the end of function label. We can try to convert
4392 them into RETURN insns if the insns in the delay slot are valid for the
4396 make_return_insns (first)
4399 rtx insn, jump_insn, pat;
4400 rtx real_return_label = end_of_function_label;
4403 /* See if there is a RETURN insn in the function other than the one we
4404 made for END_OF_FUNCTION_LABEL. If so, set up anything we can't change
4405 into a RETURN to jump to it. */
4406 for (insn = first; insn; insn = NEXT_INSN (insn))
4407 if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) == RETURN)
4409 real_return_label = get_label_before (insn);
4413 /* Show an extra usage of REAL_RETURN_LABEL so it won't go away if it
4414 was equal to END_OF_FUNCTION_LABEL. */
4415 LABEL_NUSES (real_return_label)++;
4417 /* Clear the list of insns to fill so we can use it. */
4418 obstack_free (&unfilled_slots_obstack, unfilled_firstobj);
4420 for (insn = first; insn; insn = NEXT_INSN (insn))
4424 /* Only look at filled JUMP_INSNs that go to the end of function
4426 if (GET_CODE (insn) != INSN
4427 || GET_CODE (PATTERN (insn)) != SEQUENCE
4428 || GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) != JUMP_INSN
4429 || JUMP_LABEL (XVECEXP (PATTERN (insn), 0, 0)) != end_of_function_label)
4432 pat = PATTERN (insn);
4433 jump_insn = XVECEXP (pat, 0, 0);
4435 /* If we can't make the jump into a RETURN, try to redirect it to the best
4436 RETURN and go on to the next insn. */
4437 if (! reorg_redirect_jump (jump_insn, NULL_RTX))
4439 /* Make sure redirecting the jump will not invalidate the delay
4441 if (redirect_with_delay_slots_safe_p (jump_insn,
4444 reorg_redirect_jump (jump_insn, real_return_label);
4448 /* See if this RETURN can accept the insns current in its delay slot.
4449 It can if it has more or an equal number of slots and the contents
4450 of each is valid. */
4452 flags = get_jump_flags (jump_insn, JUMP_LABEL (jump_insn));
4453 slots = num_delay_slots (jump_insn);
4454 if (slots >= XVECLEN (pat, 0) - 1)
4456 for (i = 1; i < XVECLEN (pat, 0); i++)
4458 #ifdef ANNUL_IFFALSE_SLOTS
4459 (INSN_ANNULLED_BRANCH_P (jump_insn)
4460 && INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
4461 ? eligible_for_annul_false (jump_insn, i - 1,
4462 XVECEXP (pat, 0, i), flags) :
4464 #ifdef ANNUL_IFTRUE_SLOTS
4465 (INSN_ANNULLED_BRANCH_P (jump_insn)
4466 && ! INSN_FROM_TARGET_P (XVECEXP (pat, 0, i)))
4467 ? eligible_for_annul_true (jump_insn, i - 1,
4468 XVECEXP (pat, 0, i), flags) :
4470 eligible_for_delay (jump_insn, i -1, XVECEXP (pat, 0, i), flags)))
4476 if (i == XVECLEN (pat, 0))
4479 /* We have to do something with this insn. If it is an unconditional
4480 RETURN, delete the SEQUENCE and output the individual insns,
4481 followed by the RETURN. Then set things up so we try to find
4482 insns for its delay slots, if it needs some. */
4483 if (GET_CODE (PATTERN (jump_insn)) == RETURN)
4485 rtx prev = PREV_INSN (insn);
4488 for (i = 1; i < XVECLEN (pat, 0); i++)
4489 prev = emit_insn_after (PATTERN (XVECEXP (pat, 0, i)), prev);
4491 insn = emit_jump_insn_after (PATTERN (jump_insn), prev);
4492 emit_barrier_after (insn);
4495 obstack_ptr_grow (&unfilled_slots_obstack, insn);
4498 /* It is probably more efficient to keep this with its current
4499 delay slot as a branch to a RETURN. */
4500 reorg_redirect_jump (jump_insn, real_return_label);
4503 /* Now delete REAL_RETURN_LABEL if we never used it. Then try to fill any
4504 new delay slots we have created. */
4505 if (--LABEL_NUSES (real_return_label) == 0)
4506 delete_insn (real_return_label);
4508 fill_simple_delay_slots (1);
4509 fill_simple_delay_slots (0);
4513 /* Try to find insns to place in delay slots. */
4516 dbr_schedule (first, file)
4520 rtx insn, next, epilogue_insn = 0;
4523 int old_flag_no_peephole = flag_no_peephole;
4525 /* Execute `final' once in prescan mode to delete any insns that won't be
4526 used. Don't let final try to do any peephole optimization--it will
4527 ruin dataflow information for this pass. */
4529 flag_no_peephole = 1;
4530 final (first, 0, NO_DEBUG, 1, 1);
4531 flag_no_peephole = old_flag_no_peephole;
4534 /* If the current function has no insns other than the prologue and
4535 epilogue, then do not try to fill any delay slots. */
4536 if (n_basic_blocks == 0)
4539 /* Find the highest INSN_UID and allocate and initialize our map from
4540 INSN_UID's to position in code. */
4541 for (max_uid = 0, insn = first; insn; insn = NEXT_INSN (insn))
4543 if (INSN_UID (insn) > max_uid)
4544 max_uid = INSN_UID (insn);
4545 if (GET_CODE (insn) == NOTE
4546 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
4547 epilogue_insn = insn;
4550 uid_to_ruid = (int *) alloca ((max_uid + 1) * sizeof (int *));
4551 for (i = 0, insn = first; insn; i++, insn = NEXT_INSN (insn))
4552 uid_to_ruid[INSN_UID (insn)] = i;
4554 /* Initialize the list of insns that need filling. */
4555 if (unfilled_firstobj == 0)
4557 gcc_obstack_init (&unfilled_slots_obstack);
4558 unfilled_firstobj = (rtx *) obstack_alloc (&unfilled_slots_obstack, 0);
4561 for (insn = next_active_insn (first); insn; insn = next_active_insn (insn))
4565 INSN_ANNULLED_BRANCH_P (insn) = 0;
4566 INSN_FROM_TARGET_P (insn) = 0;
4568 /* Skip vector tables. We can't get attributes for them. */
4569 if (GET_CODE (insn) == JUMP_INSN
4570 && (GET_CODE (PATTERN (insn)) == ADDR_VEC
4571 || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
4574 if (num_delay_slots (insn) > 0)
4575 obstack_ptr_grow (&unfilled_slots_obstack, insn);
4577 /* Ensure all jumps go to the last of a set of consecutive labels. */
4578 if (GET_CODE (insn) == JUMP_INSN
4579 && (condjump_p (insn) || condjump_in_parallel_p (insn))
4580 && JUMP_LABEL (insn) != 0
4581 && ((target = prev_label (next_active_insn (JUMP_LABEL (insn))))
4582 != JUMP_LABEL (insn)))
4583 redirect_jump (insn, target);
4586 /* Indicate what resources are required to be valid at the end of the current
4587 function. The condition code never is and memory always is. If the
4588 frame pointer is needed, it is and so is the stack pointer unless
4589 EXIT_IGNORE_STACK is non-zero. If the frame pointer is not needed, the
4590 stack pointer is. Registers used to return the function value are
4591 needed. Registers holding global variables are needed. */
4593 end_of_function_needs.cc = 0;
4594 end_of_function_needs.memory = 1;
4595 end_of_function_needs.unch_memory = 0;
4596 CLEAR_HARD_REG_SET (end_of_function_needs.regs);
4598 if (frame_pointer_needed)
4600 SET_HARD_REG_BIT (end_of_function_needs.regs, FRAME_POINTER_REGNUM);
4601 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
4602 SET_HARD_REG_BIT (end_of_function_needs.regs, HARD_FRAME_POINTER_REGNUM);
4604 #ifdef EXIT_IGNORE_STACK
4605 if (! EXIT_IGNORE_STACK)
4607 SET_HARD_REG_BIT (end_of_function_needs.regs, STACK_POINTER_REGNUM);
4610 SET_HARD_REG_BIT (end_of_function_needs.regs, STACK_POINTER_REGNUM);
4612 if (current_function_return_rtx != 0)
4613 mark_referenced_resources (current_function_return_rtx,
4614 &end_of_function_needs, 1);
4616 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4618 #ifdef EPILOGUE_USES
4619 || EPILOGUE_USES (i)
4622 SET_HARD_REG_BIT (end_of_function_needs.regs, i);
4624 /* The registers required to be live at the end of the function are
4625 represented in the flow information as being dead just prior to
4626 reaching the end of the function. For example, the return of a value
4627 might be represented by a USE of the return register immediately
4628 followed by an unconditional jump to the return label where the
4629 return label is the end of the RTL chain. The end of the RTL chain
4630 is then taken to mean that the return register is live.
4632 This sequence is no longer maintained when epilogue instructions are
4633 added to the RTL chain. To reconstruct the original meaning, the
4634 start of the epilogue (NOTE_INSN_EPILOGUE_BEG) is regarded as the
4635 point where these registers become live (start_of_epilogue_needs).
4636 If epilogue instructions are present, the registers set by those
4637 instructions won't have been processed by flow. Thus, those
4638 registers are additionally required at the end of the RTL chain
4639 (end_of_function_needs). */
4641 start_of_epilogue_needs = end_of_function_needs;
4643 while ((epilogue_insn = next_nonnote_insn (epilogue_insn)))
4644 mark_set_resources (epilogue_insn, &end_of_function_needs, 0, 1);
4646 /* Show we haven't computed an end-of-function label yet. */
4647 end_of_function_label = 0;
4649 /* Allocate and initialize the tables used by mark_target_live_regs. */
4651 = (struct target_info **) alloca ((TARGET_HASH_PRIME
4652 * sizeof (struct target_info *)));
4653 bzero ((char *) target_hash_table,
4654 TARGET_HASH_PRIME * sizeof (struct target_info *));
4656 bb_ticks = (int *) alloca (n_basic_blocks * sizeof (int));
4657 bzero ((char *) bb_ticks, n_basic_blocks * sizeof (int));
4659 /* Initialize the statistics for this function. */
4660 bzero ((char *) num_insns_needing_delays, sizeof num_insns_needing_delays);
4661 bzero ((char *) num_filled_delays, sizeof num_filled_delays);
4663 /* Now do the delay slot filling. Try everything twice in case earlier
4664 changes make more slots fillable. */
4666 for (reorg_pass_number = 0;
4667 reorg_pass_number < MAX_REORG_PASSES;
4668 reorg_pass_number++)
4670 fill_simple_delay_slots (1);
4671 fill_simple_delay_slots (0);
4672 fill_eager_delay_slots ();
4673 relax_delay_slots (first);
4676 /* Delete any USE insns made by update_block; subsequent passes don't need
4677 them or know how to deal with them. */
4678 for (insn = first; insn; insn = next)
4680 next = NEXT_INSN (insn);
4682 if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE
4683 && GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
4684 next = delete_insn (insn);
4687 /* If we made an end of function label, indicate that it is now
4688 safe to delete it by undoing our prior adjustment to LABEL_NUSES.
4689 If it is now unused, delete it. */
4690 if (end_of_function_label && --LABEL_NUSES (end_of_function_label) == 0)
4691 delete_insn (end_of_function_label);
4694 if (HAVE_return && end_of_function_label != 0)
4695 make_return_insns (first);
4698 obstack_free (&unfilled_slots_obstack, unfilled_firstobj);
4700 /* It is not clear why the line below is needed, but it does seem to be. */
4701 unfilled_firstobj = (rtx *) obstack_alloc (&unfilled_slots_obstack, 0);
4703 /* Reposition the prologue and epilogue notes in case we moved the
4704 prologue/epilogue insns. */
4705 reposition_prologue_and_epilogue_notes (first);
4709 register int i, j, need_comma;
4711 for (reorg_pass_number = 0;
4712 reorg_pass_number < MAX_REORG_PASSES;
4713 reorg_pass_number++)
4715 fprintf (file, ";; Reorg pass #%d:\n", reorg_pass_number + 1);
4716 for (i = 0; i < NUM_REORG_FUNCTIONS; i++)
4719 fprintf (file, ";; Reorg function #%d\n", i);
4721 fprintf (file, ";; %d insns needing delay slots\n;; ",
4722 num_insns_needing_delays[i][reorg_pass_number]);
4724 for (j = 0; j < MAX_DELAY_HISTOGRAM; j++)
4725 if (num_filled_delays[i][j][reorg_pass_number])
4728 fprintf (file, ", ");
4730 fprintf (file, "%d got %d delays",
4731 num_filled_delays[i][j][reorg_pass_number], j);
4733 fprintf (file, "\n");
4738 /* For all JUMP insns, fill in branch prediction notes, so that during
4739 assembler output a target can set branch prediction bits in the code.
4740 We have to do this now, as up until this point the destinations of
4741 JUMPS can be moved around and changed, but past right here that cannot
4743 for (insn = first; insn; insn = NEXT_INSN (insn))
4747 if (GET_CODE (insn) == INSN)
4749 rtx pat = PATTERN (insn);
4751 if (GET_CODE (pat) == SEQUENCE)
4752 insn = XVECEXP (pat, 0, 0);
4754 if (GET_CODE (insn) != JUMP_INSN)
4757 pred_flags = get_jump_flags (insn, JUMP_LABEL (insn));
4758 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_BR_PRED,
4759 GEN_INT (pred_flags),
4763 #endif /* DELAY_SLOTS */