CbC/CbC_gcc: gcc/reorg.c comparison

comparison gcc/reorg.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Perform instruction reorganizations for delay slot filling.
-Copyright (C) 1992-2017 Free Software Foundation, Inc.
+Copyright (C) 1992-2018 Free Software Foundation, Inc.
 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu).
 Hacked by Michael Tiemann (tiemann@cygnus.com).
 This file is part of GCC.
 switch (GET_CODE (insn))
 {
 case NOTE:
 case CALL_INSN:
+case DEBUG_INSN:
 return 0;
 case CODE_LABEL:
 return labels_p;
 insn = get_last_insn ();
 while (NOTE_P (insn)
 	 || (NONJUMP_INSN_P (insn)
 	     && (GET_CODE (PATTERN (insn)) == USE
-		 || GET_CODE (PATTERN (insn)) == CLOBBER)))
+		 || GET_CODE (PATTERN (insn)) == CLOBBER
+		 || GET_CODE (PATTERN (insn)) == CLOBBER_HIGH)))
 insn = PREV_INSN (insn);
 /* When a target threads its epilogue we might already have a
 suitable return insn.  If so put a label before it for the
 function_return_label.  */
 PNEW_THREAD points to a location that is to receive the place at which
 execution should continue.  */
 static void
 steal_delay_list_from_target (rtx_insn *insn, rtx condition, rtx_sequence *seq,
-			      vec<rtx_insn *> *delay_list, resources *sets,
+			      vec<rtx_insn *> *delay_list,
+			      struct resources *sets,
 			      struct resources *needed,
 			      struct resources *other_needed,
 			      int slots_to_fill, int *pslots_filled,
 			      int *pannul_p, rtx *pnew_thread)
 {
 auto_vec<rtx_insn *, 5> new_delay_list;
 int must_annul = *pannul_p;
 int used_annul = 0;
 int i;
 struct resources cc_set;
-bool *redundant;
+rtx_insn **redundant;
 /* We can't do anything if there are more delay slots in SEQ than we
 can handle, or if we don't know that it will be a taken branch.
 We know that it will be a taken branch if it is either an unconditional
 branch or a conditional branch with a stricter branch condition.
 displacement.  Give the back end a chance to tell us we can't do
 this.  */
 if (! targetm.can_follow_jump (insn, seq->insn (0)))
 return;
-redundant = XALLOCAVEC (bool, XVECLEN (seq, 0));
+redundant = XALLOCAVEC (rtx_insn *, XVECLEN (seq, 0));
 for (i = 1; i < seq->len (); i++)
 {
 rtx_insn *trial = seq->insn (i);
 int flags;
 /* Record the effect of the instructions that were redundant and which
 we therefore decided not to copy.  */
 for (i = 1; i < seq->len (); i++)
 if (redundant[i])
-update_block (seq->insn (i), insn);
+{
+	fix_reg_dead_note (redundant[i], insn);
+	update_block (seq->insn (i), insn);
+}
 /* Show the place to which we will be branching.  */
 *pnew_thread = first_active_target_insn (JUMP_LABEL (seq->insn (0)));
 /* Add any new insns to the delay list and update the count of the
 return;
 for (i = 1; i < seq->len (); i++)
 {
 rtx_insn *trial = seq->insn (i);
+rtx_insn *prior_insn;
 /* If TRIAL sets CC0, stealing it will move it too far from the use
 	 of CC0.  */
 if (insn_references_resource_p (trial, sets, false)
 	  || insn_sets_resource_p (trial, needed, false)
 	  || (HAVE_cc0 && sets_cc0_p (PATTERN (trial))))
 	break;
 /* If this insn was already done, we don't need it.  */
-if (redundant_insn (trial, insn, *delay_list))
+if ((prior_insn = redundant_insn (trial, insn, *delay_list)))
 	{
+	  fix_reg_dead_note (prior_insn, insn);
 	  update_block (trial, insn);
 	  delete_from_delay_slot (trial);
 	  continue;
 	}
 next_trial = next_nonnote_insn (trial);
 /* TRIAL must be a CALL_INSN or INSN.  Skip USE and CLOBBER.  */
 if (NONJUMP_INSN_P (trial)
-	  && (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER))
+	  && (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+	      || GET_CODE (pat) == CLOBBER_HIGH))
 	continue;
 if (GET_CODE (next_to_match) == GET_CODE (trial)
 	  /* We can't share an insn that sets cc0.  */
 	  && (!HAVE_cc0 || ! sets_cc0_p (pat))
 if (!INSN_P (trial))
 	continue;
 --insns_to_search;
 pat = PATTERN (trial);
-if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+	  || GET_CODE (pat) == CLOBBER_HIGH)
+	continue;
+if (GET_CODE (trial) == DEBUG_INSN)
 	continue;
 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (pat))
 	{
 	  /* Stop for a CALL and its delay slots because it is difficult to
 if (!INSN_P (trial))
 	continue;
 --insns_to_search;
 pat = PATTERN (trial);
-if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+	  || GET_CODE (pat) == CLOBBER_HIGH)
+	continue;
+if (GET_CODE (trial) == DEBUG_INSN)
 	continue;
 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (pat))
 	{
 	  bool annul_p = false;
 insn = prev_nonnote_insn (insn))
 if (insn == 0
 	|| LABEL_P (insn)
 	|| (NONJUMP_INSN_P (insn)
 	    && GET_CODE (PATTERN (insn)) != USE
-	    && GET_CODE (PATTERN (insn)) != CLOBBER))
+	    && GET_CODE (PATTERN (insn)) != CLOBBER
+	    && GET_CODE (PATTERN (insn)) != CLOBBER_HIGH))
 return 0;
 return 1;
 }
 	    return;
 	  }
 }
 }
-/* Delete any REG_UNUSED notes that exist on INSN but not on REDUNDANT_INSN.
+/* Delete any REG_UNUSED notes that exist on INSN but not on OTHER_INSN.
 This handles the case of udivmodXi4 instructions which optimize their
-output depending on whether any REG_UNUSED notes are present.
+output depending on whether any REG_UNUSED notes are present.  We must
-we must make sure that INSN calculates as many results as REDUNDANT_INSN
+make sure that INSN calculates as many results as OTHER_INSN does.  */
-does.  */
 static void
-update_reg_unused_notes (rtx_insn *insn, rtx redundant_insn)
+update_reg_unused_notes (rtx_insn *insn, rtx other_insn)
 {
 rtx link, next;
 for (link = REG_NOTES (insn); link; link = next)
 {
 if (REG_NOTE_KIND (link) != REG_UNUSED
 	  || !REG_P (XEXP (link, 0)))
 	continue;
-if (! find_regno_note (redundant_insn, REG_UNUSED,
+if (!find_regno_note (other_insn, REG_UNUSED, REGNO (XEXP (link, 0))))
-			     REGNO (XEXP (link, 0))))
 	remove_note (insn, link);
 }
 }
 static vec <rtx> sibling_labels;
 	      /* This must be an INSN or CALL_INSN.  */
 	      pat = PATTERN (trial);
 	      /* Stand-alone USE and CLOBBER are just for flow.  */
-	      if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+	      if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+		  || GET_CODE (pat) == CLOBBER_HIGH)
+		continue;
+	      /* And DEBUG_INSNs never go into delay slots.  */
+	      if (GET_CODE (trial) == DEBUG_INSN)
 		continue;
 	      /* Check for resource conflict first, to avoid unnecessary
 		 splitting.  */
 	      if (! insn_references_resource_p (trial, &set, true)
 	      /* This must be an INSN or CALL_INSN.  */
 	      pat = PATTERN (trial);
 	      /* Stand-alone USE and CLOBBER are just for flow.  */
-	      if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+	      if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+		  || GET_CODE (pat) == CLOBBER_HIGH)
+		continue;
+	      /* And DEBUG_INSNs do not go in delay slots.  */
+	      if (GET_CODE (trial) == DEBUG_INSN)
 		continue;
 	      /* If this already has filled delay slots, get the insn needing
 		 the delay slots.  */
 	      if (GET_CODE (pat) == SEQUENCE)
 	      && (next_trial = try_split (PATTERN (next_trial), next_trial, 0))
 	      && eligible_for_delay (insn, slots_filled, next_trial, flags)
 	      && ! can_throw_internal (trial))
 	    {
 	      /* See comment in relax_delay_slots about necessity of using
-		 next_real_insn here.  */
+		 next_real_nondebug_insn here.  */
-	      rtx_insn *new_label = next_real_insn (next_trial);
+	      rtx_insn *new_label = next_real_nondebug_insn (next_trial);
 	      if (new_label != 0)
 		new_label = get_label_before (new_label, JUMP_LABEL (trial));
 	      else
 		new_label = find_end_label (simple_return_rtx);
 LIKELY is nonzero if it is extremely likely that the branch will be
 taken and THREAD_IF_TRUE is set.  This is used for the branch at the
 end of a loop back up to the top.
-OWN_THREAD and OWN_OPPOSITE_THREAD are true if we are the only user of the
+OWN_THREAD is true if we are the only user of the thread, i.e. it is
-thread.  I.e., it is the fallthrough code of our jump or the target of the
+the target of the jump when we are the only jump going there.
-jump when we are the only jump going there.
 If OWN_THREAD is false, it must be the "true" thread of a jump.  In that
 case, we can only take insns from the head of the thread for our delay
 slot.  We then adjust the jump to point after the insns we have taken.  */
 	  own_thread = 0;
 	  continue;
 	}
 pat = PATTERN (trial);
-if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+	  || GET_CODE (pat) == CLOBBER_HIGH)
+	continue;
+if (GET_CODE (trial) == DEBUG_INSN)
 	continue;
 /* If TRIAL conflicts with the insns ahead of it, we lose.  Also,
 	 don't separate or copy insns that set and use CC0.  */
 if (! insn_references_resource_p (trial, &set, true)
 rtx target_label;
 /* Look at every JUMP_INSN and see if we can improve it.  */
 for (insn = first; insn; insn = next)
 {
-rtx_insn *other;
+rtx_insn *other, *prior_insn;
 bool crossing;
 next = next_active_insn (insn);
 /* If this is a jump insn, see if it now jumps to a jump, jumps to
 if (simplejump_or_return_p (insn)
 	  && (other = prev_active_insn (insn)) != 0
 	  && any_condjump_p (other)
 	  && no_labels_between_p (other, insn)
-	  && 0 > mostly_true_jump (other))
+	  && mostly_true_jump (other) < 0)
 	{
 	  rtx other_target = JUMP_LABEL (other);
 	  target_label = JUMP_LABEL (insn);
 	  if (invert_jump (as_a <rtx_jump_insn *> (other), target_label, 0))
 delay_insn = pat->insn (0);
 /* See if the first insn in the delay slot is redundant with some
 	 previous insn.  Remove it from the delay slot if so; then set up
 	 to reprocess this insn.  */
-if (redundant_insn (pat->insn (1), delay_insn, vNULL))
+if ((prior_insn = redundant_insn (pat->insn (1), delay_insn, vNULL)))
 	{
+	  fix_reg_dead_note (prior_insn, insn);
 	  update_block (pat->insn (1), insn);
 	  delete_from_delay_slot (pat->insn (1));
 	  next = prev_active_insn (next);
 	  continue;
 	}
 	    CROSSING_JUMP_P (delay_jump_insn) = 1;
 	}
 /* If the first insn at TARGET_LABEL is redundant with a previous
 	 insn, redirect the jump to the following insn and process again.
-	 We use next_real_insn instead of next_active_insn so we
+	 We use next_real_nondebug_insn instead of next_active_insn so we
 	 don't skip USE-markers, or we'll end up with incorrect
 	 liveness info.  */
-trial = next_real_insn (target_label);
+trial = next_real_nondebug_insn (target_label);
 if (trial && GET_CODE (PATTERN (trial)) != SEQUENCE
 	  && redundant_insn (trial, insn, vNULL)
 	  && ! can_throw_internal (trial))
 	{
 	  /* Figure out where to emit the special USE insn so we don't
 	  if (tmp)
 	    {
 	      /* Insert the special USE insn and update dataflow info.
 		 We know "trial" is an insn here as it is the output of
-		 next_real_insn () above.  */
+		 next_real_nondebug_insn () above.  */
 	      update_block (as_a <rtx_insn *> (trial), tmp);
 	      /* Now emit a label before the special USE insn, and
 		 redirect our jump to the new label.  */
 	      target_label = get_label_before (PREV_INSN (tmp), target_label);
 	      continue;
 	    }
 	}
 /* See if we have a simple (conditional) jump that is useless.  */
-if (! INSN_ANNULLED_BRANCH_P (delay_jump_insn)
+if (!CROSSING_JUMP_P (delay_jump_insn)
-	  && ! condjump_in_parallel_p (delay_jump_insn)
+	  && !INSN_ANNULLED_BRANCH_P (delay_jump_insn)
+	  && !condjump_in_parallel_p (delay_jump_insn)
 	  && prev_active_insn (as_a<rtx_insn *> (target_label)) == insn
-	  && ! BARRIER_P (prev_nonnote_insn (as_a<rtx_insn *> (target_label)))
+	  && !BARRIER_P (prev_nonnote_insn (as_a<rtx_insn *> (target_label)))
 	  /* If the last insn in the delay slot sets CC0 for some insn,
 	     various code assumes that it is in a delay slot.  We could
 	     put it back where it belonged and delete the register notes,
 	     but it doesn't seem worthwhile in this uncommon case.  */
 	  && (!HAVE_cc0
 	 RETURN, delete the SEQUENCE and output the individual insns,
 	 followed by the RETURN.  Then set things up so we try to find
 	 insns for its delay slots, if it needs some.  */
 if (ANY_RETURN_P (PATTERN (jump_insn)))
 	{
-	  rtx_insn *prev = PREV_INSN (insn);
+	  rtx_insn *after = PREV_INSN (insn);
 	  delete_related_insns (insn);
-	  for (i = 1; i < XVECLEN (pat, 0); i++)
+	  insn = jump_insn;
-	    prev = emit_insn_after (PATTERN (XVECEXP (pat, 0, i)), prev);
+	  for (i = 1; i < pat->len (); i++)
+	    after = emit_copy_of_insn_after (pat->insn (i), after);
-	  insn = emit_jump_insn_after (PATTERN (jump_insn), prev);
+	  add_insn_after (insn, after, NULL);
 	  emit_barrier_after (insn);
 	  if (slots)
 	    obstack_ptr_grow (&unfilled_slots_obstack, insn);
 	}
 for (insn = first; insn; insn = NEXT_INSN (insn))
 	{
 	  if (! insn->deleted ()
 	      && NONJUMP_INSN_P (insn)
 	      && GET_CODE (PATTERN (insn)) != USE
-	      && GET_CODE (PATTERN (insn)) != CLOBBER)
+	      && GET_CODE (PATTERN (insn)) != CLOBBER
+	      && GET_CODE (PATTERN (insn)) != CLOBBER_HIGH)
 	    {
 	      if (GET_CODE (PATTERN (insn)) == SEQUENCE)
 		{
 rtx control;
 		  j = XVECLEN (PATTERN (insn), 0) - 1;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/reorg.c @ 131:84e7813d76e9