case REG_NOALIAS:
distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)     rtx notes;     rtx from_insn;     rtx i3, i2;     rtx elim_i2, elim_i1;{  rtx note, next_note;  rtx tem;  for (note = notes; note; note = next_note)    {      rtx place = 0, place2 = 0;      /* If this NOTE references a pseudo register, ensure it references	 the latest copy of that register.  */      if (XEXP (note, 0) && GET_CODE (XEXP (note, 0)) == REG	  && REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER)	XEXP (note, 0) = regno_reg_rtx[REGNO (XEXP (note, 0))];      next_note = XEXP (note, 1);      switch (REG_NOTE_KIND (note))	{	case REG_UNUSED:	  /* Any clobbers for i3 may still exist, and so we must process	     REG_UNUSED notes from that insn.	     Any clobbers from i2 or i1 can only exist if they were added by	     recog_for_combine.  In that case, recog_for_combine created the	     necessary REG_UNUSED notes.  Trying to keep any original	     REG_UNUSED notes from these insns can cause incorrect output	     if it is for the same register as the original i3 dest.	     In that case, we will notice that the register is set in i3,	     and then add a REG_UNUSED note for the destination of i3, which	     is wrong.  However, it is possible to have REG_UNUSED notes from	     i2 or i1 for register which were both used and clobbered, so	     we keep notes from i2 or i1 if they will turn into REG_DEAD	     notes.  */	  /* If this register is set or clobbered in I3, put the note there	     unless there is one already.  */	  if (reg_set_p (XEXP (note, 0), PATTERN (i3)))	    {	      if (from_insn != i3)		break;	      if (! (GET_CODE (XEXP (note, 0)) == REG		     ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))		     : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))		place = i3;	    }	  /* Otherwise, if this register is used by I3, then this register	     now dies here, so we must put a REG_DEAD note here unless there	     is one already.  */	  else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))		   && ! (GET_CODE (XEXP (note, 0)) == REG			 ? find_regno_note (i3, REG_DEAD, REGNO (XEXP (note, 0)))			 : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))	    {	      PUT_REG_NOTE_KIND (note, REG_DEAD);	      place = i3;	    }	  break;	case REG_EQUAL:	case REG_EQUIV:	case REG_NONNEG:	  /* These notes say something about results of an insn.  We can	     only support them if they used to be on I3 in which case they	     remain on I3.  Otherwise they are ignored.	     If the note refers to an expression that is not a constant, we	     must also ignore the note since we cannot tell whether the	     equivalence is still true.  It might be possible to do	     slightly better than this (we only have a problem if I2DEST	     or I1DEST is present in the expression), but it doesn't	     seem worth the trouble.  */	  if (from_insn == i3	      && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))	    place = i3;	  break;	case REG_INC:	case REG_NO_CONFLICT:	case REG_LABEL:	  /* These notes say something about how a register is used.  They must	     be present on any use of the register in I2 or I3.  */	  if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))	    place = i3;	  if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))	    {	      if (place)		place2 = i2;	      else		place = i2;	    }	  break;	case REG_WAS_0:	  /* It is too much trouble to try to see if this note is still	     correct in all situations.  It is better to simply delete it.  */	  break;	case REG_RETVAL:	  /* If the insn previously containing this note still exists,	     put it back where it was.  Otherwise move it to the previous	     insn.  Adjust the corresponding REG_LIBCALL note.  */	  if (GET_CODE (from_insn) != NOTE)	    place = from_insn;	  else	    {	      tem = find_reg_note (XEXP (note, 0), REG_LIBCALL, NULL_RTX);	      place = prev_real_insn (from_insn);	      if (tem && place)		XEXP (tem, 0) = place;	    }	  break;	case REG_LIBCALL:	  /* This is handled similarly to REG_RETVAL.  */	  if (GET_CODE (from_insn) != NOTE)	    place = from_insn;	  else	    {	      tem = find_reg_note (XEXP (note, 0), REG_RETVAL, NULL_RTX);	      place = next_real_insn (from_insn);	      if (tem && place)		XEXP (tem, 0) = place;	    }	  break;	case REG_DEAD:	  /* If the register is used as an input in I3, it dies there.	     Similarly for I2, if it is non-zero and adjacent to I3.	     If the register is not used as an input in either I3 or I2	     and it is not one of the registers we were supposed to eliminate,	     there are two possibilities.  We might have a non-adjacent I2	     or we might have somehow eliminated an additional register	     from a computation.  For example, we might have had A & B where	     we discover that B will always be zero.  In this case we will	     eliminate the reference to A.	     In both cases, we must search to see if we can find a previous	     use of A and put the death note there.  */	  if (from_insn	      && GET_CODE (from_insn) == CALL_INSN              && find_reg_fusage (from_insn, USE, XEXP (note, 0)))	    place = from_insn;	  else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))	    place = i3;	  else if (i2 != 0 && next_nonnote_insn (i2) == i3		   && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))	    place = i2;	  if (XEXP (note, 0) == elim_i2 || XEXP (note, 0) == elim_i1)	    break;	  /* If the register is used in both I2 and I3 and it dies in I3, 	     we might have added another reference to it.  If reg_n_refs	     was 2, bump it to 3.  This has to be correct since the 	     register must have been set somewhere.  The reason this is	     done is because local-alloc.c treats 2 references as a 	     special case.  */	  if (place == i3 && i2 != 0 && GET_CODE (XEXP (note, 0)) == REG	      && reg_n_refs[REGNO (XEXP (note, 0))]== 2	      && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))	    reg_n_refs[REGNO (XEXP (note, 0))] = 3;	  if (place == 0)	    {	      for (tem = prev_nonnote_insn (i3);		   place == 0 && tem		   && (GET_CODE (tem) == INSN || GET_CODE (tem) == CALL_INSN);		   tem = prev_nonnote_insn (tem))		{		  /* If the register is being set at TEM, see if that is all		     TEM is doing.  If so, delete TEM.  Otherwise, make this		     into a REG_UNUSED note instead.  */		  if (reg_set_p (XEXP (note, 0), PATTERN (tem)))		    {		      rtx set = single_set (tem);		      /* Verify that it was the set, and not a clobber that			 modified the register.  */		      if (set != 0 && ! side_effects_p (SET_SRC (set))			  && (rtx_equal_p (XEXP (note, 0), SET_DEST (set))			      || (GET_CODE (SET_DEST (set)) == SUBREG				  && rtx_equal_p (XEXP (note, 0),						  XEXP (SET_DEST (set), 0)))))			{			  /* Move the notes and links of TEM elsewhere.			     This might delete other dead insns recursively. 			     First set the pattern to something that won't use			     any register.  */			  PATTERN (tem) = pc_rtx;			  distribute_notes (REG_NOTES (tem), tem, tem,					    NULL_RTX, NULL_RTX, NULL_RTX);			  distribute_links (LOG_LINKS (tem));			  PUT_CODE (tem, NOTE);			  NOTE_LINE_NUMBER (tem) = NOTE_INSN_DELETED;			  NOTE_SOURCE_FILE (tem) = 0;			}		      else			{			  PUT_REG_NOTE_KIND (note, REG_UNUSED);			  			  /*  If there isn't already a REG_UNUSED note, put one			      here.  */			  if (! find_regno_note (tem, REG_UNUSED,						 REGNO (XEXP (note, 0))))			    place = tem;			  break;		      }		  }		else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))			 || (GET_CODE (tem) == CALL_INSN			     && find_reg_fusage (tem, USE, XEXP (note, 0))))		  {		    place = tem;		    /* If we are doing a 3->2 combination, and we have a		       register which formerly died in i3 and was not used		       by i2, which now no longer dies in i3 and is used in		       i2 but does not die in i2, and place is between i2		       and i3, then we may need to move a link from place to		       i2.  */		    if (i2 && INSN_UID (place) <= max_uid_cuid			&& INSN_CUID (place) > INSN_CUID (i2)			&& from_insn && INSN_CUID (from_insn) > INSN_CUID (i2)			&& reg_referenced_p (XEXP (note, 0), PATTERN (i2)))		      {			rtx links = LOG_LINKS (place);			LOG_LINKS (place) = 0;			distribute_links (links);		      }		    break;		  }		}	      	      /* If we haven't found an insn for the death note and it		 is still a REG_DEAD note, but we have hit a CODE_LABEL,		 insert a USE insn for the register at that label and		 put the death node there.  This prevents problems with		 call-state tracking in caller-save.c.  */	      if (REG_NOTE_KIND (note) == REG_DEAD && place == 0 && tem != 0)		{		  place		    = emit_insn_after (gen_rtx (USE, VOIDmode, XEXP (note, 0)),				       tem);		  /* If this insn was emitted between blocks, then update		     basic_block_head of the current block to include it.  */		  if (basic_block_end[this_basic_block - 1] == tem)		    basic_block_head[this_basic_block] = place;		}	    }	  /* If the register is set or already dead at PLACE, we needn't do	     anything with this note if it is still a REG_DEAD note.  	     Note that we cannot use just `dead_or_set_p' here since we can	     convert an assignment to a register into a bit-field assignment.	     Therefore, we must also omit the note if the register is the 	     target of a bitfield assignment.  */	     	  if (place && REG_NOTE_KIND (note) == REG_DEAD)	    {	      int regno = REGNO (XEXP (note, 0));	      if (dead_or_set_p (place, XEXP (note, 0))		  || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))		{		  /* Unless the register previously died in PLACE, clear		     reg_last_death.  [I no longer understand why this is		     being done.] */		  if (reg_last_death[regno] != place)		    reg_last_death[regno] = 0;		  place = 0;		}	      else		reg_last_death[regno] = place;	      /* If this is a death note for a hard reg that is occupying		 multiple registers, ensure that we are still using all		 parts of the object.  If we find a piece of the object		 that is unused, we must add a USE for that piece before		 PLACE and put the appropriate REG_DEAD note on it.		 An alternative would be to put a REG_UNUSED for the pieces		 on the insn that set the register, but that can't be done if		 it is not in the same block.  It is simpler, though less		 efficient, to add the USE insns.  */	      if (place && regno < FIRST_PSEUDO_REGISTER		  && HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0))) > 1)		{		  int endregno		    = regno + HARD_REGNO_NREGS (regno,						GET_MODE (XEXP (note, 0)));		  int all_used = 1;		  int i;		  for (i = regno; i < endregno; i++)		    if (! refers_to_regno_p (i, i + 1, PATTERN (place), 0)			&& ! find_regno_fusage (place, USE, i))		      {			rtx piece = gen_rtx (REG, reg_raw_mode[i], i);			rtx p;			/* See if we already placed a USE note for this			   register in front of PLACE.  */			for (p = place;			     GET_CODE (PREV_INSN (p)) == INSN			     && GET_CODE (PATTERN (PREV_INSN (p))) == USE;			     p = PREV_INSN (p))			  if (rtx_equal_p (piece,					   XEXP (PATTERN (PREV_INSN (p)), 0)))			    {			      p = 0;			      break;			    }			if (p)			  {			    rtx use_insn			      = emit_insn_before (gen_rtx (USE, VOIDmode,							   piece),						  p);			    REG_NOTES (use_insn)			      = gen_rtx (EXPR_LIST, REG_DEAD, piece,					 REG_NOTES (use_insn));			  }			all_used = 0;		      }		  /* Check for the case where the register dying partially		     overlaps the register set by this insn.  */		  if (all_used)		    for (i = regno; i < endregno; i++)		      if (dead_or_set_regno_p (place, i))			  {			    all_used = 0;			    break;			  }		  if (! all_used)		    {		      /* Put only REG_DEAD notes for pieces that are			 still used and that are not already dead or set.  */		      for (i = regno; i < endregno; i++)			{			  rtx piece = gen_rtx (REG, reg_raw_mode[i], i);			  if ((reg_referenced_p (piece, PATTERN (place))			       || (GET_CODE (place) == CALL_INSN				   && find_reg_fusage (place, USE, piece)))			      && ! dead_or_set_p (place, piece)			      && ! reg_bitfield_target_p (piece,							  PATTERN (place)))			    REG_NOTES (place) = gen_rtx (EXPR_LIST, REG_DEAD,							 piece,							 REG_NOTES (place));			}		      place = 0;		    }		}	    }	  break;	default:	  /* Any other notes should not be present at this point in the	     compilation.  */	  abort ();	}      if (place)	{	  XEXP (note, 1) = REG_NOTES (place);	  REG_NOTES (place) = note;	}      else if ((REG_NOTE_KIND (note) == REG_DEAD		|| REG_NOTE_KIND (note) == REG_UNUSED)	       && GET_CODE (XEXP (note, 0)) == REG)	reg_n_deaths[REGNO (XEXP (note, 0))]--;      if (place2)	{	  if ((REG_NOTE_KIND (note) == REG_DEAD	       || REG_NOTE_KIND (note) == REG_UNUSED)	      && GET_CODE (XEXP (note, 0)) == REG)	    reg_n_deaths[REGNO (XEXP (note, 0))]++;	  REG_NOTES (place2) = gen_rtx (GET_CODE (note), REG_NOTE_KIND (note),					XEXP (note, 0), REG_NOTES (place2));	}    }}