CbC/CbC_gcc: gcc/genautomata.c comparison

comparison gcc/genautomata.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* Pipeline hazard description translator.
-Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
+Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
 Free Software Foundation, Inc.
 Written by Vladimir Makarov <vmakarov@redhat.com>
 This file is part of GCC.
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 /* References:
-1. Detecting pipeline structural hazards quickly. T. Proebsting,
+1. The finite state automaton based pipeline hazard recognizer and
+instruction scheduler in GCC.  V. Makarov.  Proceedings of GCC
+summit, 2003.
+2. Detecting pipeline structural hazards quickly. T. Proebsting,
 C. Fraser. Proceedings of ACM SIGPLAN-SIGACT Symposium on
 Principles of Programming Languages, pages 280--286, 1994.
 This article is a good start point to understand usage of finite
 state automata for pipeline hazard recognizers.  But I'd
-recommend the 2nd article for more deep understanding.
+recommend the 1st and 3rd article for more deep understanding.
-2. Efficient Instruction Scheduling Using Finite State Automata:
+3. Efficient Instruction Scheduling Using Finite State Automata:
 V. Bala and N. Rubin, Proceedings of MICRO-28.  This is the best
 article about usage of finite state automata for pipeline hazard
 recognizers.
-The current implementation is different from the 2nd article in the
+The current implementation is described in the 1st article and it
-following:
+is different from the 3rd article in the following:
 1. New operator `|' (alternative) is permitted in functional unit
 reservation which can be treated deterministically and
 non-deterministically.
 /* Declare vector types for various data structures: */
 DEF_VEC_P(alt_state_t);
-DEF_VEC_ALLOC_P(alt_state_t,heap);
+DEF_VEC_ALLOC_P(alt_state_t, heap);
 DEF_VEC_P(ainsn_t);
-DEF_VEC_ALLOC_P(ainsn_t,heap);
+DEF_VEC_ALLOC_P(ainsn_t, heap);
 DEF_VEC_P(state_t);
-DEF_VEC_ALLOC_P(state_t,heap);
+DEF_VEC_ALLOC_P(state_t, heap);
 DEF_VEC_P(decl_t);
-DEF_VEC_ALLOC_P(decl_t,heap);
+DEF_VEC_ALLOC_P(decl_t, heap);
 DEF_VEC_P(reserv_sets_t);
-DEF_VEC_ALLOC_P(reserv_sets_t,heap);
+DEF_VEC_ALLOC_P(reserv_sets_t, heap);
 DEF_VEC_I(vect_el_t);
 DEF_VEC_ALLOC_I(vect_el_t, heap);
-typedef VEC(vect_el_t,heap) *vla_hwint_t;
+typedef VEC(vect_el_t, heap) *vla_hwint_t;
 /* Forward declarations of functions used before their definitions, only.  */
 static regexp_t gen_regexp_sequence    (const char *);
 static void reserv_sets_or             (reserv_sets_t, reserv_sets_t,
 				        reserv_sets_t);
 /* The following field value is order number (0, 1, ...) of given
 insn.  */
 int insn_num;
 /* The following field value is list of bypasses in which given insn
-is output insn.  */
+is output insn.  Bypasses with the same input insn stay one after
+another in the list in the same order as their occurrences in the
+description but the bypass without a guard stays always the last
+in a row of bypasses with the same input insn.  */
 struct bypass_decl *bypass_list;
 /* The following fields are defined by automaton generator.  */
 /* The following field is the insn regexp transformed that
 return name;
 }
 /* Pointers to all declarations during IR generation are stored in the
 following.  */
-static VEC(decl_t,heap) *decls;
+static VEC(decl_t, heap) *decls;
 /* Given a pointer to a (char *) and a separator, return an alloc'ed
 string containing the next separated element, taking parentheses
 into account if PAR_FLAG has nonzero value.  Advance the pointer to
 after the string scanned, or the end-of-string.  Return NULL if at
 DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
 DECL_UNIT (decl)->automaton_name = XSTR (def, 1);
 DECL_UNIT (decl)->query_p = 0;
 DECL_UNIT (decl)->min_occ_cycle_num = -1;
 DECL_UNIT (decl)->in_set_p = 0;
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 }
 /* Process a DEFINE_QUERY_CPU_UNIT.
 decl->mode = dm_unit;
 decl->pos = 0;
 DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
 DECL_UNIT (decl)->automaton_name = XSTR (def, 1);
 DECL_UNIT (decl)->query_p = 1;
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 }
 /* Process a DEFINE_BYPASS.
 	decl->pos = 0;
 	DECL_BYPASS (decl)->latency = XINT (def, 0);
 	DECL_BYPASS (decl)->out_insn_name = out_insns [i];
 	DECL_BYPASS (decl)->in_insn_name = in_insns [j];
 	DECL_BYPASS (decl)->bypass_guard_name = XSTR (def, 3);
-	VEC_safe_push (decl_t,heap, decls, decl);
+	VEC_safe_push (decl_t, heap, decls, decl);
 }
 }
 /* Process an EXCLUSION_SET.
 if (i < first_vect_length)
 DECL_EXCL (decl)->names [i] = first_str_cpu_units [i];
 else
 DECL_EXCL (decl)->names [i]
 	= second_str_cpu_units [i - first_vect_length];
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 /* Process a PRESENCE_SET, a FINAL_PRESENCE_SET, an ABSENCE_SET,
 FINAL_ABSENCE_SET (it is depended on PRESENCE_P and FINAL_P).
 DECL_ABSENCE (decl)->names = str_cpu_units;
 DECL_ABSENCE (decl)->patterns = str_patterns;
 DECL_ABSENCE (decl)->patterns_num = patterns_length;
 DECL_ABSENCE (decl)->final_p = final_p;
 }
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 /* Process a PRESENCE_SET.
 This gives information about a cpu unit reservation requirements.
 {
 decl = XCREATENODE (struct decl);
 decl->mode = dm_automaton;
 decl->pos = 0;
 DECL_AUTOMATON (decl)->name = check_name (str_automata [i], decl->pos);
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 }
 /* Process an AUTOMATA_OPTION.
 decl = XCREATENODE (struct decl);
 decl->mode = dm_reserv;
 decl->pos = 0;
 DECL_RESERV (decl)->name = check_name (XSTR (def, 0), decl->pos);
 DECL_RESERV (decl)->regexp = gen_regexp (XSTR (def, 1));
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 /* Process a DEFINE_INSN_RESERVATION.
 This gives information about the reservation of cpu units by an
 DECL_INSN_RESERV (decl)->name
 = check_name (XSTR (def, 0), decl->pos);
 DECL_INSN_RESERV (decl)->default_latency = XINT (def, 1);
 DECL_INSN_RESERV (decl)->condexp = XEXP (def, 2);
 DECL_INSN_RESERV (decl)->regexp = gen_regexp (XSTR (def, 3));
-VEC_safe_push (decl_t,heap, decls, decl);
+VEC_safe_push (decl_t, heap, decls, decl);
 }
 /* The function evaluates hash value (0..UINT_MAX) of string.  */
 static decl_t
 insert_automaton_decl (decl_t automaton_decl)
 {
 void **entry_ptr;
-entry_ptr = htab_find_slot (automaton_decl_table, automaton_decl, 1);
+entry_ptr = htab_find_slot (automaton_decl_table, automaton_decl, INSERT);
 if (*entry_ptr == NULL)
 *entry_ptr = (void *) automaton_decl;
 return (decl_t) *entry_ptr;
 }
 static decl_t
 insert_insn_decl (decl_t insn_decl)
 {
 void **entry_ptr;
-entry_ptr = htab_find_slot (insn_decl_table, insn_decl, 1);
+entry_ptr = htab_find_slot (insn_decl_table, insn_decl, INSERT);
 if (*entry_ptr == NULL)
 *entry_ptr = (void *) insn_decl;
 return (decl_t) *entry_ptr;
 }
 static decl_t
 insert_decl (decl_t decl)
 {
 void **entry_ptr;
-entry_ptr = htab_find_slot (decl_table, decl, 1);
+entry_ptr = htab_find_slot (decl_table, decl, INSERT);
 if (*entry_ptr == NULL)
 *entry_ptr = (void *) decl;
 return (decl_t) *entry_ptr;
 }
 			  error ("unit `%s' excludes and requires presence of `%s'",
 				 dst->unit_decl->name, unit->name);
 			  no_error_flag = 0;
 			}
 		      else
-			warning
+			warning ("unit `%s' excludes and requires presence of `%s'",
-			  (0, "unit `%s' excludes and requires presence of `%s'",
 			   dst->unit_decl->name, unit->name);
 		    }
 		}
 	    else if (pat->units_num == 1)
 	      for (curr_pat_el = dst->unit_decl->presence_list;
 		if (curr_pat_el->units_num == 1
 		    && unit == curr_pat_el->unit_decls [0])
 		  {
 		    if (!w_flag)
 		      {
-			error
+			error ("unit `%s' requires absence and presence of `%s'",
-			  ("unit `%s' requires absence and presence of `%s'",
+			       dst->unit_decl->name, unit->name);
-			   dst->unit_decl->name, unit->name);
 			no_error_flag = 0;
 		      }
 		    else
-		      warning
+		      warning ("unit `%s' requires absence and presence of `%s'",
-			(0, "unit `%s' requires absence and presence of `%s'",
+			       dst->unit_decl->name, unit->name);
-			 dst->unit_decl->name, unit->name);
 		  }
 	    if (no_error_flag)
 	      {
 		for (prev_el = (presence_p
 				? (final_p
 	  }
 }
 }
-/* The function searches for bypass with given IN_INSN_RESERV in given
+/* The function inserts BYPASS in the list of bypasses of the
-BYPASS_LIST.  */
+corresponding output insn.  The order of bypasses in the list is
-static struct bypass_decl *
+decribed in a comment for member `bypass_list' (see above).  If
-find_bypass (struct bypass_decl *bypass_list,
+there is already the same bypass in the list the function reports
-	     struct insn_reserv_decl *in_insn_reserv)
+this and does nothing.  */
-{
+static void
-struct bypass_decl *bypass;
+insert_bypass (struct bypass_decl *bypass)
+{
-for (bypass = bypass_list; bypass != NULL; bypass = bypass->next)
+struct bypass_decl *curr, *last;
-if (bypass->in_insn_reserv == in_insn_reserv)
+struct insn_reserv_decl *out_insn_reserv = bypass->out_insn_reserv;
-break;
+struct insn_reserv_decl *in_insn_reserv = bypass->in_insn_reserv;
-return bypass;
+for (curr = out_insn_reserv->bypass_list, last = NULL;
+curr != NULL;
+last = curr, curr = curr->next)
+if (curr->in_insn_reserv == in_insn_reserv)
+{
+	if ((bypass->bypass_guard_name != NULL
+	     && curr->bypass_guard_name != NULL
+	     && ! strcmp (bypass->bypass_guard_name, curr->bypass_guard_name))
+	    || bypass->bypass_guard_name == curr->bypass_guard_name)
+	  {
+	    if (bypass->bypass_guard_name == NULL)
+	      {
+		if (!w_flag)
+		  error ("the same bypass `%s - %s' is already defined",
+			 bypass->out_insn_name, bypass->in_insn_name);
+		else
+		  warning ("the same bypass `%s - %s' is already defined",
+			   bypass->out_insn_name, bypass->in_insn_name);
+	      }
+	    else if (!w_flag)
+	      error ("the same bypass `%s - %s' (guard %s) is already defined",
+		     bypass->out_insn_name, bypass->in_insn_name,
+		     bypass->bypass_guard_name);
+	    else
+	      warning
+		("the same bypass `%s - %s' (guard %s) is already defined",
+		 bypass->out_insn_name, bypass->in_insn_name,
+		 bypass->bypass_guard_name);
+	    return;
+	  }
+	if (curr->bypass_guard_name == NULL)
+	  break;
+	if (curr->next == NULL || curr->next->in_insn_reserv != in_insn_reserv)
+	  {
+	    last = curr;
+	    break;
+	  }
+}
+if (last == NULL)
+{
+bypass->next = out_insn_reserv->bypass_list;
+out_insn_reserv->bypass_list = bypass;
+}
+else
+{
+bypass->next = last->next;
+last->next = bypass;
+}
 }
 /* The function processes pipeline description declarations, checks
 their correctness, and forms exclusion/presence/absence sets.  */
 static void
 decl_t decl;
 decl_t automaton_decl;
 decl_t decl_in_table;
 decl_t out_insn_reserv;
 decl_t in_insn_reserv;
-struct bypass_decl *bypass;
 int automaton_presence;
 int i;
 /* Checking repeated automata declarations.  */
 automaton_presence = 0;
 	    {
 	      if (!w_flag)
 		error ("repeated declaration of automaton `%s'",
 		       DECL_AUTOMATON (decl)->name);
 	      else
-		warning (0, "repeated declaration of automaton `%s'",
+		warning ("repeated declaration of automaton `%s'",
 			 DECL_AUTOMATON (decl)->name);
 	    }
 	}
 }
 /* Checking undeclared automata, repeated declarations (except for
 	    {
 	      DECL_BYPASS (decl)->out_insn_reserv
 		= DECL_INSN_RESERV (out_insn_reserv);
 	      DECL_BYPASS (decl)->in_insn_reserv
 		= DECL_INSN_RESERV (in_insn_reserv);
-	      bypass
+	      insert_bypass (DECL_BYPASS (decl));
-		= find_bypass (DECL_INSN_RESERV (out_insn_reserv)->bypass_list,
-			       DECL_BYPASS (decl)->in_insn_reserv);
-	      if (bypass != NULL)
-		{
-		  if (DECL_BYPASS (decl)->latency == bypass->latency)
-		    {
-		      if (!w_flag)
-			error
-			  ("the same bypass `%s - %s' is already defined",
-			   DECL_BYPASS (decl)->out_insn_name,
-			   DECL_BYPASS (decl)->in_insn_name);
-		      else
-			warning
-			  (0, "the same bypass `%s - %s' is already defined",
-			   DECL_BYPASS (decl)->out_insn_name,
-			   DECL_BYPASS (decl)->in_insn_name);
-		    }
-		  else
-		    error ("bypass `%s - %s' is already defined",
-			   DECL_BYPASS (decl)->out_insn_name,
-			   DECL_BYPASS (decl)->in_insn_name);
-		}
-	      else
-		{
-		  DECL_BYPASS (decl)->next
-		    = DECL_INSN_RESERV (out_insn_reserv)->bypass_list;
-		  DECL_INSN_RESERV (out_insn_reserv)->bypass_list
-		    = DECL_BYPASS (decl);
-		}
 	    }
 	}
 }
 /* Check exclusion set declarations and form exclusion sets.  */
 	  && !DECL_AUTOMATON (decl)->automaton_is_used)
 	{
 	  if (!w_flag)
 	    error ("automaton `%s' is not used", DECL_AUTOMATON (decl)->name);
 	  else
-	    warning (0, "automaton `%s' is not used",
+	    warning ("automaton `%s' is not used",
 		     DECL_AUTOMATON (decl)->name);
 	}
 }
 }
 if (decl->mode == dm_unit && !DECL_UNIT (decl)->unit_is_used)
 	{
 	  if (!w_flag)
 	    error ("unit `%s' is not used", DECL_UNIT (decl)->name);
 	  else
-	    warning (0, "unit `%s' is not used", DECL_UNIT (decl)->name);
+	    warning ("unit `%s' is not used", DECL_UNIT (decl)->name);
 	}
 else if (decl->mode == dm_reserv && !DECL_RESERV (decl)->reserv_is_used)
 	{
 	  if (!w_flag)
 	    error ("reservation `%s' is not used", DECL_RESERV (decl)->name);
 	  else
-	    warning (0, "reservation `%s' is not used", DECL_RESERV (decl)->name);
+	    warning ("reservation `%s' is not used", DECL_RESERV (decl)->name);
 	}
 }
 }
 /* The following variable value is number of reservation being
 case rm_allof:
 {
 	int max_cycle = 0;
 	int min_cycle = 0;
 	for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
 	  {
 	    process_regexp_cycles (REGEXP_ALLOF (regexp)->regexps [i],
 				   max_start_cycle, min_start_cycle,
 				   max_finish_cycle, min_finish_cycle);
 case rm_oneof:
 {
 	int max_cycle = 0;
 	int min_cycle = 0;
 	for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
 	  {
 	    process_regexp_cycles (REGEXP_ONEOF (regexp)->regexps [i],
 				   max_start_cycle, min_start_cycle,
 				   max_finish_cycle, min_finish_cycle);
 static alt_state_t
 uniq_sort_alt_states (alt_state_t alt_states_list)
 {
 alt_state_t curr_alt_state;
-VEC(alt_state_t,heap) *alt_states;
+VEC(alt_state_t, heap) *alt_states;
 size_t i;
 size_t prev_unique_state_ind;
 alt_state_t result;
 if (alt_states_list == 0)
 return 0;
 if (alt_states_list->next_alt_state == 0)
 return alt_states_list;
-alt_states = VEC_alloc (alt_state_t,heap, 150);
+alt_states = VEC_alloc (alt_state_t, heap, 150);
 for (curr_alt_state = alt_states_list;
 curr_alt_state != NULL;
 curr_alt_state = curr_alt_state->next_alt_state)
-VEC_safe_push (alt_state_t,heap, alt_states, curr_alt_state);
+VEC_safe_push (alt_state_t, heap, alt_states, curr_alt_state);
 qsort (VEC_address (alt_state_t, alt_states),
 	 VEC_length  (alt_state_t, alt_states),
 	 sizeof (alt_state_t), alt_state_cmp);
 = VEC_index (alt_state_t, alt_states, i);
 VEC_last (alt_state_t, alt_states)->next_sorted_alt_state = 0;
 result = VEC_index (alt_state_t, alt_states, 0);
-VEC_free (alt_state_t,heap, alt_states);
+VEC_free (alt_state_t, heap, alt_states);
 return result;
 }
 /* The function checks equality of alt state lists.  Remember that the
 lists must be already sorted by the previous function.  */
 static state_t
 insert_state (state_t state)
 {
 void **entry_ptr;
-entry_ptr = htab_find_slot (state_table, (void *) state, 1);
+entry_ptr = htab_find_slot (state_table, (void *) state, INSERT);
 if (*entry_ptr == NULL)
 *entry_ptr = (void *) state;
 return (state_t) *entry_ptr;
 }
 void **entry_ptr;
 if (current_automata_list == NULL)
 return NULL;
 entry_ptr = htab_find_slot (automata_list_table,
-			      (void *) current_automata_list, 1);
+			      (void *) current_automata_list, INSERT);
 if (*entry_ptr == NULL)
 *entry_ptr = (void *) current_automata_list;
 else
 free_automata_list (current_automata_list);
 current_automata_list = NULL;
 		      }
 		    break;
 		  default:
 		    break;
 		  }
 	      if (allof_length == 1)
 		REGEXP_SEQUENCE (result)->regexps [i] = allof_op;
 	      else
 		{
 		  allof = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
 /* The following variable value is TRUE if the first annotated message
 about units to automata distribution has been output.  */
 static int annotation_message_reported_p;
+/* The vector contains all decls which are automata.  */
+static VEC(decl_t, heap) *automaton_decls;
 /* The following structure describes usage of a unit in a reservation.  */
 struct unit_usage
 {
 unit_decl_t unit_decl;
 /* The following forms a list of units used on the same cycle in the
-same alternative.  */
+same alternative.  The list is ordered by the correspdoning unit
+declarations and there is no unit declaration duplication in the
+list.  */
 struct unit_usage *next;
 };
 typedef struct unit_usage *unit_usage_t;
 DEF_VEC_P(unit_usage_t);
-DEF_VEC_ALLOC_P(unit_usage_t,heap);
+DEF_VEC_ALLOC_P(unit_usage_t, heap);
 /* Obstack for unit_usage structures.  */
 static struct obstack unit_usages;
 /* VLA for representation of array of pointers to unit usage
 structures.  There is an element for each combination of
 (alternative number, cycle).  Unit usages on given cycle in
 alternative with given number are referred through element with
-index equals to the cycle * number of all alternatives in the regexp
+index equals to the cycle * number of all alternatives in the
-+ the alternative number.  */
+regexp + the alternative number.  */
-static VEC(unit_usage_t,heap) *cycle_alt_unit_usages;
+static VEC(unit_usage_t, heap) *cycle_alt_unit_usages;
 /* The following function creates the structure unit_usage for UNIT on
 CYCLE in REGEXP alternative with ALT_NUM.  The structure is made
 accessed through cycle_alt_unit_usages.  */
 static void
 store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle,
 		      int alt_num)
 {
 size_t length;
 unit_decl_t unit_decl;
-unit_usage_t unit_usage_ptr;
+unit_usage_t unit_usage_ptr, curr, prev;
 int index;
 gcc_assert (regexp && regexp->mode == rm_oneof
 	      && alt_num < REGEXP_ONEOF (regexp)->regexps_num);
 unit_decl = REGEXP_UNIT (unit)->unit_decl;
 length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num;
 while (VEC_length (unit_usage_t, cycle_alt_unit_usages) < length)
-VEC_safe_push (unit_usage_t,heap, cycle_alt_unit_usages, 0);
+VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, 0);
+index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num;
+prev = NULL;
+for (curr = VEC_index (unit_usage_t, cycle_alt_unit_usages, index);
+curr != NULL;
+prev = curr, curr = curr->next)
+if (curr->unit_decl >= unit_decl)
+break;
+if (curr != NULL && curr->unit_decl == unit_decl)
+return;
 obstack_blank (&unit_usages, sizeof (struct unit_usage));
 unit_usage_ptr = (struct unit_usage *) obstack_base (&unit_usages);
 obstack_finish (&unit_usages);
 unit_usage_ptr->unit_decl = unit_decl;
-index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num;
-unit_usage_ptr->next = VEC_index (unit_usage_t, cycle_alt_unit_usages, index);
-VEC_replace (unit_usage_t, cycle_alt_unit_usages, index, unit_usage_ptr);
 unit_decl->last_distribution_check_cycle = -1; /* undefined */
-}
+unit_usage_ptr->next = curr;
+if (prev == NULL)
+VEC_replace (unit_usage_t, cycle_alt_unit_usages, index, unit_usage_ptr);
+else
+prev->next = unit_usage_ptr;
+}
+/* Return true if unit UNIT_DECL is present on the LIST.  */
+static bool
+unit_present_on_list_p (unit_usage_t list, unit_decl_t unit_decl)
+{
+while (list != NULL)
+{
+if (list->unit_decl == unit_decl)
+	return true;
+list = list->next;
+}
+return false;
+}
+/* The function returns true if reservations of alternatives ALT1 and
+ALT2 are equal after excluding reservations of units of
+EXCLUDED_AUTOMATON_DECL.  */
+static bool
+equal_alternatives_p (int alt1, int alt2, int n_alts,
+		      struct automaton_decl *excluded_automaton_decl)
+{
+int i;
+unit_usage_t list1, list2;
+for (i = 0;
+i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages);
+i += n_alts)
+{
+for (list1 = VEC_index (unit_usage_t, cycle_alt_unit_usages, i + alt1),
+	     list2 = VEC_index (unit_usage_t, cycle_alt_unit_usages, i + alt2);;
+	   list1 = list1->next, list2 = list2->next)
+	{
+	  while (list1 != NULL
+		 && list1->unit_decl->automaton_decl == excluded_automaton_decl)
+	    list1 = list1->next;
+	  while (list2 != NULL
+		 && list2->unit_decl->automaton_decl == excluded_automaton_decl)
+	    list2 = list2->next;
+	  if (list1 == NULL || list2 == NULL)
+	    {
+	      if (list1 != list2)
+		return false;
+	      else
+		break;
+	    }
+	  if (list1->unit_decl != list2->unit_decl)
+	    return false;
+	}
+}
+return true;
+}
+DEF_VEC_I(int);
+DEF_VEC_ALLOC_I(int, heap);
 /* The function processes given REGEXP to find units with the wrong
 distribution.  */
 static void
 check_regexp_units_distribution (const char *insn_reserv_name,
 				 regexp_t regexp)
 {
-int i, j, k, cycle;
+int i, j, k, cycle, start, n_alts, alt, alt2;
+bool annotation_reservation_message_reported_p;
 regexp_t seq, allof, unit;
-struct unit_usage *unit_usage_ptr, *other_unit_usage_ptr;
+struct unit_usage *unit_usage_ptr;
+VEC(int, heap) *marked;
 if (regexp == NULL || regexp->mode != rm_oneof)
 return;
 /* Store all unit usages in the regexp:  */
 obstack_init (&unit_usages);
-cycle_alt_unit_usages = 0;
+cycle_alt_unit_usages = VEC_alloc (unit_usage_t, heap, 10);
 for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
 {
 seq = REGEXP_ONEOF (regexp)->regexps [i];
 switch (seq->mode)
 			store_alt_unit_usage (regexp, unit, j, i);
 		      else
 			gcc_assert (unit->mode == rm_nothing);
 		    }
 		  break;
 		case rm_unit:
 		  store_alt_unit_usage (regexp, allof, j, i);
 		  break;
 		case rm_nothing:
 		  break;
 		default:
 		  gcc_unreachable ();
 		}
 	    }
 	  break;
 	      switch (unit->mode)
 		{
 		case rm_unit:
 		  store_alt_unit_usage (regexp, unit, 0, i);
 		  break;
 		case rm_nothing:
 		  break;
 		default:
 		  gcc_unreachable ();
 		}
 	    }
 	  break;
 	  gcc_unreachable ();
 	}
 }
 /* Check distribution:  */
 for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i++)
-{
+for (unit_usage_ptr = VEC_index (unit_usage_t, cycle_alt_unit_usages, i);
-cycle = i / REGEXP_ONEOF (regexp)->regexps_num;
+	 unit_usage_ptr != NULL;
+	 unit_usage_ptr = unit_usage_ptr->next)
+unit_usage_ptr->unit_decl->last_distribution_check_cycle = -1;
+n_alts = REGEXP_ONEOF (regexp)->regexps_num;
+marked = VEC_alloc (int, heap, n_alts);
+for (i = 0; i < n_alts; i++)
+VEC_safe_push (int, heap, marked, 0);
+annotation_reservation_message_reported_p = false;
+for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i++)
+{
+cycle = i / n_alts;
+start = cycle * n_alts;
 for (unit_usage_ptr = VEC_index (unit_usage_t, cycle_alt_unit_usages, i);
 	   unit_usage_ptr != NULL;
 	   unit_usage_ptr = unit_usage_ptr->next)
-	if (cycle != unit_usage_ptr->unit_decl->last_distribution_check_cycle)
+	{
-	  {
+	  if (unit_usage_ptr->unit_decl->last_distribution_check_cycle == cycle)
-	    unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle;
+	    continue;
-	    for (k = cycle * REGEXP_ONEOF (regexp)->regexps_num;
+	  unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle;
-		 k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
+	  for (alt = 0; alt < n_alts; alt++)
-		   && k == cycle * REGEXP_ONEOF (regexp)->regexps_num;
+	    if (! unit_present_on_list_p (VEC_index (unit_usage_t,
-		 k++)
+						     cycle_alt_unit_usages,
-	      {
+						     start + alt),
-		for (other_unit_usage_ptr
+					  unit_usage_ptr->unit_decl))
-		       = VEC_index (unit_usage_t, cycle_alt_unit_usages, k);
+	      break;
-		     other_unit_usage_ptr != NULL;
+	  if (alt >= n_alts)
-		     other_unit_usage_ptr = other_unit_usage_ptr->next)
+	    continue;
-		  if (unit_usage_ptr->unit_decl->automaton_decl
+	  memset (VEC_address (int, marked), 0, n_alts * sizeof (int));
-		      == other_unit_usage_ptr->unit_decl->automaton_decl)
+	  for (alt = 0; alt < n_alts; alt++)
-		    break;
+	    {
-		if (other_unit_usage_ptr == NULL
+	      if (! unit_present_on_list_p (VEC_index (unit_usage_t,
-		    && (VEC_index (unit_usage_t, cycle_alt_unit_usages, k)
+						       cycle_alt_unit_usages,
-			!= NULL))
+						       start + alt),
-		  break;
+					    unit_usage_ptr->unit_decl))
-	      }
+		continue;
-	    if (k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
+	      for (j = 0;
-		&& k == cycle * REGEXP_ONEOF (regexp)->regexps_num)
+		   j < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages);
-	      {
+		   j++)
-		if (!annotation_message_reported_p)
+		{
-		  {
+		  alt2 = j % n_alts;
-		    fprintf (stderr, "\n");
+		  if (! unit_present_on_list_p
-		    error ("The following units do not satisfy units-automata distribution rule");
+		        (VEC_index (unit_usage_t, cycle_alt_unit_usages,
-		    error (" (A unit of given unit automaton should be on each reserv. altern.)");
+				    start + alt2),
-		    annotation_message_reported_p = TRUE;
+			 unit_usage_ptr->unit_decl)
-		  }
+		      && equal_alternatives_p (alt, alt2, n_alts,
-		error ("Unit %s, reserv. %s, cycle %d",
+					       unit_usage_ptr
-		       unit_usage_ptr->unit_decl->name, insn_reserv_name,
+					       ->unit_decl->automaton_decl))
-		       cycle);
+		    {
-	      }
+		      VEC_replace (int, marked, alt, 1);
-	  }
+		      VEC_replace (int, marked, alt2, 1);
-}
+		    }
-VEC_free (unit_usage_t,heap, cycle_alt_unit_usages);
+		}
+	    }
+	  for (alt = 0; alt < n_alts && VEC_index (int, marked, alt); alt++)
+	    ;
+	  if (alt < n_alts && 0)
+	    {
+	      if (! annotation_message_reported_p)
+		{
+		  fprintf (stderr, "\n");
+		  error ("The following units do not satisfy units-automata distribution rule");
+		  error ("(Unit presence on one alt and its absence on other alt\n");
+		  error (" result in different other automata reservations)");
+		  annotation_message_reported_p = TRUE;
+		}
+	      if (! annotation_reservation_message_reported_p)
+		{
+		  error ("Reserv %s:", insn_reserv_name);
+		  annotation_reservation_message_reported_p = true;
+		}
+	      error ("  Unit %s, cycle %d, alt %d, another alt %d",
+		     unit_usage_ptr->unit_decl->name, cycle, i % n_alts, alt);
+	    }
+	}
+}
+VEC_free (int, heap, marked);
+VEC_free (unit_usage_t, heap, cycle_alt_unit_usages);
 obstack_free (&unit_usages, NULL);
 }
 /* The function finds units which violates units to automata
 distribution rule.  If the units exist, report about them.  */
 decl_t decl;
 int i;
 if (progress_flag)
 fprintf (stderr, "Check unit distributions to automata...");
-annotation_message_reported_p = FALSE;
+automaton_decls = NULL;
 for (i = 0; i < description->decls_num; i++)
 {
 decl = description->decls [i];
-if (decl->mode == dm_insn_reserv)
+if (decl->mode == dm_automaton)
-	check_regexp_units_distribution
+	VEC_safe_push (decl_t, heap, automaton_decls, decl);
-	  (DECL_INSN_RESERV (decl)->name,
+}
-	   DECL_INSN_RESERV (decl)->transformed_regexp);
+if (VEC_length (decl_t, automaton_decls) > 1)
-}
+{
+annotation_message_reported_p = FALSE;
+for (i = 0; i < description->decls_num; i++)
+	{
+	  decl = description->decls [i];
+	  if (decl->mode == dm_insn_reserv)
+	    check_regexp_units_distribution
+	      (DECL_INSN_RESERV (decl)->name,
+	       DECL_INSN_RESERV (decl)->transformed_regexp);
+	}
+}
+VEC_free (decl_t, heap, automaton_decls);
 if (progress_flag)
 fprintf (stderr, "done\n");
 }
 if (REGEXP_UNIT (regexp)->unit_decl->corresponding_automaton_num
 == automaton->automaton_order_num)
 set_state_reserv (state_being_formed, curr_cycle,
 REGEXP_UNIT (regexp)->unit_decl->unit_num);
 return curr_cycle;
 case rm_sequence:
 for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
 	curr_cycle
 	  = process_seq_for_forming_states
 	    (REGEXP_SEQUENCE (regexp)->regexps [i], automaton, curr_cycle) + 1;
 case rm_allof:
 {
 	int finish_cycle = 0;
 	int cycle;
 	for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
 	  {
 	    cycle = process_seq_for_forming_states (REGEXP_ALLOF (regexp)
 						    ->regexps [i],
 						    automaton, curr_cycle);
 static void
 form_ainsn_with_same_reservs (automaton_t automaton)
 {
 ainsn_t curr_ainsn;
 size_t i;
-VEC(ainsn_t,heap) *last_insns = VEC_alloc (ainsn_t,heap, 150);
+VEC(ainsn_t, heap) *last_insns = VEC_alloc (ainsn_t, heap, 150);
 for (curr_ainsn = automaton->ainsn_list;
 curr_ainsn != NULL;
 curr_ainsn = curr_ainsn->next_ainsn)
 if (curr_ainsn->insn_reserv_decl
 {
 VEC_safe_push (ainsn_t, heap, last_insns, curr_ainsn);
 curr_ainsn->first_insn_with_same_reservs = 1;
 }
 }
-VEC_free (ainsn_t,heap, last_insns);
+VEC_free (ainsn_t, heap, last_insns);
 }
 /* Forming unit reservations which can affect creating the automaton
 states achieved from a given state.  It permits to build smaller
 automata in many cases.  We would have the same automata after
 state_t state;
 state_t start_state;
 state_t state2;
 ainsn_t advance_cycle_ainsn;
 arc_t added_arc;
-VEC(state_t,heap) *state_stack = VEC_alloc(state_t,heap, 150);
+VEC(state_t, heap) *state_stack = VEC_alloc(state_t, heap, 150);
 int states_n;
 reserv_sets_t reservs_matter = form_reservs_matter (automaton);
 /* Create the start state (empty state).  */
 start_state = insert_state (get_free_state (1, automaton));
 automaton->start_state = start_state;
 start_state->it_was_placed_in_stack_for_NDFA_forming = 1;
-VEC_safe_push (state_t,heap, state_stack, start_state);
+VEC_safe_push (state_t, heap, state_stack, start_state);
 states_n = 1;
 while (VEC_length (state_t, state_stack) != 0)
 {
 state = VEC_pop (state_t, state_stack);
 advance_cycle_ainsn = NULL;
 state2 = states_union (state, state2, reservs_matter);
 if (!state2->it_was_placed_in_stack_for_NDFA_forming)
 {
 state2->it_was_placed_in_stack_for_NDFA_forming
 			      = 1;
-VEC_safe_push (state_t,heap, state_stack, state2);
+VEC_safe_push (state_t, heap, state_stack, state2);
 			    states_n++;
 			    if (progress_flag && states_n % 100 == 0)
 			      fprintf (stderr, ".");
 }
 			added_arc = add_arc (state, state2, ainsn);
 /* Add transition to advance cycle.  */
 state2 = state_shift (state, reservs_matter);
 if (!state2->it_was_placed_in_stack_for_NDFA_forming)
 {
 state2->it_was_placed_in_stack_for_NDFA_forming = 1;
-VEC_safe_push (state_t,heap, state_stack, state2);
+VEC_safe_push (state_t, heap, state_stack, state2);
 	  states_n++;
 	  if (progress_flag && states_n % 100 == 0)
 	    fprintf (stderr, ".");
 }
 gcc_assert (advance_cycle_ainsn);
 add_arc (state, state2, advance_cycle_ainsn);
 }
-VEC_free (state_t,heap, state_stack);
+VEC_free (state_t, heap, state_stack);
 }
 /* Form lists of all arcs of STATE marked by the same ainsn.  */
 static void
 form_arcs_marked_by_insn (state_t state)
 same insn.  If the composed state is not in STATE_STACK yet, it is
 pushed into STATE_STACK.  */
 static int
 create_composed_state (state_t original_state, arc_t arcs_marked_by_insn,
-		       VEC(state_t,heap) **state_stack)
+		       VEC(state_t, heap) **state_stack)
 {
 state_t state;
 alt_state_t alt_state, curr_alt_state;
 alt_state_t new_alt_state;
 arc_t curr_arc;
 }
 }
 if (!state->it_was_placed_in_stack_for_DFA_forming)
 {
 state->it_was_placed_in_stack_for_DFA_forming = 1;
-VEC_safe_push (state_t,heap, *state_stack, state);
+VEC_safe_push (state_t, heap, *state_stack, state);
 }
 return new_state_p;
 }
 /* The function transforms nondeterministic AUTOMATON into
 NDFA_to_DFA (automaton_t automaton)
 {
 state_t start_state;
 state_t state;
 decl_t decl;
-VEC(state_t,heap) *state_stack;
+VEC(state_t, heap) *state_stack;
 int i;
 int states_n;
-state_stack = VEC_alloc (state_t,heap, 0);
+state_stack = VEC_alloc (state_t, heap, 0);
 /* Create the start state (empty state).  */
 start_state = automaton->start_state;
 start_state->it_was_placed_in_stack_for_DFA_forming = 1;
-VEC_safe_push (state_t,heap, state_stack, start_state);
+VEC_safe_push (state_t, heap, state_stack, start_state);
 states_n = 1;
 while (VEC_length (state_t, state_stack) != 0)
 {
 state = VEC_pop (state_t, state_stack);
 form_arcs_marked_by_insn (state);
 	      if (progress_flag && states_n % 100 == 0)
 		fprintf (stderr, ".");
 	    }
 	}
 }
-VEC_free (state_t,heap, state_stack);
+VEC_free (state_t, heap, state_stack);
 }
 /* The following variable value is current number (1, 2, ...) of passing
 graph of states.  */
 static int curr_state_graph_pass_num;
 curr_state_graph_pass_num = 0;
 }
 /* The following vla is used for storing pointers to all achieved
 states.  */
-static VEC(state_t,heap) *all_achieved_states;
+static VEC(state_t, heap) *all_achieved_states;
 /* This function is called by function pass_states to add an achieved
 STATE.  */
 static void
 add_achieved_state (state_t state)
 {
-VEC_safe_push (state_t,heap, all_achieved_states, state);
+VEC_safe_push (state_t, heap, all_achieved_states, state);
 }
 /* The function sets up equivalence numbers of insns which mark all
 out arcs of STATE by equiv_class_num_1 (if ODD_ITERATION_FLAG has
 nonzero value) or by equiv_class_num_2 of the destination state.
 {
 int i, num = 0;
 unsigned int sz;
 sz = (description->query_units_num + sizeof (int) * CHAR_BIT - 1)
 / (sizeof (int) * CHAR_BIT);
 state->presence_signature = XCREATENODEVEC (unsigned int, sz);
 for (i = 0; i < description->units_num; i++)
 if (units_array [i]->query_p)
 {
 	int presence1_p = first_cycle_unit_presence (state, i);
 /* The function makes initial partition of STATES on equivalent
 classes and saves it into *CLASSES.  This function requires the input
 to be sorted via compare_states_for_equiv().  */
 static int
-init_equiv_class (VEC(state_t,heap) *states, VEC (state_t,heap) **classes)
+init_equiv_class (VEC(state_t, heap) *states, VEC (state_t, heap) **classes)
 {
 size_t i;
 state_t prev = 0;
 int class_num = 1;
-*classes = VEC_alloc (state_t,heap, 150);
+*classes = VEC_alloc (state_t, heap, 150);
 for (i = 0; i < VEC_length (state_t, states); i++)
 {
 state_t state = VEC_index (state_t, states, i);
 if (prev)
 {
 	  if (compare_states_for_equiv (&prev, &state) != 0)
 	    {
-	      VEC_safe_push (state_t,heap, *classes, prev);
+	      VEC_safe_push (state_t, heap, *classes, prev);
 	      class_num++;
 	      prev = NULL;
 	    }
 }
 state->equiv_class_num_1 = class_num;
 state->next_equiv_class_state = prev;
 prev = state;
 }
 if (prev)
-VEC_safe_push (state_t,heap, *classes, prev);
+VEC_safe_push (state_t, heap, *classes, prev);
 return class_num;
 }
 /* The function copies pointers to equivalent states from vla FROM
 into vla TO.  */
 static void
-copy_equiv_class (VEC(state_t,heap) **to, VEC(state_t,heap) *from)
+copy_equiv_class (VEC(state_t, heap) **to, VEC(state_t, heap) *from)
 {
-VEC_free (state_t,heap, *to);
+VEC_free (state_t, heap, *to);
-*to = VEC_copy (state_t,heap, from);
+*to = VEC_copy (state_t, heap, from);
 }
 /* The function processes equivalence class given by its first state,
 FIRST_STATE, on odd iteration if ODD_ITERATION_FLAG.  If there
 are not equivalent states, the function partitions the class
 *NEXT_ITERATION_CLASSES, increments *NEW_EQUIV_CLASS_NUM_PTR ans
 assigns it to the state equivalence number.  If the class has been
 partitioned, the function returns nonzero value.  */
 static int
 partition_equiv_class (state_t first_state, int odd_iteration_flag,
-		       VEC(state_t,heap) **next_iteration_classes,
+		       VEC(state_t, heap) **next_iteration_classes,
 		       int *new_equiv_class_num_ptr)
 {
 state_t new_equiv_class;
 int partition_p;
 state_t curr_state;
 		 curr_state = first_state->next_equiv_class_state;
 	       curr_state != NULL;
 	       curr_state = next_state)
 	    {
 	      next_state = curr_state->next_equiv_class_state;
 	      if (state_is_differed (curr_state, first_state,
 				     odd_iteration_flag))
 		{
 		  /* Remove curr state from the class equivalence.  */
 		  prev_state->next_equiv_class_state = next_state;
 		  /* Add curr state to the new class equivalence.  */
 		prev_state = curr_state;
 	    }
 	  clear_arc_insns_equiv_num (first_state);
 	}
 if (new_equiv_class != NULL)
-	VEC_safe_push (state_t,heap, *next_iteration_classes, new_equiv_class);
+	VEC_safe_push (state_t, heap, *next_iteration_classes, new_equiv_class);
 first_state = new_equiv_class;
 }
 return partition_p;
 }
 /* The function finds equivalent states of AUTOMATON.  */
 static void
 evaluate_equiv_classes (automaton_t automaton,
-			VEC(state_t,heap) **equiv_classes)
+			VEC(state_t, heap) **equiv_classes)
 {
 int new_equiv_class_num;
 int odd_iteration_flag;
 int finish_flag;
-VEC (state_t,heap) *next_iteration_classes;
+VEC (state_t, heap) *next_iteration_classes;
 size_t i;
-all_achieved_states = VEC_alloc (state_t,heap, 1500);
+all_achieved_states = VEC_alloc (state_t, heap, 1500);
 pass_states (automaton, add_achieved_state);
 pass_states (automaton, cache_presence);
 qsort (VEC_address (state_t, all_achieved_states),
 	 VEC_length (state_t, all_achieved_states),
 sizeof (state_t), compare_states_for_equiv);
 				   &next_iteration_classes,
 				   &new_equiv_class_num))
 	  finish_flag = 0;
 }
 while (!finish_flag);
-VEC_free (state_t,heap, next_iteration_classes);
+VEC_free (state_t, heap, next_iteration_classes);
-VEC_free (state_t,heap, all_achieved_states);
+VEC_free (state_t, heap, all_achieved_states);
 }
 /* The function merges equivalent states of AUTOMATON.  */
 static void
-merge_states (automaton_t automaton, VEC(state_t,heap) *equiv_classes)
+merge_states (automaton_t automaton, VEC(state_t, heap) *equiv_classes)
 {
 state_t curr_state;
 state_t new_state;
 state_t first_class_state;
 alt_state_t alt_states;
 /* The top level function for minimization of deterministic
 AUTOMATON.  */
 static void
 minimize_DFA (automaton_t automaton)
 {
-VEC(state_t,heap) *equiv_classes = 0;
+VEC(state_t, heap) *equiv_classes = 0;
 evaluate_equiv_classes (automaton, &equiv_classes);
 merge_states (automaton, equiv_classes);
 pass_states (automaton, set_new_cycle_flags);
-VEC_free (state_t,heap, equiv_classes);
+VEC_free (state_t, heap, equiv_classes);
 }
 /* Values of two variables are counted number of states and arcs in an
 automaton.  */
 static int curr_counted_states_num;
 case rm_unit: case rm_reserv:
 {
 	const char *name = (regexp->mode == rm_unit
 			    ? REGEXP_UNIT (regexp)->name
 			    : REGEXP_RESERV (regexp)->name);
 	obstack_grow (&irp, name, strlen (name));
 	break;
 }
 case rm_sequence:
 for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
 	{
 	  if (i != 0)
 	    obstack_1grow (&irp, ',');
 || REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
 obstack_1grow (&irp, ')');
 }
 obstack_1grow (&irp, ')');
 break;
 case rm_oneof:
 for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
 	{
 	  if (i != 0)
 	    obstack_1grow (&irp, '|');
 	  form_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
 	  if (REGEXP_ONEOF (regexp)->regexps[i]->mode == rm_sequence)
 obstack_1grow (&irp, ')');
 	}
 break;
 case rm_repeat:
 {
 	char digits [30];
 	if (REGEXP_REPEAT (regexp)->regexp->mode == rm_sequence
 	    || REGEXP_REPEAT (regexp)->regexp->mode == rm_allof
 	    || REGEXP_REPEAT (regexp)->regexp->mode == rm_oneof)
 	  obstack_1grow (&irp, '(');
 	form_regexp (REGEXP_REPEAT (regexp)->regexp);
 {
 ainsn_t ainsn;
 int insn_value;
 vla_hwint_t translate_vect;
-translate_vect = VEC_alloc (vect_el_t,heap, description->insns_num);
+translate_vect = VEC_alloc (vect_el_t, heap, description->insns_num);
 for (insn_value = 0; insn_value < description->insns_num; insn_value++)
 /* Undefined value */
 VEC_quick_push (vect_el_t, translate_vect,
 		    automaton->insn_equiv_classes_num);
 fprintf (output_file, " ");
 output_translate_vect_name (output_file, automaton);
 fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
 output_vect (translate_vect);
 fprintf (output_file, "};\n\n");
-VEC_free (vect_el_t,heap, translate_vect);
+VEC_free (vect_el_t, heap, translate_vect);
 }
 /* The value in a table state x ainsn -> something which represents
 undefined value.  */
 static int undefined_vect_el_value;
 int i;
 tab = XCREATENODE (struct state_ainsn_table);
 tab->automaton = automaton;
-tab->comb_vect  = VEC_alloc (vect_el_t,heap, 10000);
+tab->comb_vect  = VEC_alloc (vect_el_t, heap, 10000);
-tab->check_vect = VEC_alloc (vect_el_t,heap, 10000);
+tab->check_vect = VEC_alloc (vect_el_t, heap, 10000);
 tab->base_vect  = 0;
-VEC_safe_grow (vect_el_t,heap, tab->base_vect,
+VEC_safe_grow (vect_el_t, heap, tab->base_vect,
 		 automaton->achieved_states_num);
 full_vect_length = (automaton->insn_equiv_classes_num
 * automaton->achieved_states_num);
-tab->full_vect  = VEC_alloc (vect_el_t,heap, full_vect_length);
+tab->full_vect  = VEC_alloc (vect_el_t, heap, full_vect_length);
 for (i = 0; i < full_vect_length; i++)
 VEC_quick_push (vect_el_t, tab->full_vect, undefined_vect_el_value);
 tab->min_base_vect_el_value = 0;
 tab->max_base_vect_el_value = 0;
 real_vect_length = tab->automaton->insn_equiv_classes_num;
 /* Form full vector in the table: */
 {
 size_t full_base = tab->automaton->insn_equiv_classes_num * vect_num;
 if (VEC_length (vect_el_t, tab->full_vect) < full_base + vect_length)
-VEC_safe_grow (vect_el_t,heap, tab->full_vect,
+VEC_safe_grow (vect_el_t, heap, tab->full_vect,
 		     full_base + vect_length);
 for (i = 0; i < vect_length; i++)
 VEC_replace (vect_el_t, tab->full_vect, full_base + i,
 		   VEC_index (vect_el_t, vect, i));
 }
 /* Expand comb and check vectors.  */
 vect_el = undefined_vect_el_value;
 no_state_value = tab->automaton->achieved_states_num;
 while (additional_els_num > 0)
 {
-VEC_safe_push (vect_el_t,heap, tab->comb_vect, vect_el);
+VEC_safe_push (vect_el_t, heap, tab->comb_vect, vect_el);
-VEC_safe_push (vect_el_t,heap, tab->check_vect, no_state_value);
+VEC_safe_push (vect_el_t, heap, tab->check_vect, no_state_value);
 additional_els_num--;
 }
 gcc_assert (VEC_length (vect_el_t, tab->comb_vect)
 	      >= comb_vect_index + real_vect_length);
 /* Fill comb and check vectors.  */
 gcc_assert (ainsn);
 equiv_class_num = ainsn->insn_equiv_class_num;
 for (vect_index = VEC_length (vect_el_t, *vect);
 vect_index <= equiv_class_num;
 vect_index++)
-VEC_safe_push (vect_el_t,heap, *vect, undefined_vect_el_value);
+VEC_safe_push (vect_el_t, heap, *vect, undefined_vect_el_value);
 VEC_replace (vect_el_t, *vect, equiv_class_num, el_value);
 }
 /* This is for forming vector of states of an automaton.  */
-static VEC(state_t,heap) *output_states_vect;
+static VEC(state_t, heap) *output_states_vect;
 /* The function is called by function pass_states.  The function adds
 STATE to `output_states_vect'.  */
 static void
 add_states_vect_el (state_t state)
 {
-VEC_safe_push (state_t,heap, output_states_vect, state);
+VEC_safe_push (state_t, heap, output_states_vect, state);
 }
 /* Form and output vectors (comb, check, base or full vector)
 representing transition table of AUTOMATON.  */
 static void
 output_state_ainsn_table
 (automaton->trans_table, "state transitions",
 output_trans_full_vect_name, output_trans_comb_vect_name,
 output_trans_check_vect_name, output_trans_base_vect_name);
-VEC_free (state_t,heap, output_states_vect);
+VEC_free (state_t, heap, output_states_vect);
-VEC_free (vect_el_t,heap, transition_vect);
+VEC_free (vect_el_t, heap, transition_vect);
 }
 /* The current number of passing states to find minimal issue delay
 value for an ainsn and state.  */
 static int curr_state_pass_num;
 output_states_vect = 0;
 pass_states (automaton, add_states_vect_el);
 min_issue_delay_len = (VEC_length (state_t, output_states_vect)
 			 * automaton->insn_equiv_classes_num);
-min_issue_delay_vect = VEC_alloc (vect_el_t,heap, min_issue_delay_len);
+min_issue_delay_vect = VEC_alloc (vect_el_t, heap, min_issue_delay_len);
 for (i = 0; i < min_issue_delay_len; i++)
 VEC_quick_push (vect_el_t, min_issue_delay_vect, 0);
 automaton->max_min_delay = 0;
 for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
 cfactor = 1;
 automaton->min_issue_delay_table_compression_factor = cfactor;
 compressed_min_issue_delay_len = (min_issue_delay_len+cfactor-1) / cfactor;
 compressed_min_issue_delay_vect
-= VEC_alloc (vect_el_t,heap, compressed_min_issue_delay_len);
+= VEC_alloc (vect_el_t, heap, compressed_min_issue_delay_len);
 for (i = 0; i < compressed_min_issue_delay_len; i++)
 VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, 0);
 for (i = 0; i < min_issue_delay_len; i++)
 cx |= x << (8 - (i % cfactor + 1) * (8 / cfactor));
 VEC_replace (vect_el_t, compressed_min_issue_delay_vect, ci, cx);
 }
 output_vect (compressed_min_issue_delay_vect);
 fprintf (output_file, "};\n\n");
-VEC_free (state_t,heap, output_states_vect);
+VEC_free (state_t, heap, output_states_vect);
-VEC_free (vect_el_t,heap, min_issue_delay_vect);
+VEC_free (vect_el_t, heap, min_issue_delay_vect);
-VEC_free (vect_el_t,heap, compressed_min_issue_delay_vect);
+VEC_free (vect_el_t, heap, compressed_min_issue_delay_vect);
 }
 /* Form and output vector representing the locked states of
 AUTOMATON.  */
 static void
 first).  */
 automaton->locked_states = 0;
 output_states_vect = 0;
 pass_states (automaton, add_states_vect_el);
-VEC_safe_grow (vect_el_t,heap, dead_lock_vect,
+VEC_safe_grow (vect_el_t, heap, dead_lock_vect,
 		 VEC_length (state_t, output_states_vect));
 for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
 {
 state_t s = VEC_index (state_t, output_states_vect, i);
 arc = first_out_arc (s);
 fprintf (output_file, " ");
 output_dead_lock_vect_name (output_file, automaton);
 fprintf (output_file, "[] = {\n");
 output_vect (dead_lock_vect);
 fprintf (output_file, "};\n\n");
-VEC_free (state_t,heap, output_states_vect);
+VEC_free (state_t, heap, output_states_vect);
-VEC_free (vect_el_t,heap, dead_lock_vect);
+VEC_free (vect_el_t, heap, dead_lock_vect);
 }
 /* Form and output vector representing reserved units of the states of
 AUTOMATON.  */
 static void
 /* Create vector.  */
 state_byte_size = (description->query_units_num + 7) / 8;
 reserved_units_size = (VEC_length (state_t, output_states_vect)
 			 * state_byte_size);
-reserved_units_table = VEC_alloc (vect_el_t,heap, reserved_units_size);
+reserved_units_table = VEC_alloc (vect_el_t, heap, reserved_units_size);
 for (i = 0; i < reserved_units_size; i++)
 VEC_quick_push (vect_el_t, reserved_units_table, 0);
 for (n = 0; n < VEC_length (state_t, output_states_vect); n++)
 {
 state_t s = VEC_index (state_t, output_states_vect, n);
 fprintf (output_file, "[] = {\n");
 output_vect (reserved_units_table);
 fprintf (output_file, "};\n#endif /* #if %s */\n\n",
 	   CPU_UNITS_QUERY_MACRO_NAME);
-VEC_free (state_t,heap, output_states_vect);
+VEC_free (state_t, heap, output_states_vect);
-VEC_free (vect_el_t,heap, reserved_units_table);
+VEC_free (vect_el_t, heap, reserved_units_table);
 }
 /* The function outputs all tables representing DFA(s) used for fast
 pipeline hazards recognition.  */
 static void
 	   INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN2_CODE_NAME,
 	   CHIP_NAME);
 fprintf (output_file, "}\n\n");
 }
 /* Output the array holding default latency values.  These are used in
 insn_latency and maximal_insn_latency function implementations.  */
 static void
 output_default_latencies (void)
 {
 int i, j, col;
 	    gcc_assert (bypass->in_insn_reserv->insn_num
 			!= (DECL_INSN_RESERV
 			    (advance_cycle_insn_decl)->insn_num));
 	    fprintf (output_file, "        case %d:\n",
 		     bypass->in_insn_reserv->insn_num);
-	    if (bypass->bypass_guard_name == NULL)
+	    for (;;)
-	      fprintf (output_file, "          return %d;\n",
-		       bypass->latency);
-	    else
 	      {
-		fprintf (output_file,
+		if (bypass->bypass_guard_name == NULL)
-			 "          if (%s (%s, %s))\n",
+		  {
-			 bypass->bypass_guard_name, INSN_PARAMETER_NAME,
+		    gcc_assert (bypass->next == NULL
-			 INSN2_PARAMETER_NAME);
+				|| (bypass->in_insn_reserv
-		fprintf (output_file,
+				    != bypass->next->in_insn_reserv));
-			 "            return %d;\n          break;\n",
+		    fprintf (output_file, "          return %d;\n",
-			 bypass->latency);
+			     bypass->latency);
+		  }
+		else
+		  {
+		    fprintf (output_file,
+			     "          if (%s (%s, %s))\n",
+			     bypass->bypass_guard_name, INSN_PARAMETER_NAME,
+			     INSN2_PARAMETER_NAME);
+		    fprintf (output_file, "            return %d;\n",
+			     bypass->latency);
+		  }
+		if (bypass->next == NULL
+		    || bypass->in_insn_reserv != bypass->next->in_insn_reserv)
+		  break;
+		bypass = bypass->next;
 	      }
+	    if (bypass->bypass_guard_name != NULL)
+	      fprintf (output_file, "          break;\n");
 	  }
 	fputs ("        }\n      break;\n", output_file);
 }
 fprintf (output_file, "    }\n  return default_latencies[%s];\n}\n\n",
 decl = description->decls [i];
 if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
 	{
 	  gcc_assert (j == DECL_INSN_RESERV (decl)->insn_num);
 	  j++;
 	  fprintf (output_file, "\n      \"%s\",",
 		   regexp_representation (DECL_INSN_RESERV (decl)->regexp));
 	  finish_regexp_representation ();
 	}
 }
 fprintf (output_description_file, "\n\n");
 }
 /* The following variable is used for forming array of all possible cpu unit
 reservations described by the current DFA state.  */
-static VEC(reserv_sets_t,heap) *state_reservs;
+static VEC(reserv_sets_t, heap) *state_reservs;
 /* The function forms `state_reservs' for STATE.  */
 static void
 add_state_reservs (state_t state)
 {
 for (curr_alt_state = state->component_states;
 curr_alt_state != NULL;
 curr_alt_state = curr_alt_state->next_sorted_alt_state)
 add_state_reservs (curr_alt_state->state);
 else
-VEC_safe_push (reserv_sets_t,heap, state_reservs, state->reservs);
+VEC_safe_push (reserv_sets_t, heap, state_reservs, state->reservs);
 }
 /* The function outputs readable representation of all out arcs of
 STATE.  */
 static void
 add_state_reservs (state);
 qsort (VEC_address (reserv_sets_t, state_reservs),
 	 VEC_length (reserv_sets_t, state_reservs),
 sizeof (reserv_sets_t), state_reservs_cmp);
 remove_state_duplicate_reservs ();
-for (i = 1; i < VEC_length (reserv_sets_t, state_reservs); i++)
+for (i = 0; i < VEC_length (reserv_sets_t, state_reservs); i++)
 {
 fprintf (output_description_file, "    ");
 output_reserv_sets (output_description_file,
 			  VEC_index (reserv_sets_t, state_reservs, i));
 fprintf (output_description_file, "\n");
 }
 fprintf (output_description_file, "\n");
 output_state_arcs (state);
-VEC_free (reserv_sets_t,heap, state_reservs);
+VEC_free (reserv_sets_t, heap, state_reservs);
 }
 /* The following function output readable representation of
 DFAs used for fast recognition of pipeline hazards.  */
 static void
 		  if (!w_flag)
 		    error ("Automaton `%s': Insn `%s' will never be issued",
 			   automaton->corresponding_automaton_decl->name,
 			   reserv_ainsn->insn_reserv_decl->name);
 		  else
-		    warning
+		    warning ("Automaton `%s': Insn `%s' will never be issued",
-		      (0, "Automaton `%s': Insn `%s' will never be issued",
+			     automaton->corresponding_automaton_decl->name,
-		       automaton->corresponding_automaton_decl->name,
+			     reserv_ainsn->insn_reserv_decl->name);
-		       reserv_ainsn->insn_reserv_decl->name);
 		}
 	      else
 		{
 		  if (!w_flag)
 		    error ("Insn `%s' will never be issued",
 			   reserv_ainsn->insn_reserv_decl->name);
 		  else
-		    warning (0, "Insn `%s' will never be issued",
+		    warning ("Insn `%s' will never be issued",
 			     reserv_ainsn->insn_reserv_decl->name);
 		}
 	  }
 }
 }
 /* The following vla is used for storing pointers to all achieved
 states.  */
-static VEC(state_t,heap) *automaton_states;
+static VEC(state_t, heap) *automaton_states;
 /* This function is called by function pass_states to add an achieved
 STATE.  */
 static void
 add_automaton_state (state_t state)
 {
-VEC_safe_push (state_t,heap, automaton_states, state);
+VEC_safe_push (state_t, heap, automaton_states, state);
 }
 /* The following function forms list of important automata (whose
 states may be changed after the insn issue) for each insn.  */
 static void
 		     ainsn = ainsn->next_same_reservs_insn)
 		  ainsn->important_p = TRUE;
 	      }
 	}
 }
-VEC_free (state_t,heap, automaton_states);
+VEC_free (state_t, heap, automaton_states);
 /* Create automata sets for the insns.  */
 for (i = 0; i < description->decls_num; i++)
 {
 decl = description->decls [i];
 }
 if (have_error)
 return FATAL_EXIT_CODE;
-puts ("/* Generated automatically by the program `genautomata'\n"
-	"   from the machine description file `md'.  */\n\n"
-	"#include \"config.h\"\n"
-	"#include \"system.h\"\n"
-	"#include \"coretypes.h\"\n"
-	"#include \"tm.h\"\n"
-	"#include \"rtl.h\"\n"
-	"#include \"tm_p.h\"\n"
-	"#include \"insn-config.h\"\n"
-	"#include \"recog.h\"\n"
-	"#include \"regs.h\"\n"
-	"#include \"real.h\"\n"
-	"#include \"output.h\"\n"
-	"#include \"insn-attr.h\"\n"
-	"#include \"toplev.h\"\n"
-	"#include \"flags.h\"\n"
-	"#include \"function.h\"\n");
 if (VEC_length (decl_t, decls) > 0)
 {
 expand_automata ();
-write_automata ();
+if (!have_error)
+	{
+	  puts ("/* Generated automatically by the program `genautomata'\n"
+		"   from the machine description file `md'.  */\n\n"
+		"#include \"config.h\"\n"
+		"#include \"system.h\"\n"
+		"#include \"coretypes.h\"\n"
+		"#include \"tm.h\"\n"
+		"#include \"rtl.h\"\n"
+		"#include \"tm_p.h\"\n"
+		"#include \"insn-config.h\"\n"
+		"#include \"recog.h\"\n"
+		"#include \"regs.h\"\n"
+		"#include \"real.h\"\n"
+		"#include \"output.h\"\n"
+		"#include \"insn-attr.h\"\n"
+		"#include \"toplev.h\"\n"
+		"#include \"flags.h\"\n"
+		"#include \"function.h\"\n");
+	  write_automata ();
+	}
 }
 fflush (stdout);
-return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
+return (ferror (stdout) != 0 || have_error
-}
+	  ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/genautomata.c @ 55:77e2b8dfacca gcc-4.4.5