if (--LABEL_NUSES (JUMP_LABEL (insn)) == 0) {  delete_insn (JUMP_LABEL (insn));  while (next && INSN_DELETED_P (next)) next = NEXT_INSN (next); return next; }
{ rtx lab = JUMP_LABEL (insn), lab_next;  if (--LABEL_NUSES (lab) == 0) {  delete_insn (lab);   while (next && INSN_DELETED_P (next)) next = NEXT_INSN (next); return next; } else if ((lab_next = next_nonnote_insn (lab)) != NULL && GET_CODE (lab_next) == JUMP_INSN && (GET_CODE (PATTERN (lab_next)) == ADDR_VEC || GET_CODE (PATTERN (lab_next)) == ADDR_DIFF_VEC)) {  delete_insn (lab_next); } }
delete_insn (insn)     register rtx insn;{  register rtx next = NEXT_INSN (insn);  register rtx prev = PREV_INSN (insn);  register int was_code_label = (GET_CODE (insn) == CODE_LABEL);  register int dont_really_delete = 0;  while (next && INSN_DELETED_P (next))    next = NEXT_INSN (next);  /* This insn is already deleted => return first following nondeleted.  */  if (INSN_DELETED_P (insn))    return next;  if (was_code_label)    remove_node_from_expr_list (insn, &nonlocal_goto_handler_labels);  /* Don't delete user-declared labels.  Convert them to special NOTEs     instead.  */  if (was_code_label && LABEL_NAME (insn) != 0      && optimize && ! dont_really_delete)    {      PUT_CODE (insn, NOTE);      NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED_LABEL;      NOTE_SOURCE_FILE (insn) = 0;      dont_really_delete = 1;    }  else    /* Mark this insn as deleted.  */    INSN_DELETED_P (insn) = 1;  /* If this is an unconditional jump, delete it from the jump chain.  */  if (simplejump_p (insn))    delete_from_jump_chain (insn);  /* If instruction is followed by a barrier,     delete the barrier too.  */  if (next != 0 && GET_CODE (next) == BARRIER)    {      INSN_DELETED_P (next) = 1;      next = NEXT_INSN (next);    }  /* Patch out INSN (and the barrier if any) */  if (optimize && ! dont_really_delete)    {      if (prev)	{	  NEXT_INSN (prev) = next;	  if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)	    NEXT_INSN (XVECEXP (PATTERN (prev), 0,				XVECLEN (PATTERN (prev), 0) - 1)) = next;	}      if (next)	{	  PREV_INSN (next) = prev;	  if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)	    PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;	}      if (prev && NEXT_INSN (prev) == 0)	set_last_insn (prev);    }  /* If deleting a jump, decrement the count of the label,     and delete the label if it is now unused.  */  if (GET_CODE (insn) == JUMP_INSN && JUMP_LABEL (insn))    if (--LABEL_NUSES (JUMP_LABEL (insn)) == 0)      {	/* This can delete NEXT or PREV,	   either directly if NEXT is JUMP_LABEL (INSN),	   or indirectly through more levels of jumps.  */	delete_insn (JUMP_LABEL (insn));	/* I feel a little doubtful about this loop,	   but I see no clean and sure alternative way	   to find the first insn after INSN that is not now deleted.	   I hope this works.  */	while (next && INSN_DELETED_P (next))	  next = NEXT_INSN (next);	return next;      }  /* Likewise if we're deleting a dispatch table.  */  if (GET_CODE (insn) == JUMP_INSN      && (GET_CODE (PATTERN (insn)) == ADDR_VEC	  || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))    {      rtx pat = PATTERN (insn);      int i, diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;      int len = XVECLEN (pat, diff_vec_p);      for (i = 0; i < len; i++)	if (--LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0)) == 0)	  delete_insn (XEXP (XVECEXP (pat, diff_vec_p, i), 0));      while (next && INSN_DELETED_P (next))	next = NEXT_INSN (next);      return next;    }  while (prev && (INSN_DELETED_P (prev) || GET_CODE (prev) == NOTE))    prev = PREV_INSN (prev);  /* If INSN was a label and a dispatch table follows it,     delete the dispatch table.  The tablejump must have gone already.     It isn't useful to fall through into a table.  */  if (was_code_label      && NEXT_INSN (insn) != 0      && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN      && (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC	  || GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))    next = delete_insn (NEXT_INSN (insn));  /* If INSN was a label, delete insns following it if now unreachable.  */  if (was_code_label && prev && GET_CODE (prev) == BARRIER)    {      register RTX_CODE code;      while (next != 0	     && (GET_RTX_CLASS (code = GET_CODE (next)) == 'i'		 || code == NOTE || code == BARRIER		 || (code == CODE_LABEL && INSN_DELETED_P (next))))	{	  if (code == NOTE	      && NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)	    next = NEXT_INSN (next);	  /* Keep going past other deleted labels to delete what follows.  */	  else if (code == CODE_LABEL && INSN_DELETED_P (next))	    next = NEXT_INSN (next);	  else	    /* Note: if this deletes a jump, it can cause more	       deletion of unreachable code, after a different label.	       As long as the value from this recursive call is correct,	       this invocation functions correctly.  */	    next = delete_insn (next);	}    }  return next;}