gcc/gcc/reorg.c

54    target that would only be safe to execute knowing that the branch
62    steal insns from the target of backward branches.
90    from the branch target, there is code expansion if it is not the
91    only way to reach that target.
352   /* When a target threads its epilogue we might already have a
676        from the L1 target.
748 	 branch, thread our jump to the target of that branch.  Don't
940 	 backwards from the target label.  If we find a NOTE_INSN_LOOP_BEG
950 	 forwards from the target label.  If we find a NOTE_INSN_LOOP_VTOP
1024 get_branch_condition (insn, target)
1026      rtx target;
1035     return target == 0 ? const_true_rtx : 0;
1041   if (GET_CODE (src) == LABEL_REF && XEXP (src, 0) == target)
1045 	   && ((target == 0 && GET_CODE (XEXP (src, 1)) == RETURN)
1047 		   && XEXP (XEXP (src, 1), 0) == target))
1052 	   && ((target == 0 && GET_CODE (XEXP (src, 2)) == RETURN)
1054 		   && XEXP (XEXP (src, 2), 0) == target))
1569      target.  */
1603    same label; in that case the first insn at the target might want to go
1618 redundant_insn (insn, target, delay_list)
1620      rtx target;
1623   rtx target_main = target;
1635   for (trial = PREV_INSN (target); trial; trial = PREV_INSN (trial))
1699   if (GET_CODE (target) == INSN && GET_CODE (PATTERN (target)) == SEQUENCE)
1700     target_main = XVECEXP (PATTERN (target), 0, 0);
1728   if (GET_CODE (target) == INSN && GET_CODE (PATTERN (target)) == SEQUENCE)
1729     for (i = 1; i < XVECLEN (PATTERN (target), 0); i++)
1730       if (insn_sets_resource_p (XVECEXP (PATTERN (target), 0, i), &needed, 1))
1736   for (trial = PREV_INSN (target);
1785 	      /* Unless this is an annulled insn from the target of a branch,
1817    it is the target of the branch insn being scanned.  If ALLOW_FALLTHROUGH
1863 /* Called when INSN is being moved from a location near the target of a jump.
1877   /* Ignore if this was in a delay slot and it came from the target of
1940    is a REG_DEAD note for the target of start_insn between start_insn
2203 	 There used to be code which continued past the target label if
2204 	 we saw all uses of the target label.  This code did not work,
2206 	 both annulled and marked as from the target.  This can happen as a
2216 	  rtx target = 0;
2234 		target = JUMP_LABEL (insn);
2261 	      /* If this is a jump insn to our target, indicate that we have
2264 		 target and add them to NEEDED.  */
2267 		  if (target == 0)
2269 		  else if (JUMP_LABEL (trial_delay) != target)
2284 	      if (target == 0
2325 	     unconditional branch, try the insn at the branch target.  We can
2328 	     Don't do this if the insn at the branch target is a branch.  */
2333 	      && (target == 0 || JUMP_LABEL (trial) == target)
2362 	      if (target)
2368 	 target of the jump.  */
2500    thread.  I.e., it is the fallthrough code of our jump or the target of the
2791      likely that the branch will be taken, see if the insn at our target
2905    the target or the following insns into the delay slot.  If annulling is
2954       /* Get the next active fallthrough and target insns and see if we own
2975 	 target, then our fallthrough insns.  If it is not, expected to branch,
2991 		 the next insn at the target.  */
3076 	     If so, invert this jump and point it to the target of the
3181 	     This allows the count of the jump target to be properly
3184 	  /* Clear the from target bit, since these insns are no longer
3294 	     This allows the count of the jump target to be properly
3297 	  /* Clear the from target bit, since these insns are no longer
3324 	 it to the target of the second jump.  We cannot do this for
3561       rtx target;
3579 	  && ((target = prev_label (next_active_insn (JUMP_LABEL (insn))))
3581 	redirect_jump (insn, target);
3669      assembler output a target can set branch prediction bits in the code.