contrib/gcc/emit-rtl.c

69 /* This is *not* reset after each function.  It gives each CODE_LABEL
541      We'll also need to fix some code that runs after reload that wants to
772   /* Don't let anything called after initial flow analysis create new
1460      info.  Callers should not set DECL_RTL until after the call to
2084    Used for an inline-procedure after copying the insn chain.  */
2851 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2883 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2933 /* Find the next insn after INSN that really does something.  This routine
2977 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
3040 /* Return the next insn that uses CC0 after INSN, which is assumed to
3124   rtx after = NEXT_INSN (trial);
3143   if (after && BARRIER_P (after))
3146       after = NEXT_INSN (after);
3278      set LAST and continue from the insn after the one returned.
3281   for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3288     ? (after ? PREV_INSN (after) : last_insn)
3387 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3393 add_insn_after (rtx insn, rtx after)
3395   rtx next = NEXT_INSN (after);
3398   gcc_assert (!optimize || !INSN_DELETED_P (after));
3401   PREV_INSN (insn) = after;
3409   else if (last_insn == after)
3416 	if (after == stack->last)
3425   if (!BARRIER_P (after)
3427       && (bb = BLOCK_FOR_INSN (after)))
3434       if (BB_END (bb) == after
3442   NEXT_INSN (after) = insn;
3443   if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
3445       rtx sequence = PATTERN (after);
3624    They are moved to a new position after the insn AFTER.
3628    called after delay-slot filling has been done.  */
3631 reorder_insns_nobb (rtx from, rtx to, rtx after)
3644   if (NEXT_INSN (after))
3645     PREV_INSN (NEXT_INSN (after)) = to;
3647   NEXT_INSN (to) = NEXT_INSN (after);
3648   PREV_INSN (from) = after;
3649   NEXT_INSN (after) = from;
3650   if (after == last_insn)
3656 reorder_insns (rtx from, rtx to, rtx after)
3661   reorder_insns_nobb (from, to, after);
3663   if (!BARRIER_P (after)
3664       && (bb = BLOCK_FOR_INSN (after)))
3677       if (BB_END (bb) == after)
3727    generated would almost certainly die right after it was created.  */
3915 emit_insn_after_1 (rtx first, rtx after)
3921   if (!BARRIER_P (after)
3922       && (bb = BLOCK_FOR_INSN (after)))
3930       if (BB_END (bb) == after)
3937   after_after = NEXT_INSN (after);
3939   NEXT_INSN (after) = first;
3940   PREV_INSN (first) = after;
3945   if (after == last_insn)
3950 /* Make X be output after the insn AFTER.  */
3953 emit_insn_after_noloc (rtx x, rtx after)
3955   rtx last = after;
3957   gcc_assert (after);
3970       last = emit_insn_after_1 (x, after);
3981       add_insn_after (last, after);
3992 emit_insn_after_with_line_notes (rtx x, rtx after, rtx from)
3995   rtx after_line = find_line_note (after);
3996   rtx insn = emit_insn_after (x, after);
3999     emit_note_copy_after (from_line, after);
4006    and output it after the insn AFTER.  */
4009 emit_jump_insn_after_noloc (rtx x, rtx after)
4013   gcc_assert (after);
4023       last = emit_insn_after_1 (x, after);
4034       add_insn_after (last, after);
4042    and output it after the instruction AFTER.  */
4045 emit_call_insn_after_noloc (rtx x, rtx after)
4049   gcc_assert (after);
4059       last = emit_insn_after_1 (x, after);
4070       add_insn_after (last, after);
4078    and output it after the insn AFTER.  */
4081 emit_barrier_after (rtx after)
4087   add_insn_after (insn, after);
4091 /* Emit the label LABEL after the insn AFTER.  */
4094 emit_label_after (rtx label, rtx after)
4102       add_insn_after (label, after);
4108 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
4111 emit_note_after (int subtype, rtx after)
4120   add_insn_after (note, after);
4124 /* Emit a copy of note ORIG after the insn AFTER.  */
4127 emit_note_copy_after (rtx orig, rtx after)
4142   add_insn_after (note, after);
4149 emit_insn_after_setloc (rtx pattern, rtx after, int loc)
4151   rtx last = emit_insn_after_noloc (pattern, after);
4156   after = NEXT_INSN (after);
4159       if (active_insn_p (after) && !INSN_LOCATOR (after))
4160 	INSN_LOCATOR (after) = loc;
4161       if (after == last)
4163       after = NEXT_INSN (after);
4170 emit_insn_after (rtx pattern, rtx after)
4172   if (INSN_P (after))
4173     return emit_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4175     return emit_insn_after_noloc (pattern, after);
4180 emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc)
4182   rtx last = emit_jump_insn_after_noloc (pattern, after);
4187   after = NEXT_INSN (after);
4190       if (active_insn_p (after) && !INSN_LOCATOR (after))
4191 	INSN_LOCATOR (after) = loc;
4192       if (after == last)
4194       after = NEXT_INSN (after);
4201 emit_jump_insn_after (rtx pattern, rtx after)
4203   if (INSN_P (after))
4204     return emit_jump_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4206     return emit_jump_insn_after_noloc (pattern, after);
4211 emit_call_insn_after_setloc (rtx pattern, rtx after, int loc)
4213   rtx last = emit_call_insn_after_noloc (pattern, after);
4218   after = NEXT_INSN (after);
4221       if (active_insn_p (after) && !INSN_LOCATOR (after))
4222 	INSN_LOCATOR (after) = loc;
4223       if (after == last)
4225       after = NEXT_INSN (after);
4232 emit_call_insn_after (rtx pattern, rtx after)
4234   if (INSN_P (after))
4235     return emit_call_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
4237     return emit_call_insn_after_noloc (pattern, after);
5074   /* We need to call this function after we set the scalar const_tiny_rtx
5328 /* Produce exact duplicate of insn INSN after AFTER.
5332 emit_copy_of_insn_after (rtx insn, rtx after)
5340       new = emit_insn_after (copy_insn (PATTERN (insn)), after);
5344       new = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
5348       new = emit_call_insn_after (copy_insn (PATTERN (insn)), after);