This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Patch preventing generation function insn_alts by default.


  The following patch switches off generation of function `insn_alts'
by default.  It is done because no one port uses the function now and
the function code is big enough.  To use the function, please set up
macro AUTOMATON_ALTS to nonzero in the machine '.h' file.

  The patch has been committed into the main line.

Vlad



2003-01-20  Vladimir Makarov  <vmakarov@redhat.com>

        * genattrtab.h (INSN_ALTS_FUNC_NAME): Move it from
genautomata.c.
        
        * genautomata.c (INSN_ALTS_FUNC_NAME): Move it into
genattrtab.h.

        * genattr.c (main): Output default definition of AUTOMATON_ALTS.
        Wrap up definition of `insn_alts'.

        * genattrtab.c (main): Wrap up `insn_alts'.
Index: haifa-sched.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/haifa-sched.c,v
retrieving revision 1.215
diff -c -p -r1.215 haifa-sched.c
*** haifa-sched.c	9 Jan 2003 23:15:28 -0000	1.215
--- haifa-sched.c	16 Jan 2003 22:25:08 -0000
*************** move_insn (insn, last)
*** 1769,1774 ****
--- 1769,1793 ----
  {
    rtx retval = NULL;
  
+   /* If INSN has SCHED_GROUP_P set, then issue it and any other
+      insns with SCHED_GROUP_P set first.  */
+   while (SCHED_GROUP_P (insn))
+     {
+       rtx prev = PREV_INSN (insn);
+       
+       /* Move a SCHED_GROUP_P insn.  */
+       move_insn1 (insn, last);
+       /* If this is the first call to reemit_notes, then record
+ 	 its return value.  */
+       if (retval == NULL_RTX)
+ 	retval = reemit_notes (insn, insn);
+       else
+ 	reemit_notes (insn, insn);
+       /* Consume SCHED_GROUP_P flag.  */
+       SCHED_GROUP_P (insn) = 0;
+       insn = prev;
+     }
+ 
    /* Now move the first non SCHED_GROUP_P insn.  */
    move_insn1 (insn, last);
  
*************** move_insn (insn, last)
*** 1779,1786 ****
    else
      reemit_notes (insn, insn);
  
-   SCHED_GROUP_P (insn) = 0;
- 
    return retval;
  }
  
--- 1798,1803 ----
*************** set_priorities (head, tail)
*** 2376,2382 ****
        if (GET_CODE (insn) == NOTE)
  	continue;
  
!       n_insn++;
        (void) priority (insn);
      }
  
--- 2393,2400 ----
        if (GET_CODE (insn) == NOTE)
  	continue;
  
!       if (! SCHED_GROUP_P (insn))
! 	n_insn++;
        (void) priority (insn);
      }
  
cvs server: I know nothing about haifa-sched.c.orig
Index: sched-deps.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-deps.c,v
retrieving revision 1.52
diff -c -p -r1.52 sched-deps.c
*** sched-deps.c	9 Jan 2003 23:15:28 -0000	1.52
--- sched-deps.c	16 Jan 2003 22:25:09 -0000
*************** static sbitmap *forward_dependency_cache
*** 83,94 ****
--- 83,96 ----
  static int deps_may_trap_p PARAMS ((rtx));
  static void add_dependence_list PARAMS ((rtx, rtx, enum reg_note));
  static void add_dependence_list_and_free PARAMS ((rtx, rtx *, enum reg_note));
+ static void remove_dependence PARAMS ((rtx, rtx));
  static void set_sched_group_p PARAMS ((rtx));
  
  static void flush_pending_lists PARAMS ((struct deps *, rtx, int, int));
  static void sched_analyze_1 PARAMS ((struct deps *, rtx, rtx));
  static void sched_analyze_2 PARAMS ((struct deps *, rtx, rtx));
  static void sched_analyze_insn PARAMS ((struct deps *, rtx, rtx, rtx));
+ static rtx group_leader PARAMS ((rtx));
  
  static rtx get_condition PARAMS ((rtx));
  static int conditions_mutex_p PARAMS ((rtx, rtx));
*************** add_dependence (insn, elem, dep_type)
*** 235,247 ****
        rtx nnext;
        while ((nnext = next_nonnote_insn (next)) != NULL
  	     && INSN_P (nnext)
- 	     && next != insn
  	     && SCHED_GROUP_P (nnext))
  	next = nnext;
  
!       if (insn != next)
! 	add_dependence (insn, next, REG_DEP_ANTI);
  
      }
  
  
--- 237,252 ----
        rtx nnext;
        while ((nnext = next_nonnote_insn (next)) != NULL
  	     && INSN_P (nnext)
  	     && SCHED_GROUP_P (nnext))
  	next = nnext;
  
!       /* Again, don't depend an insn on itself.  */
!       if (insn == next)
! 	return;
  
+       /* Make the dependence to NEXT, the last insn of the group,
+ 	 instead of the original ELEM.  */
+       elem = next;
      }
  
  
*************** add_dependence_list_and_free (insn, list
*** 380,385 ****
--- 385,460 ----
      }
  }
  
+ /* Remove ELEM wrapped in an INSN_LIST from the LOG_LINKS
+    of INSN.  Abort if not found.  */
+ 
+ static void
+ remove_dependence (insn, elem)
+      rtx insn;
+      rtx elem;
+ {
+   rtx prev, link, next;
+   int found = 0;
+ 
+   for (prev = 0, link = LOG_LINKS (insn); link; link = next)
+     {
+       next = XEXP (link, 1);
+       if (XEXP (link, 0) == elem)
+ 	{
+ 	  if (prev)
+ 	    XEXP (prev, 1) = next;
+ 	  else
+ 	    LOG_LINKS (insn) = next;
+ 
+ #ifdef INSN_SCHEDULING
+ 	  /* If we are removing a dependency from the LOG_LINKS list,
+ 	     make sure to remove it from the cache too.  */
+ 	  if (true_dependency_cache != NULL)
+ 	    {
+ 	      if (REG_NOTE_KIND (link) == 0)
+ 		RESET_BIT (true_dependency_cache[INSN_LUID (insn)],
+ 			   INSN_LUID (elem));
+ 	      else if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
+ 		RESET_BIT (anti_dependency_cache[INSN_LUID (insn)],
+ 			   INSN_LUID (elem));
+ 	      else if (REG_NOTE_KIND (link) == REG_DEP_OUTPUT)
+ 		RESET_BIT (output_dependency_cache[INSN_LUID (insn)],
+ 			   INSN_LUID (elem));
+ 	    }
+ #endif
+ 
+ 	  free_INSN_LIST_node (link);
+ 
+ 	  found = 1;
+ 	}
+       else
+ 	prev = link;
+     }
+ 
+   if (!found)
+     abort ();
+   return;
+ }
+ 
+ /* Return an insn which represents a SCHED_GROUP, which is
+    the last insn in the group.  */
+ 
+ static rtx
+ group_leader (insn)
+      rtx insn;
+ {
+   rtx prev;
+ 
+   do
+     {
+       prev = insn;
+       insn = next_nonnote_insn (insn);
+     }
+   while (insn && INSN_P (insn) && SCHED_GROUP_P (insn));
+ 
+   return prev;
+ }
+ 
  /* Set SCHED_GROUP_P and care for the rest of the bookkeeping that
     goes along with that.  */
  
*************** set_sched_group_p (insn)
*** 391,411 ****
  
    SCHED_GROUP_P (insn) = 1;
  
!   for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
!     {
!       prev = insn;
!       do
! 	{
! 	  prev = prev_nonnote_insn (prev);
! 	  if (XEXP (link, 0) == prev)
! 	    break;
! 	}
!       while (SCHED_GROUP_P (prev));
!       if (XEXP (link, 0) != prev)
! 	add_dependence (prev, XEXP (link, 0), REG_DEP_ANTI);
!     }
    prev = prev_nonnote_insn (insn);
!   add_dependence (insn, prev, REG_DEP_ANTI);
  }
  
  /* Process an insn's memory dependencies.  There are four kinds of
--- 466,487 ----
  
    SCHED_GROUP_P (insn) = 1;
  
!   /* There may be a note before this insn now, but all notes will
!      be removed before we actually try to schedule the insns, so
!      it won't cause a problem later.  We must avoid it here
!      though.  */
    prev = prev_nonnote_insn (insn);
!   
!   /* Make a copy of all dependencies on the immediately previous
!      insn, and add to this insn.  This is so that all the
!      dependencies will apply to the group.  Remove an explicit
!      dependence on this insn as SCHED_GROUP_P now represents it.  */
!   
!   if (find_insn_list (prev, LOG_LINKS (insn)))
!     remove_dependence (insn, prev);
!   
!   for (link = LOG_LINKS (prev); link; link = XEXP (link, 1))
!     add_dependence (insn, XEXP (link, 0), REG_NOTE_KIND (link));
  }
  
  /* Process an insn's memory dependencies.  There are four kinds of
*************** compute_forward_dependences (head, tail)
*** 1370,1378 ****
        if (! INSN_P (insn))
  	continue;
  
        for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
  	{
! 	  rtx x = XEXP (link, 0);
  	  rtx new_link;
  
  	  if (x != XEXP (link, 0))
--- 1446,1456 ----
        if (! INSN_P (insn))
  	continue;
  
+       insn = group_leader (insn);
+       
        for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
  	{
! 	  rtx x = group_leader (XEXP (link, 0));
  	  rtx new_link;
  
  	  if (x != XEXP (link, 0))
cvs server: I know nothing about sched-deps.c.orig
Index: sched-ebb.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-ebb.c,v
retrieving revision 1.19
diff -c -p -r1.19 sched-ebb.c
*** sched-ebb.c	9 Jan 2003 23:15:28 -0000	1.19
--- sched-ebb.c	16 Jan 2003 22:25:09 -0000
*************** init_ready_list (ready)
*** 90,98 ****
       Count number of insns in the target block being scheduled.  */
    for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
      {
!       if (INSN_DEP_COUNT (insn) == 0)
  	ready_add (ready, insn);
!       if (!(SCHED_GROUP_P (insn)))
  	target_n_insns++;
      }
  }
--- 90,105 ----
       Count number of insns in the target block being scheduled.  */
    for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
      {
!       rtx next;
! 
!       if (! INSN_P (insn))
! 	continue;
!       next = NEXT_INSN (insn);
! 
!       if (INSN_DEP_COUNT (insn) == 0
! 	  && (! INSN_P (next) || SCHED_GROUP_P (next) == 0))
  	ready_add (ready, insn);
!       if (! SCHED_GROUP_P (insn))
  	target_n_insns++;
      }
  }
cvs server: I know nothing about sched-ebb.c.orig
Index: sched-rgn.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-rgn.c,v
retrieving revision 1.55
diff -c -p -r1.55 sched-rgn.c
*** sched-rgn.c	9 Jan 2003 23:15:28 -0000	1.55
--- sched-rgn.c	16 Jan 2003 22:25:09 -0000
*************** init_ready_list (ready)
*** 2023,2031 ****
       Count number of insns in the target block being scheduled.  */
    for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
      {
!       if (INSN_DEP_COUNT (insn) == 0)
  	ready_add (ready, insn);
!       target_n_insns++;
      }
  
    /* Add to ready list all 'ready' insns in valid source blocks.
--- 2023,2039 ----
       Count number of insns in the target block being scheduled.  */
    for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
      {
!       rtx next;
! 
!       if (! INSN_P (insn))
! 	continue;
!       next = NEXT_INSN (insn);
! 
!       if (INSN_DEP_COUNT (insn) == 0
! 	  && (! INSN_P (next) || SCHED_GROUP_P (next) == 0))
  	ready_add (ready, insn);
!       if (! SCHED_GROUP_P (insn))
! 	target_n_insns++;
      }
  
    /* Add to ready list all 'ready' insns in valid source blocks.
*************** init_ready_list (ready)
*** 2059,2066 ****
  							     insn, insn) <= 3)))
  			&& check_live (insn, bb_src)
  			&& is_exception_free (insn, bb_src, target_bb))))
! 	      if (INSN_DEP_COUNT (insn) == 0)
! 		ready_add (ready, insn);
  	  }
        }
  }
--- 2067,2085 ----
  							     insn, insn) <= 3)))
  			&& check_live (insn, bb_src)
  			&& is_exception_free (insn, bb_src, target_bb))))
! 	      {
! 		rtx next;
! 
! 		/* Note that we haven't squirreled away the notes for
! 		   blocks other than the current.  So if this is a
! 		   speculative insn, NEXT might otherwise be a note.  */
! 		next = next_nonnote_insn (insn);
! 		if (INSN_DEP_COUNT (insn) == 0
! 		    && (! next
! 			|| ! INSN_P (next)
! 			|| SCHED_GROUP_P (next) == 0))
! 		  ready_add (ready, insn);
! 	      }
  	  }
        }
  }
*************** can_schedule_ready_p (insn)
*** 2078,2083 ****
--- 2097,2103 ----
    /* An interblock motion?  */
    if (INSN_BB (insn) != target_bb)
      {
+       rtx temp;
        basic_block b1;
  
        if (IS_SPECULATIVE_INSN (insn))
*************** can_schedule_ready_p (insn)
*** 2094,2102 ****
  	}
        nr_inter++;
  
        /* Update source block boundaries.  */
!       b1 = BLOCK_FOR_INSN (insn);
!       if (insn == b1->head && insn == b1->end)
  	{
  	  /* We moved all the insns in the basic block.
  	     Emit a note after the last insn and update the
--- 2114,2131 ----
  	}
        nr_inter++;
  
+       /* Find the beginning of the scheduling group.  */
+       /* ??? Ought to update basic block here, but later bits of
+ 	 schedule_block assumes the original insn block is
+ 	 still intact.  */
+ 
+       temp = insn;
+       while (SCHED_GROUP_P (temp))
+ 	temp = PREV_INSN (temp);
+ 
        /* Update source block boundaries.  */
!       b1 = BLOCK_FOR_INSN (temp);
!       if (temp == b1->head && temp == b1->end)
  	{
  	  /* We moved all the insns in the basic block.
  	     Emit a note after the last insn and update the
*************** can_schedule_ready_p (insn)
*** 2110,2118 ****
  	  /* We took insns from the end of the basic block,
  	     so update the end of block boundary so that it
  	     points to the first insn we did not move.  */
! 	  b1->end = PREV_INSN (insn);
  	}
!       else if (insn == b1->head)
  	{
  	  /* We took insns from the start of the basic block,
  	     so update the start of block boundary so that
--- 2139,2147 ----
  	  /* We took insns from the end of the basic block,
  	     so update the end of block boundary so that it
  	     points to the first insn we did not move.  */
! 	  b1->end = PREV_INSN (temp);
  	}
!       else if (temp == b1->head)
  	{
  	  /* We took insns from the start of the basic block,
  	     so update the start of block boundary so that
*************** add_branch_dependences (head, tail)
*** 2332,2337 ****
--- 2361,2377 ----
  	  CANT_MOVE (insn) = 1;
  
  	  last = insn;
+ 	  /* Skip over insns that are part of a group.
+ 	     Make each insn explicitly depend on the previous insn.
+ 	     This ensures that only the group header will ever enter
+ 	     the ready queue (and, when scheduled, will automatically
+ 	     schedule the SCHED_GROUP_P block).  */
+ 	  while (SCHED_GROUP_P (insn))
+ 	    {
+ 	      rtx temp = prev_nonnote_insn (insn);
+ 	      add_dependence (insn, temp, REG_DEP_ANTI);
+ 	      insn = temp;
+ 	    }
  	}
  
        /* Don't overrun the bounds of the basic block.  */
*************** add_branch_dependences (head, tail)
*** 2353,2358 ****
--- 2393,2402 ----
  
  	add_dependence (last, insn, REG_DEP_ANTI);
  	INSN_REF_COUNT (insn) = 1;
+ 	
+ 	/* Skip over insns that are part of a group.  */
+ 	while (SCHED_GROUP_P (insn))
+ 	  insn = prev_nonnote_insn (insn);
        }
  }
  

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]