--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gcc/genautomata.c	Fri Jul 17 14:47:48 2009 +0900
@@ -0,0 +1,9424 @@
+/* Pipeline hazard description translator.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
+   Free Software Foundation, Inc.
+
+   Written by Vladimir Makarov <vmakarov@redhat.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 3, or (at your option) any
+later version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+/* References:
+
+   1. 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.
+
+   2. 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
+   following:
+
+   1. New operator `|' (alternative) is permitted in functional unit
+      reservation which can be treated deterministically and
+      non-deterministically.
+
+   2. Possibility of usage of nondeterministic automata too.
+
+   3. Possibility to query functional unit reservations for given
+      automaton state.
+
+   4. Several constructions to describe impossible reservations
+      (`exclusion_set', `presence_set', `final_presence_set',
+      `absence_set', and `final_absence_set').
+
+   5. No reverse automata are generated.  Trace instruction scheduling
+      requires this.  It can be easily added in the future if we
+      really need this.
+
+   6. Union of automaton states are not generated yet.  It is planned
+      to be implemented.  Such feature is needed to make more accurate
+      interlock insn scheduling to get state describing functional
+      unit reservation in a joint CFG point.  */
+
+/* This file code processes constructions of machine description file
+   which describes automaton used for recognition of processor pipeline
+   hazards by insn scheduler and can be used for other tasks (such as
+   VLIW insn packing.
+
+   The translator functions `gen_cpu_unit', `gen_query_cpu_unit',
+   `gen_bypass', `gen_excl_set', `gen_presence_set',
+   `gen_final_presence_set', `gen_absence_set',
+   `gen_final_absence_set', `gen_automaton', `gen_automata_option',
+   `gen_reserv', `gen_insn_reserv' are called from file
+   `genattrtab.c'.  They transform RTL constructions describing
+   automata in .md file into internal representation convenient for
+   further processing.
+
+   The translator major function `expand_automata' processes the
+   description internal representation into finite state automaton.
+   It can be divided on:
+
+     o checking correctness of the automaton pipeline description
+       (major function is `check_all_description').
+
+     o generating automaton (automata) from the description (major
+       function is `make_automaton').
+
+     o optional transformation of nondeterministic finite state
+       automata into deterministic ones if the alternative operator
+       `|' is treated nondeterministically in the description (major
+       function is NDFA_to_DFA).
+
+     o optional minimization of the finite state automata by merging
+       equivalent automaton states (major function is `minimize_DFA').
+
+     o forming tables (some as comb vectors) and attributes
+       representing the automata (functions output_..._table).
+
+   Function `write_automata' outputs the created finite state
+   automaton as different tables and functions which works with the
+   automata to inquire automaton state and to change its state.  These
+   function are used by gcc instruction scheduler and may be some
+   other gcc code.  */
+
+#include "bconfig.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "rtl.h"
+#include "obstack.h"
+#include "errors.h"
+#include "gensupport.h"
+
+#include <math.h>
+#include "hashtab.h"
+#include "vec.h"
+
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+
+/* Positions in machine description file.  Now they are not used.  But
+   they could be used in the future for better diagnostic messages.  */
+typedef int pos_t;
+
+/* The following is element of vector of current (and planned in the
+   future) functional unit reservations.  */
+typedef unsigned HOST_WIDE_INT set_el_t;
+
+/* Reservations of function units are represented by value of the following
+   type.  */
+typedef set_el_t *reserv_sets_t;
+typedef const set_el_t *const_reserv_sets_t;
+
+/* The following structure describes a ticker.  */
+struct ticker
+{
+  /* The following member value is time of the ticker creation with
+     taking into account time when the ticker is off.  Active time of
+     the ticker is current time minus the value.  */
+  int modified_creation_time;
+  /* The following member value is time (incremented by one) when the
+     ticker was off.  Zero value means that now the ticker is on.  */
+  int incremented_off_time;
+};
+
+/* The ticker is represented by the following type.  */
+typedef struct ticker ticker_t;
+
+/* The following type describes elements of output vectors.  */
+typedef HOST_WIDE_INT vect_el_t;
+
+/* Forward declaration of structures of internal representation of
+   pipeline description based on NDFA.  */
+
+struct unit_decl;
+struct bypass_decl;
+struct result_decl;
+struct automaton_decl;
+struct unit_pattern_rel_decl;
+struct reserv_decl;
+struct insn_reserv_decl;
+struct decl;
+struct unit_regexp;
+struct result_regexp;
+struct reserv_regexp;
+struct nothing_regexp;
+struct sequence_regexp;
+struct repeat_regexp;
+struct allof_regexp;
+struct oneof_regexp;
+struct regexp;
+struct description;
+struct unit_set_el;
+struct pattern_set_el;
+struct pattern_reserv;
+struct state;
+struct alt_state;
+struct arc;
+struct ainsn;
+struct automaton;
+struct state_ainsn_table;
+
+/* The following typedefs are for brevity.  */
+typedef struct unit_decl *unit_decl_t;
+typedef const struct unit_decl *const_unit_decl_t;
+typedef struct decl *decl_t;
+typedef const struct decl *const_decl_t;
+typedef struct regexp *regexp_t;
+typedef struct unit_set_el *unit_set_el_t;
+typedef struct pattern_set_el *pattern_set_el_t;
+typedef struct pattern_reserv *pattern_reserv_t;
+typedef struct alt_state *alt_state_t;
+typedef struct state *state_t;
+typedef const struct state *const_state_t;
+typedef struct arc *arc_t;
+typedef struct ainsn *ainsn_t;
+typedef struct automaton *automaton_t;
+typedef struct automata_list_el *automata_list_el_t;
+typedef const struct automata_list_el *const_automata_list_el_t;
+typedef struct state_ainsn_table *state_ainsn_table_t;
+
+/* Undefined position.  */
+static pos_t no_pos = 0;
+
+/* All IR is stored in the following obstack.  */
+static struct obstack irp;
+
+
+/* Declare vector types for various data structures: */
+
+DEF_VEC_P(alt_state_t);
+DEF_VEC_ALLOC_P(alt_state_t,heap);
+DEF_VEC_P(ainsn_t);
+DEF_VEC_ALLOC_P(ainsn_t,heap);
+DEF_VEC_P(state_t);
+DEF_VEC_ALLOC_P(state_t,heap);
+DEF_VEC_P(decl_t);
+DEF_VEC_ALLOC_P(decl_t,heap);
+DEF_VEC_P(reserv_sets_t);
+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;
+
+/* 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);
+static reserv_sets_t get_excl_set      (reserv_sets_t);
+static int check_presence_pattern_sets (reserv_sets_t,
+					reserv_sets_t, int);
+static int check_absence_pattern_sets  (reserv_sets_t, reserv_sets_t,
+					int);
+static arc_t first_out_arc             (const_state_t);
+static arc_t next_out_arc              (arc_t);
+
+
+
+/* Options with the following names can be set up in automata_option
+   construction.  Because the strings occur more one time we use the
+   macros.  */
+
+#define NO_MINIMIZATION_OPTION "-no-minimization"
+#define TIME_OPTION "-time"
+#define STATS_OPTION "-stats"
+#define V_OPTION "-v"
+#define W_OPTION "-w"
+#define NDFA_OPTION "-ndfa"
+#define PROGRESS_OPTION "-progress"
+
+/* The following flags are set up by function `initiate_automaton_gen'.  */
+
+/* Make automata with nondeterministic reservation by insns (`-ndfa').  */
+static int ndfa_flag;
+
+/* Do not make minimization of DFA (`-no-minimization').  */
+static int no_minimization_flag;
+
+/* Value of this variable is number of automata being generated.  The
+   actual number of automata may be less this value if there is not
+   sufficient number of units.  This value is defined by argument of
+   option `-split' or by constructions automaton if the value is zero
+   (it is default value of the argument).  */
+static int split_argument;
+
+/* Flag of output time statistics (`-time').  */
+static int time_flag;
+
+/* Flag of automata statistics (`-stats').  */
+static int stats_flag;
+
+/* Flag of creation of description file which contains description of
+   result automaton and statistics information (`-v').  */
+static int v_flag;
+
+/* Flag of output of a progress bar showing how many states were
+   generated so far for automaton being processed (`-progress').  */
+static int progress_flag;
+
+/* Flag of generating warning instead of error for non-critical errors
+   (`-w').  */
+static int w_flag;
+
+
+/* Output file for pipeline hazard recognizer (PHR) being generated.
+   The value is NULL if the file is not defined.  */
+static FILE *output_file;
+
+/* Description file of PHR.  The value is NULL if the file is not
+   created.  */
+static FILE *output_description_file;
+
+/* PHR description file name.  */
+static char *output_description_file_name;
+
+/* Value of the following variable is node representing description
+   being processed.  This is start point of IR.  */
+static struct description *description;
+
+
+
+/* This page contains description of IR structure (nodes).  */
+
+enum decl_mode
+{
+  dm_unit,
+  dm_bypass,
+  dm_automaton,
+  dm_excl,
+  dm_presence,
+  dm_absence,
+  dm_reserv,
+  dm_insn_reserv
+};
+
+/* This describes define_cpu_unit and define_query_cpu_unit (see file
+   rtl.def).  */
+struct unit_decl
+{
+  const char *name;
+  /* NULL if the automaton name is absent.  */
+  const char *automaton_name;
+  /* If the following value is not zero, the cpu unit reservation is
+     described in define_query_cpu_unit.  */
+  char query_p;
+
+  /* The following fields are defined by checker.  */
+
+  /* The following field value is nonzero if the unit is used in an
+     regexp.  */
+  char unit_is_used;
+
+  /* The following field value is order number (0, 1, ...) of given
+     unit.  */
+  int unit_num;
+  /* The following field value is corresponding declaration of
+     automaton which was given in description.  If the field value is
+     NULL then automaton in the unit declaration was absent.  */
+  struct automaton_decl *automaton_decl;
+  /* The following field value is maximal cycle number (1, ...) on
+     which given unit occurs in insns.  Zero value means that given
+     unit is not used in insns.  */
+  int max_occ_cycle_num;
+  /* The following field value is minimal cycle number (0, ...) on
+     which given unit occurs in insns.  -1 value means that given
+     unit is not used in insns.  */
+  int min_occ_cycle_num;
+  /* The following list contains units which conflict with given
+     unit.  */
+  unit_set_el_t excl_list;
+  /* The following list contains patterns which are required to
+     reservation of given unit.  */
+  pattern_set_el_t presence_list;
+  pattern_set_el_t final_presence_list;
+  /* The following list contains patterns which should be not present
+     in reservation for given unit.  */
+  pattern_set_el_t absence_list;
+  pattern_set_el_t final_absence_list;
+  /* The following is used only when `query_p' has nonzero value.
+     This is query number for the unit.  */
+  int query_num;
+  /* The following is the last cycle on which the unit was checked for
+     correct distributions of units to automata in a regexp.  */
+  int last_distribution_check_cycle;
+
+  /* The following fields are defined by automaton generator.  */
+
+  /* The following field value is number of the automaton to which
+     given unit belongs.  */
+  int corresponding_automaton_num;
+  /* If the following value is not zero, the cpu unit is present in a
+     `exclusion_set' or in right part of a `presence_set',
+     `final_presence_set', `absence_set', and
+     `final_absence_set'define_query_cpu_unit.  */
+  char in_set_p;
+};
+
+/* This describes define_bypass (see file rtl.def).  */
+struct bypass_decl
+{
+  int latency;
+  const char *out_insn_name;
+  const char *in_insn_name;
+  const char *bypass_guard_name;
+
+  /* The following fields are defined by checker.  */
+
+  /* output and input insns of given bypass.  */
+  struct insn_reserv_decl *out_insn_reserv;
+  struct insn_reserv_decl *in_insn_reserv;
+  /* The next bypass for given output insn.  */
+  struct bypass_decl *next;
+};
+
+/* This describes define_automaton (see file rtl.def).  */
+struct automaton_decl
+{
+  const char *name;
+
+  /* The following fields are defined by automaton generator.  */
+
+  /* The following field value is nonzero if the automaton is used in
+     an regexp definition.  */
+  char automaton_is_used;
+
+  /* The following fields are defined by checker.  */
+
+  /* The following field value is the corresponding automaton.  This
+     field is not NULL only if the automaton is present in unit
+     declarations and the automatic partition on automata is not
+     used.  */
+  automaton_t corresponding_automaton;
+};
+
+/* This describes exclusion relations: exclusion_set (see file
+   rtl.def).  */
+struct excl_rel_decl
+{
+  int all_names_num;
+  int first_list_length;
+  char *names [1];
+};
+
+/* This describes unit relations: [final_]presence_set or
+   [final_]absence_set (see file rtl.def).  */
+struct unit_pattern_rel_decl
+{
+  int final_p;
+  int names_num;
+  int patterns_num;
+  char **names;
+  char ***patterns;
+};
+
+/* This describes define_reservation (see file rtl.def).  */
+struct reserv_decl
+{
+  const char *name;
+  regexp_t regexp;
+
+  /* The following fields are defined by checker.  */
+
+  /* The following field value is nonzero if the unit is used in an
+     regexp.  */
+  char reserv_is_used;
+  /* The following field is used to check up cycle in expression
+     definition.  */
+  int loop_pass_num;
+};
+
+/* This describes define_insn_reservation (see file rtl.def).  */
+struct insn_reserv_decl
+{
+  rtx condexp;
+  int default_latency;
+  regexp_t regexp;
+  const char *name;
+
+  /* The following fields are defined by checker.  */
+
+  /* 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.  */
+  struct bypass_decl *bypass_list;
+
+  /* The following fields are defined by automaton generator.  */
+
+  /* The following field is the insn regexp transformed that
+     the regexp has not optional regexp, repetition regexp, and an
+     reservation name (i.e. reservation identifiers are changed by the
+     corresponding regexp) and all alternations are the top level
+     of the regexp.  The value can be NULL only if it is special
+     insn `cycle advancing'.  */
+  regexp_t transformed_regexp;
+  /* The following field value is list of arcs marked given
+     insn.  The field is used in transformation NDFA -> DFA.  */
+  arc_t arcs_marked_by_insn;
+  /* The two following fields are used during minimization of a finite state
+     automaton.  */
+  /* The field value is number of equivalence class of state into
+     which arc marked by given insn enters from a state (fixed during
+     an automaton minimization).  */
+  int equiv_class_num;
+  /* The following member value is the list to automata which can be
+     changed by the insn issue.  */
+  automata_list_el_t important_automata_list;
+  /* The following member is used to process insn once for output.  */
+  int processed_p;
+};
+
+/* This contains a declaration mentioned above.  */
+struct decl
+{
+  /* What node in the union? */
+  enum decl_mode mode;
+  pos_t pos;
+  union
+  {
+    struct unit_decl unit;
+    struct bypass_decl bypass;
+    struct automaton_decl automaton;
+    struct excl_rel_decl excl;
+    struct unit_pattern_rel_decl presence;
+    struct unit_pattern_rel_decl absence;
+    struct reserv_decl reserv;
+    struct insn_reserv_decl insn_reserv;
+  } decl;
+};
+
+/* The following structures represent parsed reservation strings.  */
+enum regexp_mode
+{
+  rm_unit,
+  rm_reserv,
+  rm_nothing,
+  rm_sequence,
+  rm_repeat,
+  rm_allof,
+  rm_oneof
+};
+
+/* Cpu unit in reservation.  */
+struct unit_regexp
+{
+  const char *name;
+  unit_decl_t unit_decl;
+};
+
+/* Define_reservation in a reservation.  */
+struct reserv_regexp
+{
+  const char *name;
+  struct reserv_decl *reserv_decl;
+};
+
+/* Absence of reservation (represented by string `nothing').  */
+struct nothing_regexp
+{
+  /* This used to be empty but ISO C doesn't allow that.  */
+  char unused;
+};
+
+/* Representation of reservations separated by ',' (see file
+   rtl.def).  */
+struct sequence_regexp
+{
+  int regexps_num;
+  regexp_t regexps [1];
+};
+
+/* Representation of construction `repeat' (see file rtl.def).  */
+struct repeat_regexp
+{
+  int repeat_num;
+  regexp_t regexp;
+};
+
+/* Representation of reservations separated by '+' (see file
+   rtl.def).  */
+struct allof_regexp
+{
+  int regexps_num;
+  regexp_t regexps [1];
+};
+
+/* Representation of reservations separated by '|' (see file
+   rtl.def).  */
+struct oneof_regexp
+{
+  int regexps_num;
+  regexp_t regexps [1];
+};
+
+/* Representation of a reservation string.  */
+struct regexp
+{
+  /* What node in the union? */
+  enum regexp_mode mode;
+  pos_t pos;
+  union
+  {
+    struct unit_regexp unit;
+    struct reserv_regexp reserv;
+    struct nothing_regexp nothing;
+    struct sequence_regexp sequence;
+    struct repeat_regexp repeat;
+    struct allof_regexp allof;
+    struct oneof_regexp oneof;
+  } regexp;
+};
+
+/* Represents description of pipeline hazard description based on
+   NDFA.  */
+struct description
+{
+  int decls_num;
+
+  /* The following fields are defined by checker.  */
+
+  /* The following fields values are correspondingly number of all
+     units, query units, and insns in the description.  */
+  int units_num;
+  int query_units_num;
+  int insns_num;
+  /* The following field value is max length (in cycles) of
+     reservations of insns.  The field value is defined only for
+     correct programs.  */
+  int max_insn_reserv_cycles;
+
+  /* The following fields are defined by automaton generator.  */
+
+  /* The following field value is the first automaton.  */
+  automaton_t first_automaton;
+
+  /* The following field is created by pipeline hazard parser and
+     contains all declarations.  We allocate additional entry for
+     special insn "cycle advancing" which is added by the automaton
+     generator.  */
+  decl_t decls [1];
+};
+
+
+/* The following nodes are created in automaton checker.  */
+
+/* The following nodes represent exclusion set for cpu units.  Each
+   element is accessed through only one excl_list.  */
+struct unit_set_el
+{
+  unit_decl_t unit_decl;
+  unit_set_el_t next_unit_set_el;
+};
+
+/* The following nodes represent presence or absence pattern for cpu
+   units.  Each element is accessed through only one presence_list or
+   absence_list.  */
+struct pattern_set_el
+{
+  /* The number of units in unit_decls.  */
+  int units_num;
+  /* The units forming the pattern.  */
+  struct unit_decl **unit_decls;
+  pattern_set_el_t next_pattern_set_el;
+};
+
+
+/* The following nodes are created in automaton generator.  */
+
+
+/* The following nodes represent presence or absence pattern for cpu
+   units.  Each element is accessed through only one element of
+   unit_presence_set_table or unit_absence_set_table.  */
+struct pattern_reserv
+{
+  reserv_sets_t reserv;
+  pattern_reserv_t next_pattern_reserv;
+};
+
+/* The following node type describes state automaton.  The state may
+   be deterministic or non-deterministic.  Non-deterministic state has
+   several component states which represent alternative cpu units
+   reservations.  The state also is used for describing a
+   deterministic reservation of automaton insn.  */
+struct state
+{
+  /* The following member value is nonzero if there is a transition by
+     cycle advancing.  */
+  int new_cycle_p;
+  /* The following field is list of processor unit reservations on
+     each cycle.  */
+  reserv_sets_t reservs;
+  /* The following field is unique number of given state between other
+     states.  */
+  int unique_num;
+  /* The following field value is automaton to which given state
+     belongs.  */
+  automaton_t automaton;
+  /* The following field value is the first arc output from given
+     state.  */
+  arc_t first_out_arc;
+  unsigned int num_out_arcs;
+  /* The following field is used to form NDFA.  */
+  char it_was_placed_in_stack_for_NDFA_forming;
+  /* The following field is used to form DFA.  */
+  char it_was_placed_in_stack_for_DFA_forming;
+  /* The following field is used to transform NDFA to DFA and DFA
+     minimization.  The field value is not NULL if the state is a
+     compound state.  In this case the value of field `unit_sets_list'
+     is NULL.  All states in the list are in the hash table.  The list
+     is formed through field `next_sorted_alt_state'.  We should
+     support only one level of nesting state.  */
+  alt_state_t component_states;
+  /* The following field is used for passing graph of states.  */
+  int pass_num;
+  /* The list of states belonging to one equivalence class is formed
+     with the aid of the following field.  */
+  state_t next_equiv_class_state;
+  /* The two following fields are used during minimization of a finite
+     state automaton.  */
+  int equiv_class_num_1, equiv_class_num_2;
+  /* The following field is used during minimization of a finite state
+     automaton.  The field value is state corresponding to equivalence
+     class to which given state belongs.  */
+  state_t equiv_class_state;
+  unsigned int *presence_signature;
+  /* The following field value is the order number of given state.
+     The states in final DFA is enumerated with the aid of the
+     following field.  */
+  int order_state_num;
+  /* This member is used for passing states for searching minimal
+     delay time.  */
+  int state_pass_num;
+  /* The following member is used to evaluate min issue delay of insn
+     for a state.  */
+  int min_insn_issue_delay;
+};
+
+/* Automaton arc.  */
+struct arc
+{
+  /* The following field refers for the state into which given arc
+     enters.  */
+  state_t to_state;
+  /* The following field describes that the insn issue (with cycle
+     advancing for special insn `cycle advancing' and without cycle
+     advancing for others) makes transition from given state to
+     another given state.  */
+  ainsn_t insn;
+  /* The following field value is the next arc output from the same
+     state.  */
+  arc_t next_out_arc;
+  /* List of arcs marked given insn is formed with the following
+     field.  The field is used in transformation NDFA -> DFA.  */
+  arc_t next_arc_marked_by_insn;
+};
+
+/* The following node type describes a deterministic alternative in
+   non-deterministic state which characterizes cpu unit reservations
+   of automaton insn or which is part of NDFA.  */
+struct alt_state
+{
+  /* The following field is a deterministic state which characterizes
+     unit reservations of the instruction.  */
+  state_t state;
+  /* The following field refers to the next state which characterizes
+     unit reservations of the instruction.  */
+  alt_state_t next_alt_state;
+  /* The following field refers to the next state in sorted list.  */
+  alt_state_t next_sorted_alt_state;
+};
+
+/* The following node type describes insn of automaton.  They are
+   labels of FA arcs.  */
+struct ainsn
+{
+  /* The following field value is the corresponding insn declaration
+     of description.  */
+  struct insn_reserv_decl *insn_reserv_decl;
+  /* The following field value is the next insn declaration for an
+     automaton.  */
+  ainsn_t next_ainsn;
+  /* The following field is states which characterize automaton unit
+     reservations of the instruction.  The value can be NULL only if it
+     is special insn `cycle advancing'.  */
+  alt_state_t alt_states;
+  /* The following field is sorted list of states which characterize
+     automaton unit reservations of the instruction.  The value can be
+     NULL only if it is special insn `cycle advancing'.  */
+  alt_state_t sorted_alt_states;
+  /* The following field refers the next automaton insn with
+     the same reservations.  */
+  ainsn_t next_same_reservs_insn;
+  /* The following field is flag of the first automaton insn with the
+     same reservations in the declaration list.  Only arcs marked such
+     insn is present in the automaton.  This significantly decreases
+     memory requirements especially when several automata are
+     formed.  */
+  char first_insn_with_same_reservs;
+  /* The following member has nonzero value if there is arc from state of
+     the automaton marked by the ainsn.  */
+  char arc_exists_p;
+  /* Cyclic list of insns of an equivalence class is formed with the
+     aid of the following field.  */
+  ainsn_t next_equiv_class_insn;
+  /* The following field value is nonzero if the insn declaration is
+     the first insn declaration with given equivalence number.  */
+  char first_ainsn_with_given_equivalence_num;
+  /* The following field is number of class of equivalence of insns.
+     It is necessary because many insns may be equivalent with the
+     point of view of pipeline hazards.  */
+  int insn_equiv_class_num;
+  /* The following member value is TRUE if there is an arc in the
+     automaton marked by the insn into another state.  In other
+     words, the insn can change the state of the automaton.  */
+  int important_p;
+};
+
+/* The following describes an automaton for PHR.  */
+struct automaton
+{
+  /* The following field value is the list of insn declarations for
+     given automaton.  */
+  ainsn_t ainsn_list;
+  /* The following field value is the corresponding automaton
+     declaration.  This field is not NULL only if the automatic
+     partition on automata is not used.  */
+  struct automaton_decl *corresponding_automaton_decl;
+  /* The following field value is the next automaton.  */
+  automaton_t next_automaton;
+  /* The following field is start state of FA.  There are not unit
+     reservations in the state.  */
+  state_t start_state;
+  /* The following field value is number of equivalence classes of
+     insns (see field `insn_equiv_class_num' in
+     `insn_reserv_decl').  */
+  int insn_equiv_classes_num;
+  /* The following field value is number of states of final DFA.  */
+  int achieved_states_num;
+  /* The following field value is the order number (0, 1, ...) of
+     given automaton.  */
+  int automaton_order_num;
+  /* The following fields contain statistics information about
+     building automaton.  */
+  int NDFA_states_num, DFA_states_num;
+  /* The following field value is defined only if minimization of DFA
+     is used.  */
+  int minimal_DFA_states_num;
+  int NDFA_arcs_num, DFA_arcs_num;
+  /* The following field value is defined only if minimization of DFA
+     is used.  */
+  int minimal_DFA_arcs_num;
+  /* The following member refers for two table state x ainsn -> int.
+     ??? Above sentence is incomprehensible.  */
+  state_ainsn_table_t trans_table;
+  /* The following member value is maximal value of min issue delay
+     for insns of the automaton.  */
+  int max_min_delay;
+  /* Usually min issue delay is small and we can place several (2, 4,
+     8) elements in one vector element.  So the compression factor can
+     be 1 (no compression), 2, 4, 8.  */
+  int min_issue_delay_table_compression_factor;
+  /* Total number of locked states in this automaton.  */
+  int locked_states;
+};
+
+/* The following is the element of the list of automata.  */
+struct automata_list_el
+{
+  /* The automaton itself.  */
+  automaton_t automaton;
+  /* The next automata set element.  */
+  automata_list_el_t next_automata_list_el;
+};
+
+/* The following structure describes a table state X ainsn -> int(>= 0).  */
+struct state_ainsn_table
+{
+  /* Automaton to which given table belongs.  */
+  automaton_t automaton;
+  /* The following tree vectors for comb vector implementation of the
+     table.  */
+  vla_hwint_t comb_vect;
+  vla_hwint_t check_vect;
+  vla_hwint_t base_vect;
+  /* This is simple implementation of the table.  */
+  vla_hwint_t full_vect;
+  /* Minimal and maximal values of the previous vectors.  */
+  int min_comb_vect_el_value, max_comb_vect_el_value;
+  int min_base_vect_el_value, max_base_vect_el_value;
+};
+
+/* Macros to access members of unions.  Use only them for access to
+   union members of declarations and regexps.  */
+
+#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+
+#define DECL_UNIT(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_unit)					\
+       decl_mode_check_failed (_decl->mode, "dm_unit",			\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.unit; }))
+
+#define DECL_BYPASS(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_bypass)					\
+       decl_mode_check_failed (_decl->mode, "dm_bypass",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.bypass; }))
+
+#define DECL_AUTOMATON(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_automaton)					\
+       decl_mode_check_failed (_decl->mode, "dm_automaton",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.automaton; }))
+
+#define DECL_EXCL(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_excl)					\
+       decl_mode_check_failed (_decl->mode, "dm_excl",			\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.excl; }))
+
+#define DECL_PRESENCE(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_presence)					\
+       decl_mode_check_failed (_decl->mode, "dm_presence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.presence; }))
+
+#define DECL_ABSENCE(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_absence)					\
+       decl_mode_check_failed (_decl->mode, "dm_absence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.absence; }))
+
+#define DECL_RESERV(d) __extension__					\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_reserv)					\
+       decl_mode_check_failed (_decl->mode, "dm_reserv",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.reserv; }))
+
+#define DECL_INSN_RESERV(d) __extension__				\
+(({ __typeof (d) const _decl = (d);					\
+     if (_decl->mode != dm_insn_reserv)					\
+       decl_mode_check_failed (_decl->mode, "dm_insn_reserv",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_decl)->decl.insn_reserv; }))
+
+static const char *decl_name (enum decl_mode);
+static void decl_mode_check_failed (enum decl_mode, const char *,
+				    const char *, int, const char *)
+     ATTRIBUTE_NORETURN;
+
+/* Return string representation of declaration mode MODE.  */
+static const char *
+decl_name (enum decl_mode mode)
+{
+  static char str [100];
+
+  if (mode == dm_unit)
+    return "dm_unit";
+  else if (mode == dm_bypass)
+    return "dm_bypass";
+  else if (mode == dm_automaton)
+    return "dm_automaton";
+  else if (mode == dm_excl)
+    return "dm_excl";
+  else if (mode == dm_presence)
+    return "dm_presence";
+  else if (mode == dm_absence)
+    return "dm_absence";
+  else if (mode == dm_reserv)
+    return "dm_reserv";
+  else if (mode == dm_insn_reserv)
+    return "dm_insn_reserv";
+  else
+    sprintf (str, "unknown (%d)", (int) mode);
+  return str;
+}
+
+/* The function prints message about unexpected declaration and finish
+   the program.  */
+static void
+decl_mode_check_failed (enum decl_mode mode, const char *expected_mode_str,
+			const char *file, int line, const char *func)
+{
+  fprintf
+    (stderr,
+     "\n%s: %d: error in %s: DECL check: expected decl %s, have %s\n",
+     file, line, func, expected_mode_str, decl_name (mode));
+  exit (1);
+}
+
+
+#define REGEXP_UNIT(r) __extension__					\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_unit)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_unit",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.unit; }))
+
+#define REGEXP_RESERV(r) __extension__					\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_reserv)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_reserv",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.reserv; }))
+
+#define REGEXP_SEQUENCE(r) __extension__				\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_sequence)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_sequence",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.sequence; }))
+
+#define REGEXP_REPEAT(r) __extension__					\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_repeat)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_repeat",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.repeat; }))
+
+#define REGEXP_ALLOF(r) __extension__					\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_allof)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_allof",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.allof; }))
+
+#define REGEXP_ONEOF(r) __extension__					\
+(({ struct regexp *const _regexp = (r);					\
+     if (_regexp->mode != rm_oneof)					\
+       regexp_mode_check_failed (_regexp->mode, "rm_oneof",		\
+			       __FILE__, __LINE__, __FUNCTION__);	\
+     &(_regexp)->regexp.oneof; }))
+
+static const char *regexp_name (enum regexp_mode);
+static void regexp_mode_check_failed (enum regexp_mode, const char *,
+				      const char *, int,
+				      const char *) ATTRIBUTE_NORETURN;
+
+
+/* Return string representation of regexp mode MODE.  */
+static const char *
+regexp_name (enum regexp_mode mode)
+{
+  switch (mode)
+    {
+    case rm_unit:
+      return "rm_unit";
+    case rm_reserv:
+      return "rm_reserv";
+    case rm_nothing:
+      return "rm_nothing";
+    case rm_sequence:
+      return "rm_sequence";
+    case rm_repeat:
+      return "rm_repeat";
+    case rm_allof:
+      return "rm_allof";
+    case rm_oneof:
+      return "rm_oneof";
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* The function prints message about unexpected regexp and finish the
+   program.  */
+static void
+regexp_mode_check_failed (enum regexp_mode mode,
+			  const char *expected_mode_str,
+			  const char *file, int line, const char *func)
+{
+  fprintf
+    (stderr,
+     "\n%s: %d: error in %s: REGEXP check: expected decl %s, have %s\n",
+     file, line, func, expected_mode_str, regexp_name (mode));
+  exit (1);
+}
+
+#else /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
+
+#define DECL_UNIT(d) (&(d)->decl.unit)
+#define DECL_BYPASS(d) (&(d)->decl.bypass)
+#define DECL_AUTOMATON(d) (&(d)->decl.automaton)
+#define DECL_EXCL(d) (&(d)->decl.excl)
+#define DECL_PRESENCE(d) (&(d)->decl.presence)
+#define DECL_ABSENCE(d) (&(d)->decl.absence)
+#define DECL_RESERV(d) (&(d)->decl.reserv)
+#define DECL_INSN_RESERV(d) (&(d)->decl.insn_reserv)
+
+#define REGEXP_UNIT(r) (&(r)->regexp.unit)
+#define REGEXP_RESERV(r) (&(r)->regexp.reserv)
+#define REGEXP_SEQUENCE(r) (&(r)->regexp.sequence)
+#define REGEXP_REPEAT(r) (&(r)->regexp.repeat)
+#define REGEXP_ALLOF(r) (&(r)->regexp.allof)
+#define REGEXP_ONEOF(r) (&(r)->regexp.oneof)
+
+#endif /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
+
+#define XCREATENODE(T) ((T *) create_node (sizeof (T)))
+#define XCREATENODEVEC(T, N) ((T *) create_node (sizeof (T) * (N)))
+#define XCREATENODEVAR(T, S) ((T *) create_node ((S)))
+
+#define XCOPYNODE(T, P) ((T *) copy_node ((P), sizeof (T)))
+#define XCOPYNODEVEC(T, P, N) ((T *) copy_node ((P), sizeof (T) * (N)))
+#define XCOPYNODEVAR(T, P, S) ((T *) copy_node ((P), (S)))
+
+/* Create IR structure (node).  */
+static void *
+create_node (size_t size)
+{
+  void *result;
+
+  obstack_blank (&irp, size);
+  result = obstack_base (&irp);
+  obstack_finish (&irp);
+  /* Default values of members are NULL and zero.  */
+  memset (result, 0, size);
+  return result;
+}
+
+/* Copy IR structure (node).  */
+static void *
+copy_node (const void *from, size_t size)
+{
+  void *const result = create_node (size);
+  memcpy (result, from, size);
+  return result;
+}
+
+/* The function checks that NAME does not contain quotes (`"').  */
+static const char *
+check_name (const char * name, pos_t pos ATTRIBUTE_UNUSED)
+{
+  const char *str;
+
+  for (str = name; *str != '\0'; str++)
+    if (*str == '\"')
+      error ("Name `%s' contains quotes", name);
+  return name;
+}
+
+/* Pointers to all declarations during IR generation are stored in the
+   following.  */
+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
+   end of string.  */
+static char *
+next_sep_el (const char **pstr, int sep, int par_flag)
+{
+  char *out_str;
+  const char *p;
+  int pars_num;
+  int n_spaces;
+
+  /* Remove leading whitespaces.  */
+  while (ISSPACE ((int) **pstr))
+    (*pstr)++;
+
+  if (**pstr == '\0')
+    return NULL;
+
+  n_spaces = 0;
+  for (pars_num = 0, p = *pstr; *p != '\0'; p++)
+    {
+      if (par_flag && *p == '(')
+	pars_num++;
+      else if (par_flag && *p == ')')
+	pars_num--;
+      else if (pars_num == 0 && *p == sep)
+	break;
+      if (pars_num == 0 && ISSPACE ((int) *p))
+	n_spaces++;
+      else
+	{
+	  for (; n_spaces != 0; n_spaces--)
+	    obstack_1grow (&irp, p [-n_spaces]);
+	  obstack_1grow (&irp, *p);
+	}
+    }
+  obstack_1grow (&irp, '\0');
+  out_str = obstack_base (&irp);
+  obstack_finish (&irp);
+
+  *pstr = p;
+  if (**pstr == sep)
+    (*pstr)++;
+
+  return out_str;
+}
+
+/* Given a string and a separator, return the number of separated
+   elements in it, taking parentheses into account if PAR_FLAG has
+   nonzero value.  Return 0 for the null string, -1 if parentheses is
+   not balanced.  */
+static int
+n_sep_els (const char *s, int sep, int par_flag)
+{
+  int n;
+  int pars_num;
+
+  if (*s == '\0')
+    return 0;
+
+  for (pars_num = 0, n = 1; *s; s++)
+    if (par_flag && *s == '(')
+      pars_num++;
+    else if (par_flag && *s == ')')
+      pars_num--;
+    else if (pars_num == 0 && *s == sep)
+      n++;
+
+  return (pars_num != 0 ? -1 : n);
+}
+
+/* Given a string and a separator, return vector of strings which are
+   elements in the string and number of elements through els_num.
+   Take parentheses into account if PAREN_P has nonzero value.  The
+   function also inserts the end marker NULL at the end of vector.
+   Return 0 for the null string, -1 if parentheses are not balanced.  */
+static char **
+get_str_vect (const char *str, int *els_num, int sep, int paren_p)
+{
+  int i;
+  char **vect;
+  const char **pstr;
+  char *trail;
+
+  *els_num = n_sep_els (str, sep, paren_p);
+  if (*els_num <= 0)
+    return NULL;
+  obstack_blank (&irp, sizeof (char *) * (*els_num + 1));
+  vect = (char **) obstack_base (&irp);
+  obstack_finish (&irp);
+  pstr = &str;
+  for (i = 0; i < *els_num; i++)
+    vect [i] = next_sep_el (pstr, sep, paren_p);
+  trail = next_sep_el (pstr, sep, paren_p);
+  gcc_assert (!trail);
+  vect [i] = NULL;
+  return vect;
+}
+
+/* Process a DEFINE_CPU_UNIT.
+
+   This gives information about a unit contained in CPU.  We fill a
+   struct unit_decl with information used later by `expand_automata'.  */
+static void
+gen_cpu_unit (rtx def)
+{
+  decl_t decl;
+  char **str_cpu_units;
+  int vect_length;
+  int i;
+
+  str_cpu_units = get_str_vect (XSTR (def, 0), &vect_length, ',', FALSE);
+  if (str_cpu_units == NULL)
+    fatal ("invalid string `%s' in define_cpu_unit", XSTR (def, 0));
+  for (i = 0; i < vect_length; i++)
+    {
+      decl = XCREATENODE (struct decl);
+      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 = 0;
+      DECL_UNIT (decl)->min_occ_cycle_num = -1;
+      DECL_UNIT (decl)->in_set_p = 0;
+      VEC_safe_push (decl_t,heap, decls, decl);
+    }
+}
+
+/* Process a DEFINE_QUERY_CPU_UNIT.
+
+   This gives information about a unit contained in CPU.  We fill a
+   struct unit_decl with information used later by `expand_automata'.  */
+static void
+gen_query_cpu_unit (rtx def)
+{
+  decl_t decl;
+  char **str_cpu_units;
+  int vect_length;
+  int i;
+
+  str_cpu_units = get_str_vect (XSTR (def, 0), &vect_length, ',',
+				FALSE);
+  if (str_cpu_units == NULL)
+    fatal ("invalid string `%s' in define_query_cpu_unit", XSTR (def, 0));
+  for (i = 0; i < vect_length; i++)
+    {
+      decl = XCREATENODE (struct decl);
+      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);
+    }
+}
+
+/* Process a DEFINE_BYPASS.
+
+   This gives information about a unit contained in the CPU.  We fill
+   in a struct bypass_decl with information used later by
+   `expand_automata'.  */
+static void
+gen_bypass (rtx def)
+{
+  decl_t decl;
+  char **out_insns;
+  int out_length;
+  char **in_insns;
+  int in_length;
+  int i, j;
+
+  out_insns = get_str_vect (XSTR (def, 1), &out_length, ',', FALSE);
+  if (out_insns == NULL)
+    fatal ("invalid string `%s' in define_bypass", XSTR (def, 1));
+  in_insns = get_str_vect (XSTR (def, 2), &in_length, ',', FALSE);
+  if (in_insns == NULL)
+    fatal ("invalid string `%s' in define_bypass", XSTR (def, 2));
+  for (i = 0; i < out_length; i++)
+    for (j = 0; j < in_length; j++)
+      {
+	decl = XCREATENODE (struct decl);
+	decl->mode = dm_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);
+      }
+}
+
+/* Process an EXCLUSION_SET.
+
+   This gives information about a cpu unit conflicts.  We fill a
+   struct excl_rel_decl (excl) with information used later by
+   `expand_automata'.  */
+static void
+gen_excl_set (rtx def)
+{
+  decl_t decl;
+  char **first_str_cpu_units;
+  char **second_str_cpu_units;
+  int first_vect_length;
+  int length;
+  int i;
+
+  first_str_cpu_units
+    = get_str_vect (XSTR (def, 0), &first_vect_length, ',', FALSE);
+  if (first_str_cpu_units == NULL)
+    fatal ("invalid first string `%s' in exclusion_set", XSTR (def, 0));
+  second_str_cpu_units = get_str_vect (XSTR (def, 1), &length, ',',
+				       FALSE);
+  if (second_str_cpu_units == NULL)
+    fatal ("invalid second string `%s' in exclusion_set", XSTR (def, 1));
+  length += first_vect_length;
+  decl = XCREATENODEVAR (struct decl, sizeof (struct decl) + (length - 1) * sizeof (char *));
+  decl->mode = dm_excl;
+  decl->pos = 0;
+  DECL_EXCL (decl)->all_names_num = length;
+  DECL_EXCL (decl)->first_list_length = first_vect_length;
+  for (i = 0; i < length; i++)
+    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);
+}
+
+/* Process a PRESENCE_SET, a FINAL_PRESENCE_SET, an ABSENCE_SET,
+   FINAL_ABSENCE_SET (it is depended on PRESENCE_P and FINAL_P).
+
+   This gives information about a cpu unit reservation requirements.
+   We fill a struct unit_pattern_rel_decl with information used later
+   by `expand_automata'.  */
+static void
+gen_presence_absence_set (rtx def, int presence_p, int final_p)
+{
+  decl_t decl;
+  char **str_cpu_units;
+  char **str_pattern_lists;
+  char ***str_patterns;
+  int cpu_units_length;
+  int length;
+  int patterns_length;
+  int i;
+
+  str_cpu_units = get_str_vect (XSTR (def, 0), &cpu_units_length, ',',
+				FALSE);
+  if (str_cpu_units == NULL)
+    fatal ((presence_p
+	    ? (final_p
+	       ? "invalid first string `%s' in final_presence_set"
+	       : "invalid first string `%s' in presence_set")
+	    : (final_p
+	       ? "invalid first string `%s' in final_absence_set"
+	       : "invalid first string `%s' in absence_set")),
+	   XSTR (def, 0));
+  str_pattern_lists = get_str_vect (XSTR (def, 1),
+				    &patterns_length, ',', FALSE);
+  if (str_pattern_lists == NULL)
+    fatal ((presence_p
+	    ? (final_p
+	       ? "invalid second string `%s' in final_presence_set"
+	       : "invalid second string `%s' in presence_set")
+	    : (final_p
+	       ? "invalid second string `%s' in final_absence_set"
+	       : "invalid second string `%s' in absence_set")), XSTR (def, 1));
+  str_patterns = XOBNEWVEC (&irp, char **, patterns_length);
+  for (i = 0; i < patterns_length; i++)
+    {
+      str_patterns [i] = get_str_vect (str_pattern_lists [i],
+				       &length, ' ', FALSE);
+      gcc_assert (str_patterns [i]);
+    }
+  decl = XCREATENODE (struct decl);
+  decl->pos = 0;
+  if (presence_p)
+    {
+      decl->mode = dm_presence;
+      DECL_PRESENCE (decl)->names_num = cpu_units_length;
+      DECL_PRESENCE (decl)->names = str_cpu_units;
+      DECL_PRESENCE (decl)->patterns = str_patterns;
+      DECL_PRESENCE (decl)->patterns_num = patterns_length;
+      DECL_PRESENCE (decl)->final_p = final_p;
+    }
+  else
+    {
+      decl->mode = dm_absence;
+      DECL_ABSENCE (decl)->names_num = cpu_units_length;
+      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);
+}
+
+/* Process a PRESENCE_SET.
+
+    This gives information about a cpu unit reservation requirements.
+   We fill a struct unit_pattern_rel_decl (presence) with information
+   used later by `expand_automata'.  */
+static void
+gen_presence_set (rtx def)
+{
+  gen_presence_absence_set (def, TRUE, FALSE);
+}
+
+/* Process a FINAL_PRESENCE_SET.
+
+   This gives information about a cpu unit reservation requirements.
+   We fill a struct unit_pattern_rel_decl (presence) with information
+   used later by `expand_automata'.  */
+static void
+gen_final_presence_set (rtx def)
+{
+  gen_presence_absence_set (def, TRUE, TRUE);
+}
+
+/* Process an ABSENCE_SET.
+
+   This gives information about a cpu unit reservation requirements.
+   We fill a struct unit_pattern_rel_decl (absence) with information
+   used later by `expand_automata'.  */
+static void
+gen_absence_set (rtx def)
+{
+  gen_presence_absence_set (def, FALSE, FALSE);
+}
+
+/* Process a FINAL_ABSENCE_SET.
+
+   This gives information about a cpu unit reservation requirements.
+   We fill a struct unit_pattern_rel_decl (absence) with information
+   used later by `expand_automata'.  */
+static void
+gen_final_absence_set (rtx def)
+{
+  gen_presence_absence_set (def, FALSE, TRUE);
+}
+
+/* Process a DEFINE_AUTOMATON.
+
+   This gives information about a finite state automaton used for
+   recognizing pipeline hazards.  We fill a struct automaton_decl
+   with information used later by `expand_automata'.  */
+static void
+gen_automaton (rtx def)
+{
+  decl_t decl;
+  char **str_automata;
+  int vect_length;
+  int i;
+
+  str_automata = get_str_vect (XSTR (def, 0), &vect_length, ',', FALSE);
+  if (str_automata == NULL)
+    fatal ("invalid string `%s' in define_automaton", XSTR (def, 0));
+  for (i = 0; i < vect_length; i++)
+    {
+      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);
+    }
+}
+
+/* Process an AUTOMATA_OPTION.
+
+   This gives information how to generate finite state automaton used
+   for recognizing pipeline hazards.  */
+static void
+gen_automata_option (rtx def)
+{
+  if (strcmp (XSTR (def, 0), NO_MINIMIZATION_OPTION + 1) == 0)
+    no_minimization_flag = 1;
+  else if (strcmp (XSTR (def, 0), TIME_OPTION + 1) == 0)
+    time_flag = 1;
+  else if (strcmp (XSTR (def, 0), STATS_OPTION + 1) == 0)
+    stats_flag = 1;
+  else if (strcmp (XSTR (def, 0), V_OPTION + 1) == 0)
+    v_flag = 1;
+  else if (strcmp (XSTR (def, 0), W_OPTION + 1) == 0)
+    w_flag = 1;
+  else if (strcmp (XSTR (def, 0), NDFA_OPTION + 1) == 0)
+    ndfa_flag = 1;
+  else if (strcmp (XSTR (def, 0), PROGRESS_OPTION + 1) == 0)
+    progress_flag = 1;
+  else
+    fatal ("invalid option `%s' in automata_option", XSTR (def, 0));
+}
+
+/* Name in reservation to denote absence reservation.  */
+#define NOTHING_NAME "nothing"
+
+/* The following string contains original reservation string being
+   parsed.  */
+static const char *reserv_str;
+
+/* Parse an element in STR.  */
+static regexp_t
+gen_regexp_el (const char *str)
+{
+  regexp_t regexp;
+  char *dstr;
+  int len;
+
+  if (*str == '(')
+    {
+      len = strlen (str);
+      if (str [len - 1] != ')')
+	fatal ("garbage after ) in reservation `%s'", reserv_str);
+      dstr = XALLOCAVAR (char, len - 1);
+      memcpy (dstr, str + 1, len - 2);
+      dstr [len-2] = '\0';
+      regexp = gen_regexp_sequence (dstr);
+    }
+  else if (strcmp (str, NOTHING_NAME) == 0)
+    {
+      regexp = XCREATENODE (struct regexp);
+      regexp->mode = rm_nothing;
+    }
+  else
+    {
+      regexp = XCREATENODE (struct regexp);
+      regexp->mode = rm_unit;
+      REGEXP_UNIT (regexp)->name = str;
+    }
+  return regexp;
+}
+
+/* Parse construction `repeat' in STR.  */
+static regexp_t
+gen_regexp_repeat (const char *str)
+{
+  regexp_t regexp;
+  regexp_t repeat;
+  char **repeat_vect;
+  int els_num;
+  int i;
+
+  repeat_vect = get_str_vect (str, &els_num, '*', TRUE);
+  if (repeat_vect == NULL)
+    fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
+  if (els_num > 1)
+    {
+      regexp = gen_regexp_el (repeat_vect [0]);
+      for (i = 1; i < els_num; i++)
+	{
+	  repeat = XCREATENODE (struct regexp);
+	  repeat->mode = rm_repeat;
+	  REGEXP_REPEAT (repeat)->regexp = regexp;
+	  REGEXP_REPEAT (repeat)->repeat_num = atoi (repeat_vect [i]);
+          if (REGEXP_REPEAT (repeat)->repeat_num <= 1)
+            fatal ("repetition `%s' <= 1 in reservation `%s'",
+                   str, reserv_str);
+          regexp = repeat;
+	}
+      return regexp;
+    }
+  else
+    return gen_regexp_el (str);
+}
+
+/* Parse reservation STR which possibly contains separator '+'.  */
+static regexp_t
+gen_regexp_allof (const char *str)
+{
+  regexp_t allof;
+  char **allof_vect;
+  int els_num;
+  int i;
+
+  allof_vect = get_str_vect (str, &els_num, '+', TRUE);
+  if (allof_vect == NULL)
+    fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
+  if (els_num > 1)
+    {
+      allof = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+			      + sizeof (regexp_t) * (els_num - 1));
+      allof->mode = rm_allof;
+      REGEXP_ALLOF (allof)->regexps_num = els_num;
+      for (i = 0; i < els_num; i++)
+	REGEXP_ALLOF (allof)->regexps [i] = gen_regexp_repeat (allof_vect [i]);
+      return allof;
+    }
+  else
+    return gen_regexp_repeat (str);
+}
+
+/* Parse reservation STR which possibly contains separator '|'.  */
+static regexp_t
+gen_regexp_oneof (const char *str)
+{
+  regexp_t oneof;
+  char **oneof_vect;
+  int els_num;
+  int i;
+
+  oneof_vect = get_str_vect (str, &els_num, '|', TRUE);
+  if (oneof_vect == NULL)
+    fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
+  if (els_num > 1)
+    {
+      oneof = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+			      + sizeof (regexp_t) * (els_num - 1));
+      oneof->mode = rm_oneof;
+      REGEXP_ONEOF (oneof)->regexps_num = els_num;
+      for (i = 0; i < els_num; i++)
+	REGEXP_ONEOF (oneof)->regexps [i] = gen_regexp_allof (oneof_vect [i]);
+      return oneof;
+    }
+  else
+    return gen_regexp_allof (str);
+}
+
+/* Parse reservation STR which possibly contains separator ','.  */
+static regexp_t
+gen_regexp_sequence (const char *str)
+{
+  regexp_t sequence;
+  char **sequence_vect;
+  int els_num;
+  int i;
+
+  sequence_vect = get_str_vect (str, &els_num, ',', TRUE);
+  if (els_num > 1)
+    {
+      sequence = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				 + sizeof (regexp_t) * (els_num - 1));
+      sequence->mode = rm_sequence;
+      REGEXP_SEQUENCE (sequence)->regexps_num = els_num;
+      for (i = 0; i < els_num; i++)
+	REGEXP_SEQUENCE (sequence)->regexps [i]
+          = gen_regexp_oneof (sequence_vect [i]);
+      return sequence;
+    }
+  else
+    return gen_regexp_oneof (str);
+}
+
+/* Parse construction reservation STR.  */
+static regexp_t
+gen_regexp (const char *str)
+{
+  reserv_str = str;
+  return gen_regexp_sequence (str);;
+}
+
+/* Process a DEFINE_RESERVATION.
+
+   This gives information about a reservation of cpu units.  We fill
+   in a struct reserv_decl with information used later by
+   `expand_automata'.  */
+static void
+gen_reserv (rtx def)
+{
+  decl_t decl;
+
+  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);
+}
+
+/* Process a DEFINE_INSN_RESERVATION.
+
+   This gives information about the reservation of cpu units by an
+   insn.  We fill a struct insn_reserv_decl with information used
+   later by `expand_automata'.  */
+static void
+gen_insn_reserv (rtx def)
+{
+  decl_t decl;
+
+  decl = XCREATENODE (struct decl);
+  decl->mode = dm_insn_reserv;
+  decl->pos = 0;
+  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);
+}
+
+
+
+/* The function evaluates hash value (0..UINT_MAX) of string.  */
+static unsigned
+string_hash (const char *string)
+{
+  unsigned result, i;
+
+  for (result = i = 0;*string++ != '\0'; i++)
+    result += ((unsigned char) *string << (i % CHAR_BIT));
+  return result;
+}
+
+
+
+/* This page contains abstract data `table of automaton declarations'.
+   Elements of the table is nodes representing automaton declarations.
+   Key of the table elements is name of given automaton.  Remember
+   that automaton names have own space.  */
+
+/* The function evaluates hash value of an automaton declaration.  The
+   function is used by abstract data `hashtab'.  The function returns
+   hash value (0..UINT_MAX) of given automaton declaration.  */
+static hashval_t
+automaton_decl_hash (const void *automaton_decl)
+{
+  const_decl_t const decl = (const_decl_t) automaton_decl;
+
+  gcc_assert (decl->mode != dm_automaton
+	      || DECL_AUTOMATON (decl)->name);
+  return string_hash (DECL_AUTOMATON (decl)->name);
+}
+
+/* The function tests automaton declarations on equality of their
+   keys.  The function is used by abstract data `hashtab'.  The
+   function returns 1 if the declarations have the same key, 0
+   otherwise.  */
+static int
+automaton_decl_eq_p (const void* automaton_decl_1,
+		     const void* automaton_decl_2)
+{
+  const_decl_t const decl1 = (const_decl_t) automaton_decl_1;
+  const_decl_t const decl2 = (const_decl_t) automaton_decl_2;
+
+  gcc_assert (decl1->mode == dm_automaton
+	      && DECL_AUTOMATON (decl1)->name
+	      && decl2->mode == dm_automaton
+	      && DECL_AUTOMATON (decl2)->name);
+  return strcmp (DECL_AUTOMATON (decl1)->name,
+		 DECL_AUTOMATON (decl2)->name) == 0;
+}
+
+/* The automaton declaration table itself is represented by the
+   following variable.  */
+static htab_t automaton_decl_table;
+
+/* The function inserts automaton declaration into the table.  The
+   function does nothing if an automaton declaration with the same key
+   exists already in the table.  The function returns automaton
+   declaration node in the table with the same key as given automaton
+   declaration node.  */
+static decl_t
+insert_automaton_decl (decl_t automaton_decl)
+{
+  void **entry_ptr;
+
+  entry_ptr = htab_find_slot (automaton_decl_table, automaton_decl, 1);
+  if (*entry_ptr == NULL)
+    *entry_ptr = (void *) automaton_decl;
+  return (decl_t) *entry_ptr;
+}
+
+/* The following variable value is node representing automaton
+   declaration.  The node used for searching automaton declaration
+   with given name.  */
+static struct decl work_automaton_decl;
+
+/* The function searches for automaton declaration in the table with
+   the same key as node representing name of the automaton
+   declaration.  The function returns node found in the table, NULL if
+   such node does not exist in the table.  */
+static decl_t
+find_automaton_decl (const char *name)
+{
+  void *entry;
+
+  work_automaton_decl.mode = dm_automaton;
+  DECL_AUTOMATON (&work_automaton_decl)->name = name;
+  entry = htab_find (automaton_decl_table, &work_automaton_decl);
+  return (decl_t) entry;
+}
+
+/* The function creates empty automaton declaration table and node
+   representing automaton declaration and used for searching automaton
+   declaration with given name.  The function must be called only once
+   before any work with the automaton declaration table.  */
+static void
+initiate_automaton_decl_table (void)
+{
+  work_automaton_decl.mode = dm_automaton;
+  automaton_decl_table = htab_create (10, automaton_decl_hash,
+				      automaton_decl_eq_p, (htab_del) 0);
+}
+
+/* The function deletes the automaton declaration table.  Only call of
+   function `initiate_automaton_decl_table' is possible immediately
+   after this function call.  */
+static void
+finish_automaton_decl_table (void)
+{
+  htab_delete (automaton_decl_table);
+}
+
+
+
+/* This page contains abstract data `table of insn declarations'.
+   Elements of the table is nodes representing insn declarations.  Key
+   of the table elements is name of given insn (in corresponding
+   define_insn_reservation).  Remember that insn names have own
+   space.  */
+
+/* The function evaluates hash value of an insn declaration.  The
+   function is used by abstract data `hashtab'.  The function returns
+   hash value (0..UINT_MAX) of given insn declaration.  */
+static hashval_t
+insn_decl_hash (const void *insn_decl)
+{
+  const_decl_t const decl = (const_decl_t) insn_decl;
+
+  gcc_assert (decl->mode == dm_insn_reserv
+	      && DECL_INSN_RESERV (decl)->name);
+  return string_hash (DECL_INSN_RESERV (decl)->name);
+}
+
+/* The function tests insn declarations on equality of their keys.
+   The function is used by abstract data `hashtab'.  The function
+   returns 1 if declarations have the same key, 0 otherwise.  */
+static int
+insn_decl_eq_p (const void *insn_decl_1, const void *insn_decl_2)
+{
+  const_decl_t const decl1 = (const_decl_t) insn_decl_1;
+  const_decl_t const decl2 = (const_decl_t) insn_decl_2;
+
+  gcc_assert (decl1->mode == dm_insn_reserv
+	      && DECL_INSN_RESERV (decl1)->name
+	      && decl2->mode == dm_insn_reserv
+	      && DECL_INSN_RESERV (decl2)->name);
+  return strcmp (DECL_INSN_RESERV (decl1)->name,
+                 DECL_INSN_RESERV (decl2)->name) == 0;
+}
+
+/* The insn declaration table itself is represented by the following
+   variable.  The table does not contain insn reservation
+   declarations.  */
+static htab_t insn_decl_table;
+
+/* The function inserts insn declaration into the table.  The function
+   does nothing if an insn declaration with the same key exists
+   already in the table.  The function returns insn declaration node
+   in the table with the same key as given insn declaration node.  */
+static decl_t
+insert_insn_decl (decl_t insn_decl)
+{
+  void **entry_ptr;
+
+  entry_ptr = htab_find_slot (insn_decl_table, insn_decl, 1);
+  if (*entry_ptr == NULL)
+    *entry_ptr = (void *) insn_decl;
+  return (decl_t) *entry_ptr;
+}
+
+/* The following variable value is node representing insn reservation
+   declaration.  The node used for searching insn reservation
+   declaration with given name.  */
+static struct decl work_insn_decl;
+
+/* The function searches for insn reservation declaration in the table
+   with the same key as node representing name of the insn reservation
+   declaration.  The function returns node found in the table, NULL if
+   such node does not exist in the table.  */
+static decl_t
+find_insn_decl (const char *name)
+{
+  void *entry;
+
+  work_insn_decl.mode = dm_insn_reserv;
+  DECL_INSN_RESERV (&work_insn_decl)->name = name;
+  entry = htab_find (insn_decl_table, &work_insn_decl);
+  return (decl_t) entry;
+}
+
+/* The function creates empty insn declaration table and node
+   representing insn declaration and used for searching insn
+   declaration with given name.  The function must be called only once
+   before any work with the insn declaration table.  */
+static void
+initiate_insn_decl_table (void)
+{
+  work_insn_decl.mode = dm_insn_reserv;
+  insn_decl_table = htab_create (10, insn_decl_hash, insn_decl_eq_p,
+				 (htab_del) 0);
+}
+
+/* The function deletes the insn declaration table.  Only call of
+   function `initiate_insn_decl_table' is possible immediately after
+   this function call.  */
+static void
+finish_insn_decl_table (void)
+{
+  htab_delete (insn_decl_table);
+}
+
+
+
+/* This page contains abstract data `table of declarations'.  Elements
+   of the table is nodes representing declarations (of units and
+   reservations).  Key of the table elements is names of given
+   declarations.  */
+
+/* The function evaluates hash value of a declaration.  The function
+   is used by abstract data `hashtab'.  The function returns hash
+   value (0..UINT_MAX) of given declaration.  */
+static hashval_t
+decl_hash (const void *decl)
+{
+  const_decl_t const d = (const_decl_t) decl;
+
+  gcc_assert ((d->mode == dm_unit && DECL_UNIT (d)->name)
+	      || (d->mode == dm_reserv && DECL_RESERV (d)->name));
+  return string_hash (d->mode == dm_unit
+		      ? DECL_UNIT (d)->name : DECL_RESERV (d)->name);
+}
+
+/* The function tests declarations on equality of their keys.  The
+   function is used by abstract data 'hashtab'.  The function
+   returns 1 if the declarations have the same key, 0 otherwise.  */
+static int
+decl_eq_p (const void *decl_1, const void *decl_2)
+{
+  const_decl_t const d1 = (const_decl_t) decl_1;
+  const_decl_t const d2 = (const_decl_t) decl_2;
+
+  gcc_assert ((d1->mode == dm_unit && DECL_UNIT (d1)->name)
+	      || (d1->mode == dm_reserv && DECL_RESERV (d1)->name));
+  gcc_assert ((d2->mode == dm_unit && DECL_UNIT (d2)->name)
+	      || (d2->mode == dm_reserv && DECL_RESERV (d2)->name));
+  return strcmp ((d1->mode == dm_unit
+                  ? DECL_UNIT (d1)->name : DECL_RESERV (d1)->name),
+                 (d2->mode == dm_unit
+                  ? DECL_UNIT (d2)->name : DECL_RESERV (d2)->name)) == 0;
+}
+
+/* The declaration table itself is represented by the following
+   variable.  */
+static htab_t decl_table;
+
+/* The function inserts declaration into the table.  The function does
+   nothing if a declaration with the same key exists already in the
+   table.  The function returns declaration node in the table with the
+   same key as given declaration node.  */
+
+static decl_t
+insert_decl (decl_t decl)
+{
+  void **entry_ptr;
+
+  entry_ptr = htab_find_slot (decl_table, decl, 1);
+  if (*entry_ptr == NULL)
+    *entry_ptr = (void *) decl;
+  return (decl_t) *entry_ptr;
+}
+
+/* The following variable value is node representing declaration.  The
+   node used for searching declaration with given name.  */
+static struct decl work_decl;
+
+/* The function searches for declaration in the table with the same
+   key as node representing name of the declaration.  The function
+   returns node found in the table, NULL if such node does not exist
+   in the table.  */
+static decl_t
+find_decl (const char *name)
+{
+  void *entry;
+
+  work_decl.mode = dm_unit;
+  DECL_UNIT (&work_decl)->name = name;
+  entry = htab_find (decl_table, &work_decl);
+  return (decl_t) entry;
+}
+
+/* The function creates empty declaration table and node representing
+   declaration and used for searching declaration with given name.
+   The function must be called only once before any work with the
+   declaration table.  */
+static void
+initiate_decl_table (void)
+{
+  work_decl.mode = dm_unit;
+  decl_table = htab_create (10, decl_hash, decl_eq_p, (htab_del) 0);
+}
+
+/* The function deletes the declaration table.  Only call of function
+   `initiate_declaration_table' is possible immediately after this
+   function call.  */
+static void
+finish_decl_table (void)
+{
+  htab_delete (decl_table);
+}
+
+
+
+/* This page contains checker of pipeline hazard description.  */
+
+/* Checking NAMES in an exclusion clause vector and returning formed
+   unit_set_el_list.  */
+static unit_set_el_t
+process_excls (char **names, int num, pos_t excl_pos ATTRIBUTE_UNUSED)
+{
+  unit_set_el_t el_list;
+  unit_set_el_t last_el;
+  unit_set_el_t new_el;
+  decl_t decl_in_table;
+  int i;
+
+  el_list = NULL;
+  last_el = NULL;
+  for (i = 0; i < num; i++)
+    {
+      decl_in_table = find_decl (names [i]);
+      if (decl_in_table == NULL)
+	error ("unit `%s' in exclusion is not declared", names [i]);
+      else if (decl_in_table->mode != dm_unit)
+	error ("`%s' in exclusion is not unit", names [i]);
+      else
+	{
+	  new_el = XCREATENODE (struct unit_set_el);
+	  new_el->unit_decl = DECL_UNIT (decl_in_table);
+	  new_el->next_unit_set_el = NULL;
+	  if (last_el == NULL)
+	    el_list = last_el = new_el;
+	  else
+	    {
+	      last_el->next_unit_set_el = new_el;
+	      last_el = last_el->next_unit_set_el;
+	    }
+	}
+    }
+  return el_list;
+}
+
+/* The function adds each element from SOURCE_LIST to the exclusion
+   list of the each element from DEST_LIST.  Checking situation "unit
+   excludes itself".  */
+static void
+add_excls (unit_set_el_t dest_list, unit_set_el_t source_list,
+	   pos_t excl_pos ATTRIBUTE_UNUSED)
+{
+  unit_set_el_t dst;
+  unit_set_el_t src;
+  unit_set_el_t curr_el;
+  unit_set_el_t prev_el;
+  unit_set_el_t copy;
+
+  for (dst = dest_list; dst != NULL; dst = dst->next_unit_set_el)
+    for (src = source_list; src != NULL; src = src->next_unit_set_el)
+      {
+	if (dst->unit_decl == src->unit_decl)
+	  {
+	    error ("unit `%s' excludes itself", src->unit_decl->name);
+	    continue;
+	  }
+	if (dst->unit_decl->automaton_name != NULL
+	    && src->unit_decl->automaton_name != NULL
+	    && strcmp (dst->unit_decl->automaton_name,
+		       src->unit_decl->automaton_name) != 0)
+	  {
+	    error ("units `%s' and `%s' in exclusion set belong to different automata",
+		   src->unit_decl->name, dst->unit_decl->name);
+	    continue;
+	  }
+	for (curr_el = dst->unit_decl->excl_list, prev_el = NULL;
+	     curr_el != NULL;
+	     prev_el = curr_el, curr_el = curr_el->next_unit_set_el)
+	  if (curr_el->unit_decl == src->unit_decl)
+	    break;
+	if (curr_el == NULL)
+	  {
+	    /* Element not found - insert.  */
+	    copy = XCOPYNODE (struct unit_set_el, src);
+	    copy->next_unit_set_el = NULL;
+	    if (prev_el == NULL)
+	      dst->unit_decl->excl_list = copy;
+	    else
+	      prev_el->next_unit_set_el = copy;
+	}
+    }
+}
+
+/* Checking NAMES in presence/absence clause and returning the
+   formed unit_set_el_list.  The function is called only after
+   processing all exclusion sets.  */
+static unit_set_el_t
+process_presence_absence_names (char **names, int num,
+				pos_t req_pos ATTRIBUTE_UNUSED,
+				int presence_p, int final_p)
+{
+  unit_set_el_t el_list;
+  unit_set_el_t last_el;
+  unit_set_el_t new_el;
+  decl_t decl_in_table;
+  int i;
+
+  el_list = NULL;
+  last_el = NULL;
+  for (i = 0; i < num; i++)
+    {
+      decl_in_table = find_decl (names [i]);
+      if (decl_in_table == NULL)
+	error ((presence_p
+		? (final_p
+		   ? "unit `%s' in final presence set is not declared"
+		   : "unit `%s' in presence set is not declared")
+		: (final_p
+		   ? "unit `%s' in final absence set is not declared"
+		   : "unit `%s' in absence set is not declared")), names [i]);
+      else if (decl_in_table->mode != dm_unit)
+	error ((presence_p
+		? (final_p
+		   ? "`%s' in final presence set is not unit"
+		   : "`%s' in presence set is not unit")
+		: (final_p
+		   ? "`%s' in final absence set is not unit"
+		   : "`%s' in absence set is not unit")), names [i]);
+      else
+	{
+	  new_el = XCREATENODE (struct unit_set_el);
+	  new_el->unit_decl = DECL_UNIT (decl_in_table);
+	  new_el->next_unit_set_el = NULL;
+	  if (last_el == NULL)
+	    el_list = last_el = new_el;
+	  else
+	    {
+	      last_el->next_unit_set_el = new_el;
+	      last_el = last_el->next_unit_set_el;
+	    }
+	}
+    }
+  return el_list;
+}
+
+/* Checking NAMES in patterns of a presence/absence clause and
+   returning the formed pattern_set_el_list.  The function is called
+   only after processing all exclusion sets.  */
+static pattern_set_el_t
+process_presence_absence_patterns (char ***patterns, int num,
+				   pos_t req_pos ATTRIBUTE_UNUSED,
+				   int presence_p, int final_p)
+{
+  pattern_set_el_t el_list;
+  pattern_set_el_t last_el;
+  pattern_set_el_t new_el;
+  decl_t decl_in_table;
+  int i, j;
+
+  el_list = NULL;
+  last_el = NULL;
+  for (i = 0; i < num; i++)
+    {
+      for (j = 0; patterns [i] [j] != NULL; j++)
+	;
+      new_el = XCREATENODEVAR (struct pattern_set_el,
+			       sizeof (struct pattern_set_el)
+			       + sizeof (struct unit_decl *) * j);
+      new_el->unit_decls
+	= (struct unit_decl **) ((char *) new_el
+				 + sizeof (struct pattern_set_el));
+      new_el->next_pattern_set_el = NULL;
+      if (last_el == NULL)
+	el_list = last_el = new_el;
+      else
+	{
+	  last_el->next_pattern_set_el = new_el;
+	  last_el = last_el->next_pattern_set_el;
+	}
+      new_el->units_num = 0;
+      for (j = 0; patterns [i] [j] != NULL; j++)
+	{
+	  decl_in_table = find_decl (patterns [i] [j]);
+	  if (decl_in_table == NULL)
+	    error ((presence_p
+		    ? (final_p
+		       ? "unit `%s' in final presence set is not declared"
+		       : "unit `%s' in presence set is not declared")
+		    : (final_p
+		       ? "unit `%s' in final absence set is not declared"
+		       : "unit `%s' in absence set is not declared")),
+		   patterns [i] [j]);
+	  else if (decl_in_table->mode != dm_unit)
+	    error ((presence_p
+		    ? (final_p
+		       ? "`%s' in final presence set is not unit"
+		       : "`%s' in presence set is not unit")
+		    : (final_p
+		       ? "`%s' in final absence set is not unit"
+		       : "`%s' in absence set is not unit")),
+		   patterns [i] [j]);
+	  else
+	    {
+	      new_el->unit_decls [new_el->units_num]
+		= DECL_UNIT (decl_in_table);
+	      new_el->units_num++;
+	    }
+	}
+    }
+  return el_list;
+}
+
+/* The function adds each element from PATTERN_LIST to presence (if
+   PRESENCE_P) or absence list of the each element from DEST_LIST.
+   Checking situations "unit requires own absence", and "unit excludes
+   and requires presence of ...", "unit requires absence and presence
+   of ...", "units in (final) presence set belong to different
+   automata", and "units in (final) absence set belong to different
+   automata".  Remember that we process absence sets only after all
+   presence sets.  */
+static void
+add_presence_absence (unit_set_el_t dest_list,
+		      pattern_set_el_t pattern_list,
+		      pos_t req_pos ATTRIBUTE_UNUSED,
+		      int presence_p, int final_p)
+{
+  unit_set_el_t dst;
+  pattern_set_el_t pat;
+  struct unit_decl *unit;
+  unit_set_el_t curr_excl_el;
+  pattern_set_el_t curr_pat_el;
+  pattern_set_el_t prev_el;
+  pattern_set_el_t copy;
+  int i;
+  int no_error_flag;
+
+  for (dst = dest_list; dst != NULL; dst = dst->next_unit_set_el)
+    for (pat = pattern_list; pat != NULL; pat = pat->next_pattern_set_el)
+      {
+	for (i = 0; i < pat->units_num; i++)
+	  {
+	    unit = pat->unit_decls [i];
+	    if (dst->unit_decl == unit && pat->units_num == 1 && !presence_p)
+	      {
+		error ("unit `%s' requires own absence", unit->name);
+		continue;
+	      }
+	    if (dst->unit_decl->automaton_name != NULL
+		&& unit->automaton_name != NULL
+		&& strcmp (dst->unit_decl->automaton_name,
+			   unit->automaton_name) != 0)
+	      {
+		error ((presence_p
+			? (final_p
+			   ? "units `%s' and `%s' in final presence set belong to different automata"
+			   : "units `%s' and `%s' in presence set belong to different automata")
+			: (final_p
+			   ? "units `%s' and `%s' in final absence set belong to different automata"
+			   : "units `%s' and `%s' in absence set belong to different automata")),
+		       unit->name, dst->unit_decl->name);
+		continue;
+	      }
+	    no_error_flag = 1;
+	    if (presence_p)
+	      for (curr_excl_el = dst->unit_decl->excl_list;
+		   curr_excl_el != NULL;
+		   curr_excl_el = curr_excl_el->next_unit_set_el)
+		{
+		  if (unit == curr_excl_el->unit_decl && pat->units_num == 1)
+		    {
+		      if (!w_flag)
+			{
+			  error ("unit `%s' excludes and requires presence of `%s'",
+				 dst->unit_decl->name, unit->name);
+			  no_error_flag = 0;
+			}
+		      else
+			warning
+			  (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;
+		   curr_pat_el != NULL;
+		   curr_pat_el = curr_pat_el->next_pattern_set_el)
+		if (curr_pat_el->units_num == 1
+		    && unit == curr_pat_el->unit_decls [0])
+		  {
+		    if (!w_flag)
+		      {
+			error
+			  ("unit `%s' requires absence and presence of `%s'",
+			   dst->unit_decl->name, unit->name);
+			no_error_flag = 0;
+		      }
+		    else
+		      warning
+			(0, "unit `%s' requires absence and presence of `%s'",
+			 dst->unit_decl->name, unit->name);
+		  }
+	    if (no_error_flag)
+	      {
+		for (prev_el = (presence_p
+				? (final_p
+				   ? dst->unit_decl->final_presence_list
+				   : dst->unit_decl->final_presence_list)
+				: (final_p
+				   ? dst->unit_decl->final_absence_list
+				   : dst->unit_decl->absence_list));
+		     prev_el != NULL && prev_el->next_pattern_set_el != NULL;
+		     prev_el = prev_el->next_pattern_set_el)
+		  ;
+		copy = XCOPYNODE (struct pattern_set_el, pat);
+		copy->next_pattern_set_el = NULL;
+		if (prev_el == NULL)
+		  {
+		    if (presence_p)
+		      {
+			if (final_p)
+			  dst->unit_decl->final_presence_list = copy;
+			else
+			  dst->unit_decl->presence_list = copy;
+		      }
+		    else if (final_p)
+		      dst->unit_decl->final_absence_list = copy;
+		    else
+		      dst->unit_decl->absence_list = copy;
+		  }
+		else
+		  prev_el->next_pattern_set_el = copy;
+	      }
+	  }
+      }
+}
+
+
+/* The function searches for bypass with given IN_INSN_RESERV in given
+   BYPASS_LIST.  */
+static struct bypass_decl *
+find_bypass (struct bypass_decl *bypass_list,
+	     struct insn_reserv_decl *in_insn_reserv)
+{
+  struct bypass_decl *bypass;
+
+  for (bypass = bypass_list; bypass != NULL; bypass = bypass->next)
+    if (bypass->in_insn_reserv == in_insn_reserv)
+      break;
+  return bypass;
+}
+
+/* The function processes pipeline description declarations, checks
+   their correctness, and forms exclusion/presence/absence sets.  */
+static void
+process_decls (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;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_automaton)
+	{
+	  automaton_presence = 1;
+	  decl_in_table = insert_automaton_decl (decl);
+	  if (decl_in_table != decl)
+	    {
+	      if (!w_flag)
+		error ("repeated declaration of automaton `%s'",
+		       DECL_AUTOMATON (decl)->name);
+	      else
+		warning (0, "repeated declaration of automaton `%s'",
+			 DECL_AUTOMATON (decl)->name);
+	    }
+	}
+    }
+  /* Checking undeclared automata, repeated declarations (except for
+     automata) and correctness of their attributes (insn latency times
+     etc.).  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv)
+	{
+	  if (DECL_INSN_RESERV (decl)->default_latency < 0)
+	    error ("define_insn_reservation `%s' has negative latency time",
+		   DECL_INSN_RESERV (decl)->name);
+	  DECL_INSN_RESERV (decl)->insn_num = description->insns_num;
+	  description->insns_num++;
+	  decl_in_table = insert_insn_decl (decl);
+	  if (decl_in_table != decl)
+	    error ("`%s' is already used as insn reservation name",
+		   DECL_INSN_RESERV (decl)->name);
+	}
+      else if (decl->mode == dm_bypass)
+	{
+	  if (DECL_BYPASS (decl)->latency < 0)
+	    error ("define_bypass `%s - %s' has negative latency time",
+		   DECL_BYPASS (decl)->out_insn_name,
+		   DECL_BYPASS (decl)->in_insn_name);
+	}
+      else if (decl->mode == dm_unit || decl->mode == dm_reserv)
+	{
+	  if (decl->mode == dm_unit)
+	    {
+	      DECL_UNIT (decl)->automaton_decl = NULL;
+	      if (DECL_UNIT (decl)->automaton_name != NULL)
+		{
+		  automaton_decl
+                    = find_automaton_decl (DECL_UNIT (decl)->automaton_name);
+		  if (automaton_decl == NULL)
+		    error ("automaton `%s' is not declared",
+			   DECL_UNIT (decl)->automaton_name);
+		  else
+		    {
+		      DECL_AUTOMATON (automaton_decl)->automaton_is_used = 1;
+		      DECL_UNIT (decl)->automaton_decl
+			= DECL_AUTOMATON (automaton_decl);
+		    }
+		}
+	      else if (automaton_presence)
+		error ("define_unit `%s' without automaton when one defined",
+		       DECL_UNIT (decl)->name);
+	      DECL_UNIT (decl)->unit_num = description->units_num;
+	      description->units_num++;
+	      if (strcmp (DECL_UNIT (decl)->name, NOTHING_NAME) == 0)
+		{
+		  error ("`%s' is declared as cpu unit", NOTHING_NAME);
+		  continue;
+		}
+	      decl_in_table = find_decl (DECL_UNIT (decl)->name);
+	    }
+	  else
+	    {
+	      if (strcmp (DECL_RESERV (decl)->name, NOTHING_NAME) == 0)
+		{
+		  error ("`%s' is declared as cpu reservation", NOTHING_NAME);
+		  continue;
+		}
+	      decl_in_table = find_decl (DECL_RESERV (decl)->name);
+	    }
+	  if (decl_in_table == NULL)
+	    decl_in_table = insert_decl (decl);
+	  else
+	    {
+	      if (decl->mode == dm_unit)
+		error ("repeated declaration of unit `%s'",
+		       DECL_UNIT (decl)->name);
+	      else
+		error ("repeated declaration of reservation `%s'",
+		       DECL_RESERV (decl)->name);
+	    }
+	}
+    }
+  /* Check bypasses and form list of bypasses for each (output)
+     insn.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_bypass)
+	{
+	  out_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->out_insn_name);
+	  in_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->in_insn_name);
+	  if (out_insn_reserv == NULL)
+	    error ("there is no insn reservation `%s'",
+		   DECL_BYPASS (decl)->out_insn_name);
+	  else if (in_insn_reserv == NULL)
+	    error ("there is no insn reservation `%s'",
+		   DECL_BYPASS (decl)->in_insn_name);
+	  else
+	    {
+	      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
+		= 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.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_excl)
+	{
+	  unit_set_el_t unit_set_el_list;
+	  unit_set_el_t unit_set_el_list_2;
+
+	  unit_set_el_list
+            = process_excls (DECL_EXCL (decl)->names,
+			     DECL_EXCL (decl)->first_list_length, decl->pos);
+	  unit_set_el_list_2
+	    = process_excls (&DECL_EXCL (decl)->names
+			     [DECL_EXCL (decl)->first_list_length],
+                             DECL_EXCL (decl)->all_names_num
+                             - DECL_EXCL (decl)->first_list_length,
+                             decl->pos);
+	  add_excls (unit_set_el_list, unit_set_el_list_2, decl->pos);
+	  add_excls (unit_set_el_list_2, unit_set_el_list, decl->pos);
+	}
+    }
+
+  /* Check presence set declarations and form presence sets.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_presence)
+	{
+	  unit_set_el_t unit_set_el_list;
+	  pattern_set_el_t pattern_set_el_list;
+
+	  unit_set_el_list
+            = process_presence_absence_names
+	      (DECL_PRESENCE (decl)->names, DECL_PRESENCE (decl)->names_num,
+	       decl->pos, TRUE, DECL_PRESENCE (decl)->final_p);
+	  pattern_set_el_list
+	    = process_presence_absence_patterns
+	      (DECL_PRESENCE (decl)->patterns,
+	       DECL_PRESENCE (decl)->patterns_num,
+	       decl->pos, TRUE, DECL_PRESENCE (decl)->final_p);
+	  add_presence_absence (unit_set_el_list, pattern_set_el_list,
+				decl->pos, TRUE,
+				DECL_PRESENCE (decl)->final_p);
+	}
+    }
+
+  /* Check absence set declarations and form absence sets.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_absence)
+	{
+	  unit_set_el_t unit_set_el_list;
+	  pattern_set_el_t pattern_set_el_list;
+
+	  unit_set_el_list
+            = process_presence_absence_names
+	      (DECL_ABSENCE (decl)->names, DECL_ABSENCE (decl)->names_num,
+	       decl->pos, FALSE, DECL_ABSENCE (decl)->final_p);
+	  pattern_set_el_list
+	    = process_presence_absence_patterns
+	      (DECL_ABSENCE (decl)->patterns,
+	       DECL_ABSENCE (decl)->patterns_num,
+	       decl->pos, FALSE, DECL_ABSENCE (decl)->final_p);
+	  add_presence_absence (unit_set_el_list, pattern_set_el_list,
+				decl->pos, FALSE,
+				DECL_ABSENCE (decl)->final_p);
+	}
+    }
+}
+
+/* The following function checks that declared automaton is used.  If
+   the automaton is not used, the function fixes error/warning.  The
+   following function must be called only after `process_decls'.  */
+static void
+check_automaton_usage (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_automaton
+	  && !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",
+		     DECL_AUTOMATON (decl)->name);
+	}
+    }
+}
+
+/* The following recursive function processes all regexp in order to
+   fix usage of units or reservations and to fix errors of undeclared
+   name.  The function may change unit_regexp onto reserv_regexp.
+   Remember that reserv_regexp does not exist before the function
+   call.  */
+static regexp_t
+process_regexp (regexp_t regexp)
+{
+  decl_t decl_in_table;
+  regexp_t new_regexp;
+  int i;
+
+  switch (regexp->mode)
+    {
+    case rm_unit:
+      decl_in_table = find_decl (REGEXP_UNIT (regexp)->name);
+      if (decl_in_table == NULL)
+        error ("undeclared unit or reservation `%s'",
+	       REGEXP_UNIT (regexp)->name);
+      else
+	switch (decl_in_table->mode)
+	  {
+	  case dm_unit:
+	    DECL_UNIT (decl_in_table)->unit_is_used = 1;
+	    REGEXP_UNIT (regexp)->unit_decl = DECL_UNIT (decl_in_table);
+	    break;
+
+	  case dm_reserv:
+	    DECL_RESERV (decl_in_table)->reserv_is_used = 1;
+	    new_regexp = XCREATENODE (struct regexp);
+	    new_regexp->mode = rm_reserv;
+	    new_regexp->pos = regexp->pos;
+	    REGEXP_RESERV (new_regexp)->name = REGEXP_UNIT (regexp)->name;
+	    REGEXP_RESERV (new_regexp)->reserv_decl
+	      = DECL_RESERV (decl_in_table);
+	    regexp = new_regexp;
+	    break;
+
+	  default:
+	    gcc_unreachable ();
+	}
+      break;
+    case rm_sequence:
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	REGEXP_SEQUENCE (regexp)->regexps [i]
+	  = process_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+      break;
+    case rm_allof:
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	REGEXP_ALLOF (regexp)->regexps [i]
+	  = process_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+      break;
+    case rm_oneof:
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	REGEXP_ONEOF (regexp)->regexps [i]
+	  = process_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+      break;
+    case rm_repeat:
+      REGEXP_REPEAT (regexp)->regexp
+	= process_regexp (REGEXP_REPEAT (regexp)->regexp);
+      break;
+    case rm_nothing:
+      break;
+    default:
+      gcc_unreachable ();
+    }
+  return regexp;
+}
+
+/* The following function processes regexp of define_reservation and
+   define_insn_reservation with the aid of function
+   `process_regexp'.  */
+static void
+process_regexp_decls (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_reserv)
+	DECL_RESERV (decl)->regexp
+	  = process_regexp (DECL_RESERV (decl)->regexp);
+      else if (decl->mode == dm_insn_reserv)
+	DECL_INSN_RESERV (decl)->regexp
+	  = process_regexp (DECL_INSN_RESERV (decl)->regexp);
+    }
+}
+
+/* The following function checks that declared unit is used.  If the
+   unit is not used, the function fixes errors/warnings.  The
+   following function must be called only after `process_decls',
+   `process_regexp_decls'.  */
+static void
+check_usage (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      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);
+	}
+      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);
+	}
+    }
+}
+
+/* The following variable value is number of reservation being
+   processed on loop recognition.  */
+static int curr_loop_pass_num;
+
+/* The following recursive function returns nonzero value if REGEXP
+   contains given decl or reservations in given regexp refers for
+   given decl.  */
+static int
+loop_in_regexp (regexp_t regexp, decl_t start_decl)
+{
+  int i;
+
+  if (regexp == NULL)
+    return 0;
+  switch (regexp->mode)
+    {
+      case rm_unit:
+	return 0;
+
+    case rm_reserv:
+      if (start_decl->mode == dm_reserv
+          && REGEXP_RESERV (regexp)->reserv_decl == DECL_RESERV (start_decl))
+        return 1;
+      else if (REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
+	       == curr_loop_pass_num)
+        /* declaration has been processed.  */
+        return 0;
+      else
+        {
+	  REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
+            = curr_loop_pass_num;
+          return loop_in_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp,
+                                 start_decl);
+        }
+
+    case rm_sequence:
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_SEQUENCE (regexp)->regexps [i], start_decl))
+	  return 1;
+      return 0;
+
+    case rm_allof:
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_ALLOF (regexp)->regexps [i], start_decl))
+	  return 1;
+      return 0;
+
+    case rm_oneof:
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	if (loop_in_regexp (REGEXP_ONEOF (regexp)->regexps [i], start_decl))
+	  return 1;
+      return 0;
+
+    case rm_repeat:
+      return loop_in_regexp (REGEXP_REPEAT (regexp)->regexp, start_decl);
+
+    case rm_nothing:
+      return 0;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* The following function fixes errors "cycle in definition ...".  The
+   function uses function `loop_in_regexp' for that.  */
+static void
+check_loops_in_regexps (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_reserv)
+	DECL_RESERV (decl)->loop_pass_num = 0;
+    }
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      curr_loop_pass_num = i;
+
+      if (decl->mode == dm_reserv)
+	  {
+	    DECL_RESERV (decl)->loop_pass_num = curr_loop_pass_num;
+	    if (loop_in_regexp (DECL_RESERV (decl)->regexp, decl))
+	      {
+		gcc_assert (DECL_RESERV (decl)->regexp);
+		error ("cycle in definition of reservation `%s'",
+		       DECL_RESERV (decl)->name);
+	      }
+	  }
+    }
+}
+
+/* The function recursively processes IR of reservation and defines
+   max and min cycle for reservation of unit.  */
+static void
+process_regexp_cycles (regexp_t regexp, int max_start_cycle,
+		       int min_start_cycle, int *max_finish_cycle,
+		       int *min_finish_cycle)
+{
+  int i;
+
+  switch (regexp->mode)
+    {
+    case rm_unit:
+      if (REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num < max_start_cycle)
+	REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num = max_start_cycle;
+      if (REGEXP_UNIT (regexp)->unit_decl->min_occ_cycle_num > min_start_cycle
+	  || REGEXP_UNIT (regexp)->unit_decl->min_occ_cycle_num == -1)
+	REGEXP_UNIT (regexp)->unit_decl->min_occ_cycle_num = min_start_cycle;
+      *max_finish_cycle = max_start_cycle;
+      *min_finish_cycle = min_start_cycle;
+      break;
+
+    case rm_reserv:
+      process_regexp_cycles (REGEXP_RESERV (regexp)->reserv_decl->regexp,
+			     max_start_cycle, min_start_cycle,
+			     max_finish_cycle, min_finish_cycle);
+      break;
+
+    case rm_repeat:
+      for (i = 0; i < REGEXP_REPEAT (regexp)->repeat_num; i++)
+	{
+	  process_regexp_cycles (REGEXP_REPEAT (regexp)->regexp,
+				 max_start_cycle, min_start_cycle,
+				 max_finish_cycle, min_finish_cycle);
+	  max_start_cycle = *max_finish_cycle + 1;
+	  min_start_cycle = *min_finish_cycle + 1;
+	}
+      break;
+
+    case rm_sequence:
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	{
+	  process_regexp_cycles (REGEXP_SEQUENCE (regexp)->regexps [i],
+				 max_start_cycle, min_start_cycle,
+				 max_finish_cycle, min_finish_cycle);
+	  max_start_cycle = *max_finish_cycle + 1;
+	  min_start_cycle = *min_finish_cycle + 1;
+	}
+      break;
+
+    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);
+	    if (max_cycle < *max_finish_cycle)
+	      max_cycle = *max_finish_cycle;
+	    if (i == 0 || min_cycle > *min_finish_cycle)
+	      min_cycle = *min_finish_cycle;
+	  }
+	*max_finish_cycle = max_cycle;
+	*min_finish_cycle = min_cycle;
+      }
+      break;
+
+    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);
+	    if (max_cycle < *max_finish_cycle)
+	      max_cycle = *max_finish_cycle;
+	    if (i == 0 || min_cycle > *min_finish_cycle)
+	      min_cycle = *min_finish_cycle;
+	  }
+	*max_finish_cycle = max_cycle;
+	*min_finish_cycle = min_cycle;
+      }
+      break;
+
+    case rm_nothing:
+      *max_finish_cycle = max_start_cycle;
+      *min_finish_cycle = min_start_cycle;
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* The following function is called only for correct program.  The
+   function defines max reservation of insns in cycles.  */
+static void
+evaluate_max_reserv_cycles (void)
+{
+  int max_insn_cycles_num;
+  int min_insn_cycles_num;
+  decl_t decl;
+  int i;
+
+  description->max_insn_reserv_cycles = 0;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv)
+      {
+        process_regexp_cycles (DECL_INSN_RESERV (decl)->regexp, 0, 0,
+			       &max_insn_cycles_num, &min_insn_cycles_num);
+        if (description->max_insn_reserv_cycles < max_insn_cycles_num)
+	  description->max_insn_reserv_cycles = max_insn_cycles_num;
+      }
+    }
+  description->max_insn_reserv_cycles++;
+}
+
+/* The following function calls functions for checking all
+   description.  */
+static void
+check_all_description (void)
+{
+  process_decls ();
+  check_automaton_usage ();
+  process_regexp_decls ();
+  check_usage ();
+  check_loops_in_regexps ();
+  if (!have_error)
+    evaluate_max_reserv_cycles ();
+}
+
+
+
+/* The page contains abstract data `ticker'.  This data is used to
+   report time of different phases of building automata.  It is
+   possibly to write a description for which automata will be built
+   during several minutes even on fast machine.  */
+
+/* The following function creates ticker and makes it active.  */
+static ticker_t
+create_ticker (void)
+{
+  ticker_t ticker;
+
+  ticker.modified_creation_time = get_run_time ();
+  ticker.incremented_off_time = 0;
+  return ticker;
+}
+
+/* The following function switches off given ticker.  */
+static void
+ticker_off (ticker_t *ticker)
+{
+  if (ticker->incremented_off_time == 0)
+    ticker->incremented_off_time = get_run_time () + 1;
+}
+
+/* The following function switches on given ticker.  */
+static void
+ticker_on (ticker_t *ticker)
+{
+  if (ticker->incremented_off_time != 0)
+    {
+      ticker->modified_creation_time
+        += get_run_time () - ticker->incremented_off_time + 1;
+      ticker->incremented_off_time = 0;
+    }
+}
+
+/* The following function returns current time in milliseconds since
+   the moment when given ticker was created.  */
+static int
+active_time (ticker_t ticker)
+{
+  if (ticker.incremented_off_time != 0)
+    return ticker.incremented_off_time - 1 - ticker.modified_creation_time;
+  else
+    return get_run_time () - ticker.modified_creation_time;
+}
+
+/* The following function returns string representation of active time
+   of given ticker.  The result is string representation of seconds
+   with accuracy of 1/100 second.  Only result of the last call of the
+   function exists.  Therefore the following code is not correct
+
+      printf ("parser time: %s\ngeneration time: %s\n",
+              active_time_string (parser_ticker),
+              active_time_string (generation_ticker));
+
+   Correct code has to be the following
+
+      printf ("parser time: %s\n", active_time_string (parser_ticker));
+      printf ("generation time: %s\n",
+              active_time_string (generation_ticker));
+
+*/
+static void
+print_active_time (FILE *f, ticker_t ticker)
+{
+  int msecs;
+
+  msecs = active_time (ticker);
+  fprintf (f, "%d.%06d", msecs / 1000000, msecs % 1000000);
+}
+
+
+
+/* The following variable value is number of automaton which are
+   really being created.  This value is defined on the base of
+   argument of option `-split'.  If the variable has zero value the
+   number of automata is defined by the constructions `%automaton'.
+   This case occurs when option `-split' is absent or has zero
+   argument.  If constructions `define_automaton' is absent only one
+   automaton is created.  */
+static int automata_num;
+
+/* The following variable values are times of
+       o transformation of regular expressions
+       o building NDFA (DFA if !ndfa_flag)
+       o NDFA -> DFA   (simply the same automaton if !ndfa_flag)
+       o DFA minimization
+       o building insn equivalence classes
+       o all previous ones
+       o code output */
+static ticker_t transform_time;
+static ticker_t NDFA_time;
+static ticker_t NDFA_to_DFA_time;
+static ticker_t minimize_time;
+static ticker_t equiv_time;
+static ticker_t automaton_generation_time;
+static ticker_t output_time;
+
+/* The following variable values are times of
+       all checking
+       all generation
+       all pipeline hazard translator work */
+static ticker_t check_time;
+static ticker_t generation_time;
+static ticker_t all_time;
+
+
+
+/* Pseudo insn decl which denotes advancing cycle.  */
+static decl_t advance_cycle_insn_decl;
+static void
+add_advance_cycle_insn_decl (void)
+{
+  advance_cycle_insn_decl = XCREATENODE (struct decl);
+  advance_cycle_insn_decl->mode = dm_insn_reserv;
+  advance_cycle_insn_decl->pos = no_pos;
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->regexp = NULL;
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->name = "$advance_cycle";
+  DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num
+    = description->insns_num;
+  description->decls [description->decls_num] = advance_cycle_insn_decl;
+  description->decls_num++;
+  description->insns_num++;
+}
+
+
+/* Abstract data `alternative states' which represents
+   nondeterministic nature of the description (see comments for
+   structures alt_state and state).  */
+
+/* List of free states.  */
+static alt_state_t first_free_alt_state;
+
+#ifndef NDEBUG
+/* The following variables is maximal number of allocated nodes
+   alt_state.  */
+static int allocated_alt_states_num = 0;
+#endif
+
+/* The following function returns free node alt_state.  It may be new
+   allocated node or node freed earlier.  */
+static alt_state_t
+get_free_alt_state (void)
+{
+  alt_state_t result;
+
+  if (first_free_alt_state != NULL)
+    {
+      result = first_free_alt_state;
+      first_free_alt_state = first_free_alt_state->next_alt_state;
+    }
+  else
+    {
+#ifndef NDEBUG
+      allocated_alt_states_num++;
+#endif
+      result = XCREATENODE (struct alt_state);
+    }
+  result->state = NULL;
+  result->next_alt_state = NULL;
+  result->next_sorted_alt_state = NULL;
+  return result;
+}
+
+/* The function frees node ALT_STATE.  */
+static void
+free_alt_state (alt_state_t alt_state)
+{
+  if (alt_state == NULL)
+    return;
+  alt_state->next_alt_state = first_free_alt_state;
+  first_free_alt_state = alt_state;
+}
+
+/* The function frees list started with node ALT_STATE_LIST.  */
+static void
+free_alt_states (alt_state_t alt_states_list)
+{
+  alt_state_t curr_alt_state;
+  alt_state_t next_alt_state;
+
+  for (curr_alt_state = alt_states_list;
+       curr_alt_state != NULL;
+       curr_alt_state = next_alt_state)
+    {
+      next_alt_state = curr_alt_state->next_alt_state;
+      free_alt_state (curr_alt_state);
+    }
+}
+
+/* The function compares unique numbers of alt states.  */
+static int
+alt_state_cmp (const void *alt_state_ptr_1, const void *alt_state_ptr_2)
+{
+  if ((*(const alt_state_t *) alt_state_ptr_1)->state->unique_num
+      == (*(const alt_state_t *) alt_state_ptr_2)->state->unique_num)
+    return 0;
+  else if ((*(const alt_state_t *) alt_state_ptr_1)->state->unique_num
+	   < (*(const alt_state_t *) alt_state_ptr_2)->state->unique_num)
+    return -1;
+  else
+    return 1;
+}
+
+/* The function sorts ALT_STATES_LIST and removes duplicated alt
+   states from the list.  The comparison key is alt state unique
+   number.  */
+
+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;
+  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);
+  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);
+
+  qsort (VEC_address (alt_state_t, alt_states),
+	 VEC_length  (alt_state_t, alt_states),
+	 sizeof (alt_state_t), alt_state_cmp);
+
+  prev_unique_state_ind = 0;
+  for (i = 1; i < VEC_length (alt_state_t, alt_states); i++)
+    if (VEC_index (alt_state_t, alt_states, prev_unique_state_ind)->state
+	!= VEC_index (alt_state_t, alt_states, i)->state)
+      {
+	prev_unique_state_ind++;
+	VEC_replace (alt_state_t, alt_states, prev_unique_state_ind,
+		     VEC_index (alt_state_t, alt_states, i));
+      }
+  VEC_truncate (alt_state_t, alt_states, prev_unique_state_ind + 1);
+
+  for (i = 1; i < VEC_length (alt_state_t, alt_states); i++)
+    VEC_index (alt_state_t, alt_states, i-1)->next_sorted_alt_state
+      = 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);
+  return result;
+}
+
+/* The function checks equality of alt state lists.  Remember that the
+   lists must be already sorted by the previous function.  */
+static int
+alt_states_eq (alt_state_t alt_states_1, alt_state_t alt_states_2)
+{
+  while (alt_states_1 != NULL && alt_states_2 != NULL
+         && alt_state_cmp (&alt_states_1, &alt_states_2) == 0)
+    {
+      alt_states_1 = alt_states_1->next_sorted_alt_state;
+      alt_states_2 = alt_states_2->next_sorted_alt_state;
+    }
+  return alt_states_1 == alt_states_2;
+}
+
+/* Initialization of the abstract data.  */
+static void
+initiate_alt_states (void)
+{
+  first_free_alt_state = NULL;
+}
+
+/* Finishing work with the abstract data.  */
+static void
+finish_alt_states (void)
+{
+}
+
+
+
+/* The page contains macros for work with bits strings.  We could use
+   standard gcc bitmap or sbitmap but it would result in difficulties
+   of building canadian cross.  */
+
+/* Set bit number bitno in the bit string.  The macro is not side
+   effect proof.  */
+#define SET_BIT(bitstring, bitno)					  \
+  (((char *) (bitstring)) [(bitno) / CHAR_BIT] |= 1 << (bitno) % CHAR_BIT)
+
+#define CLEAR_BIT(bitstring, bitno)					  \
+  (((char *) (bitstring)) [(bitno) / CHAR_BIT] &= ~(1 << (bitno) % CHAR_BIT))
+
+/* Test if bit number bitno in the bitstring is set.  The macro is not
+   side effect proof.  */
+#define TEST_BIT(bitstring, bitno)                                        \
+  (((char *) (bitstring)) [(bitno) / CHAR_BIT] >> (bitno) % CHAR_BIT & 1)
+
+
+
+/* This page contains abstract data `state'.  */
+
+/* Maximal length of reservations in cycles (>= 1).  */
+static int max_cycles_num;
+
+/* Number of set elements (see type set_el_t) needed for
+   representation of one cycle reservation.  It is depended on units
+   number.  */
+static int els_in_cycle_reserv;
+
+/* Number of set elements (see type set_el_t) needed for
+   representation of maximal length reservation.  Deterministic
+   reservation is stored as set (bit string) of length equal to the
+   variable value * number of bits in set_el_t.  */
+static int els_in_reservs;
+
+/* Array of pointers to unit declarations.  */
+static unit_decl_t *units_array;
+
+/* Temporary reservation of maximal length.  */
+static reserv_sets_t temp_reserv;
+
+/* The state table itself is represented by the following variable.  */
+static htab_t state_table;
+
+/* Linked list of free 'state' structures to be recycled.  The
+   next_equiv_class_state pointer is borrowed for a free list.  */
+static state_t first_free_state;
+
+static int curr_unique_state_num;
+
+#ifndef NDEBUG
+/* The following variables is maximal number of allocated nodes
+   `state'.  */
+static int allocated_states_num = 0;
+#endif
+
+/* Allocate new reservation set.  */
+static reserv_sets_t
+alloc_empty_reserv_sets (void)
+{
+  reserv_sets_t result;
+
+  obstack_blank (&irp, els_in_reservs * sizeof (set_el_t));
+  result = (reserv_sets_t) obstack_base (&irp);
+  obstack_finish (&irp);
+  memset (result, 0, els_in_reservs * sizeof (set_el_t));
+  return result;
+}
+
+/* Hash value of reservation set.  */
+static unsigned
+reserv_sets_hash_value (reserv_sets_t reservs)
+{
+  set_el_t hash_value;
+  unsigned result;
+  int reservs_num, i;
+  set_el_t *reserv_ptr;
+
+  hash_value = 0;
+  reservs_num = els_in_reservs;
+  reserv_ptr = reservs;
+  i = 0;
+  while (reservs_num != 0)
+    {
+      reservs_num--;
+      hash_value += ((*reserv_ptr >> i)
+		     | (*reserv_ptr << (sizeof (set_el_t) * CHAR_BIT - i)));
+      i++;
+      if (i == sizeof (set_el_t) * CHAR_BIT)
+	i = 0;
+      reserv_ptr++;
+    }
+  if (sizeof (set_el_t) <= sizeof (unsigned))
+    return hash_value;
+  result = 0;
+  for (i = sizeof (set_el_t); i > 0; i -= sizeof (unsigned) - 1)
+    {
+      result += (unsigned) hash_value;
+      hash_value >>= (sizeof (unsigned) - 1) * CHAR_BIT;
+    }
+  return result;
+}
+
+/* Comparison of given reservation sets.  */
+static int
+reserv_sets_cmp (const_reserv_sets_t reservs_1, const_reserv_sets_t reservs_2)
+{
+  int reservs_num;
+  const set_el_t *reserv_ptr_1;
+  const set_el_t *reserv_ptr_2;
+
+  gcc_assert (reservs_1 && reservs_2);
+  reservs_num = els_in_reservs;
+  reserv_ptr_1 = reservs_1;
+  reserv_ptr_2 = reservs_2;
+  while (reservs_num != 0 && *reserv_ptr_1 == *reserv_ptr_2)
+    {
+      reservs_num--;
+      reserv_ptr_1++;
+      reserv_ptr_2++;
+    }
+  if (reservs_num == 0)
+    return 0;
+  else if (*reserv_ptr_1 < *reserv_ptr_2)
+    return -1;
+  else
+    return 1;
+}
+
+/* The function checks equality of the reservation sets.  */
+static int
+reserv_sets_eq (const_reserv_sets_t reservs_1, const_reserv_sets_t reservs_2)
+{
+  return reserv_sets_cmp (reservs_1, reservs_2) == 0;
+}
+
+/* Set up in the reservation set that unit with UNIT_NUM is used on
+   CYCLE_NUM.  */
+static void
+set_unit_reserv (reserv_sets_t reservs, int cycle_num, int unit_num)
+{
+  gcc_assert (cycle_num < max_cycles_num);
+  SET_BIT (reservs, cycle_num * els_in_cycle_reserv
+           * sizeof (set_el_t) * CHAR_BIT + unit_num);
+}
+
+/* Set up in the reservation set RESERVS that unit with UNIT_NUM is
+   used on CYCLE_NUM.  */
+static int
+test_unit_reserv (reserv_sets_t reservs, int cycle_num, int unit_num)
+{
+  gcc_assert (cycle_num < max_cycles_num);
+  return TEST_BIT (reservs, cycle_num * els_in_cycle_reserv
+		   * sizeof (set_el_t) * CHAR_BIT + unit_num);
+}
+
+/* The function checks that the reservation sets are intersected,
+   i.e. there is a unit reservation on a cycle in both reservation
+   sets.  */
+static int
+reserv_sets_are_intersected (reserv_sets_t operand_1,
+			     reserv_sets_t operand_2)
+{
+  set_el_t *el_ptr_1;
+  set_el_t *el_ptr_2;
+  set_el_t *cycle_ptr_1;
+  set_el_t *cycle_ptr_2;
+
+  gcc_assert (operand_1 && operand_2);
+  for (el_ptr_1 = operand_1, el_ptr_2 = operand_2;
+       el_ptr_1 < operand_1 + els_in_reservs;
+       el_ptr_1++, el_ptr_2++)
+    if (*el_ptr_1 & *el_ptr_2)
+      return 1;
+  reserv_sets_or (temp_reserv, operand_1, operand_2);
+  for (cycle_ptr_1 = operand_1, cycle_ptr_2 = operand_2;
+       cycle_ptr_1 < operand_1 + els_in_reservs;
+       cycle_ptr_1 += els_in_cycle_reserv, cycle_ptr_2 += els_in_cycle_reserv)
+    {
+      for (el_ptr_1 = cycle_ptr_1, el_ptr_2 = get_excl_set (cycle_ptr_2);
+	   el_ptr_1 < cycle_ptr_1 + els_in_cycle_reserv;
+	   el_ptr_1++, el_ptr_2++)
+	if (*el_ptr_1 & *el_ptr_2)
+	  return 1;
+      if (!check_presence_pattern_sets (cycle_ptr_1, cycle_ptr_2, FALSE))
+	return 1;
+      if (!check_presence_pattern_sets (temp_reserv + (cycle_ptr_2
+						       - operand_2),
+					cycle_ptr_2, TRUE))
+	return 1;
+      if (!check_absence_pattern_sets (cycle_ptr_1, cycle_ptr_2, FALSE))
+	return 1;
+      if (!check_absence_pattern_sets (temp_reserv + (cycle_ptr_2 - operand_2),
+				       cycle_ptr_2, TRUE))
+	return 1;
+    }
+  return 0;
+}
+
+/* The function sets up RESULT bits by bits of OPERAND shifted on one
+   cpu cycle.  The remaining bits of OPERAND (representing the last
+   cycle unit reservations) are not changed.  */
+static void
+reserv_sets_shift (reserv_sets_t result, reserv_sets_t operand)
+{
+  int i;
+
+  gcc_assert (result && operand && result != operand);
+  for (i = els_in_cycle_reserv; i < els_in_reservs; i++)
+    result [i - els_in_cycle_reserv] = operand [i];
+}
+
+/* OR of the reservation sets.  */
+static void
+reserv_sets_or (reserv_sets_t result, reserv_sets_t operand_1,
+		reserv_sets_t operand_2)
+{
+  set_el_t *el_ptr_1;
+  set_el_t *el_ptr_2;
+  set_el_t *result_set_el_ptr;
+
+  gcc_assert (result && operand_1 && operand_2);
+  for (el_ptr_1 = operand_1, el_ptr_2 = operand_2, result_set_el_ptr = result;
+       el_ptr_1 < operand_1 + els_in_reservs;
+       el_ptr_1++, el_ptr_2++, result_set_el_ptr++)
+    *result_set_el_ptr = *el_ptr_1 | *el_ptr_2;
+}
+
+/* AND of the reservation sets.  */
+static void
+reserv_sets_and (reserv_sets_t result, reserv_sets_t operand_1,
+		reserv_sets_t operand_2)
+{
+  set_el_t *el_ptr_1;
+  set_el_t *el_ptr_2;
+  set_el_t *result_set_el_ptr;
+
+  gcc_assert (result && operand_1 && operand_2);
+  for (el_ptr_1 = operand_1, el_ptr_2 = operand_2, result_set_el_ptr = result;
+       el_ptr_1 < operand_1 + els_in_reservs;
+       el_ptr_1++, el_ptr_2++, result_set_el_ptr++)
+    *result_set_el_ptr = *el_ptr_1 & *el_ptr_2;
+}
+
+/* The function outputs string representation of units reservation on
+   cycle START_CYCLE in the reservation set.  The function uses repeat
+   construction if REPETITION_NUM > 1.  */
+static void
+output_cycle_reservs (FILE *f, reserv_sets_t reservs, int start_cycle,
+		      int repetition_num)
+{
+  int unit_num;
+  int reserved_units_num;
+
+  reserved_units_num = 0;
+  for (unit_num = 0; unit_num < description->units_num; unit_num++)
+    if (TEST_BIT (reservs, start_cycle * els_in_cycle_reserv
+                  * sizeof (set_el_t) * CHAR_BIT + unit_num))
+      reserved_units_num++;
+  gcc_assert (repetition_num > 0);
+  if (repetition_num != 1 && reserved_units_num > 1)
+    fprintf (f, "(");
+  reserved_units_num = 0;
+  for (unit_num = 0;
+       unit_num < description->units_num;
+       unit_num++)
+    if (TEST_BIT (reservs, start_cycle * els_in_cycle_reserv
+		  * sizeof (set_el_t) * CHAR_BIT + unit_num))
+      {
+        if (reserved_units_num != 0)
+          fprintf (f, "+");
+        reserved_units_num++;
+        fprintf (f, "%s", units_array [unit_num]->name);
+      }
+  if (reserved_units_num == 0)
+    fprintf (f, NOTHING_NAME);
+  gcc_assert (repetition_num > 0);
+  if (repetition_num != 1 && reserved_units_num > 1)
+    fprintf (f, ")");
+  if (repetition_num != 1)
+    fprintf (f, "*%d", repetition_num);
+}
+
+/* The function outputs string representation of units reservation in
+   the reservation set.  */
+static void
+output_reserv_sets (FILE *f, reserv_sets_t reservs)
+{
+  int start_cycle = 0;
+  int cycle;
+  int repetition_num;
+
+  repetition_num = 0;
+  for (cycle = 0; cycle < max_cycles_num; cycle++)
+    if (repetition_num == 0)
+      {
+        repetition_num++;
+        start_cycle = cycle;
+      }
+    else if (memcmp
+             ((char *) reservs + start_cycle * els_in_cycle_reserv
+	      * sizeof (set_el_t),
+              (char *) reservs + cycle * els_in_cycle_reserv
+	      * sizeof (set_el_t),
+	      els_in_cycle_reserv * sizeof (set_el_t)) == 0)
+      repetition_num++;
+    else
+      {
+        if (start_cycle != 0)
+          fprintf (f, ", ");
+        output_cycle_reservs (f, reservs, start_cycle, repetition_num);
+        repetition_num = 1;
+        start_cycle = cycle;
+      }
+  if (start_cycle < max_cycles_num)
+    {
+      if (start_cycle != 0)
+        fprintf (f, ", ");
+      output_cycle_reservs (f, reservs, start_cycle, repetition_num);
+    }
+}
+
+/* The following function returns free node state for AUTOMATON.  It
+   may be new allocated node or node freed earlier.  The function also
+   allocates reservation set if WITH_RESERVS has nonzero value.  */
+static state_t
+get_free_state (int with_reservs, automaton_t automaton)
+{
+  state_t result;
+
+  gcc_assert (max_cycles_num > 0 && automaton);
+  if (first_free_state)
+    {
+      result = first_free_state;
+      first_free_state = result->next_equiv_class_state;
+
+      result->next_equiv_class_state = NULL;
+      result->automaton = automaton;
+      result->first_out_arc = NULL;
+      result->it_was_placed_in_stack_for_NDFA_forming = 0;
+      result->it_was_placed_in_stack_for_DFA_forming = 0;
+      result->component_states = NULL;
+    }
+  else
+    {
+#ifndef NDEBUG
+      allocated_states_num++;
+#endif
+      result = XCREATENODE (struct state);
+      result->automaton = automaton;
+      result->first_out_arc = NULL;
+      result->unique_num = curr_unique_state_num;
+      curr_unique_state_num++;
+    }
+  if (with_reservs)
+    {
+      if (result->reservs == NULL)
+        result->reservs = alloc_empty_reserv_sets ();
+      else
+        memset (result->reservs, 0, els_in_reservs * sizeof (set_el_t));
+    }
+  return result;
+}
+
+/* The function frees node STATE.  */
+static void
+free_state (state_t state)
+{
+  free_alt_states (state->component_states);
+  state->next_equiv_class_state = first_free_state;
+  first_free_state = state;
+}
+
+/* Hash value of STATE.  If STATE represents deterministic state it is
+   simply hash value of the corresponding reservation set.  Otherwise
+   it is formed from hash values of the component deterministic
+   states.  One more key is order number of state automaton.  */
+static hashval_t
+state_hash (const void *state)
+{
+  unsigned int hash_value;
+  alt_state_t alt_state;
+
+  if (((const_state_t) state)->component_states == NULL)
+    hash_value = reserv_sets_hash_value (((const_state_t) state)->reservs);
+  else
+    {
+      hash_value = 0;
+      for (alt_state = ((const_state_t) state)->component_states;
+           alt_state != NULL;
+           alt_state = alt_state->next_sorted_alt_state)
+        hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
+                       | (hash_value << CHAR_BIT))
+                      + alt_state->state->unique_num);
+    }
+  hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
+                 | (hash_value << CHAR_BIT))
+                + ((const_state_t) state)->automaton->automaton_order_num);
+  return hash_value;
+}
+
+/* Return nonzero value if the states are the same.  */
+static int
+state_eq_p (const void *state_1, const void *state_2)
+{
+  alt_state_t alt_state_1;
+  alt_state_t alt_state_2;
+
+  if (((const_state_t) state_1)->automaton != ((const_state_t) state_2)->automaton)
+    return 0;
+  else if (((const_state_t) state_1)->component_states == NULL
+           && ((const_state_t) state_2)->component_states == NULL)
+    return reserv_sets_eq (((const_state_t) state_1)->reservs,
+			   ((const_state_t) state_2)->reservs);
+  else if (((const_state_t) state_1)->component_states != NULL
+           && ((const_state_t) state_2)->component_states != NULL)
+    {
+      for (alt_state_1 = ((const_state_t) state_1)->component_states,
+           alt_state_2 = ((const_state_t) state_2)->component_states;
+           alt_state_1 != NULL && alt_state_2 != NULL;
+           alt_state_1 = alt_state_1->next_sorted_alt_state,
+	   alt_state_2 = alt_state_2->next_sorted_alt_state)
+        /* All state in the list must be already in the hash table.
+           Also the lists must be sorted.  */
+        if (alt_state_1->state != alt_state_2->state)
+          return 0;
+      return alt_state_1 == alt_state_2;
+    }
+  else
+    return 0;
+}
+
+/* Insert STATE into the state table.  */
+static state_t
+insert_state (state_t state)
+{
+  void **entry_ptr;
+
+  entry_ptr = htab_find_slot (state_table, (void *) state, 1);
+  if (*entry_ptr == NULL)
+    *entry_ptr = (void *) state;
+  return (state_t) *entry_ptr;
+}
+
+/* Add reservation of unit with UNIT_NUM on cycle CYCLE_NUM to
+   deterministic STATE.  */
+static void
+set_state_reserv (state_t state, int cycle_num, int unit_num)
+{
+  set_unit_reserv (state->reservs, cycle_num, unit_num);
+}
+
+/* Return nonzero value if the deterministic states contains a
+   reservation of the same cpu unit on the same cpu cycle.  */
+static int
+intersected_state_reservs_p (state_t state1, state_t state2)
+{
+  gcc_assert (state1->automaton == state2->automaton);
+  return reserv_sets_are_intersected (state1->reservs, state2->reservs);
+}
+
+/* Return deterministic state (inserted into the table) which
+   representing the automaton state which is union of reservations of
+   the deterministic states masked by RESERVS.  */
+static state_t
+states_union (state_t state1, state_t state2, reserv_sets_t reservs)
+{
+  state_t result;
+  state_t state_in_table;
+
+  gcc_assert (state1->automaton == state2->automaton);
+  result = get_free_state (1, state1->automaton);
+  reserv_sets_or (result->reservs, state1->reservs, state2->reservs);
+  reserv_sets_and (result->reservs, result->reservs, reservs);
+  state_in_table = insert_state (result);
+  if (result != state_in_table)
+    {
+      free_state (result);
+      result = state_in_table;
+    }
+  return result;
+}
+
+/* Return deterministic state (inserted into the table) which
+   represent the automaton state is obtained from deterministic STATE
+   by advancing cpu cycle and masking by RESERVS.  */
+static state_t
+state_shift (state_t state, reserv_sets_t reservs)
+{
+  state_t result;
+  state_t state_in_table;
+
+  result = get_free_state (1, state->automaton);
+  reserv_sets_shift (result->reservs, state->reservs);
+  reserv_sets_and (result->reservs, result->reservs, reservs);
+  state_in_table = insert_state (result);
+  if (result != state_in_table)
+    {
+      free_state (result);
+      result = state_in_table;
+    }
+  return result;
+}
+
+/* Initialization of the abstract data.  */
+static void
+initiate_states (void)
+{
+  decl_t decl;
+  int i;
+
+  if (description->units_num)
+    units_array = XNEWVEC (unit_decl_t, description->units_num);
+  else
+    units_array = 0;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	units_array [DECL_UNIT (decl)->unit_num] = DECL_UNIT (decl);
+    }
+  max_cycles_num = description->max_insn_reserv_cycles;
+  els_in_cycle_reserv
+    = ((description->units_num + sizeof (set_el_t) * CHAR_BIT - 1)
+       / (sizeof (set_el_t) * CHAR_BIT));
+  els_in_reservs = els_in_cycle_reserv * max_cycles_num;
+  curr_unique_state_num = 0;
+  initiate_alt_states ();
+  state_table = htab_create (1500, state_hash, state_eq_p, (htab_del) 0);
+  temp_reserv = alloc_empty_reserv_sets ();
+}
+
+/* Finishing work with the abstract data.  */
+static void
+finish_states (void)
+{
+  free (units_array);
+  units_array = 0;
+  htab_delete (state_table);
+  first_free_state = NULL;
+  finish_alt_states ();
+}
+
+
+
+/* Abstract data `arcs'.  */
+
+/* List of free arcs.  */
+static arc_t first_free_arc;
+
+#ifndef NDEBUG
+/* The following variables is maximal number of allocated nodes
+   `arc'.  */
+static int allocated_arcs_num = 0;
+#endif
+
+/* The function frees node ARC.  */
+static void
+free_arc (arc_t arc)
+{
+  arc->next_out_arc = first_free_arc;
+  first_free_arc = arc;
+}
+
+/* The function removes and frees ARC staring from FROM_STATE.  */
+static void
+remove_arc (state_t from_state, arc_t arc)
+{
+  arc_t prev_arc;
+  arc_t curr_arc;
+
+  gcc_assert (arc);
+  for (prev_arc = NULL, curr_arc = from_state->first_out_arc;
+       curr_arc != NULL;
+       prev_arc = curr_arc, curr_arc = curr_arc->next_out_arc)
+    if (curr_arc == arc)
+      break;
+  gcc_assert (curr_arc);
+  if (prev_arc == NULL)
+    from_state->first_out_arc = arc->next_out_arc;
+  else
+    prev_arc->next_out_arc = arc->next_out_arc;
+  from_state->num_out_arcs--;
+  free_arc (arc);
+}
+
+/* The functions returns arc with given characteristics (or NULL if
+   the arc does not exist).  */
+static arc_t
+find_arc (state_t from_state, state_t to_state, ainsn_t insn)
+{
+  arc_t arc;
+
+  for (arc = first_out_arc (from_state); arc != NULL; arc = next_out_arc (arc))
+    if (arc->to_state == to_state && arc->insn == insn)
+      return arc;
+  return NULL;
+}
+
+/* The function adds arc from FROM_STATE to TO_STATE marked by AINSN.
+   The function returns added arc (or already existing arc).  */
+static arc_t
+add_arc (state_t from_state, state_t to_state, ainsn_t ainsn)
+{
+  arc_t new_arc;
+
+  new_arc = find_arc (from_state, to_state, ainsn);
+  if (new_arc != NULL)
+    return new_arc;
+  if (first_free_arc == NULL)
+    {
+#ifndef NDEBUG
+      allocated_arcs_num++;
+#endif
+      new_arc = XCREATENODE (struct arc);
+      new_arc->to_state = NULL;
+      new_arc->insn = NULL;
+      new_arc->next_out_arc = NULL;
+    }
+  else
+    {
+      new_arc = first_free_arc;
+      first_free_arc =  first_free_arc->next_out_arc;
+    }
+  new_arc->to_state = to_state;
+  new_arc->insn = ainsn;
+  ainsn->arc_exists_p = 1;
+  new_arc->next_out_arc = from_state->first_out_arc;
+  from_state->first_out_arc = new_arc;
+  from_state->num_out_arcs++;
+  new_arc->next_arc_marked_by_insn = NULL;
+  return new_arc;
+}
+
+/* The function returns the first arc starting from STATE.  */
+static arc_t
+first_out_arc (const_state_t state)
+{
+  return state->first_out_arc;
+}
+
+/* The function returns next out arc after ARC.  */
+static arc_t
+next_out_arc (arc_t arc)
+{
+  return arc->next_out_arc;
+}
+
+/* Initialization of the abstract data.  */
+static void
+initiate_arcs (void)
+{
+  first_free_arc = NULL;
+}
+
+/* Finishing work with the abstract data.  */
+static void
+finish_arcs (void)
+{
+}
+
+
+
+/* Abstract data `automata lists'.  */
+
+/* List of free states.  */
+static automata_list_el_t first_free_automata_list_el;
+
+/* The list being formed.  */
+static automata_list_el_t current_automata_list;
+
+/* Hash table of automata lists.  */
+static htab_t automata_list_table;
+
+/* The following function returns free automata list el.  It may be
+   new allocated node or node freed earlier.  */
+static automata_list_el_t
+get_free_automata_list_el (void)
+{
+  automata_list_el_t result;
+
+  if (first_free_automata_list_el != NULL)
+    {
+      result = first_free_automata_list_el;
+      first_free_automata_list_el
+	= first_free_automata_list_el->next_automata_list_el;
+    }
+  else
+    result = XCREATENODE (struct automata_list_el);
+  result->automaton = NULL;
+  result->next_automata_list_el = NULL;
+  return result;
+}
+
+/* The function frees node AUTOMATA_LIST_EL.  */
+static void
+free_automata_list_el (automata_list_el_t automata_list_el)
+{
+  if (automata_list_el == NULL)
+    return;
+  automata_list_el->next_automata_list_el = first_free_automata_list_el;
+  first_free_automata_list_el = automata_list_el;
+}
+
+/* The function frees list AUTOMATA_LIST.  */
+static void
+free_automata_list (automata_list_el_t automata_list)
+{
+  automata_list_el_t curr_automata_list_el;
+  automata_list_el_t next_automata_list_el;
+
+  for (curr_automata_list_el = automata_list;
+       curr_automata_list_el != NULL;
+       curr_automata_list_el = next_automata_list_el)
+    {
+      next_automata_list_el = curr_automata_list_el->next_automata_list_el;
+      free_automata_list_el (curr_automata_list_el);
+    }
+}
+
+/* Hash value of AUTOMATA_LIST.  */
+static hashval_t
+automata_list_hash (const void *automata_list)
+{
+  unsigned int hash_value;
+  const_automata_list_el_t curr_automata_list_el;
+
+  hash_value = 0;
+  for (curr_automata_list_el = (const_automata_list_el_t) automata_list;
+       curr_automata_list_el != NULL;
+       curr_automata_list_el = curr_automata_list_el->next_automata_list_el)
+    hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
+		   | (hash_value << CHAR_BIT))
+		  + curr_automata_list_el->automaton->automaton_order_num);
+  return hash_value;
+}
+
+/* Return nonzero value if the automata_lists are the same.  */
+static int
+automata_list_eq_p (const void *automata_list_1, const void *automata_list_2)
+{
+  const_automata_list_el_t automata_list_el_1;
+  const_automata_list_el_t automata_list_el_2;
+
+  for (automata_list_el_1 = (const_automata_list_el_t) automata_list_1,
+	 automata_list_el_2 = (const_automata_list_el_t) automata_list_2;
+       automata_list_el_1 != NULL && automata_list_el_2 != NULL;
+       automata_list_el_1 = automata_list_el_1->next_automata_list_el,
+	 automata_list_el_2 = automata_list_el_2->next_automata_list_el)
+    if (automata_list_el_1->automaton != automata_list_el_2->automaton)
+      return 0;
+  return automata_list_el_1 == automata_list_el_2;
+}
+
+/* Initialization of the abstract data.  */
+static void
+initiate_automata_lists (void)
+{
+  first_free_automata_list_el = NULL;
+  automata_list_table = htab_create (1500, automata_list_hash,
+				     automata_list_eq_p, (htab_del) 0);
+}
+
+/* The following function starts new automata list and makes it the
+   current one.  */
+static void
+automata_list_start (void)
+{
+  current_automata_list = NULL;
+}
+
+/* The following function adds AUTOMATON to the current list.  */
+static void
+automata_list_add (automaton_t automaton)
+{
+  automata_list_el_t el;
+
+  el = get_free_automata_list_el ();
+  el->automaton = automaton;
+  el->next_automata_list_el = current_automata_list;
+  current_automata_list = el;
+}
+
+/* The following function finishes forming the current list, inserts
+   it into the table and returns it.  */
+static automata_list_el_t
+automata_list_finish (void)
+{
+  void **entry_ptr;
+
+  if (current_automata_list == NULL)
+    return NULL;
+  entry_ptr = htab_find_slot (automata_list_table,
+			      (void *) current_automata_list, 1);
+  if (*entry_ptr == NULL)
+    *entry_ptr = (void *) current_automata_list;
+  else
+    free_automata_list (current_automata_list);
+  current_automata_list = NULL;
+  return (automata_list_el_t) *entry_ptr;
+}
+
+/* Finishing work with the abstract data.  */
+static void
+finish_automata_lists (void)
+{
+  htab_delete (automata_list_table);
+}
+
+
+
+/* The page contains abstract data for work with exclusion sets (see
+   exclusion_set in file rtl.def).  */
+
+/* The following variable refers to an exclusion set returned by
+   get_excl_set.  This is bit string of length equal to cpu units
+   number.  If exclusion set for given unit contains 1 for a unit,
+   then simultaneous reservation of the units is prohibited.  */
+static reserv_sets_t excl_set;
+
+/* The array contains exclusion sets for each unit.  */
+static reserv_sets_t *unit_excl_set_table;
+
+/* The following function forms the array containing exclusion sets
+   for each unit.  */
+static void
+initiate_excl_sets (void)
+{
+  decl_t decl;
+  reserv_sets_t unit_excl_set;
+  unit_set_el_t el;
+  int i;
+
+  obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
+  excl_set = (reserv_sets_t) obstack_base (&irp);
+  obstack_finish (&irp);
+  obstack_blank (&irp, description->units_num * sizeof (reserv_sets_t));
+  unit_excl_set_table = (reserv_sets_t *) obstack_base (&irp);
+  obstack_finish (&irp);
+  /* Evaluate unit exclusion sets.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	{
+	  obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
+	  unit_excl_set = (reserv_sets_t) obstack_base (&irp);
+	  obstack_finish (&irp);
+	  memset (unit_excl_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
+	  for (el = DECL_UNIT (decl)->excl_list;
+	       el != NULL;
+	       el = el->next_unit_set_el)
+	    {
+	      SET_BIT (unit_excl_set, el->unit_decl->unit_num);
+	      el->unit_decl->in_set_p = TRUE;
+	    }
+          unit_excl_set_table [DECL_UNIT (decl)->unit_num] = unit_excl_set;
+        }
+    }
+}
+
+/* The function sets up and return EXCL_SET which is union of
+   exclusion sets for each unit in IN_SET.  */
+static reserv_sets_t
+get_excl_set (reserv_sets_t in_set)
+{
+  int excl_char_num;
+  int chars_num;
+  int i;
+  int start_unit_num;
+  int unit_num;
+
+  chars_num = els_in_cycle_reserv * sizeof (set_el_t);
+  memset (excl_set, 0, chars_num);
+  for (excl_char_num = 0; excl_char_num < chars_num; excl_char_num++)
+    if (((unsigned char *) in_set) [excl_char_num])
+      for (i = CHAR_BIT - 1; i >= 0; i--)
+	if ((((unsigned char *) in_set) [excl_char_num] >> i) & 1)
+	  {
+	    start_unit_num = excl_char_num * CHAR_BIT + i;
+	    if (start_unit_num >= description->units_num)
+	      return excl_set;
+	    for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++)
+	      {
+		excl_set [unit_num]
+		  |= unit_excl_set_table [start_unit_num] [unit_num];
+	      }
+	  }
+  return excl_set;
+}
+
+
+
+/* The page contains abstract data for work with presence/absence
+   pattern sets (see presence_set/absence_set in file rtl.def).  */
+
+/* The following arrays contain correspondingly presence, final
+   presence, absence, and final absence patterns for each unit.  */
+static pattern_reserv_t *unit_presence_set_table;
+static pattern_reserv_t *unit_final_presence_set_table;
+static pattern_reserv_t *unit_absence_set_table;
+static pattern_reserv_t *unit_final_absence_set_table;
+
+/* The following function forms list of reservation sets for given
+   PATTERN_LIST.  */
+static pattern_reserv_t
+form_reserv_sets_list (pattern_set_el_t pattern_list)
+{
+  pattern_set_el_t el;
+  pattern_reserv_t first, curr, prev;
+  int i;
+
+  prev = first = NULL;
+  for (el = pattern_list; el != NULL; el = el->next_pattern_set_el)
+    {
+      curr = XCREATENODE (struct pattern_reserv);
+      curr->reserv = alloc_empty_reserv_sets ();
+      curr->next_pattern_reserv = NULL;
+      for (i = 0; i < el->units_num; i++)
+	{
+	  SET_BIT (curr->reserv, el->unit_decls [i]->unit_num);
+	  el->unit_decls [i]->in_set_p = TRUE;
+	}
+      if (prev != NULL)
+	prev->next_pattern_reserv = curr;
+      else
+	first = curr;
+      prev = curr;
+    }
+  return first;
+}
+
+ /* The following function forms the array containing presence and
+   absence pattern sets for each unit.  */
+static void
+initiate_presence_absence_pattern_sets (void)
+{
+  decl_t decl;
+  int i;
+
+  obstack_blank (&irp, description->units_num * sizeof (pattern_reserv_t));
+  unit_presence_set_table = (pattern_reserv_t *) obstack_base (&irp);
+  obstack_finish (&irp);
+  obstack_blank (&irp, description->units_num * sizeof (pattern_reserv_t));
+  unit_final_presence_set_table = (pattern_reserv_t *) obstack_base (&irp);
+  obstack_finish (&irp);
+  obstack_blank (&irp, description->units_num * sizeof (pattern_reserv_t));
+  unit_absence_set_table = (pattern_reserv_t *) obstack_base (&irp);
+  obstack_finish (&irp);
+  obstack_blank (&irp, description->units_num * sizeof (pattern_reserv_t));
+  unit_final_absence_set_table = (pattern_reserv_t *) obstack_base (&irp);
+  obstack_finish (&irp);
+  /* Evaluate unit presence/absence sets.  */
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	{
+          unit_presence_set_table [DECL_UNIT (decl)->unit_num]
+	    = form_reserv_sets_list (DECL_UNIT (decl)->presence_list);
+          unit_final_presence_set_table [DECL_UNIT (decl)->unit_num]
+	    = form_reserv_sets_list (DECL_UNIT (decl)->final_presence_list);
+          unit_absence_set_table [DECL_UNIT (decl)->unit_num]
+	    = form_reserv_sets_list (DECL_UNIT (decl)->absence_list);
+          unit_final_absence_set_table [DECL_UNIT (decl)->unit_num]
+	    = form_reserv_sets_list (DECL_UNIT (decl)->final_absence_list);
+        }
+    }
+}
+
+/* The function checks that CHECKED_SET satisfies all presence pattern
+   sets for units in ORIGINAL_SET.  The function returns TRUE if it
+   is ok.  */
+static int
+check_presence_pattern_sets (reserv_sets_t checked_set,
+			     reserv_sets_t original_set,
+			     int final_p)
+{
+  int char_num;
+  int chars_num;
+  int i;
+  int start_unit_num;
+  int unit_num;
+  int presence_p;
+  pattern_reserv_t pat_reserv;
+
+  chars_num = els_in_cycle_reserv * sizeof (set_el_t);
+  for (char_num = 0; char_num < chars_num; char_num++)
+    if (((unsigned char *) original_set) [char_num])
+      for (i = CHAR_BIT - 1; i >= 0; i--)
+	if ((((unsigned char *) original_set) [char_num] >> i) & 1)
+	  {
+	    start_unit_num = char_num * CHAR_BIT + i;
+	    if (start_unit_num >= description->units_num)
+	      break;
+	    if ((final_p
+		 && unit_final_presence_set_table [start_unit_num] == NULL)
+		|| (!final_p
+		    && unit_presence_set_table [start_unit_num] == NULL))
+	      continue;
+	    presence_p = FALSE;
+	    for (pat_reserv = (final_p
+			       ? unit_final_presence_set_table [start_unit_num]
+			       : unit_presence_set_table [start_unit_num]);
+		 pat_reserv != NULL;
+		 pat_reserv = pat_reserv->next_pattern_reserv)
+	      {
+		for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++)
+		  if ((checked_set [unit_num] & pat_reserv->reserv [unit_num])
+		      != pat_reserv->reserv [unit_num])
+		    break;
+		presence_p = presence_p || unit_num >= els_in_cycle_reserv;
+	      }
+	    if (!presence_p)
+	      return FALSE;
+	  }
+  return TRUE;
+}
+
+/* The function checks that CHECKED_SET satisfies all absence pattern
+   sets for units in ORIGINAL_SET.  The function returns TRUE if it
+   is ok.  */
+static int
+check_absence_pattern_sets (reserv_sets_t checked_set,
+			    reserv_sets_t original_set,
+			    int final_p)
+{
+  int char_num;
+  int chars_num;
+  int i;
+  int start_unit_num;
+  int unit_num;
+  pattern_reserv_t pat_reserv;
+
+  chars_num = els_in_cycle_reserv * sizeof (set_el_t);
+  for (char_num = 0; char_num < chars_num; char_num++)
+    if (((unsigned char *) original_set) [char_num])
+      for (i = CHAR_BIT - 1; i >= 0; i--)
+	if ((((unsigned char *) original_set) [char_num] >> i) & 1)
+	  {
+	    start_unit_num = char_num * CHAR_BIT + i;
+	    if (start_unit_num >= description->units_num)
+	      break;
+	    for (pat_reserv = (final_p
+			       ? unit_final_absence_set_table [start_unit_num]
+			       : unit_absence_set_table [start_unit_num]);
+		 pat_reserv != NULL;
+		 pat_reserv = pat_reserv->next_pattern_reserv)
+	      {
+		for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++)
+		  if ((checked_set [unit_num] & pat_reserv->reserv [unit_num])
+		      != pat_reserv->reserv [unit_num]
+		      && pat_reserv->reserv [unit_num])
+		    break;
+		if (unit_num >= els_in_cycle_reserv)
+		  return FALSE;
+	      }
+	  }
+  return TRUE;
+}
+
+
+
+/* This page contains code for transformation of original reservations
+   described in .md file.  The main goal of transformations is
+   simplifying reservation and lifting up all `|' on the top of IR
+   reservation representation.  */
+
+
+/* The following function makes copy of IR representation of
+   reservation.  The function also substitutes all reservations
+   defined by define_reservation by corresponding value during making
+   the copy.  */
+static regexp_t
+copy_insn_regexp (regexp_t regexp)
+{
+  regexp_t  result;
+  int i;
+
+  switch (regexp->mode)
+    {
+    case rm_reserv:
+      result = copy_insn_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp);
+      break;
+
+    case rm_unit:
+      result = XCOPYNODE (struct regexp, regexp);
+      break;
+
+    case rm_repeat:
+      result = XCOPYNODE (struct regexp, regexp);
+      REGEXP_REPEAT (result)->regexp
+        = copy_insn_regexp (REGEXP_REPEAT (regexp)->regexp);
+      break;
+
+    case rm_sequence:
+      result = XCOPYNODEVAR (struct regexp, regexp,
+			     sizeof (struct regexp) + sizeof (regexp_t)
+			     * (REGEXP_SEQUENCE (regexp)->regexps_num - 1));
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	REGEXP_SEQUENCE (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+      break;
+
+    case rm_allof:
+      result = XCOPYNODEVAR (struct regexp, regexp,
+			     sizeof (struct regexp) + sizeof (regexp_t)
+			     * (REGEXP_ALLOF (regexp)->regexps_num - 1));
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	REGEXP_ALLOF (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+      break;
+
+    case rm_oneof:
+      result = XCOPYNODEVAR (struct regexp, regexp,
+			     sizeof (struct regexp) + sizeof (regexp_t)
+			     * (REGEXP_ONEOF (regexp)->regexps_num - 1));
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	REGEXP_ONEOF (result)->regexps [i]
+	  = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+      break;
+
+    case rm_nothing:
+      result = XCOPYNODE (struct regexp, regexp);
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+  return result;
+}
+
+/* The following variable is set up 1 if a transformation has been
+   applied.  */
+static int regexp_transformed_p;
+
+/* The function makes transformation
+   A*N -> A, A, ...  */
+static regexp_t
+transform_1 (regexp_t regexp)
+{
+  int i;
+  int repeat_num;
+  regexp_t operand;
+  pos_t pos;
+
+  if (regexp->mode == rm_repeat)
+    {
+      repeat_num = REGEXP_REPEAT (regexp)->repeat_num;
+      gcc_assert (repeat_num > 1);
+      operand = REGEXP_REPEAT (regexp)->regexp;
+      pos = regexp->mode;
+      regexp = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+			       + sizeof (regexp_t) * (repeat_num - 1));
+      regexp->mode = rm_sequence;
+      regexp->pos = pos;
+      REGEXP_SEQUENCE (regexp)->regexps_num = repeat_num;
+      for (i = 0; i < repeat_num; i++)
+	REGEXP_SEQUENCE (regexp)->regexps [i] = copy_insn_regexp (operand);
+      regexp_transformed_p = 1;
+    }
+  return regexp;
+}
+
+/* The function makes transformations
+   ...,(A,B,...),C,... -> ...,A,B,...,C,...
+   ...+(A+B+...)+C+... -> ...+A+B+...+C+...
+   ...|(A|B|...)|C|... -> ...|A|B|...|C|...  */
+static regexp_t
+transform_2 (regexp_t regexp)
+{
+  if (regexp->mode == rm_sequence)
+    {
+      regexp_t sequence = NULL;
+      regexp_t result;
+      int sequence_index = 0;
+      int i, j;
+
+      for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_sequence)
+	  {
+	    sequence_index = i;
+	    sequence = REGEXP_SEQUENCE (regexp)->regexps [i];
+	    break;
+	  }
+      if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
+	{
+	  gcc_assert (REGEXP_SEQUENCE (sequence)->regexps_num > 1
+		      && REGEXP_SEQUENCE (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t)
+				   * (REGEXP_SEQUENCE (regexp)->regexps_num
+				      + REGEXP_SEQUENCE (sequence)->regexps_num
+				      - 2));
+	  result->mode = rm_sequence;
+	  result->pos = regexp->pos;
+	  REGEXP_SEQUENCE (result)->regexps_num
+            = (REGEXP_SEQUENCE (regexp)->regexps_num
+               + REGEXP_SEQUENCE (sequence)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+            if (i < sequence_index)
+              REGEXP_SEQUENCE (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+            else if (i > sequence_index)
+              REGEXP_SEQUENCE (result)->regexps
+                [i + REGEXP_SEQUENCE (sequence)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+            else
+              for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
+                REGEXP_SEQUENCE (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_SEQUENCE (sequence)->regexps [j]);
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+    }
+  else if (regexp->mode == rm_allof)
+    {
+      regexp_t allof = NULL;
+      regexp_t result;
+      int allof_index = 0;
+      int i, j;
+
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_allof)
+	  {
+	    allof_index = i;
+	    allof = REGEXP_ALLOF (regexp)->regexps [i];
+	    break;
+	  }
+      if (i < REGEXP_ALLOF (regexp)->regexps_num)
+	{
+	  gcc_assert (REGEXP_ALLOF (allof)->regexps_num > 1
+		      && REGEXP_ALLOF (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t)
+				   * (REGEXP_ALLOF (regexp)->regexps_num
+				      + REGEXP_ALLOF (allof)->regexps_num - 2));
+	  result->mode = rm_allof;
+	  result->pos = regexp->pos;
+	  REGEXP_ALLOF (result)->regexps_num
+            = (REGEXP_ALLOF (regexp)->regexps_num
+               + REGEXP_ALLOF (allof)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+            if (i < allof_index)
+              REGEXP_ALLOF (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+            else if (i > allof_index)
+              REGEXP_ALLOF (result)->regexps
+                [i + REGEXP_ALLOF (allof)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+            else
+              for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
+                REGEXP_ALLOF (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_ALLOF (allof)->regexps [j]);
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+    }
+  else if (regexp->mode == rm_oneof)
+    {
+      regexp_t oneof = NULL;
+      regexp_t result;
+      int oneof_index = 0;
+      int i, j;
+
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	if (REGEXP_ONEOF (regexp)->regexps [i]->mode == rm_oneof)
+	  {
+	    oneof_index = i;
+	    oneof = REGEXP_ONEOF (regexp)->regexps [i];
+	    break;
+	  }
+      if (i < REGEXP_ONEOF (regexp)->regexps_num)
+	{
+	  gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1
+		      && REGEXP_ONEOF (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t)
+				   * (REGEXP_ONEOF (regexp)->regexps_num
+				      + REGEXP_ONEOF (oneof)->regexps_num - 2));
+	  result->mode = rm_oneof;
+	  result->pos = regexp->pos;
+	  REGEXP_ONEOF (result)->regexps_num
+	    = (REGEXP_ONEOF (regexp)->regexps_num
+               + REGEXP_ONEOF (oneof)->regexps_num - 1);
+	  for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+            if (i < oneof_index)
+              REGEXP_ONEOF (result)->regexps [i]
+                = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+            else if (i > oneof_index)
+              REGEXP_ONEOF (result)->regexps
+                [i + REGEXP_ONEOF (oneof)->regexps_num - 1]
+                = copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+            else
+              for (j = 0; j < REGEXP_ONEOF (oneof)->regexps_num; j++)
+                REGEXP_ONEOF (result)->regexps [i + j]
+                  = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [j]);
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+    }
+  return regexp;
+}
+
+/* The function makes transformations
+   ...,A|B|...,C,... -> (...,A,C,...)|(...,B,C,...)|...
+   ...+(A|B|...)+C+... -> (...+A+C+...)|(...+B+C+...)|...
+   ...+(A,B,...)+C+... -> (...+A+C+...),B,...
+   ...+(A,B,...)+(C,D,...) -> (A+C),(B+D),...  */
+static regexp_t
+transform_3 (regexp_t regexp)
+{
+  if (regexp->mode == rm_sequence)
+    {
+      regexp_t oneof = NULL;
+      int oneof_index = 0;
+      regexp_t result;
+      regexp_t sequence;
+      int i, j;
+
+      for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_oneof)
+	  {
+	    oneof_index = i;
+	    oneof = REGEXP_SEQUENCE (regexp)->regexps [i];
+	    break;
+	  }
+      if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
+	{
+	  gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1
+		      && REGEXP_SEQUENCE (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t)
+				   * (REGEXP_ONEOF (oneof)->regexps_num - 1));
+	  result->mode = rm_oneof;
+	  result->pos = regexp->pos;
+	  REGEXP_ONEOF (result)->regexps_num
+	    = REGEXP_ONEOF (oneof)->regexps_num;
+	  for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
+	    {
+	      sequence
+                = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				  + sizeof (regexp_t)
+				  * (REGEXP_SEQUENCE (regexp)->regexps_num - 1));
+	      sequence->mode = rm_sequence;
+	      sequence->pos = regexp->pos;
+	      REGEXP_SEQUENCE (sequence)->regexps_num
+                = REGEXP_SEQUENCE (regexp)->regexps_num;
+              REGEXP_ONEOF (result)->regexps [i] = sequence;
+	      for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
+		if (j != oneof_index)
+		  REGEXP_SEQUENCE (sequence)->regexps [j]
+		    = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [j]);
+		else
+		  REGEXP_SEQUENCE (sequence)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
+	    }
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+    }
+  else if (regexp->mode == rm_allof)
+    {
+      regexp_t oneof = NULL;
+      regexp_t seq;
+      int oneof_index = 0;
+      int max_seq_length, allof_length;
+      regexp_t result;
+      regexp_t allof = NULL;
+      regexp_t allof_op = NULL;
+      int i, j;
+
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_oneof)
+	  {
+	    oneof_index = i;
+	    oneof = REGEXP_ALLOF (regexp)->regexps [i];
+	    break;
+	  }
+      if (i < REGEXP_ALLOF (regexp)->regexps_num)
+	{
+	  gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1
+		      && REGEXP_ALLOF (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t)
+				   * (REGEXP_ONEOF (oneof)->regexps_num - 1));
+	  result->mode = rm_oneof;
+	  result->pos = regexp->pos;
+	  REGEXP_ONEOF (result)->regexps_num
+	    = REGEXP_ONEOF (oneof)->regexps_num;
+	  for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
+	    {
+	      allof
+		= XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				  + sizeof (regexp_t)
+				  * (REGEXP_ALLOF (regexp)->regexps_num - 1));
+	      allof->mode = rm_allof;
+	      allof->pos = regexp->pos;
+	      REGEXP_ALLOF (allof)->regexps_num
+                = REGEXP_ALLOF (regexp)->regexps_num;
+              REGEXP_ONEOF (result)->regexps [i] = allof;
+	      for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
+		if (j != oneof_index)
+		  REGEXP_ALLOF (allof)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [j]);
+		else
+		  REGEXP_ALLOF (allof)->regexps [j]
+		    = copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
+	    }
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+      max_seq_length = 0;
+      if (regexp->mode == rm_allof)
+	for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	  {
+	    switch (REGEXP_ALLOF (regexp)->regexps [i]->mode)
+	      {
+	      case rm_sequence:
+		seq = REGEXP_ALLOF (regexp)->regexps [i];
+		if (max_seq_length < REGEXP_SEQUENCE (seq)->regexps_num)
+		  max_seq_length = REGEXP_SEQUENCE (seq)->regexps_num;
+		break;
+
+	      case rm_unit:
+	      case rm_nothing:
+		break;
+
+	      default:
+		max_seq_length = 0;
+		goto break_for;
+	      }
+	  }
+    break_for:
+      if (max_seq_length != 0)
+	{
+	  gcc_assert (max_seq_length != 1
+		      && REGEXP_ALLOF (regexp)->regexps_num > 1);
+	  result = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+				   + sizeof (regexp_t) * (max_seq_length - 1));
+	  result->mode = rm_sequence;
+	  result->pos = regexp->pos;
+	  REGEXP_SEQUENCE (result)->regexps_num = max_seq_length;
+	  for (i = 0; i < max_seq_length; i++)
+	    {
+	      allof_length = 0;
+	      for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
+		switch (REGEXP_ALLOF (regexp)->regexps [j]->mode)
+		  {
+		  case rm_sequence:
+		    if (i < (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+					      ->regexps [j])->regexps_num))
+		      {
+			allof_op
+			  = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+					      ->regexps [j])
+			     ->regexps [i]);
+			allof_length++;
+		      }
+		    break;
+		  case rm_unit:
+		  case rm_nothing:
+		    if (i == 0)
+		      {
+			allof_op = REGEXP_ALLOF (regexp)->regexps [j];
+			allof_length++;
+		      }
+		    break;
+		  default:
+		    break;
+		  }
+	      
+	      if (allof_length == 1)
+		REGEXP_SEQUENCE (result)->regexps [i] = allof_op;
+	      else
+		{
+		  allof = XCREATENODEVAR (struct regexp, sizeof (struct regexp)
+					  + sizeof (regexp_t)
+					  * (allof_length - 1));
+		  allof->mode = rm_allof;
+		  allof->pos = regexp->pos;
+		  REGEXP_ALLOF (allof)->regexps_num = allof_length;
+		  REGEXP_SEQUENCE (result)->regexps [i] = allof;
+		  allof_length = 0;
+		  for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
+		    if (REGEXP_ALLOF (regexp)->regexps [j]->mode == rm_sequence
+			&& (i <
+			    (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+					      ->regexps [j])->regexps_num)))
+		      {
+			allof_op = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
+						     ->regexps [j])
+				    ->regexps [i]);
+			REGEXP_ALLOF (allof)->regexps [allof_length]
+			  = allof_op;
+			allof_length++;
+		      }
+		    else if (i == 0
+			     && (REGEXP_ALLOF (regexp)->regexps [j]->mode
+				 == rm_unit
+				 || (REGEXP_ALLOF (regexp)->regexps [j]->mode
+				     == rm_nothing)))
+		      {
+			allof_op = REGEXP_ALLOF (regexp)->regexps [j];
+			REGEXP_ALLOF (allof)->regexps [allof_length]
+			  = allof_op;
+			allof_length++;
+		      }
+		}
+	    }
+	  regexp_transformed_p = 1;
+	  regexp = result;
+	}
+    }
+  return regexp;
+}
+
+/* The function traverses IR of reservation and applies transformations
+   implemented by FUNC.  */
+static regexp_t
+regexp_transform_func (regexp_t regexp, regexp_t (*func) (regexp_t regexp))
+{
+  int i;
+
+  switch (regexp->mode)
+    {
+    case rm_sequence:
+      for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+	REGEXP_SEQUENCE (regexp)->regexps [i]
+	  = regexp_transform_func (REGEXP_SEQUENCE (regexp)->regexps [i],
+				   func);
+      break;
+
+    case rm_allof:
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	REGEXP_ALLOF (regexp)->regexps [i]
+	  = regexp_transform_func (REGEXP_ALLOF (regexp)->regexps [i], func);
+      break;
+
+    case rm_oneof:
+      for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+	REGEXP_ONEOF (regexp)->regexps [i]
+	  = regexp_transform_func (REGEXP_ONEOF (regexp)->regexps [i], func);
+      break;
+
+    case rm_repeat:
+      REGEXP_REPEAT (regexp)->regexp
+	= regexp_transform_func (REGEXP_REPEAT (regexp)->regexp, func);
+      break;
+
+    case rm_nothing:
+    case rm_unit:
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+  return (*func) (regexp);
+}
+
+/* The function applies all transformations for IR representation of
+   reservation REGEXP.  */
+static regexp_t
+transform_regexp (regexp_t regexp)
+{
+  regexp = regexp_transform_func (regexp, transform_1);
+  do
+    {
+      regexp_transformed_p = 0;
+      regexp = regexp_transform_func (regexp, transform_2);
+      regexp = regexp_transform_func (regexp, transform_3);
+    }
+  while (regexp_transformed_p);
+  return regexp;
+}
+
+/* The function applies all transformations for reservations of all
+   insn declarations.  */
+static void
+transform_insn_regexps (void)
+{
+  decl_t decl;
+  int i;
+
+  transform_time = create_ticker ();
+  add_advance_cycle_insn_decl ();
+  if (progress_flag)
+    fprintf (stderr, "Reservation transformation...");
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
+	DECL_INSN_RESERV (decl)->transformed_regexp
+	  = transform_regexp (copy_insn_regexp
+			      (DECL_INSN_RESERV (decl)->regexp));
+    }
+  if (progress_flag)
+    fprintf (stderr, "done\n");
+  ticker_off (&transform_time);
+}
+
+
+
+/* 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 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.  */
+  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);
+
+/* 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
+   + the alternative number.  */
+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;
+  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);
+  
+  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 */
+}
+
+/* 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;
+  regexp_t seq, allof, unit;
+  struct unit_usage *unit_usage_ptr, *other_unit_usage_ptr;
+
+  if (regexp == NULL || regexp->mode != rm_oneof)
+    return;
+  /* Store all unit usages in the regexp:  */
+  obstack_init (&unit_usages);
+  cycle_alt_unit_usages = 0;
+
+  for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
+    {
+      seq = REGEXP_ONEOF (regexp)->regexps [i];
+      switch (seq->mode)
+	{
+	case rm_sequence:
+	  for (j = 0; j < REGEXP_SEQUENCE (seq)->regexps_num; j++)
+	    {
+	      allof = REGEXP_SEQUENCE (seq)->regexps [j];
+	      switch (allof->mode)
+		{
+		case rm_allof:
+		  for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++)
+		    {
+		      unit = REGEXP_ALLOF (allof)->regexps [k];
+		      if (unit->mode == rm_unit)
+			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;
+
+	case rm_allof:
+	  for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
+	    {
+	      unit = REGEXP_ALLOF (seq)->regexps [k];
+	      switch (unit->mode)
+		{
+		case rm_unit:
+		  store_alt_unit_usage (regexp, unit, 0, i);
+		  break;
+		  
+		case rm_nothing:
+		  break;
+		  
+		default:
+		  gcc_unreachable ();
+		}
+	    }
+	  break;
+
+	case rm_unit:
+	  store_alt_unit_usage (regexp, seq, 0, i);
+	  break;
+
+	case rm_nothing:
+	  break;
+
+	default:
+	  gcc_unreachable ();
+	}
+    }
+  /* Check distribution:  */
+  for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i++)
+    {
+      cycle = i / REGEXP_ONEOF (regexp)->regexps_num;
+      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)
+	  {
+	    unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle;
+	    for (k = cycle * REGEXP_ONEOF (regexp)->regexps_num;
+		 k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
+		   && k == cycle * REGEXP_ONEOF (regexp)->regexps_num;
+		 k++)
+	      {
+		for (other_unit_usage_ptr
+		       = VEC_index (unit_usage_t, cycle_alt_unit_usages, k);
+		     other_unit_usage_ptr != NULL;
+		     other_unit_usage_ptr = other_unit_usage_ptr->next)
+		  if (unit_usage_ptr->unit_decl->automaton_decl
+		      == other_unit_usage_ptr->unit_decl->automaton_decl)
+		    break;
+		if (other_unit_usage_ptr == NULL
+		    && (VEC_index (unit_usage_t, cycle_alt_unit_usages, k)
+			!= NULL))
+		  break;
+	      }
+	    if (k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
+		&& k == cycle * REGEXP_ONEOF (regexp)->regexps_num)
+	      {
+		if (!annotation_message_reported_p)
+		  {
+		    fprintf (stderr, "\n");
+		    error ("The following units do not satisfy units-automata distribution rule");
+		    error (" (A unit of given unit automaton should be on each reserv. altern.)");
+		    annotation_message_reported_p = TRUE;
+		  }
+		error ("Unit %s, reserv. %s, cycle %d",
+		       unit_usage_ptr->unit_decl->name, insn_reserv_name,
+		       cycle);
+	      }
+	  }
+    }
+  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.  */
+static void
+check_unit_distributions_to_automata (void)
+{
+  decl_t decl;
+  int i;
+
+  if (progress_flag)
+    fprintf (stderr, "Check unit distributions to automata...");
+  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);
+    }
+  if (progress_flag)
+    fprintf (stderr, "done\n");
+}
+
+
+
+/* The page contains code for building alt_states (see comments for
+   IR) describing all possible insns reservations of an automaton.  */
+
+/* Current state being formed for which the current alt_state
+   refers.  */
+static state_t state_being_formed;
+
+/* Current alt_state being formed.  */
+static alt_state_t alt_state_being_formed;
+
+/* This recursive function processes `,' and units in reservation
+   REGEXP for forming alt_states of AUTOMATON.  It is believed that
+   CURR_CYCLE is start cycle of all reservation REGEXP.  */
+static int
+process_seq_for_forming_states (regexp_t regexp, automaton_t automaton,
+				int curr_cycle)
+{
+  int i;
+
+  if (regexp == NULL)
+    return curr_cycle;
+
+  switch (regexp->mode)
+    {
+    case rm_unit:
+      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;
+      return curr_cycle;
+
+    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);
+	    if (finish_cycle < cycle)
+	      finish_cycle = cycle;
+	  }
+	return finish_cycle;
+      }
+
+    case rm_nothing:
+      return curr_cycle;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* This recursive function finishes forming ALT_STATE of AUTOMATON and
+   inserts alt_state into the table.  */
+static void
+finish_forming_alt_state (alt_state_t alt_state,
+			  automaton_t automaton ATTRIBUTE_UNUSED)
+{
+  state_t state_in_table;
+  state_t corresponding_state;
+
+  corresponding_state = alt_state->state;
+  state_in_table = insert_state (corresponding_state);
+  if (state_in_table != corresponding_state)
+    {
+      free_state (corresponding_state);
+      alt_state->state = state_in_table;
+    }
+}
+
+/* The following variable value is current automaton insn for whose
+   reservation the alt states are created.  */
+static ainsn_t curr_ainsn;
+
+/* This recursive function processes `|' in reservation REGEXP for
+   forming alt_states of AUTOMATON.  List of the alt states should
+   have the same order as in the description.  */
+static void
+process_alts_for_forming_states (regexp_t regexp, automaton_t automaton,
+				 int inside_oneof_p)
+{
+  int i;
+
+  if (regexp->mode != rm_oneof)
+    {
+      alt_state_being_formed = get_free_alt_state ();
+      state_being_formed = get_free_state (1, automaton);
+      alt_state_being_formed->state = state_being_formed;
+      /* We inserts in reverse order but we process alternatives also
+         in reverse order.  So we have the same order of alternative
+         as in the description.  */
+      alt_state_being_formed->next_alt_state = curr_ainsn->alt_states;
+      curr_ainsn->alt_states = alt_state_being_formed;
+      (void) process_seq_for_forming_states (regexp, automaton, 0);
+      finish_forming_alt_state (alt_state_being_formed, automaton);
+    }
+  else
+    {
+      gcc_assert (!inside_oneof_p);
+      /* We processes it in reverse order to get list with the same
+	 order as in the description.  See also the previous
+	 commentary.  */
+      for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
+	process_alts_for_forming_states (REGEXP_ONEOF (regexp)->regexps [i],
+					 automaton, 1);
+    }
+}
+
+/* Create nodes alt_state for all AUTOMATON insns.  */
+static void
+create_alt_states (automaton_t automaton)
+{
+  struct insn_reserv_decl *reserv_decl;
+
+  for (curr_ainsn = automaton->ainsn_list;
+       curr_ainsn != NULL;
+       curr_ainsn = curr_ainsn->next_ainsn)
+    {
+      reserv_decl = curr_ainsn->insn_reserv_decl;
+      if (reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
+        {
+          curr_ainsn->alt_states = NULL;
+          process_alts_for_forming_states (reserv_decl->transformed_regexp,
+					   automaton, 0);
+          curr_ainsn->sorted_alt_states
+	    = uniq_sort_alt_states (curr_ainsn->alt_states);
+        }
+    }
+}
+
+
+
+/* The page contains major code for building DFA(s) for fast pipeline
+   hazards recognition.  */
+
+/* The function forms list of ainsns of AUTOMATON with the same
+   reservation.  */
+
+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);
+
+  for (curr_ainsn = automaton->ainsn_list;
+       curr_ainsn != NULL;
+       curr_ainsn = curr_ainsn->next_ainsn)
+    if (curr_ainsn->insn_reserv_decl
+	== DECL_INSN_RESERV (advance_cycle_insn_decl))
+      {
+        curr_ainsn->next_same_reservs_insn = NULL;
+        curr_ainsn->first_insn_with_same_reservs = 1;
+      }
+    else
+      {
+        for (i = 0; i < VEC_length (ainsn_t, last_insns); i++)
+          if (alt_states_eq
+              (curr_ainsn->sorted_alt_states,
+               VEC_index (ainsn_t, last_insns, i)->sorted_alt_states))
+            break;
+        curr_ainsn->next_same_reservs_insn = NULL;
+        if (i < VEC_length (ainsn_t, last_insns))
+          {
+            curr_ainsn->first_insn_with_same_reservs = 0;
+	    VEC_index (ainsn_t, last_insns, i)->next_same_reservs_insn
+	      = curr_ainsn;
+            VEC_replace (ainsn_t, last_insns, i, curr_ainsn);
+          }
+        else
+          {
+            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);
+}
+
+/* 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
+   the minimization without such optimization, but the automaton
+   right after the building could be huge.  So in other words, usage
+   of reservs_matter means some minimization during building the
+   automaton.  */
+static reserv_sets_t
+form_reservs_matter (automaton_t automaton)
+{
+  int cycle, unit;
+  reserv_sets_t reservs_matter = alloc_empty_reserv_sets();
+
+  for (cycle = 0; cycle < max_cycles_num; cycle++)
+    for (unit = 0; unit < description->units_num; unit++)
+      if (units_array [unit]->automaton_decl
+	  == automaton->corresponding_automaton_decl
+	  && (cycle >= units_array [unit]->min_occ_cycle_num
+	      /* We can not remove queried unit from reservations.  */
+	      || units_array [unit]->query_p
+	      /* We can not remove units which are used
+		 `exclusion_set', `presence_set',
+		 `final_presence_set', `absence_set', and
+		 `final_absence_set'.  */
+	      || units_array [unit]->in_set_p))
+	set_unit_reserv (reservs_matter, cycle, unit);
+  return reservs_matter;
+}
+
+/* The following function creates all states of nondeterministic AUTOMATON.  */
+static void
+make_automaton (automaton_t automaton)
+{
+  ainsn_t ainsn;
+  struct insn_reserv_decl *insn_reserv_decl;
+  alt_state_t alt_state;
+  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);
+  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);
+  states_n = 1;
+  while (VEC_length (state_t, state_stack) != 0)
+    {
+      state = VEC_pop (state_t, state_stack);
+      advance_cycle_ainsn = NULL;
+      for (ainsn = automaton->ainsn_list;
+	   ainsn != NULL;
+	   ainsn = ainsn->next_ainsn)
+        if (ainsn->first_insn_with_same_reservs)
+          {
+            insn_reserv_decl = ainsn->insn_reserv_decl;
+            if (insn_reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
+              {
+		/* We process alt_states in the same order as they are
+                   present in the description.  */
+		added_arc = NULL;
+                for (alt_state = ainsn->alt_states;
+                     alt_state != NULL;
+                     alt_state = alt_state->next_alt_state)
+                  {
+                    state2 = alt_state->state;
+                    if (!intersected_state_reservs_p (state, state2))
+                      {
+                        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);
+			    states_n++;
+			    if (progress_flag && states_n % 100 == 0)
+			      fprintf (stderr, ".");
+                          }
+			added_arc = add_arc (state, state2, ainsn);
+			if (!ndfa_flag)
+			  break;
+                      }
+                  }
+		if (!ndfa_flag && added_arc != NULL)
+		  {
+		    for (alt_state = ainsn->alt_states;
+			 alt_state != NULL;
+			 alt_state = alt_state->next_alt_state)
+		      state2 = alt_state->state;
+		  }
+              }
+            else
+              advance_cycle_ainsn = 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);
+	  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);
+}
+
+/* Form lists of all arcs of STATE marked by the same ainsn.  */
+static void
+form_arcs_marked_by_insn (state_t state)
+{
+  decl_t decl;
+  arc_t arc;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv)
+	DECL_INSN_RESERV (decl)->arcs_marked_by_insn = NULL;
+    }
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    {
+      gcc_assert (arc->insn);
+      arc->next_arc_marked_by_insn
+	= arc->insn->insn_reserv_decl->arcs_marked_by_insn;
+      arc->insn->insn_reserv_decl->arcs_marked_by_insn = arc;
+    }
+}
+
+/* The function creates composed state (see comments for IR) from
+   ORIGINAL_STATE and list of arcs ARCS_MARKED_BY_INSN marked by the
+   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)
+{
+  state_t state;
+  alt_state_t alt_state, curr_alt_state;
+  alt_state_t new_alt_state;
+  arc_t curr_arc;
+  arc_t next_arc;
+  state_t state_in_table;
+  state_t temp_state;
+  alt_state_t canonical_alt_states_list;
+  int alts_number;
+  int new_state_p = 0;
+
+  if (arcs_marked_by_insn == NULL)
+    return new_state_p;
+  if (arcs_marked_by_insn->next_arc_marked_by_insn == NULL)
+    state = arcs_marked_by_insn->to_state;
+  else
+    {
+      gcc_assert (ndfa_flag);
+      /* Create composed state.  */
+      state = get_free_state (0, arcs_marked_by_insn->to_state->automaton);
+      curr_alt_state = NULL;
+      for (curr_arc = arcs_marked_by_insn;
+           curr_arc != NULL;
+           curr_arc = curr_arc->next_arc_marked_by_insn)
+	if (curr_arc->to_state->component_states == NULL)
+	  {
+	    new_alt_state = get_free_alt_state ();
+	    new_alt_state->next_alt_state = curr_alt_state;
+	    new_alt_state->state = curr_arc->to_state;
+	    curr_alt_state = new_alt_state;
+	  }
+	else
+	  for (alt_state = curr_arc->to_state->component_states;
+	       alt_state != NULL;
+	       alt_state = alt_state->next_sorted_alt_state)
+	    {
+	      new_alt_state = get_free_alt_state ();
+	      new_alt_state->next_alt_state = curr_alt_state;
+	      new_alt_state->state = alt_state->state;
+	      gcc_assert (!alt_state->state->component_states);
+	      curr_alt_state = new_alt_state;
+	    }
+      /* There are not identical sets in the alt state list.  */
+      canonical_alt_states_list = uniq_sort_alt_states (curr_alt_state);
+      if (canonical_alt_states_list->next_sorted_alt_state == NULL)
+        {
+          temp_state = state;
+          state = canonical_alt_states_list->state;
+          free_state (temp_state);
+        }
+      else
+        {
+          state->component_states = canonical_alt_states_list;
+          state_in_table = insert_state (state);
+          if (state_in_table != state)
+            {
+              gcc_assert
+		(state_in_table->it_was_placed_in_stack_for_DFA_forming);
+              free_state (state);
+              state = state_in_table;
+            }
+          else
+            {
+              gcc_assert (!state->it_was_placed_in_stack_for_DFA_forming);
+	      new_state_p = 1;
+              for (curr_alt_state = state->component_states;
+                   curr_alt_state != NULL;
+                   curr_alt_state = curr_alt_state->next_sorted_alt_state)
+                for (curr_arc = first_out_arc (curr_alt_state->state);
+                     curr_arc != NULL;
+                     curr_arc = next_out_arc (curr_arc))
+		  add_arc (state, curr_arc->to_state, curr_arc->insn);
+            }
+          arcs_marked_by_insn->to_state = state;
+          for (alts_number = 0,
+	       curr_arc = arcs_marked_by_insn->next_arc_marked_by_insn;
+               curr_arc != NULL;
+               curr_arc = next_arc)
+            {
+              next_arc = curr_arc->next_arc_marked_by_insn;
+              remove_arc (original_state, curr_arc);
+	      alts_number++;
+            }
+        }
+    }
+  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);
+    }
+  return new_state_p;
+}
+
+/* The function transforms nondeterministic AUTOMATON into
+   deterministic.  */
+
+static void
+NDFA_to_DFA (automaton_t automaton)
+{
+  state_t start_state;
+  state_t state;
+  decl_t decl;
+  VEC(state_t,heap) *state_stack;
+  int i;
+  int states_n;
+
+  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);
+  states_n = 1;
+  while (VEC_length (state_t, state_stack) != 0)
+    {
+      state = VEC_pop (state_t, state_stack);
+      form_arcs_marked_by_insn (state);
+      for (i = 0; i < description->decls_num; i++)
+	{
+	  decl = description->decls [i];
+	  if (decl->mode == dm_insn_reserv
+	      && create_composed_state
+	         (state, DECL_INSN_RESERV (decl)->arcs_marked_by_insn,
+		  &state_stack))
+	    {
+	      states_n++;
+	      if (progress_flag && states_n % 100 == 0)
+		fprintf (stderr, ".");
+	    }
+	}
+    }
+  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;
+
+/* This recursive function passes all states achieved from START_STATE
+   and applies APPLIED_FUNC to them.  */
+static void
+pass_state_graph (state_t start_state, void (*applied_func) (state_t state))
+{
+  arc_t arc;
+
+  if (start_state->pass_num == curr_state_graph_pass_num)
+    return;
+  start_state->pass_num = curr_state_graph_pass_num;
+  (*applied_func) (start_state);
+  for (arc = first_out_arc (start_state);
+       arc != NULL;
+       arc = next_out_arc (arc))
+    pass_state_graph (arc->to_state, applied_func);
+}
+
+/* This recursive function passes all states of AUTOMATON and applies
+   APPLIED_FUNC to them.  */
+static void
+pass_states (automaton_t automaton, void (*applied_func) (state_t state))
+{
+  curr_state_graph_pass_num++;
+  pass_state_graph (automaton->start_state, applied_func);
+}
+
+/* The function initializes code for passing of all states.  */
+static void
+initiate_pass_states (void)
+{
+  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;
+
+/* 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);
+}
+
+/* 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.
+   The function returns number of out arcs of STATE.  */
+static void
+set_out_arc_insns_equiv_num (state_t state, int odd_iteration_flag)
+{
+  arc_t arc;
+
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    {
+      gcc_assert (!arc->insn->insn_reserv_decl->equiv_class_num);
+      arc->insn->insn_reserv_decl->equiv_class_num
+	= (odd_iteration_flag
+           ? arc->to_state->equiv_class_num_1
+	   : arc->to_state->equiv_class_num_2);
+      gcc_assert (arc->insn->insn_reserv_decl->equiv_class_num);
+    }
+}
+
+/* The function clears equivalence numbers and alt_states in all insns
+   which mark all out arcs of STATE.  */
+static void
+clear_arc_insns_equiv_num (state_t state)
+{
+  arc_t arc;
+
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    arc->insn->insn_reserv_decl->equiv_class_num = 0;
+}
+
+
+/* The following function returns TRUE if STATE reserves the unit with
+   UNIT_NUM on the first cycle.  */
+static int
+first_cycle_unit_presence (state_t state, int unit_num)
+{
+  alt_state_t alt_state;
+
+  if (state->component_states == NULL)
+    return test_unit_reserv (state->reservs, 0, unit_num);
+  else
+    {
+      for (alt_state = state->component_states;
+	   alt_state != NULL;
+	   alt_state = alt_state->next_sorted_alt_state)
+	if (test_unit_reserv (alt_state->state->reservs, 0, unit_num))
+	  return true;
+    }
+  return false;
+}
+
+/* This fills in the presence_signature[] member of STATE.  */
+static void
+cache_presence (state_t 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);
+	state->presence_signature[num / (sizeof (int) * CHAR_BIT)]
+	  |= (!!presence1_p) << (num % (sizeof (int) * CHAR_BIT));
+	num++;
+      }
+}
+
+/* The function returns nonzero value if STATE is not equivalent to
+   ANOTHER_STATE from the same current partition on equivalence
+   classes.  Another state has ANOTHER_STATE_OUT_ARCS_NUM number of
+   output arcs.  Iteration of making equivalence partition is defined
+   by ODD_ITERATION_FLAG.  */
+static int
+state_is_differed (state_t state, state_t another_state,
+		   int odd_iteration_flag)
+{
+  arc_t arc;
+  unsigned int sz, si;
+
+  gcc_assert (state->num_out_arcs == another_state->num_out_arcs);
+
+  sz = (description->query_units_num + sizeof (int) * CHAR_BIT - 1)
+	/ (sizeof (int) * CHAR_BIT);
+
+  for (si = 0; si < sz; si++)
+    gcc_assert (state->presence_signature[si]
+		== another_state->presence_signature[si]);
+
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    {
+      if ((odd_iteration_flag
+           ? arc->to_state->equiv_class_num_1
+	   : arc->to_state->equiv_class_num_2)
+          != arc->insn->insn_reserv_decl->equiv_class_num)
+        return 1;
+    }
+
+  return 0;
+}
+
+/* Compares two states pointed to by STATE_PTR_1 and STATE_PTR_2
+   and return -1, 0 or 1.  This function can be used as predicate for
+   qsort().  It requires the member presence_signature[] of both
+   states be filled.  */
+static int
+compare_states_for_equiv (const void *state_ptr_1,
+			  const void *state_ptr_2)
+{
+  const_state_t const s1 = *(const_state_t const*)state_ptr_1;
+  const_state_t const s2 = *(const_state_t const*)state_ptr_2;
+  unsigned int sz, si;
+  if (s1->num_out_arcs < s2->num_out_arcs)
+    return -1;
+  else if (s1->num_out_arcs > s2->num_out_arcs)
+    return 1;
+
+  sz = (description->query_units_num + sizeof (int) * CHAR_BIT - 1)
+	/ (sizeof (int) * CHAR_BIT);
+
+  for (si = 0; si < sz; si++)
+    if (s1->presence_signature[si] < s2->presence_signature[si])
+      return -1;
+    else if (s1->presence_signature[si] > s2->presence_signature[si])
+      return 1;
+  return 0;
+}
+
+/* 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)
+{
+  size_t i;
+  state_t prev = 0;
+  int class_num = 1;
+
+  *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);
+	      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);
+  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)
+{
+  VEC_free (state_t,heap, *to);
+  *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
+   removing nonequivalent states and placing them in
+   *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,
+		       int *new_equiv_class_num_ptr)
+{
+  state_t new_equiv_class;
+  int partition_p;
+  state_t curr_state;
+  state_t prev_state;
+  state_t next_state;
+
+  partition_p = 0;
+
+  while (first_state != NULL)
+    {
+      new_equiv_class = NULL;
+      if (first_state->next_equiv_class_state != NULL)
+	{
+	  /* There are more one states in the class equivalence.  */
+	  set_out_arc_insns_equiv_num (first_state, odd_iteration_flag);
+	  for (prev_state = first_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.  */
+		  curr_state->next_equiv_class_state = new_equiv_class;
+		  if (new_equiv_class == NULL)
+		    (*new_equiv_class_num_ptr)++;
+		  if (odd_iteration_flag)
+		    curr_state->equiv_class_num_2 = *new_equiv_class_num_ptr;
+		  else
+		    curr_state->equiv_class_num_1 = *new_equiv_class_num_ptr;
+		  new_equiv_class = curr_state;
+		  partition_p = 1;
+		}
+	      else
+		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);
+      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)
+{
+  int new_equiv_class_num;
+  int odd_iteration_flag;
+  int finish_flag;
+  VEC (state_t,heap) *next_iteration_classes;
+  size_t i;
+
+  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);
+
+  odd_iteration_flag = 0;
+  new_equiv_class_num = init_equiv_class (all_achieved_states,
+  					  &next_iteration_classes);
+
+  do
+    {
+      odd_iteration_flag = !odd_iteration_flag;
+      finish_flag = 1;
+      copy_equiv_class (equiv_classes, next_iteration_classes);
+
+      /* Transfer equiv numbers for the next iteration.  */
+      for (i = 0; i < VEC_length (state_t, all_achieved_states); i++)
+	if (odd_iteration_flag)
+	  VEC_index (state_t, all_achieved_states, i)->equiv_class_num_2
+	    = VEC_index (state_t, all_achieved_states, i)->equiv_class_num_1;
+	else
+	  VEC_index (state_t, all_achieved_states, i)->equiv_class_num_1
+	    = VEC_index (state_t, all_achieved_states, i)->equiv_class_num_2;
+
+      for (i = 0; i < VEC_length (state_t, *equiv_classes); i++)
+	if (partition_equiv_class (VEC_index (state_t, *equiv_classes, i),
+				   odd_iteration_flag,
+				   &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, all_achieved_states);
+}
+
+/* The function merges equivalent states of AUTOMATON.  */
+static void
+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;
+  alt_state_t alt_state, new_alt_state;
+  arc_t curr_arc;
+  arc_t next_arc;
+  size_t i;
+
+  /* Create states corresponding to equivalence classes containing two
+     or more states.  */
+  for (i = 0; i < VEC_length (state_t, equiv_classes); i++)
+    {
+      curr_state = VEC_index (state_t, equiv_classes, i);
+      if (curr_state->next_equiv_class_state != NULL)
+	{
+	  /* There are more one states in the class equivalence.  */
+	  /* Create new compound state.  */
+	  new_state = get_free_state (0, automaton);
+	  alt_states = NULL;
+	  first_class_state = curr_state;
+	  for (curr_state = first_class_state;
+	       curr_state != NULL;
+	       curr_state = curr_state->next_equiv_class_state)
+	    {
+	      curr_state->equiv_class_state = new_state;
+	      if (curr_state->component_states == NULL)
+		{
+		  new_alt_state = get_free_alt_state ();
+		  new_alt_state->state = curr_state;
+		  new_alt_state->next_alt_state = alt_states;
+		  alt_states = new_alt_state;
+		}
+	      else
+		for (alt_state = curr_state->component_states;
+		     alt_state != NULL;
+		     alt_state = alt_state->next_sorted_alt_state)
+		  {
+		    new_alt_state = get_free_alt_state ();
+		    new_alt_state->state = alt_state->state;
+		    new_alt_state->next_alt_state = alt_states;
+		    alt_states = new_alt_state;
+		  }
+	    }
+	  /* Its is important that alt states were sorted before and
+	     after merging to have the same querying results.  */
+	  new_state->component_states = uniq_sort_alt_states (alt_states);
+	}
+      else
+	curr_state->equiv_class_state = curr_state;
+    }
+
+  for (i = 0; i < VEC_length (state_t, equiv_classes); i++)
+    {
+      curr_state = VEC_index (state_t, equiv_classes, i);
+      if (curr_state->next_equiv_class_state != NULL)
+	{
+	  first_class_state = curr_state;
+	  /* Create new arcs output from the state corresponding to
+	     equiv class.  */
+	  for (curr_arc = first_out_arc (first_class_state);
+	       curr_arc != NULL;
+	       curr_arc = next_out_arc (curr_arc))
+	    add_arc (first_class_state->equiv_class_state,
+		     curr_arc->to_state->equiv_class_state,
+		     curr_arc->insn);
+	  /* Delete output arcs from states of given class equivalence.  */
+	  for (curr_state = first_class_state;
+	       curr_state != NULL;
+	       curr_state = curr_state->next_equiv_class_state)
+	    {
+	      if (automaton->start_state == curr_state)
+		automaton->start_state = curr_state->equiv_class_state;
+	      /* Delete the state and its output arcs.  */
+	      for (curr_arc = first_out_arc (curr_state);
+		   curr_arc != NULL;
+		   curr_arc = next_arc)
+		{
+		  next_arc = next_out_arc (curr_arc);
+		  free_arc (curr_arc);
+		}
+	    }
+	}
+      else
+	{
+	  /* Change `to_state' of arcs output from the state of given
+	     equivalence class.  */
+	  for (curr_arc = first_out_arc (curr_state);
+	       curr_arc != NULL;
+	       curr_arc = next_out_arc (curr_arc))
+	    curr_arc->to_state = curr_arc->to_state->equiv_class_state;
+	}
+    }
+}
+
+/* The function sets up new_cycle_p for states if there is arc to the
+   state marked by advance_cycle_insn_decl.  */
+static void
+set_new_cycle_flags (state_t state)
+{
+  arc_t arc;
+
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    if (arc->insn->insn_reserv_decl
+	== DECL_INSN_RESERV (advance_cycle_insn_decl))
+      arc->to_state->new_cycle_p = 1;
+}
+
+/* The top level function for minimization of deterministic
+   AUTOMATON.  */
+static void
+minimize_DFA (automaton_t automaton)
+{
+  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);
+}
+
+/* Values of two variables are counted number of states and arcs in an
+   automaton.  */
+static int curr_counted_states_num;
+static int curr_counted_arcs_num;
+
+/* The function is called by function `pass_states' to count states
+   and arcs of an automaton.  */
+static void
+incr_states_and_arcs_nums (state_t state)
+{
+  arc_t arc;
+
+  curr_counted_states_num++;
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    curr_counted_arcs_num++;
+}
+
+/* The function counts states and arcs of AUTOMATON.  */
+static void
+count_states_and_arcs (automaton_t automaton, int *states_num,
+		       int *arcs_num)
+{
+  curr_counted_states_num = 0;
+  curr_counted_arcs_num = 0;
+  pass_states (automaton, incr_states_and_arcs_nums);
+  *states_num = curr_counted_states_num;
+  *arcs_num = curr_counted_arcs_num;
+}
+
+/* The function builds one DFA AUTOMATON for fast pipeline hazards
+   recognition after checking and simplifying IR of the
+   description.  */
+static void
+build_automaton (automaton_t automaton)
+{
+  int states_num;
+  int arcs_num;
+
+  ticker_on (&NDFA_time);
+  if (progress_flag)
+    {
+      if (automaton->corresponding_automaton_decl == NULL)
+	fprintf (stderr, "Create anonymous automaton");
+      else
+	fprintf (stderr, "Create automaton `%s'",
+		 automaton->corresponding_automaton_decl->name);
+      fprintf (stderr, " (1 dot is 100 new states):");
+    }
+  make_automaton (automaton);
+  if (progress_flag)
+    fprintf (stderr, " done\n");
+  ticker_off (&NDFA_time);
+  count_states_and_arcs (automaton, &states_num, &arcs_num);
+  automaton->NDFA_states_num = states_num;
+  automaton->NDFA_arcs_num = arcs_num;
+  ticker_on (&NDFA_to_DFA_time);
+  if (progress_flag)
+    {
+      if (automaton->corresponding_automaton_decl == NULL)
+	fprintf (stderr, "Make anonymous DFA");
+      else
+	fprintf (stderr, "Make DFA `%s'",
+		 automaton->corresponding_automaton_decl->name);
+      fprintf (stderr, " (1 dot is 100 new states):");
+    }
+  NDFA_to_DFA (automaton);
+  if (progress_flag)
+    fprintf (stderr, " done\n");
+  ticker_off (&NDFA_to_DFA_time);
+  count_states_and_arcs (automaton, &states_num, &arcs_num);
+  automaton->DFA_states_num = states_num;
+  automaton->DFA_arcs_num = arcs_num;
+  if (!no_minimization_flag)
+    {
+      ticker_on (&minimize_time);
+      if (progress_flag)
+	{
+	  if (automaton->corresponding_automaton_decl == NULL)
+	    fprintf (stderr, "Minimize anonymous DFA...");
+	  else
+	    fprintf (stderr, "Minimize DFA `%s'...",
+		     automaton->corresponding_automaton_decl->name);
+	}
+      minimize_DFA (automaton);
+      if (progress_flag)
+	fprintf (stderr, "done\n");
+      ticker_off (&minimize_time);
+      count_states_and_arcs (automaton, &states_num, &arcs_num);
+      automaton->minimal_DFA_states_num = states_num;
+      automaton->minimal_DFA_arcs_num = arcs_num;
+    }
+}
+
+
+
+/* The page contains code for enumeration  of all states of an automaton.  */
+
+/* Variable used for enumeration of all states of an automaton.  Its
+   value is current number of automaton states.  */
+static int curr_state_order_num;
+
+/* The function is called by function `pass_states' for enumerating
+   states.  */
+static void
+set_order_state_num (state_t state)
+{
+  state->order_state_num = curr_state_order_num;
+  curr_state_order_num++;
+}
+
+/* The function enumerates all states of AUTOMATON.  */
+static void
+enumerate_states (automaton_t automaton)
+{
+  curr_state_order_num = 0;
+  pass_states (automaton, set_order_state_num);
+  automaton->achieved_states_num = curr_state_order_num;
+}
+
+
+
+/* The page contains code for finding equivalent automaton insns
+   (ainsns).  */
+
+/* The function inserts AINSN into cyclic list
+   CYCLIC_EQUIV_CLASS_INSN_LIST of ainsns.  */
+static ainsn_t
+insert_ainsn_into_equiv_class (ainsn_t ainsn,
+			       ainsn_t cyclic_equiv_class_insn_list)
+{
+  if (cyclic_equiv_class_insn_list == NULL)
+    ainsn->next_equiv_class_insn = ainsn;
+  else
+    {
+      ainsn->next_equiv_class_insn
+        = cyclic_equiv_class_insn_list->next_equiv_class_insn;
+      cyclic_equiv_class_insn_list->next_equiv_class_insn = ainsn;
+    }
+  return ainsn;
+}
+
+/* The function deletes equiv_class_insn into cyclic list of
+   equivalent ainsns.  */
+static void
+delete_ainsn_from_equiv_class (ainsn_t equiv_class_insn)
+{
+  ainsn_t curr_equiv_class_insn;
+  ainsn_t prev_equiv_class_insn;
+
+  prev_equiv_class_insn = equiv_class_insn;
+  for (curr_equiv_class_insn = equiv_class_insn->next_equiv_class_insn;
+       curr_equiv_class_insn != equiv_class_insn;
+       curr_equiv_class_insn = curr_equiv_class_insn->next_equiv_class_insn)
+    prev_equiv_class_insn = curr_equiv_class_insn;
+  if (prev_equiv_class_insn != equiv_class_insn)
+    prev_equiv_class_insn->next_equiv_class_insn
+      = equiv_class_insn->next_equiv_class_insn;
+}
+
+/* The function processes AINSN of a state in order to find equivalent
+   ainsns.  INSN_ARCS_ARRAY is table: code of insn -> out arc of the
+   state.  */
+static void
+process_insn_equiv_class (ainsn_t ainsn, arc_t *insn_arcs_array)
+{
+  ainsn_t next_insn;
+  ainsn_t curr_insn;
+  ainsn_t cyclic_insn_list;
+  arc_t arc;
+
+  gcc_assert (insn_arcs_array [ainsn->insn_reserv_decl->insn_num]);
+  curr_insn = ainsn;
+  /* New class of ainsns which are not equivalent to given ainsn.  */
+  cyclic_insn_list = NULL;
+  do
+    {
+      next_insn = curr_insn->next_equiv_class_insn;
+      arc = insn_arcs_array [curr_insn->insn_reserv_decl->insn_num];
+      if (arc == NULL
+          || (insn_arcs_array [ainsn->insn_reserv_decl->insn_num]->to_state
+              != arc->to_state))
+        {
+          delete_ainsn_from_equiv_class (curr_insn);
+          cyclic_insn_list = insert_ainsn_into_equiv_class (curr_insn,
+							    cyclic_insn_list);
+        }
+      curr_insn = next_insn;
+    }
+  while (curr_insn != ainsn);
+}
+
+/* The function processes STATE in order to find equivalent ainsns.  */
+static void
+process_state_for_insn_equiv_partition (state_t state)
+{
+  arc_t arc;
+  arc_t *insn_arcs_array = XCNEWVEC (arc_t, description->insns_num);
+
+  /* Process insns of the arcs.  */
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    insn_arcs_array [arc->insn->insn_reserv_decl->insn_num] = arc;
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    process_insn_equiv_class (arc->insn, insn_arcs_array);
+
+  free (insn_arcs_array);
+}
+
+/* The function searches for equivalent ainsns of AUTOMATON.  */
+static void
+set_insn_equiv_classes (automaton_t automaton)
+{
+  ainsn_t ainsn;
+  ainsn_t first_insn;
+  ainsn_t curr_insn;
+  ainsn_t cyclic_insn_list;
+  ainsn_t insn_with_same_reservs;
+  int equiv_classes_num;
+
+  /* All insns are included in one equivalence class.  */
+  cyclic_insn_list = NULL;
+  for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
+    if (ainsn->first_insn_with_same_reservs)
+      cyclic_insn_list = insert_ainsn_into_equiv_class (ainsn,
+							cyclic_insn_list);
+  /* Process insns in order to make equivalence partition.  */
+  pass_states (automaton, process_state_for_insn_equiv_partition);
+  /* Enumerate equiv classes.  */
+  for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
+    /* Set undefined value.  */
+    ainsn->insn_equiv_class_num = -1;
+  equiv_classes_num = 0;
+  for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
+    if (ainsn->insn_equiv_class_num < 0)
+      {
+        first_insn = ainsn;
+        gcc_assert (first_insn->first_insn_with_same_reservs);
+        first_insn->first_ainsn_with_given_equivalence_num = 1;
+        curr_insn = first_insn;
+        do
+          {
+            for (insn_with_same_reservs = curr_insn;
+                 insn_with_same_reservs != NULL;
+                 insn_with_same_reservs
+		   = insn_with_same_reservs->next_same_reservs_insn)
+              insn_with_same_reservs->insn_equiv_class_num = equiv_classes_num;
+            curr_insn = curr_insn->next_equiv_class_insn;
+          }
+        while (curr_insn != first_insn);
+        equiv_classes_num++;
+      }
+  automaton->insn_equiv_classes_num = equiv_classes_num;
+}
+
+
+
+/* This page contains code for creating DFA(s) and calls functions
+   building them.  */
+
+
+/* The following value is used to prevent floating point overflow for
+   estimating an automaton bound.  The value should be less DBL_MAX on
+   the host machine.  We use here approximate minimum of maximal
+   double floating point value required by ANSI C standard.  It
+   will work for non ANSI sun compiler too.  */
+
+#define MAX_FLOATING_POINT_VALUE_FOR_AUTOMATON_BOUND  1.0E37
+
+/* The function estimate size of the single DFA used by PHR (pipeline
+   hazards recognizer).  */
+static double
+estimate_one_automaton_bound (void)
+{
+  decl_t decl;
+  double one_automaton_estimation_bound;
+  double root_value;
+  int i;
+
+  one_automaton_estimation_bound = 1.0;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	{
+	  root_value = exp (log (DECL_UNIT (decl)->max_occ_cycle_num
+				 - DECL_UNIT (decl)->min_occ_cycle_num + 1.0)
+                            / automata_num);
+	  if (MAX_FLOATING_POINT_VALUE_FOR_AUTOMATON_BOUND / root_value
+	      > one_automaton_estimation_bound)
+	    one_automaton_estimation_bound *= root_value;
+	}
+    }
+  return one_automaton_estimation_bound;
+}
+
+/* The function compares unit declarations according to their maximal
+   cycle in reservations.  */
+static int
+compare_max_occ_cycle_nums (const void *unit_decl_1,
+			    const void *unit_decl_2)
+{
+  if ((DECL_UNIT (*(const_decl_t const*) unit_decl_1)->max_occ_cycle_num)
+      < (DECL_UNIT (*(const_decl_t const*) unit_decl_2)->max_occ_cycle_num))
+    return 1;
+  else if ((DECL_UNIT (*(const_decl_t const*) unit_decl_1)->max_occ_cycle_num)
+	   == (DECL_UNIT (*(const_decl_t const*) unit_decl_2)->max_occ_cycle_num))
+    return 0;
+  else
+    return -1;
+}
+
+/* The function makes heuristic assigning automata to units.  Actually
+   efficacy of the algorithm has been checked yet??? */
+
+static void
+units_to_automata_heuristic_distr (void)
+{
+  double estimation_bound;
+  int automaton_num;
+  int rest_units_num;
+  double bound_value;
+  unit_decl_t *unit_decls;
+  int i, j;
+
+  if (description->units_num == 0)
+    return;
+  estimation_bound = estimate_one_automaton_bound ();
+  unit_decls = XNEWVEC (unit_decl_t, description->units_num);
+
+  for (i = 0, j = 0; i < description->decls_num; i++)
+    if (description->decls[i]->mode == dm_unit)
+      unit_decls[j++] = DECL_UNIT (description->decls[i]);
+  gcc_assert (j == description->units_num);
+
+  qsort (unit_decls, description->units_num,
+         sizeof (unit_decl_t), compare_max_occ_cycle_nums);
+
+  automaton_num = 0;
+  bound_value = unit_decls[0]->max_occ_cycle_num;
+  unit_decls[0]->corresponding_automaton_num = automaton_num;
+
+  for (i = 1; i < description->units_num; i++)
+    {
+      rest_units_num = description->units_num - i + 1;
+      gcc_assert (automata_num - automaton_num - 1 <= rest_units_num);
+      if (automaton_num < automata_num - 1
+          && ((automata_num - automaton_num - 1 == rest_units_num)
+              || (bound_value
+                  > (estimation_bound
+		     / unit_decls[i]->max_occ_cycle_num))))
+        {
+          bound_value = unit_decls[i]->max_occ_cycle_num;
+          automaton_num++;
+        }
+      else
+        bound_value *= unit_decls[i]->max_occ_cycle_num;
+      unit_decls[i]->corresponding_automaton_num = automaton_num;
+    }
+  gcc_assert (automaton_num == automata_num - 1);
+  free (unit_decls);
+}
+
+/* The functions creates automaton insns for each automata.  Automaton
+   insn is simply insn for given automaton which makes reservation
+   only of units of the automaton.  */
+static ainsn_t
+create_ainsns (void)
+{
+  decl_t decl;
+  ainsn_t first_ainsn;
+  ainsn_t curr_ainsn;
+  ainsn_t prev_ainsn;
+  int i;
+
+  first_ainsn = NULL;
+  prev_ainsn = NULL;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv)
+	{
+	  curr_ainsn = XCREATENODE (struct ainsn);
+	  curr_ainsn->insn_reserv_decl = DECL_INSN_RESERV (decl);
+	  curr_ainsn->important_p = FALSE;
+	  curr_ainsn->next_ainsn = NULL;
+	  if (prev_ainsn == NULL)
+	    first_ainsn = curr_ainsn;
+	  else
+	    prev_ainsn->next_ainsn = curr_ainsn;
+	  prev_ainsn = curr_ainsn;
+	}
+    }
+  return first_ainsn;
+}
+
+/* The function assigns automata to units according to constructions
+   `define_automaton' in the description.  */
+static void
+units_to_automata_distr (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	{
+	  if (DECL_UNIT (decl)->automaton_decl == NULL
+	      || (DECL_UNIT (decl)->automaton_decl->corresponding_automaton
+		  == NULL))
+	    /* Distribute to the first automaton.  */
+	    DECL_UNIT (decl)->corresponding_automaton_num = 0;
+	  else
+	    DECL_UNIT (decl)->corresponding_automaton_num
+	      = (DECL_UNIT (decl)->automaton_decl
+                 ->corresponding_automaton->automaton_order_num);
+	}
+    }
+}
+
+/* The function creates DFA(s) for fast pipeline hazards recognition
+   after checking and simplifying IR of the description.  */
+static void
+create_automata (void)
+{
+  automaton_t curr_automaton;
+  automaton_t prev_automaton;
+  decl_t decl;
+  int curr_automaton_num;
+  int i;
+
+  if (automata_num != 0)
+    {
+      units_to_automata_heuristic_distr ();
+      for (prev_automaton = NULL, curr_automaton_num = 0;
+           curr_automaton_num < automata_num;
+           curr_automaton_num++, prev_automaton = curr_automaton)
+        {
+	  curr_automaton = XCREATENODE (struct automaton);
+	  curr_automaton->ainsn_list = create_ainsns ();
+	  curr_automaton->corresponding_automaton_decl = NULL;
+	  curr_automaton->next_automaton = NULL;
+          curr_automaton->automaton_order_num = curr_automaton_num;
+          if (prev_automaton == NULL)
+            description->first_automaton = curr_automaton;
+          else
+            prev_automaton->next_automaton = curr_automaton;
+        }
+    }
+  else
+    {
+      curr_automaton_num = 0;
+      prev_automaton = NULL;
+      for (i = 0; i < description->decls_num; i++)
+	{
+	  decl = description->decls [i];
+	  if (decl->mode == dm_automaton
+	      && DECL_AUTOMATON (decl)->automaton_is_used)
+	    {
+	      curr_automaton = XCREATENODE (struct automaton);
+	      curr_automaton->ainsn_list = create_ainsns ();
+	      curr_automaton->corresponding_automaton_decl
+		= DECL_AUTOMATON (decl);
+	      curr_automaton->next_automaton = NULL;
+	      DECL_AUTOMATON (decl)->corresponding_automaton = curr_automaton;
+	      curr_automaton->automaton_order_num = curr_automaton_num;
+	      if (prev_automaton == NULL)
+		description->first_automaton = curr_automaton;
+	      else
+		prev_automaton->next_automaton = curr_automaton;
+	      curr_automaton_num++;
+	      prev_automaton = curr_automaton;
+	    }
+	}
+      if (curr_automaton_num == 0)
+	{
+	  curr_automaton = XCREATENODE (struct automaton);
+	  curr_automaton->ainsn_list = create_ainsns ();
+	  curr_automaton->corresponding_automaton_decl = NULL;
+	  curr_automaton->next_automaton = NULL;
+	  description->first_automaton = curr_automaton;
+	}
+      units_to_automata_distr ();
+    }
+  NDFA_time = create_ticker ();
+  ticker_off (&NDFA_time);
+  NDFA_to_DFA_time = create_ticker ();
+  ticker_off (&NDFA_to_DFA_time);
+  minimize_time = create_ticker ();
+  ticker_off (&minimize_time);
+  equiv_time = create_ticker ();
+  ticker_off (&equiv_time);
+  for (curr_automaton = description->first_automaton;
+       curr_automaton != NULL;
+       curr_automaton = curr_automaton->next_automaton)
+    {
+      if (progress_flag)
+	{
+	  if (curr_automaton->corresponding_automaton_decl == NULL)
+	    fprintf (stderr, "Prepare anonymous automaton creation ... ");
+	  else
+	    fprintf (stderr, "Prepare automaton `%s' creation...",
+		     curr_automaton->corresponding_automaton_decl->name);
+	}
+      create_alt_states (curr_automaton);
+      form_ainsn_with_same_reservs (curr_automaton);
+      if (progress_flag)
+	fprintf (stderr, "done\n");
+      build_automaton (curr_automaton);
+      enumerate_states (curr_automaton);
+      ticker_on (&equiv_time);
+      set_insn_equiv_classes (curr_automaton);
+      ticker_off (&equiv_time);
+    }
+}
+
+
+
+/* This page contains code for forming string representation of
+   regexp.  The representation is formed on IR obstack.  So you should
+   not work with IR obstack between regexp_representation and
+   finish_regexp_representation calls.  */
+
+/* This recursive function forms string representation of regexp
+   (without tailing '\0').  */
+static void
+form_regexp (regexp_t regexp)
+{
+  int i;
+
+  switch (regexp->mode)
+    {
+    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, ',');
+	  form_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+	}
+      break;
+
+    case rm_allof:
+      obstack_1grow (&irp, '(');
+      for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+	{
+	  if (i != 0)
+            obstack_1grow (&irp, '+');
+	  if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
+              || REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
+            obstack_1grow (&irp, '(');
+	  form_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+	  if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
+              || 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, '|');
+	  if (REGEXP_ONEOF (regexp)->regexps[i]->mode == rm_sequence)
+	    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);
+	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, ')');
+	sprintf (digits, "*%d", REGEXP_REPEAT (regexp)->repeat_num);
+	obstack_grow (&irp, digits, strlen (digits));
+	break;
+      }
+
+    case rm_nothing:
+      obstack_grow (&irp, NOTHING_NAME, strlen (NOTHING_NAME));
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
+/* The function returns string representation of REGEXP on IR
+   obstack.  */
+static const char *
+regexp_representation (regexp_t regexp)
+{
+  form_regexp (regexp);
+  obstack_1grow (&irp, '\0');
+  return obstack_base (&irp);
+}
+
+/* The function frees memory allocated for last formed string
+   representation of regexp.  */
+static void
+finish_regexp_representation (void)
+{
+  int length = obstack_object_size (&irp);
+
+  obstack_blank_fast (&irp, -length);
+}
+
+
+
+/* This page contains code for output PHR (pipeline hazards recognizer).  */
+
+/* The function outputs minimal C type which is sufficient for
+   representation numbers in range min_range_value and
+   max_range_value.  Because host machine and build machine may be
+   different, we use here minimal values required by ANSI C standard
+   instead of UCHAR_MAX, SHRT_MAX, SHRT_MIN, etc.  This is a good
+   approximation.  */
+
+static void
+output_range_type (FILE *f, long int min_range_value,
+		   long int max_range_value)
+{
+  if (min_range_value >= 0 && max_range_value <= 255)
+    fprintf (f, "unsigned char");
+  else if (min_range_value >= -127 && max_range_value <= 127)
+    fprintf (f, "signed char");
+  else if (min_range_value >= 0 && max_range_value <= 65535)
+    fprintf (f, "unsigned short");
+  else if (min_range_value >= -32767 && max_range_value <= 32767)
+    fprintf (f, "short");
+  else
+    fprintf (f, "int");
+}
+
+/* The function outputs all initialization values of VECT.  */
+static void
+output_vect (vla_hwint_t vect)
+{
+  int els_on_line;
+  size_t vect_length = VEC_length (vect_el_t, vect);
+  size_t i;
+
+  els_on_line = 1;
+  if (vect_length == 0)
+    fputs ("0 /* This is dummy el because the vect is empty */", output_file);
+  else
+    for (i = 0; i < vect_length; i++)
+      {
+	fprintf (output_file, "%5ld", (long) VEC_index (vect_el_t, vect, i));
+	if (els_on_line == 10)
+	  {
+	    els_on_line = 0;
+	    fputs (",\n", output_file);
+	  }
+	else if (i < vect_length-1)
+	  fputs (", ", output_file);
+	els_on_line++;
+      }
+}
+
+/* The following is name of the structure which represents DFA(s) for
+   PHR.  */
+#define CHIP_NAME "DFA_chip"
+
+/* The following is name of member which represents state of a DFA for
+   PHR.  */
+static void
+output_chip_member_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "automaton_state_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_automaton_state",
+             automaton->corresponding_automaton_decl->name);
+}
+
+/* The following is name of temporary variable which stores state of a
+   DFA for PHR.  */
+static void
+output_temp_chip_member_name (FILE *f, automaton_t automaton)
+{
+  fprintf (f, "_");
+  output_chip_member_name (f, automaton);
+}
+
+/* This is name of macro value which is code of pseudo_insn
+   representing advancing cpu cycle.  Its value is used as internal
+   code unknown insn.  */
+#define ADVANCE_CYCLE_VALUE_NAME "DFA__ADVANCE_CYCLE"
+
+/* Output name of translate vector for given automaton.  */
+static void
+output_translate_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "translate_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_translate", automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name for simple transition table representation.  */
+static void
+output_trans_full_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "transitions_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_transitions",
+	     automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of comb vector of the transition table for given
+   automaton.  */
+static void
+output_trans_comb_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "transitions_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_transitions",
+             automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of check vector of the transition table for given
+   automaton.  */
+static void
+output_trans_check_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "check_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_check", automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of base vector of the transition table for given
+   automaton.  */
+static void
+output_trans_base_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "base_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_base", automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of simple min issue delay table representation.  */
+static void
+output_min_issue_delay_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "min_issue_delay_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_min_issue_delay",
+             automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of deadlock vector for given automaton.  */
+static void
+output_dead_lock_vect_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "dead_lock_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_dead_lock", automaton->corresponding_automaton_decl->name);
+}
+
+/* Output name of reserved units table for AUTOMATON into file F.  */
+static void
+output_reserved_units_table_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "reserved_units_%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "%s_reserved_units",
+	     automaton->corresponding_automaton_decl->name);
+}
+
+/* Name of the PHR interface macro.  */
+#define CPU_UNITS_QUERY_MACRO_NAME "CPU_UNITS_QUERY"
+
+/* Names of an internal functions: */
+#define INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME "internal_min_issue_delay"
+
+/* This is external type of DFA(s) state.  */
+#define STATE_TYPE_NAME "state_t"
+
+#define INTERNAL_TRANSITION_FUNC_NAME "internal_state_transition"
+
+#define INTERNAL_RESET_FUNC_NAME "internal_reset"
+
+#define INTERNAL_DEAD_LOCK_FUNC_NAME "internal_state_dead_lock_p"
+
+#define INTERNAL_INSN_LATENCY_FUNC_NAME "internal_insn_latency"
+
+/* Name of cache of insn dfa codes.  */
+#define DFA_INSN_CODES_VARIABLE_NAME "dfa_insn_codes"
+
+/* Name of length of cache of insn dfa codes.  */
+#define DFA_INSN_CODES_LENGTH_VARIABLE_NAME "dfa_insn_codes_length"
+
+/* Names of the PHR interface functions: */
+#define SIZE_FUNC_NAME "state_size"
+
+#define TRANSITION_FUNC_NAME "state_transition"
+
+#define MIN_ISSUE_DELAY_FUNC_NAME "min_issue_delay"
+
+#define MIN_INSN_CONFLICT_DELAY_FUNC_NAME "min_insn_conflict_delay"
+
+#define DEAD_LOCK_FUNC_NAME "state_dead_lock_p"
+
+#define RESET_FUNC_NAME "state_reset"
+
+#define INSN_LATENCY_FUNC_NAME "insn_latency"
+
+#define PRINT_RESERVATION_FUNC_NAME "print_reservation"
+
+#define GET_CPU_UNIT_CODE_FUNC_NAME "get_cpu_unit_code"
+
+#define CPU_UNIT_RESERVATION_P_FUNC_NAME "cpu_unit_reservation_p"
+
+#define INSN_HAS_DFA_RESERVATION_P_FUNC_NAME "insn_has_dfa_reservation_p"
+
+#define DFA_CLEAN_INSN_CACHE_FUNC_NAME  "dfa_clean_insn_cache"
+
+#define DFA_CLEAR_SINGLE_INSN_CACHE_FUNC_NAME "dfa_clear_single_insn_cache"
+
+#define DFA_START_FUNC_NAME  "dfa_start"
+
+#define DFA_FINISH_FUNC_NAME "dfa_finish"
+
+/* Names of parameters of the PHR interface functions.  */
+#define STATE_NAME "state"
+
+#define INSN_PARAMETER_NAME "insn"
+
+#define INSN2_PARAMETER_NAME "insn2"
+
+#define CHIP_PARAMETER_NAME "chip"
+
+#define FILE_PARAMETER_NAME "f"
+
+#define CPU_UNIT_NAME_PARAMETER_NAME "cpu_unit_name"
+
+#define CPU_CODE_PARAMETER_NAME "cpu_unit_code"
+
+/* Names of the variables whose values are internal insn code of rtx
+   insn.  */
+#define INTERNAL_INSN_CODE_NAME "insn_code"
+
+#define INTERNAL_INSN2_CODE_NAME "insn2_code"
+
+/* Names of temporary variables in some functions.  */
+#define TEMPORARY_VARIABLE_NAME "temp"
+
+#define I_VARIABLE_NAME "i"
+
+/* Name of result variable in some functions.  */
+#define RESULT_VARIABLE_NAME "res"
+
+/* Name of function (attribute) to translate insn into internal insn
+   code.  */
+#define INTERNAL_DFA_INSN_CODE_FUNC_NAME "internal_dfa_insn_code"
+
+/* Name of function (attribute) to translate insn into internal insn
+   code with caching.  */
+#define DFA_INSN_CODE_FUNC_NAME "dfa_insn_code"
+
+/* Output C type which is used for representation of codes of states
+   of AUTOMATON.  */
+static void
+output_state_member_type (FILE *f, automaton_t automaton)
+{
+  output_range_type (f, 0, automaton->achieved_states_num);
+}
+
+/* Output definition of the structure representing current DFA(s)
+   state(s).  */
+static void
+output_chip_definitions (void)
+{
+  automaton_t automaton;
+
+  fprintf (output_file, "struct %s\n{\n", CHIP_NAME);
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      fprintf (output_file, "  ");
+      output_state_member_type (output_file, automaton);
+      fprintf (output_file, " ");
+      output_chip_member_name (output_file, automaton);
+      fprintf (output_file, ";\n");
+    }
+  fprintf (output_file, "};\n\n");
+#if 0
+  fprintf (output_file, "static struct %s %s;\n\n", CHIP_NAME, CHIP_NAME);
+#endif
+}
+
+
+/* The function outputs translate vector of internal insn code into
+   insn equivalence class number.  The equivalence class number is
+   used to access to table and vectors representing DFA(s).  */
+static void
+output_translate_vect (automaton_t automaton)
+{
+  ainsn_t ainsn;
+  int insn_value;
+  vla_hwint_t translate_vect;
+
+  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);
+
+  for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
+    VEC_replace (vect_el_t, translate_vect,
+		 ainsn->insn_reserv_decl->insn_num,
+		 ainsn->insn_equiv_class_num);
+
+  fprintf (output_file,
+           "/* Vector translating external insn codes to internal ones.*/\n");
+  fprintf (output_file, "static const ");
+  output_range_type (output_file, 0, 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);
+}
+
+/* The value in a table state x ainsn -> something which represents
+   undefined value.  */
+static int undefined_vect_el_value;
+
+/* The following function returns nonzero value if the best
+   representation of the table is comb vector.  */
+static int
+comb_vect_p (state_ainsn_table_t tab)
+{
+  return  (2 * VEC_length (vect_el_t, tab->full_vect)
+           > 5 * VEC_length (vect_el_t, tab->comb_vect));
+}
+
+/* The following function creates new table for AUTOMATON.  */
+static state_ainsn_table_t
+create_state_ainsn_table (automaton_t automaton)
+{
+  state_ainsn_table_t tab;
+  int full_vect_length;
+  int i;
+
+  tab = XCREATENODE (struct state_ainsn_table);
+  tab->automaton = automaton;
+
+  tab->comb_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,
+		 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);
+  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;
+  tab->min_comb_vect_el_value = 0;
+  tab->max_comb_vect_el_value = 0;
+  return tab;
+}
+
+/* The following function outputs the best C representation of the
+   table TAB of given TABLE_NAME.  */
+static void
+output_state_ainsn_table (state_ainsn_table_t tab, const char *table_name,
+			  void (*output_full_vect_name_func) (FILE *, automaton_t),
+			  void (*output_comb_vect_name_func) (FILE *, automaton_t),
+			  void (*output_check_vect_name_func) (FILE *, automaton_t),
+			  void (*output_base_vect_name_func) (FILE *, automaton_t))
+{
+  if (!comb_vect_p (tab))
+    {
+      fprintf (output_file, "/* Vector for %s.  */\n", table_name);
+      fprintf (output_file, "static const ");
+      output_range_type (output_file, tab->min_comb_vect_el_value,
+                         tab->max_comb_vect_el_value);
+      fprintf (output_file, " ");
+      (*output_full_vect_name_func) (output_file, tab->automaton);
+      fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
+      output_vect (tab->full_vect);
+      fprintf (output_file, "};\n\n");
+    }
+  else
+    {
+      fprintf (output_file, "/* Comb vector for %s.  */\n", table_name);
+      fprintf (output_file, "static const ");
+      output_range_type (output_file, tab->min_comb_vect_el_value,
+                         tab->max_comb_vect_el_value);
+      fprintf (output_file, " ");
+      (*output_comb_vect_name_func) (output_file, tab->automaton);
+      fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
+      output_vect (tab->comb_vect);
+      fprintf (output_file, "};\n\n");
+      fprintf (output_file, "/* Check vector for %s.  */\n", table_name);
+      fprintf (output_file, "static const ");
+      output_range_type (output_file, 0, tab->automaton->achieved_states_num);
+      fprintf (output_file, " ");
+      (*output_check_vect_name_func) (output_file, tab->automaton);
+      fprintf (output_file, "[] = {\n");
+      output_vect (tab->check_vect);
+      fprintf (output_file, "};\n\n");
+      fprintf (output_file, "/* Base vector for %s.  */\n", table_name);
+      fprintf (output_file, "static const ");
+      output_range_type (output_file, tab->min_base_vect_el_value,
+                         tab->max_base_vect_el_value);
+      fprintf (output_file, " ");
+      (*output_base_vect_name_func) (output_file, tab->automaton);
+      fprintf (output_file, "[] = {\n");
+      output_vect (tab->base_vect);
+      fprintf (output_file, "};\n\n");
+    }
+}
+
+/* The following function adds vector VECT to table TAB as its line
+   with number VECT_NUM.  */
+static void
+add_vect (state_ainsn_table_t tab, int vect_num, vla_hwint_t vect)
+{
+  int vect_length;
+  size_t real_vect_length;
+  int comb_vect_index;
+  int comb_vect_els_num;
+  int vect_index;
+  int first_unempty_vect_index;
+  int additional_els_num;
+  int no_state_value;
+  vect_el_t vect_el;
+  int i;
+  unsigned long vect_mask, comb_vect_mask;
+
+  vect_length = VEC_length (vect_el_t, vect);
+  gcc_assert (vect_length);
+  gcc_assert (VEC_last (vect_el_t, vect) != undefined_vect_el_value);
+  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,
+		     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));
+  }
+  /* Form comb vector in the table: */
+  gcc_assert (VEC_length (vect_el_t, tab->comb_vect)
+	      == VEC_length (vect_el_t, tab->check_vect));
+
+  comb_vect_els_num = VEC_length (vect_el_t, tab->comb_vect);
+  for (first_unempty_vect_index = 0;
+       first_unempty_vect_index < vect_length;
+       first_unempty_vect_index++)
+    if (VEC_index (vect_el_t, vect, first_unempty_vect_index)
+	!= undefined_vect_el_value)
+      break;
+
+  /* Search for the place in comb vect for the inserted vect.  */
+
+  /* Slow case.  */
+  if (vect_length - first_unempty_vect_index >= SIZEOF_LONG * CHAR_BIT)
+    {
+      for (comb_vect_index = 0;
+           comb_vect_index < comb_vect_els_num;
+           comb_vect_index++)
+        {
+          for (vect_index = first_unempty_vect_index;
+               vect_index < vect_length
+               && vect_index + comb_vect_index < comb_vect_els_num;
+               vect_index++)
+            if (VEC_index (vect_el_t, vect, vect_index)
+		!= undefined_vect_el_value
+                && (VEC_index (vect_el_t, tab->comb_vect,
+			       vect_index + comb_vect_index)
+		    != undefined_vect_el_value))
+              break;
+          if (vect_index >= vect_length
+              || vect_index + comb_vect_index >= comb_vect_els_num)
+            break;
+        }
+      goto found;
+    }
+
+  /* Fast case.  */
+  vect_mask = 0;
+  for (vect_index = first_unempty_vect_index;
+       vect_index < vect_length;
+       vect_index++)
+    {
+      vect_mask = vect_mask << 1;
+      if (VEC_index (vect_el_t, vect, vect_index) != undefined_vect_el_value)
+	vect_mask |= 1;
+    }
+
+  /* Search for the place in comb vect for the inserted vect.  */
+  comb_vect_index = 0;
+  if (comb_vect_els_num == 0)
+    goto found;
+
+  comb_vect_mask = 0;
+  for (vect_index = first_unempty_vect_index;
+       vect_index < vect_length && vect_index < comb_vect_els_num;
+       vect_index++)
+    {
+      comb_vect_mask <<= 1;
+      if (vect_index + comb_vect_index < comb_vect_els_num
+	  && VEC_index (vect_el_t, tab->comb_vect, vect_index + comb_vect_index)
+	     != undefined_vect_el_value)
+	comb_vect_mask |= 1;
+    }
+  if ((vect_mask & comb_vect_mask) == 0)
+    goto found;
+
+  for (comb_vect_index = 1, i = vect_length; i < comb_vect_els_num;
+       comb_vect_index++, i++)
+    {
+      comb_vect_mask = (comb_vect_mask << 1) | 1;
+      comb_vect_mask ^= (VEC_index (vect_el_t, tab->comb_vect, i)
+			 == undefined_vect_el_value);
+      if ((vect_mask & comb_vect_mask) == 0)
+	goto found;
+    }
+  for ( ; comb_vect_index < comb_vect_els_num; comb_vect_index++)
+    {
+      comb_vect_mask <<= 1;
+      if ((vect_mask & comb_vect_mask) == 0)
+	goto found;
+    }
+
+ found:
+  /* Slot was found.  */
+  additional_els_num = comb_vect_index + real_vect_length - comb_vect_els_num;
+  if (additional_els_num < 0)
+    additional_els_num = 0;
+  /* 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->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.  */
+  for (vect_index = 0; vect_index < vect_length; vect_index++)
+    if (VEC_index (vect_el_t, vect, vect_index) != undefined_vect_el_value)
+      {
+	vect_el_t x = VEC_index (vect_el_t, vect, vect_index);
+        gcc_assert (VEC_index (vect_el_t, tab->comb_vect,
+			       comb_vect_index + vect_index)
+		    == undefined_vect_el_value);
+        gcc_assert (x >= 0);
+        if (tab->max_comb_vect_el_value < x)
+          tab->max_comb_vect_el_value = x;
+        if (tab->min_comb_vect_el_value > x)
+          tab->min_comb_vect_el_value = x;
+	VEC_replace (vect_el_t, tab->comb_vect,
+		     comb_vect_index + vect_index, x);
+	VEC_replace (vect_el_t, tab->check_vect,
+		     comb_vect_index + vect_index, vect_num);
+      }
+  if (tab->max_comb_vect_el_value < undefined_vect_el_value)
+    tab->max_comb_vect_el_value = undefined_vect_el_value;
+  if (tab->min_comb_vect_el_value > undefined_vect_el_value)
+    tab->min_comb_vect_el_value = undefined_vect_el_value;
+  if (tab->max_base_vect_el_value < comb_vect_index)
+    tab->max_base_vect_el_value = comb_vect_index;
+  if (tab->min_base_vect_el_value > comb_vect_index)
+    tab->min_base_vect_el_value = comb_vect_index;
+
+  VEC_replace (vect_el_t, tab->base_vect, vect_num, comb_vect_index);
+}
+
+/* Return number of out arcs of STATE.  */
+static int
+out_state_arcs_num (const_state_t state)
+{
+  int result;
+  arc_t arc;
+
+  result = 0;
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    {
+      gcc_assert (arc->insn);
+      if (arc->insn->first_ainsn_with_given_equivalence_num)
+        result++;
+    }
+  return result;
+}
+
+/* Compare number of possible transitions from the states.  */
+static int
+compare_transition_els_num (const void *state_ptr_1,
+			    const void *state_ptr_2)
+{
+  const int transition_els_num_1
+    = out_state_arcs_num (*(const_state_t const*) state_ptr_1);
+  const int transition_els_num_2
+    = out_state_arcs_num (*(const_state_t const*) state_ptr_2);
+
+  if (transition_els_num_1 < transition_els_num_2)
+    return 1;
+  else if (transition_els_num_1 == transition_els_num_2)
+    return 0;
+  else
+    return -1;
+}
+
+/* The function adds element EL_VALUE to vector VECT for a table state
+   x AINSN.  */
+static void
+add_vect_el (vla_hwint_t *vect, ainsn_t ainsn, int el_value)
+{
+  int equiv_class_num;
+  int vect_index;
+
+  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_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;
+
+/* 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);
+}
+
+/* Form and output vectors (comb, check, base or full vector)
+   representing transition table of AUTOMATON.  */
+static void
+output_trans_table (automaton_t automaton)
+{
+  size_t i;
+  arc_t arc;
+  vla_hwint_t transition_vect = 0;
+
+  undefined_vect_el_value = automaton->achieved_states_num;
+  automaton->trans_table = create_state_ainsn_table (automaton);
+  /* Create vect of pointers to states ordered by num of transitions
+     from the state (state with the maximum num is the first).  */
+  output_states_vect = 0;
+  pass_states (automaton, add_states_vect_el);
+  qsort (VEC_address (state_t, output_states_vect),
+	 VEC_length (state_t, output_states_vect),
+         sizeof (state_t), compare_transition_els_num);
+
+  for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
+    {
+      VEC_truncate (vect_el_t, transition_vect, 0);
+      for (arc = first_out_arc (VEC_index (state_t, output_states_vect, i));
+	   arc != NULL;
+	   arc = next_out_arc (arc))
+        {
+          gcc_assert (arc->insn);
+          if (arc->insn->first_ainsn_with_given_equivalence_num)
+            add_vect_el (&transition_vect, arc->insn,
+                         arc->to_state->order_state_num);
+        }
+      add_vect (automaton->trans_table,
+		VEC_index (state_t, output_states_vect, i)->order_state_num,
+		transition_vect);
+    }
+  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 (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;
+
+/* This recursive function passes states to find minimal issue delay
+   value for AINSN.  The state being visited is STATE.  The function
+   returns minimal issue delay value for AINSN in STATE or -1 if we
+   enter into a loop.  */
+static int
+min_issue_delay_pass_states (state_t state, ainsn_t ainsn)
+{
+  arc_t arc;
+  int min_insn_issue_delay, insn_issue_delay;
+
+  if (state->state_pass_num == curr_state_pass_num
+      || state->min_insn_issue_delay != -1)
+    /* We've entered into a loop or already have the correct value for
+       given state and ainsn.  */
+    return state->min_insn_issue_delay;
+  state->state_pass_num = curr_state_pass_num;
+  min_insn_issue_delay = -1;
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    if (arc->insn == ainsn)
+      {
+	min_insn_issue_delay = 0;
+	break;
+      }
+    else
+      {
+        insn_issue_delay = min_issue_delay_pass_states (arc->to_state, ainsn);
+	if (insn_issue_delay != -1)
+	  {
+	    if (arc->insn->insn_reserv_decl
+		== DECL_INSN_RESERV (advance_cycle_insn_decl))
+	      insn_issue_delay++;
+	    if (min_insn_issue_delay == -1
+		|| min_insn_issue_delay > insn_issue_delay)
+	      {
+		min_insn_issue_delay = insn_issue_delay;
+		if (insn_issue_delay == 0)
+		  break;
+	      }
+	  }
+      }
+  return min_insn_issue_delay;
+}
+
+/* The function searches minimal issue delay value for AINSN in STATE.
+   The function can return negative value if we can not issue AINSN.  We
+   will report about it later.  */
+static int
+min_issue_delay (state_t state, ainsn_t ainsn)
+{
+  curr_state_pass_num++;
+  state->min_insn_issue_delay = min_issue_delay_pass_states (state, ainsn);
+  return state->min_insn_issue_delay;
+}
+
+/* The function initiates code for finding minimal issue delay values.
+   It should be called only once.  */
+static void
+initiate_min_issue_delay_pass_states (void)
+{
+  curr_state_pass_num = 0;
+}
+
+/* Form and output vectors representing minimal issue delay table of
+   AUTOMATON.  The table is state x ainsn -> minimal issue delay of
+   the ainsn.  */
+static void
+output_min_issue_delay_table (automaton_t automaton)
+{
+  vla_hwint_t min_issue_delay_vect;
+  vla_hwint_t compressed_min_issue_delay_vect;
+  vect_el_t min_delay;
+  ainsn_t ainsn;
+  size_t i, min_issue_delay_len;
+  size_t compressed_min_issue_delay_len;
+  size_t cfactor;
+
+  /* Create vect of pointers to states ordered by num of transitions
+     from the state (state with the maximum num is the first).  */
+  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);
+  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)
+    if (ainsn->first_ainsn_with_given_equivalence_num)
+      {
+	for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
+	  VEC_index (state_t, output_states_vect, i)->min_insn_issue_delay = -1;
+	for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
+	  {
+	    state_t s = VEC_index (state_t, output_states_vect, i);
+            min_delay = min_issue_delay (s, ainsn);
+	    if (automaton->max_min_delay < min_delay)
+	      automaton->max_min_delay = min_delay;
+	    VEC_replace (vect_el_t, min_issue_delay_vect,
+			 s->order_state_num
+			 * automaton->insn_equiv_classes_num
+			 + ainsn->insn_equiv_class_num,
+			 min_delay);
+	  }
+      }
+  fprintf (output_file, "/* Vector of min issue delay of insns.  */\n");
+  fprintf (output_file, "static const ");
+  output_range_type (output_file, 0, automaton->max_min_delay);
+  fprintf (output_file, " ");
+  output_min_issue_delay_vect_name (output_file, automaton);
+  fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
+  /* Compress the vector.  */
+  if (automaton->max_min_delay < 2)
+    cfactor = 8;
+  else if (automaton->max_min_delay < 4)
+    cfactor = 4;
+  else if (automaton->max_min_delay < 16)
+    cfactor = 2;
+  else
+    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);
+
+  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++)
+    {
+      size_t ci = i / cfactor;
+      vect_el_t x = VEC_index (vect_el_t, min_issue_delay_vect, i);
+      vect_el_t cx = VEC_index (vect_el_t, compressed_min_issue_delay_vect, ci);
+
+      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 (vect_el_t,heap, 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
+output_dead_lock_vect (automaton_t automaton)
+{
+  size_t i;
+  arc_t arc;
+  vla_hwint_t dead_lock_vect = 0;
+
+  /* Create vect of pointers to states ordered by num of
+     transitions from the state (state with the maximum num is the
+     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_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);
+      gcc_assert (arc);
+      if (next_out_arc (arc) == NULL
+	  && (arc->insn->insn_reserv_decl
+	      == DECL_INSN_RESERV (advance_cycle_insn_decl)))
+	{
+	  VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, 1);
+	  automaton->locked_states++;
+	}
+      else
+	VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num, 0);
+    }
+  if (automaton->locked_states == 0)
+    return;
+
+  fprintf (output_file, "/* Vector for locked state flags.  */\n");
+  fprintf (output_file, "static const ");
+  output_range_type (output_file, 0, 1);
+  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 (vect_el_t,heap, dead_lock_vect);
+}
+
+/* Form and output vector representing reserved units of the states of
+   AUTOMATON.  */
+static void
+output_reserved_units_table (automaton_t automaton)
+{
+  vla_hwint_t reserved_units_table = 0;
+  int state_byte_size;
+  int reserved_units_size;
+  size_t n;
+  int i;
+
+  if (description->query_units_num == 0)
+    return;
+
+  /* Create vect of pointers to states.  */
+  output_states_vect = 0;
+  pass_states (automaton, add_states_vect_el);
+  /* 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);
+		 
+  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);
+      for (i = 0; i < description->units_num; i++)
+	if (units_array [i]->query_p
+	    && first_cycle_unit_presence (s, i))
+	  {
+	    int ri = (s->order_state_num * state_byte_size
+		      + units_array [i]->query_num / 8);
+	    vect_el_t x = VEC_index (vect_el_t, reserved_units_table, ri);
+
+	    x += 1 << (units_array [i]->query_num % 8);
+	    VEC_replace (vect_el_t, reserved_units_table, ri, x);
+	  }
+    }
+  fprintf (output_file, "\n#if %s\n", CPU_UNITS_QUERY_MACRO_NAME);
+  fprintf (output_file, "/* Vector for reserved units of states.  */\n");
+  fprintf (output_file, "static const ");
+  output_range_type (output_file, 0, 255);
+  fprintf (output_file, " ");
+  output_reserved_units_table_name (output_file, automaton);
+  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 (vect_el_t,heap, reserved_units_table);
+}
+
+/* The function outputs all tables representing DFA(s) used for fast
+   pipeline hazards recognition.  */
+static void
+output_tables (void)
+{
+  automaton_t automaton;
+
+  initiate_min_issue_delay_pass_states ();
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      output_translate_vect (automaton);
+      output_trans_table (automaton);
+      output_min_issue_delay_table (automaton);
+      output_dead_lock_vect (automaton);
+      output_reserved_units_table (automaton);
+    }
+  fprintf (output_file, "\n#define %s %d\n\n", ADVANCE_CYCLE_VALUE_NAME,
+           DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num);
+}
+
+/* The function outputs definition and value of PHR interface variable
+   `max_insn_queue_index'.  Its value is not less than maximal queue
+   length needed for the insn scheduler.  */
+static void
+output_max_insn_queue_index_def (void)
+{
+  int i, max, latency;
+  decl_t decl;
+
+  max = description->max_insn_reserv_cycles;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
+	{
+	  latency = DECL_INSN_RESERV (decl)->default_latency;
+	  if (latency > max)
+	    max = latency;
+	}
+      else if (decl->mode == dm_bypass)
+	{
+	  latency = DECL_BYPASS (decl)->latency;
+	  if (latency > max)
+	    max = latency;
+	}
+    }
+  for (i = 0; (1 << i) <= max; i++)
+    ;
+  gcc_assert (i >= 0);
+  fprintf (output_file, "\nconst int max_insn_queue_index = %d;\n\n",
+	   (1 << i) - 1);
+}
+
+/* The function outputs switch cases for insn reservations using
+   function *output_automata_list_code.  */
+static void
+output_insn_code_cases (void (*output_automata_list_code)
+			(automata_list_el_t))
+{
+  decl_t decl, decl2;
+  int i, j;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv)
+	DECL_INSN_RESERV (decl)->processed_p = FALSE;
+    }
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_insn_reserv
+	  && !DECL_INSN_RESERV (decl)->processed_p)
+	{
+	  for (j = i; j < description->decls_num; j++)
+	    {
+	      decl2 = description->decls [j];
+	      if (decl2->mode == dm_insn_reserv
+		  && (DECL_INSN_RESERV (decl2)->important_automata_list
+		      == DECL_INSN_RESERV (decl)->important_automata_list))
+		{
+		  DECL_INSN_RESERV (decl2)->processed_p = TRUE;
+		  fprintf (output_file, "    case %d: /* %s */\n",
+			   DECL_INSN_RESERV (decl2)->insn_num,
+			   DECL_INSN_RESERV (decl2)->name);
+		}
+	    }
+	  (*output_automata_list_code)
+	    (DECL_INSN_RESERV (decl)->important_automata_list);
+	}
+    }
+}
+
+
+/* The function outputs a code for evaluation of a minimal delay of
+   issue of insns which have reservations in given AUTOMATA_LIST.  */
+static void
+output_automata_list_min_issue_delay_code (automata_list_el_t automata_list)
+{
+  automata_list_el_t el;
+  automaton_t automaton;
+
+  for (el = automata_list; el != NULL; el = el->next_automata_list_el)
+    {
+      automaton = el->automaton;
+      fprintf (output_file, "\n      %s = ", TEMPORARY_VARIABLE_NAME);
+      output_min_issue_delay_vect_name (output_file, automaton);
+      fprintf (output_file,
+	       (automaton->min_issue_delay_table_compression_factor != 1
+		? " [(" : " ["));
+      output_translate_vect_name (output_file, automaton);
+      fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME);
+      fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
+      output_chip_member_name (output_file, automaton);
+      fprintf (output_file, " * %d", automaton->insn_equiv_classes_num);
+      if (automaton->min_issue_delay_table_compression_factor == 1)
+	fprintf (output_file, "];\n");
+      else
+	{
+	  fprintf (output_file, ") / %d];\n",
+		   automaton->min_issue_delay_table_compression_factor);
+	  fprintf (output_file, "      %s = (%s >> (8 - (",
+		   TEMPORARY_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
+	  output_translate_vect_name (output_file, automaton);
+	  fprintf
+	    (output_file, " [%s] %% %d + 1) * %d)) & %d;\n",
+	     INTERNAL_INSN_CODE_NAME,
+	     automaton->min_issue_delay_table_compression_factor,
+	     8 / automaton->min_issue_delay_table_compression_factor,
+	     (1 << (8 / automaton->min_issue_delay_table_compression_factor))
+	     - 1);
+	}
+      if (el == automata_list)
+	fprintf (output_file, "      %s = %s;\n",
+		 RESULT_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
+      else
+	{
+	  fprintf (output_file, "      if (%s > %s)\n",
+		   TEMPORARY_VARIABLE_NAME, RESULT_VARIABLE_NAME);
+	  fprintf (output_file, "        %s = %s;\n",
+		   RESULT_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
+	}
+    }
+  fprintf (output_file, "      break;\n\n");
+}
+
+/* Output function `internal_min_issue_delay'.  */
+static void
+output_internal_min_issue_delay_func (void)
+{
+  fprintf (output_file,
+	   "static int\n%s (int %s, struct %s *%s ATTRIBUTE_UNUSED)\n",
+	   INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+	   CHIP_NAME, CHIP_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s ATTRIBUTE_UNUSED;\n  int %s = -1;\n",
+	   TEMPORARY_VARIABLE_NAME, RESULT_VARIABLE_NAME);
+  fprintf (output_file, "\n  switch (%s)\n    {\n", INTERNAL_INSN_CODE_NAME);
+  output_insn_code_cases (output_automata_list_min_issue_delay_code);
+  fprintf (output_file,
+	   "\n    default:\n      %s = -1;\n      break;\n    }\n",
+	   RESULT_VARIABLE_NAME);
+  fprintf (output_file, "  return %s;\n", RESULT_VARIABLE_NAME);
+  fprintf (output_file, "}\n\n");
+}
+
+/* The function outputs a code changing state after issue of insns
+   which have reservations in given AUTOMATA_LIST.  */
+static void
+output_automata_list_transition_code (automata_list_el_t automata_list)
+{
+  automata_list_el_t el, next_el;
+
+  fprintf (output_file, "      {\n");
+  if (automata_list != NULL && automata_list->next_automata_list_el != NULL)
+    for (el = automata_list;; el = next_el)
+      {
+        next_el = el->next_automata_list_el;
+        if (next_el == NULL)
+          break;
+        fprintf (output_file, "        ");
+        output_state_member_type (output_file, el->automaton);
+	fprintf (output_file, " ");
+        output_temp_chip_member_name (output_file, el->automaton);
+        fprintf (output_file, ";\n");
+      }
+  for (el = automata_list; el != NULL; el = el->next_automata_list_el)
+    if (comb_vect_p (el->automaton->trans_table))
+      {
+	fprintf (output_file, "\n        %s = ", TEMPORARY_VARIABLE_NAME);
+	output_trans_base_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [%s->", CHIP_PARAMETER_NAME);
+	output_chip_member_name (output_file, el->automaton);
+	fprintf (output_file, "] + ");
+	output_translate_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [%s];\n", INTERNAL_INSN_CODE_NAME);
+	fprintf (output_file, "        if (");
+	output_trans_check_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [%s] != %s->",
+		 TEMPORARY_VARIABLE_NAME, CHIP_PARAMETER_NAME);
+	output_chip_member_name (output_file, el->automaton);
+	fprintf (output_file, ")\n");
+	fprintf (output_file, "          return %s (%s, %s);\n",
+		 INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+		 CHIP_PARAMETER_NAME);
+	fprintf (output_file, "        else\n");
+	fprintf (output_file, "          ");
+	if (el->next_automata_list_el != NULL)
+	  output_temp_chip_member_name (output_file, el->automaton);
+	else
+	  {
+	    fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
+	    output_chip_member_name (output_file, el->automaton);
+	  }
+	fprintf (output_file, " = ");
+	output_trans_comb_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [%s];\n", TEMPORARY_VARIABLE_NAME);
+      }
+    else
+      {
+	fprintf (output_file, "\n        %s = ", TEMPORARY_VARIABLE_NAME);
+	output_trans_full_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [");
+	output_translate_vect_name (output_file, el->automaton);
+	fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME);
+	fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
+	output_chip_member_name (output_file, el->automaton);
+	fprintf (output_file, " * %d];\n",
+		 el->automaton->insn_equiv_classes_num);
+	fprintf (output_file, "        if (%s >= %d)\n",
+		 TEMPORARY_VARIABLE_NAME, el->automaton->achieved_states_num);
+	fprintf (output_file, "          return %s (%s, %s);\n",
+		 INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+		 CHIP_PARAMETER_NAME);
+	fprintf (output_file, "        else\n          ");
+	if (el->next_automata_list_el != NULL)
+	  output_temp_chip_member_name (output_file, el->automaton);
+	else
+	  {
+	    fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
+	    output_chip_member_name (output_file, el->automaton);
+	  }
+	fprintf (output_file, " = %s;\n", TEMPORARY_VARIABLE_NAME);
+      }
+  if (automata_list != NULL && automata_list->next_automata_list_el != NULL)
+    for (el = automata_list;; el = next_el)
+      {
+        next_el = el->next_automata_list_el;
+        if (next_el == NULL)
+          break;
+        fprintf (output_file, "        %s->", CHIP_PARAMETER_NAME);
+        output_chip_member_name (output_file, el->automaton);
+        fprintf (output_file, " = ");
+        output_temp_chip_member_name (output_file, el->automaton);
+        fprintf (output_file, ";\n");
+      }
+  fprintf (output_file, "        return -1;\n");
+  fprintf (output_file, "      }\n");
+}
+
+/* Output function `internal_state_transition'.  */
+static void
+output_internal_trans_func (void)
+{
+  fprintf (output_file,
+	   "static int\n%s (int %s, struct %s *%s ATTRIBUTE_UNUSED)\n",
+	   INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+	   CHIP_NAME, CHIP_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s ATTRIBUTE_UNUSED;\n", TEMPORARY_VARIABLE_NAME);
+  fprintf (output_file, "\n  switch (%s)\n    {\n", INTERNAL_INSN_CODE_NAME);
+  output_insn_code_cases (output_automata_list_transition_code);
+  fprintf (output_file, "\n    default:\n      return -1;\n    }\n");
+  fprintf (output_file, "}\n\n");
+}
+
+/* Output code
+
+  if (insn != 0)
+    {
+      insn_code = dfa_insn_code (insn);
+      if (insn_code > DFA__ADVANCE_CYCLE)
+        return code;
+    }
+  else
+    insn_code = DFA__ADVANCE_CYCLE;
+
+  where insn denotes INSN_NAME, insn_code denotes INSN_CODE_NAME, and
+  code denotes CODE.  */
+static void
+output_internal_insn_code_evaluation (const char *insn_name,
+				      const char *insn_code_name,
+				      int code)
+{
+  fprintf (output_file, "\n  if (%s != 0)\n    {\n", insn_name);
+  fprintf (output_file, "      %s = %s (%s);\n", insn_code_name,
+	   DFA_INSN_CODE_FUNC_NAME, insn_name);
+  fprintf (output_file, "      if (%s > %s)\n        return %d;\n",
+	   insn_code_name, ADVANCE_CYCLE_VALUE_NAME, code);
+  fprintf (output_file, "    }\n  else\n    %s = %s;\n\n",
+	   insn_code_name, ADVANCE_CYCLE_VALUE_NAME);
+}
+
+
+/* This function outputs `dfa_insn_code' and its helper function
+   `dfa_insn_code_enlarge'.  */
+static void
+output_dfa_insn_code_func (void)
+{
+  /* Emacs c-mode gets really confused if there's a { or } in column 0
+     inside a string, so don't do that.  */
+  fprintf (output_file, "\
+static void\n\
+dfa_insn_code_enlarge (int uid)\n\
+{\n\
+  int i = %s;\n\
+  %s = 2 * uid;\n\
+  %s = XRESIZEVEC (int, %s,\n\
+                 %s);\n\
+  for (; i < %s; i++)\n\
+    %s[i] = -1;\n}\n\n",
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+	   DFA_INSN_CODES_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+	   DFA_INSN_CODES_VARIABLE_NAME);
+  fprintf (output_file, "\
+static inline int\n%s (rtx %s)\n\
+{\n\
+  int uid = INSN_UID (%s);\n\
+  int %s;\n\n",
+	   DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME,
+	   INSN_PARAMETER_NAME, INTERNAL_INSN_CODE_NAME);
+
+  fprintf (output_file,
+	   "  if (uid >= %s)\n    dfa_insn_code_enlarge (uid);\n\n",
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
+  fprintf (output_file, "  %s = %s[uid];\n",
+	   INTERNAL_INSN_CODE_NAME, DFA_INSN_CODES_VARIABLE_NAME);
+  fprintf (output_file, "\
+  if (%s < 0)\n\
+    {\n\
+      %s = %s (%s);\n\
+      %s[uid] = %s;\n\
+    }\n",
+	   INTERNAL_INSN_CODE_NAME,
+	   INTERNAL_INSN_CODE_NAME,
+	   INTERNAL_DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME,
+	   DFA_INSN_CODES_VARIABLE_NAME, INTERNAL_INSN_CODE_NAME);
+  fprintf (output_file, "  return %s;\n}\n\n", INTERNAL_INSN_CODE_NAME);
+}
+
+/* The function outputs PHR interface function `state_transition'.  */
+static void
+output_trans_func (void)
+{
+  fprintf (output_file, "int\n%s (%s %s, rtx %s)\n",
+	   TRANSITION_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME,
+	   INSN_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s;\n", INTERNAL_INSN_CODE_NAME);
+  output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
+					INTERNAL_INSN_CODE_NAME, -1);
+  fprintf (output_file, "  return %s (%s, (struct %s *) %s);\n}\n\n",
+	   INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME, CHIP_NAME, STATE_NAME);
+}
+
+/* Output function `min_issue_delay'.  */
+static void
+output_min_issue_delay_func (void)
+{
+  fprintf (output_file, "int\n%s (%s %s, rtx %s)\n",
+	   MIN_ISSUE_DELAY_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME,
+	   INSN_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s;\n", INTERNAL_INSN_CODE_NAME);
+  fprintf (output_file, "\n  if (%s != 0)\n    {\n", INSN_PARAMETER_NAME);
+  fprintf (output_file, "      %s = %s (%s);\n", INTERNAL_INSN_CODE_NAME,
+	   DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME);
+  fprintf (output_file, "      if (%s > %s)\n        return 0;\n",
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+  fprintf (output_file, "    }\n  else\n    %s = %s;\n",
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+  fprintf (output_file, "\n  return %s (%s, (struct %s *) %s);\n",
+	   INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+	   CHIP_NAME, STATE_NAME);
+  fprintf (output_file, "}\n\n");
+}
+
+/* Output function `internal_dead_lock'.  */
+static void
+output_internal_dead_lock_func (void)
+{
+  automaton_t automaton;
+
+  fprintf (output_file, "static int\n%s (struct %s *ARG_UNUSED (%s))\n",
+	   INTERNAL_DEAD_LOCK_FUNC_NAME, CHIP_NAME, CHIP_PARAMETER_NAME);
+  fprintf (output_file, "{\n");
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    if (automaton->locked_states)
+      {
+	fprintf (output_file, "  if (");
+	output_dead_lock_vect_name (output_file, automaton);
+	fprintf (output_file, " [%s->", CHIP_PARAMETER_NAME);
+	output_chip_member_name (output_file, automaton);
+	fprintf (output_file, "])\n    return 1/* TRUE */;\n");
+      }
+  fprintf (output_file, "  return 0/* FALSE */;\n}\n\n");
+}
+
+/* The function outputs PHR interface function `state_dead_lock_p'.  */
+static void
+output_dead_lock_func (void)
+{
+  fprintf (output_file, "int\n%s (%s %s)\n",
+	   DEAD_LOCK_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME);
+  fprintf (output_file, "{\n  return %s ((struct %s *) %s);\n}\n\n",
+	   INTERNAL_DEAD_LOCK_FUNC_NAME, CHIP_NAME, STATE_NAME);
+}
+
+/* Output function `internal_reset'.  */
+static void
+output_internal_reset_func (void)
+{
+  fprintf (output_file, "static inline void\n%s (struct %s *%s)\n",
+	   INTERNAL_RESET_FUNC_NAME, CHIP_NAME, CHIP_PARAMETER_NAME);
+  fprintf (output_file, "{\n  memset (%s, 0, sizeof (struct %s));\n}\n\n",
+	   CHIP_PARAMETER_NAME, CHIP_NAME);
+}
+
+/* The function outputs PHR interface function `state_size'.  */
+static void
+output_size_func (void)
+{
+  fprintf (output_file, "int\n%s (void)\n", SIZE_FUNC_NAME);
+  fprintf (output_file, "{\n  return sizeof (struct %s);\n}\n\n", CHIP_NAME);
+}
+
+/* The function outputs PHR interface function `state_reset'.  */
+static void
+output_reset_func (void)
+{
+  fprintf (output_file, "void\n%s (%s %s)\n",
+	   RESET_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME);
+  fprintf (output_file, "{\n  %s ((struct %s *) %s);\n}\n\n", INTERNAL_RESET_FUNC_NAME,
+	   CHIP_NAME, STATE_NAME);
+}
+
+/* Output function `min_insn_conflict_delay'.  */
+static void
+output_min_insn_conflict_delay_func (void)
+{
+  fprintf (output_file,
+	   "int\n%s (%s %s, rtx %s, rtx %s)\n",
+	   MIN_INSN_CONFLICT_DELAY_FUNC_NAME, STATE_TYPE_NAME,
+	   STATE_NAME, INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
+  fprintf (output_file, "{\n  struct %s %s;\n  int %s, %s, transition;\n",
+	   CHIP_NAME, CHIP_NAME, INTERNAL_INSN_CODE_NAME,
+	   INTERNAL_INSN2_CODE_NAME);
+  output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
+					INTERNAL_INSN_CODE_NAME, 0);
+  output_internal_insn_code_evaluation (INSN2_PARAMETER_NAME,
+					INTERNAL_INSN2_CODE_NAME, 0);
+  fprintf (output_file, "  memcpy (&%s, %s, sizeof (%s));\n",
+	   CHIP_NAME, STATE_NAME, CHIP_NAME);
+  fprintf (output_file, "  %s (&%s);\n", INTERNAL_RESET_FUNC_NAME, CHIP_NAME);
+  fprintf (output_file, "  transition = %s (%s, &%s);\n",
+	   INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME, CHIP_NAME);
+  fprintf (output_file, "  gcc_assert (transition <= 0);\n");
+  fprintf (output_file, "  return %s (%s, &%s);\n",
+	   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;
+  decl_t decl;
+  const char *tabletype = "unsigned char";
+
+  /* Find the smallest integer type that can hold all the default
+     latency values.  */
+  for (i = 0; i < description->decls_num; i++)
+    if (description->decls[i]->mode == dm_insn_reserv)
+      {
+	decl = description->decls[i];
+	if (DECL_INSN_RESERV (decl)->default_latency > UCHAR_MAX
+	    && tabletype[0] != 'i')  /* Don't shrink it.  */
+	  tabletype = "unsigned short";
+	if (DECL_INSN_RESERV (decl)->default_latency > USHRT_MAX)
+	  tabletype = "int";
+      }
+
+  fprintf (output_file, "  static const %s default_latencies[] =\n    {",
+	   tabletype);
+
+  for (i = 0, j = 0, col = 7; i < description->decls_num; i++)
+    if (description->decls[i]->mode == dm_insn_reserv
+	&& description->decls[i] != advance_cycle_insn_decl)
+      {
+	if ((col = (col+1) % 8) == 0)
+	  fputs ("\n     ", output_file);
+	decl = description->decls[i];
+	gcc_assert (j++ == DECL_INSN_RESERV (decl)->insn_num);
+	fprintf (output_file, "% 4d,",
+		 DECL_INSN_RESERV (decl)->default_latency);
+      }
+  gcc_assert (j == DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num);
+  fputs ("\n    };\n", output_file);
+}
+
+/* Output function `internal_insn_latency'.  */
+static void
+output_internal_insn_latency_func (void)
+{
+  int i;
+  decl_t decl;
+  struct bypass_decl *bypass;
+
+  fprintf (output_file, "static int\n%s (int %s ATTRIBUTE_UNUSED,\n\tint %s ATTRIBUTE_UNUSED,\n\trtx %s ATTRIBUTE_UNUSED,\n\trtx %s ATTRIBUTE_UNUSED)\n",
+	   INTERNAL_INSN_LATENCY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
+	   INTERNAL_INSN2_CODE_NAME, INSN_PARAMETER_NAME,
+	   INSN2_PARAMETER_NAME);
+  fprintf (output_file, "{\n");
+
+  if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
+    {
+      fputs ("  return 0;\n}\n\n", output_file);
+      return;
+    }
+
+  fprintf (output_file, "  if (%s >= %s || %s >= %s)\n    return 0;\n",
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
+	   INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+
+  fprintf (output_file, "  switch (%s)\n    {\n", INTERNAL_INSN_CODE_NAME);
+  for (i = 0; i < description->decls_num; i++)
+    if (description->decls[i]->mode == dm_insn_reserv
+	&& DECL_INSN_RESERV (description->decls[i])->bypass_list)
+      {
+	decl = description->decls [i];
+	fprintf (output_file,
+		 "    case %d:\n      switch (%s)\n        {\n",
+		 DECL_INSN_RESERV (decl)->insn_num,
+		 INTERNAL_INSN2_CODE_NAME);
+	for (bypass = DECL_INSN_RESERV (decl)->bypass_list;
+	     bypass != NULL;
+	     bypass = bypass->next)
+	  {
+	    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)
+	      fprintf (output_file, "          return %d;\n",
+		       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          break;\n",
+			 bypass->latency);
+	      }
+	  }
+	fputs ("        }\n      break;\n", output_file);
+      }
+
+  fprintf (output_file, "    }\n  return default_latencies[%s];\n}\n\n",
+	   INTERNAL_INSN_CODE_NAME);
+}
+
+/* Output function `internal_maximum_insn_latency'.  */
+static void
+output_internal_maximal_insn_latency_func (void)
+{
+  decl_t decl;
+  struct bypass_decl *bypass;
+  int i;
+  int max;
+
+  fprintf (output_file, "static int\n%s (int %s ATTRIBUTE_UNUSED,\n\trtx %s ATTRIBUTE_UNUSED)\n",
+	   "internal_maximal_insn_latency", INTERNAL_INSN_CODE_NAME,
+	   INSN_PARAMETER_NAME);
+  fprintf (output_file, "{\n");
+
+  if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
+    {
+      fputs ("  return 0;\n}\n\n", output_file);
+      return;
+    }
+
+  fprintf (output_file, "  switch (%s)\n    {\n", INTERNAL_INSN_CODE_NAME);
+  for (i = 0; i < description->decls_num; i++)
+    if (description->decls[i]->mode == dm_insn_reserv
+	&& DECL_INSN_RESERV (description->decls[i])->bypass_list)
+      {
+	decl = description->decls [i];
+        max = DECL_INSN_RESERV (decl)->default_latency;
+	fprintf (output_file,
+		 "    case %d: {",
+		 DECL_INSN_RESERV (decl)->insn_num);
+	for (bypass = DECL_INSN_RESERV (decl)->bypass_list;
+	     bypass != NULL;
+	     bypass = bypass->next)
+	  {
+	    if (bypass->latency > max)
+              max = bypass->latency;
+	  }
+	fprintf (output_file, " return %d; }\n      break;\n", max);
+      }
+
+  fprintf (output_file, "    }\n  return default_latencies[%s];\n}\n\n",
+	   INTERNAL_INSN_CODE_NAME);
+}
+
+/* The function outputs PHR interface function `insn_latency'.  */
+static void
+output_insn_latency_func (void)
+{
+  fprintf (output_file, "int\n%s (rtx %s, rtx %s)\n",
+	   INSN_LATENCY_FUNC_NAME, INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s, %s;\n",
+	   INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME);
+  output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
+					INTERNAL_INSN_CODE_NAME, 0);
+  output_internal_insn_code_evaluation (INSN2_PARAMETER_NAME,
+					INTERNAL_INSN2_CODE_NAME, 0);
+  fprintf (output_file, "  return %s (%s, %s, %s, %s);\n}\n\n",
+	   INTERNAL_INSN_LATENCY_FUNC_NAME,
+	   INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME,
+	   INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
+}
+
+/* The function outputs PHR interface function `maximal_insn_latency'.  */
+static void
+output_maximal_insn_latency_func (void)
+{
+  fprintf (output_file, "int\n%s (rtx %s)\n",
+	   "maximal_insn_latency", INSN_PARAMETER_NAME);
+  fprintf (output_file, "{\n  int %s;\n",
+	   INTERNAL_INSN_CODE_NAME);
+  output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
+					INTERNAL_INSN_CODE_NAME, 0);
+  fprintf (output_file, "  return %s (%s, %s);\n}\n\n",
+	   "internal_maximal_insn_latency",
+	   INTERNAL_INSN_CODE_NAME, INSN_PARAMETER_NAME);
+}
+
+/* The function outputs PHR interface function `print_reservation'.  */
+static void
+output_print_reservation_func (void)
+{
+  decl_t decl;
+  int i, j;
+
+  fprintf (output_file,
+	   "void\n%s (FILE *%s, rtx %s ATTRIBUTE_UNUSED)\n{\n",
+           PRINT_RESERVATION_FUNC_NAME, FILE_PARAMETER_NAME,
+           INSN_PARAMETER_NAME);
+
+  if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
+    {
+      fprintf (output_file, "  fputs (\"%s\", %s);\n}\n\n",
+	       NOTHING_NAME, FILE_PARAMETER_NAME);
+      return;
+    }
+
+
+  fputs ("  static const char *const reservation_names[] =\n    {",
+	 output_file);
+
+  for (i = 0, j = 0; i < description->decls_num; i++)
+    {
+      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 ();
+	}
+    }
+  gcc_assert (j == DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num);
+
+  fprintf (output_file, "\n      \"%s\"\n    };\n  int %s;\n\n",
+	   NOTHING_NAME, INTERNAL_INSN_CODE_NAME);
+
+  fprintf (output_file, "  if (%s == 0)\n    %s = %s;\n",
+	   INSN_PARAMETER_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+  fprintf (output_file, "  else\n\
+    {\n\
+      %s = %s (%s);\n\
+      if (%s > %s)\n\
+        %s = %s;\n\
+    }\n",
+	   INTERNAL_INSN_CODE_NAME, DFA_INSN_CODE_FUNC_NAME,
+	       INSN_PARAMETER_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+
+  fprintf (output_file, "  fputs (reservation_names[%s], %s);\n}\n\n",
+	   INTERNAL_INSN_CODE_NAME, FILE_PARAMETER_NAME);
+}
+
+/* The following function is used to sort unit declaration by their
+   names.  */
+static int
+units_cmp (const void *unit1, const void *unit2)
+{
+  const_unit_decl_t const u1 = *(const_unit_decl_t const*) unit1;
+  const_unit_decl_t const u2 = *(const_unit_decl_t const*) unit2;
+
+  return strcmp (u1->name, u2->name);
+}
+
+/* The following macro value is name of struct containing unit name
+   and unit code.  */
+#define NAME_CODE_STRUCT_NAME  "name_code"
+
+/* The following macro value is name of table of struct name_code.  */
+#define NAME_CODE_TABLE_NAME   "name_code_table"
+
+/* The following macro values are member names for struct name_code.  */
+#define NAME_MEMBER_NAME       "name"
+#define CODE_MEMBER_NAME       "code"
+
+/* The following macro values are local variable names for function
+   `get_cpu_unit_code'.  */
+#define CMP_VARIABLE_NAME      "cmp"
+#define LOW_VARIABLE_NAME      "l"
+#define MIDDLE_VARIABLE_NAME   "m"
+#define HIGH_VARIABLE_NAME     "h"
+
+/* The following function outputs function to obtain internal cpu unit
+   code by the cpu unit name.  */
+static void
+output_get_cpu_unit_code_func (void)
+{
+  int i;
+  unit_decl_t *units;
+
+  fprintf (output_file, "int\n%s (const char *%s)\n",
+	   GET_CPU_UNIT_CODE_FUNC_NAME, CPU_UNIT_NAME_PARAMETER_NAME);
+  fprintf (output_file, "{\n  struct %s {const char *%s; int %s;};\n",
+	   NAME_CODE_STRUCT_NAME, NAME_MEMBER_NAME, CODE_MEMBER_NAME);
+  fprintf (output_file, "  int %s, %s, %s, %s;\n", CMP_VARIABLE_NAME,
+	   LOW_VARIABLE_NAME, MIDDLE_VARIABLE_NAME, HIGH_VARIABLE_NAME);
+  fprintf (output_file, "  static struct %s %s [] =\n    {\n",
+	   NAME_CODE_STRUCT_NAME, NAME_CODE_TABLE_NAME);
+  units = XNEWVEC (unit_decl_t, description->units_num);
+  memcpy (units, units_array, sizeof (unit_decl_t) * description->units_num);
+  qsort (units, description->units_num, sizeof (unit_decl_t), units_cmp);
+  for (i = 0; i < description->units_num; i++)
+    if (units [i]->query_p)
+      fprintf (output_file, "      {\"%s\", %d},\n",
+	       units[i]->name, units[i]->query_num);
+  fprintf (output_file, "    };\n\n");
+  fprintf (output_file, "  /* The following is binary search: */\n");
+  fprintf (output_file, "  %s = 0;\n", LOW_VARIABLE_NAME);
+  fprintf (output_file, "  %s = sizeof (%s) / sizeof (struct %s) - 1;\n",
+	   HIGH_VARIABLE_NAME, NAME_CODE_TABLE_NAME, NAME_CODE_STRUCT_NAME);
+  fprintf (output_file, "  while (%s <= %s)\n    {\n",
+	   LOW_VARIABLE_NAME, HIGH_VARIABLE_NAME);
+  fprintf (output_file, "      %s = (%s + %s) / 2;\n",
+	   MIDDLE_VARIABLE_NAME, LOW_VARIABLE_NAME, HIGH_VARIABLE_NAME);
+  fprintf (output_file, "      %s = strcmp (%s, %s [%s].%s);\n",
+	   CMP_VARIABLE_NAME, CPU_UNIT_NAME_PARAMETER_NAME,
+	   NAME_CODE_TABLE_NAME, MIDDLE_VARIABLE_NAME, NAME_MEMBER_NAME);
+  fprintf (output_file, "      if (%s < 0)\n", CMP_VARIABLE_NAME);
+  fprintf (output_file, "        %s = %s - 1;\n",
+	   HIGH_VARIABLE_NAME, MIDDLE_VARIABLE_NAME);
+  fprintf (output_file, "      else if (%s > 0)\n", CMP_VARIABLE_NAME);
+  fprintf (output_file, "        %s = %s + 1;\n",
+	   LOW_VARIABLE_NAME, MIDDLE_VARIABLE_NAME);
+  fprintf (output_file, "      else\n");
+  fprintf (output_file, "        return %s [%s].%s;\n    }\n",
+	   NAME_CODE_TABLE_NAME, MIDDLE_VARIABLE_NAME, CODE_MEMBER_NAME);
+  fprintf (output_file, "  return -1;\n}\n\n");
+  free (units);
+}
+
+/* The following function outputs function to check reservation of cpu
+   unit (its internal code will be passed as the function argument) in
+   given cpu state.  */
+static void
+output_cpu_unit_reservation_p (void)
+{
+  automaton_t automaton;
+
+  fprintf (output_file, "int\n%s (%s %s, int %s)\n",
+	   CPU_UNIT_RESERVATION_P_FUNC_NAME,
+	   STATE_TYPE_NAME, STATE_NAME,
+	   CPU_CODE_PARAMETER_NAME);
+  fprintf (output_file, "{\n  gcc_assert (%s >= 0 && %s < %d);\n",
+	   CPU_CODE_PARAMETER_NAME, CPU_CODE_PARAMETER_NAME,
+	   description->query_units_num);
+  if (description->query_units_num > 0)
+    for (automaton = description->first_automaton;
+	 automaton != NULL;
+	 automaton = automaton->next_automaton)
+      {
+	fprintf (output_file, "  if ((");
+	output_reserved_units_table_name (output_file, automaton);
+	fprintf (output_file, " [((struct %s *) %s)->", CHIP_NAME, STATE_NAME);
+	output_chip_member_name (output_file, automaton);
+	fprintf (output_file, " * %d + %s / 8] >> (%s %% 8)) & 1)\n",
+		 (description->query_units_num + 7) / 8,
+		 CPU_CODE_PARAMETER_NAME, CPU_CODE_PARAMETER_NAME);
+	fprintf (output_file, "    return 1;\n");
+      }
+  fprintf (output_file, "  return 0;\n}\n\n");
+}
+
+/* The following function outputs a function to check if insn
+   has a dfa reservation.  */
+static void
+output_insn_has_dfa_reservation_p (void)
+{
+  fprintf (output_file,
+	   "bool\n%s (rtx %s ATTRIBUTE_UNUSED)\n{\n",
+           INSN_HAS_DFA_RESERVATION_P_FUNC_NAME,
+           INSN_PARAMETER_NAME);
+
+  if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
+    {
+      fprintf (output_file, "  return false;\n}\n\n");
+      return;
+    }
+
+  fprintf (output_file, "  int %s;\n\n", INTERNAL_INSN_CODE_NAME);
+
+  fprintf (output_file, "  if (%s == 0)\n    %s = %s;\n",
+	   INSN_PARAMETER_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+  fprintf (output_file, "  else\n\
+    {\n\
+      %s = %s (%s);\n\
+      if (%s > %s)\n\
+        %s = %s;\n\
+    }\n\n",
+	   INTERNAL_INSN_CODE_NAME, DFA_INSN_CODE_FUNC_NAME,
+	       INSN_PARAMETER_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+
+  fprintf (output_file, "  return %s != %s;\n}\n\n",
+	   INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
+}
+
+/* The function outputs PHR interface functions `dfa_clean_insn_cache'
+   and 'dfa_clear_single_insn_cache'.  */
+static void
+output_dfa_clean_insn_cache_func (void)
+{
+  fprintf (output_file,
+	   "void\n%s (void)\n{\n  int %s;\n\n",
+	   DFA_CLEAN_INSN_CACHE_FUNC_NAME, I_VARIABLE_NAME);
+  fprintf (output_file,
+	   "  for (%s = 0; %s < %s; %s++)\n    %s [%s] = -1;\n}\n\n",
+	   I_VARIABLE_NAME, I_VARIABLE_NAME,
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME, I_VARIABLE_NAME,
+	   DFA_INSN_CODES_VARIABLE_NAME, I_VARIABLE_NAME);
+
+  fprintf (output_file,
+           "void\n%s (rtx %s)\n{\n  int %s;\n\n",
+           DFA_CLEAR_SINGLE_INSN_CACHE_FUNC_NAME, INSN_PARAMETER_NAME,
+	   I_VARIABLE_NAME);
+  fprintf (output_file,
+           "  %s = INSN_UID (%s);\n  if (%s < %s)\n    %s [%s] = -1;\n}\n\n",
+           I_VARIABLE_NAME, INSN_PARAMETER_NAME, I_VARIABLE_NAME,
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
+	   I_VARIABLE_NAME);
+}
+
+/* The function outputs PHR interface function `dfa_start'.  */
+static void
+output_dfa_start_func (void)
+{
+  fprintf (output_file,
+	   "void\n%s (void)\n{\n  %s = get_max_uid ();\n",
+	   DFA_START_FUNC_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
+  fprintf (output_file, "  %s = XNEWVEC (int, %s);\n",
+	   DFA_INSN_CODES_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
+  fprintf (output_file, "  %s ();\n}\n\n", DFA_CLEAN_INSN_CACHE_FUNC_NAME);
+}
+
+/* The function outputs PHR interface function `dfa_finish'.  */
+static void
+output_dfa_finish_func (void)
+{
+  fprintf (output_file, "void\n%s (void)\n{\n  free (%s);\n}\n\n",
+	   DFA_FINISH_FUNC_NAME, DFA_INSN_CODES_VARIABLE_NAME);
+}
+
+
+
+/* The page contains code for output description file (readable
+   representation of original description and generated DFA(s).  */
+
+/* The function outputs string representation of IR reservation.  */
+static void
+output_regexp (regexp_t regexp)
+{
+  fprintf (output_description_file, "%s", regexp_representation (regexp));
+  finish_regexp_representation ();
+}
+
+/* Output names of units in LIST separated by comma.  */
+static void
+output_unit_set_el_list (unit_set_el_t list)
+{
+  unit_set_el_t el;
+
+  for (el = list; el != NULL; el = el->next_unit_set_el)
+    {
+      if (el != list)
+	fprintf (output_description_file, ", ");
+      fprintf (output_description_file, "%s", el->unit_decl->name);
+    }
+}
+
+/* Output patterns in LIST separated by comma.  */
+static void
+output_pattern_set_el_list (pattern_set_el_t list)
+{
+  pattern_set_el_t el;
+  int i;
+
+  for (el = list; el != NULL; el = el->next_pattern_set_el)
+    {
+      if (el != list)
+	fprintf (output_description_file, ", ");
+      for (i = 0; i < el->units_num; i++)
+	fprintf (output_description_file, (i == 0 ? "%s" : " %s"),
+		 el->unit_decls [i]->name);
+    }
+}
+
+/* The function outputs string representation of IR define_reservation
+   and define_insn_reservation.  */
+static void
+output_description (void)
+{
+  decl_t decl;
+  int i;
+
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit)
+	{
+	  if (DECL_UNIT (decl)->excl_list != NULL)
+	    {
+	      fprintf (output_description_file, "unit %s exclusion_set: ",
+		       DECL_UNIT (decl)->name);
+	      output_unit_set_el_list (DECL_UNIT (decl)->excl_list);
+	      fprintf (output_description_file, "\n");
+	    }
+	  if (DECL_UNIT (decl)->presence_list != NULL)
+	    {
+	      fprintf (output_description_file, "unit %s presence_set: ",
+		       DECL_UNIT (decl)->name);
+	      output_pattern_set_el_list (DECL_UNIT (decl)->presence_list);
+	      fprintf (output_description_file, "\n");
+	    }
+	  if (DECL_UNIT (decl)->final_presence_list != NULL)
+	    {
+	      fprintf (output_description_file, "unit %s final_presence_set: ",
+		       DECL_UNIT (decl)->name);
+	      output_pattern_set_el_list
+		(DECL_UNIT (decl)->final_presence_list);
+	      fprintf (output_description_file, "\n");
+	    }
+	  if (DECL_UNIT (decl)->absence_list != NULL)
+	    {
+	      fprintf (output_description_file, "unit %s absence_set: ",
+		       DECL_UNIT (decl)->name);
+	      output_pattern_set_el_list (DECL_UNIT (decl)->absence_list);
+	      fprintf (output_description_file, "\n");
+	    }
+	  if (DECL_UNIT (decl)->final_absence_list != NULL)
+	    {
+	      fprintf (output_description_file, "unit %s final_absence_set: ",
+		       DECL_UNIT (decl)->name);
+	      output_pattern_set_el_list
+		(DECL_UNIT (decl)->final_absence_list);
+	      fprintf (output_description_file, "\n");
+	    }
+	}
+    }
+  fprintf (output_description_file, "\n");
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_reserv)
+	{
+          fprintf (output_description_file, "reservation %s: ",
+		   DECL_RESERV (decl)->name);
+          output_regexp (DECL_RESERV (decl)->regexp);
+          fprintf (output_description_file, "\n");
+        }
+      else if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
+        {
+          fprintf (output_description_file, "insn reservation %s ",
+		   DECL_INSN_RESERV (decl)->name);
+          print_rtl (output_description_file,
+		     DECL_INSN_RESERV (decl)->condexp);
+          fprintf (output_description_file, ": ");
+          output_regexp (DECL_INSN_RESERV (decl)->regexp);
+          fprintf (output_description_file, "\n");
+        }
+      else if (decl->mode == dm_bypass)
+	fprintf (output_description_file, "bypass %d %s %s\n",
+		 DECL_BYPASS (decl)->latency,
+		 DECL_BYPASS (decl)->out_insn_name,
+		 DECL_BYPASS (decl)->in_insn_name);
+    }
+  fprintf (output_description_file, "\n\f\n");
+}
+
+/* The function outputs name of AUTOMATON.  */
+static void
+output_automaton_name (FILE *f, automaton_t automaton)
+{
+  if (automaton->corresponding_automaton_decl == NULL)
+    fprintf (f, "#%d", automaton->automaton_order_num);
+  else
+    fprintf (f, "`%s'", automaton->corresponding_automaton_decl->name);
+}
+
+/* Maximal length of line for pretty printing into description
+   file.  */
+#define MAX_LINE_LENGTH 70
+
+/* The function outputs units name belonging to AUTOMATON.  */
+static void
+output_automaton_units (automaton_t automaton)
+{
+  decl_t decl;
+  const char *name;
+  int curr_line_length;
+  int there_is_an_automaton_unit;
+  int i;
+
+  fprintf (output_description_file, "\n  Corresponding units:\n");
+  fprintf (output_description_file, "    ");
+  curr_line_length = 4;
+  there_is_an_automaton_unit = 0;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      decl = description->decls [i];
+      if (decl->mode == dm_unit
+          && (DECL_UNIT (decl)->corresponding_automaton_num
+	      == automaton->automaton_order_num))
+	{
+	  there_is_an_automaton_unit = 1;
+	  name = DECL_UNIT (decl)->name;
+	  if (curr_line_length + strlen (name) + 1 > MAX_LINE_LENGTH )
+	    {
+	      curr_line_length = strlen (name) + 4;
+	      fprintf (output_description_file, "\n    ");
+	    }
+	  else
+	    {
+	      curr_line_length += strlen (name) + 1;
+	      fprintf (output_description_file, " ");
+	    }
+	  fprintf (output_description_file, "%s", name);
+	}
+    }
+  if (!there_is_an_automaton_unit)
+    fprintf (output_description_file, "<None>");
+  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;
+
+/* The function forms `state_reservs' for STATE.  */
+static void
+add_state_reservs (state_t state)
+{
+  alt_state_t curr_alt_state;
+
+  if (state->component_states != NULL)
+    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);
+}
+
+/* The function outputs readable representation of all out arcs of
+   STATE.  */
+static void
+output_state_arcs (state_t state)
+{
+  arc_t arc;
+  ainsn_t ainsn;
+  const char *insn_name;
+  int curr_line_length;
+
+  for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
+    {
+      ainsn = arc->insn;
+      gcc_assert (ainsn->first_insn_with_same_reservs);
+      fprintf (output_description_file, "    ");
+      curr_line_length = 7;
+      fprintf (output_description_file, "%2d: ", ainsn->insn_equiv_class_num);
+      do
+        {
+          insn_name = ainsn->insn_reserv_decl->name;
+          if (curr_line_length + strlen (insn_name) > MAX_LINE_LENGTH)
+            {
+              if (ainsn != arc->insn)
+                {
+                  fprintf (output_description_file, ",\n      ");
+                  curr_line_length = strlen (insn_name) + 6;
+                }
+              else
+                curr_line_length += strlen (insn_name);
+            }
+          else
+            {
+              curr_line_length += strlen (insn_name);
+              if (ainsn != arc->insn)
+                {
+                  curr_line_length += 2;
+                  fprintf (output_description_file, ", ");
+                }
+            }
+          fprintf (output_description_file, "%s", insn_name);
+          ainsn = ainsn->next_same_reservs_insn;
+        }
+      while (ainsn != NULL);
+      fprintf (output_description_file, "    %d \n",
+	       arc->to_state->order_state_num);
+    }
+  fprintf (output_description_file, "\n");
+}
+
+/* The following function is used for sorting possible cpu unit
+   reservation of a DFA state.  */
+static int
+state_reservs_cmp (const void *reservs_ptr_1, const void *reservs_ptr_2)
+{
+  return reserv_sets_cmp (*(const_reserv_sets_t const*) reservs_ptr_1,
+                          *(const_reserv_sets_t const*) reservs_ptr_2);
+}
+
+/* The following function is used for sorting possible cpu unit
+   reservation of a DFA state.  */
+static void
+remove_state_duplicate_reservs (void)
+{
+  size_t i, j;
+
+  for (i = 1, j = 0; i < VEC_length (reserv_sets_t, state_reservs); i++)
+    if (reserv_sets_cmp (VEC_index (reserv_sets_t, state_reservs, j),
+			 VEC_index (reserv_sets_t, state_reservs, i)))
+      {
+	j++;
+	VEC_replace (reserv_sets_t, state_reservs, j,
+		     VEC_index (reserv_sets_t, state_reservs, i));
+      }
+  VEC_truncate (reserv_sets_t, state_reservs, j + 1);
+}
+
+/* The following function output readable representation of DFA(s)
+   state used for fast recognition of pipeline hazards.  State is
+   described by possible (current and scheduled) cpu unit
+   reservations.  */
+static void
+output_state (state_t state)
+{
+  size_t i;
+
+  state_reservs = 0;
+
+  fprintf (output_description_file, "  State #%d", state->order_state_num);
+  fprintf (output_description_file,
+	   state->new_cycle_p ? " (new cycle)\n" : "\n");
+  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++)
+    {
+      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);
+}
+
+/* The following function output readable representation of
+   DFAs used for fast recognition of pipeline hazards.  */
+static void
+output_automaton_descriptions (void)
+{
+  automaton_t automaton;
+
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      fprintf (output_description_file, "\nAutomaton ");
+      output_automaton_name (output_description_file, automaton);
+      fprintf (output_description_file, "\n");
+      output_automaton_units (automaton);
+      pass_states (automaton, output_state);
+    }
+}
+
+
+
+/* The page contains top level function for generation DFA(s) used for
+   PHR.  */
+
+/* The function outputs statistics about work of different phases of
+   DFA generator.  */
+static void
+output_statistics (FILE *f)
+{
+  automaton_t automaton;
+  int states_num;
+#ifndef NDEBUG
+  int transition_comb_vect_els = 0;
+  int transition_full_vect_els = 0;
+  int min_issue_delay_vect_els = 0;
+  int locked_states = 0;
+#endif
+
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      fprintf (f, "\nAutomaton ");
+      output_automaton_name (f, automaton);
+      fprintf (f, "\n    %5d NDFA states,          %5d NDFA arcs\n",
+	       automaton->NDFA_states_num, automaton->NDFA_arcs_num);
+      fprintf (f, "    %5d DFA states,           %5d DFA arcs\n",
+	       automaton->DFA_states_num, automaton->DFA_arcs_num);
+      states_num = automaton->DFA_states_num;
+      if (!no_minimization_flag)
+	{
+	  fprintf (f, "    %5d minimal DFA states,   %5d minimal DFA arcs\n",
+		   automaton->minimal_DFA_states_num,
+		   automaton->minimal_DFA_arcs_num);
+	  states_num = automaton->minimal_DFA_states_num;
+	}
+      fprintf (f, "    %5d all insns      %5d insn equivalence classes\n",
+	       description->insns_num, automaton->insn_equiv_classes_num);
+      fprintf (f, "    %d locked states\n", automaton->locked_states);
+#ifndef NDEBUG
+      fprintf
+	(f, "%5ld transition comb vector els, %5ld trans table els: %s\n",
+	 (long) VEC_length (vect_el_t, automaton->trans_table->comb_vect),
+	 (long) VEC_length (vect_el_t, automaton->trans_table->full_vect),
+	 (comb_vect_p (automaton->trans_table)
+	  ? "use comb vect" : "use simple vect"));
+      fprintf
+        (f, "%5ld min delay table els, compression factor %d\n",
+         (long) states_num * automaton->insn_equiv_classes_num,
+	 automaton->min_issue_delay_table_compression_factor);
+      transition_comb_vect_els
+	+= VEC_length (vect_el_t, automaton->trans_table->comb_vect);
+      transition_full_vect_els
+        += VEC_length (vect_el_t, automaton->trans_table->full_vect);
+      min_issue_delay_vect_els
+	+= states_num * automaton->insn_equiv_classes_num;
+      locked_states
+	+= automaton->locked_states;
+#endif
+    }
+#ifndef NDEBUG
+  fprintf (f, "\n%5d all allocated states,     %5d all allocated arcs\n",
+	   allocated_states_num, allocated_arcs_num);
+  fprintf (f, "%5d all allocated alternative states\n",
+	   allocated_alt_states_num);
+  fprintf (f, "%5d all transition comb vector els, %5d all trans table els\n",
+	   transition_comb_vect_els, transition_full_vect_els);
+  fprintf (f, "%5d all min delay table els\n", min_issue_delay_vect_els);
+  fprintf (f, "%5d all locked states\n", locked_states);
+#endif
+}
+
+/* The function output times of work of different phases of DFA
+   generator.  */
+static void
+output_time_statistics (FILE *f)
+{
+  fprintf (f, "\n  transformation: ");
+  print_active_time (f, transform_time);
+  fprintf (f, (!ndfa_flag ? ", building DFA: " : ", building NDFA: "));
+  print_active_time (f, NDFA_time);
+  if (ndfa_flag)
+    {
+      fprintf (f, ", NDFA -> DFA: ");
+      print_active_time (f, NDFA_to_DFA_time);
+    }
+  fprintf (f, "\n  DFA minimization: ");
+  print_active_time (f, minimize_time);
+  fprintf (f, ", making insn equivalence: ");
+  print_active_time (f, equiv_time);
+  fprintf (f, "\n all automaton generation: ");
+  print_active_time (f, automaton_generation_time);
+  fprintf (f, ", output: ");
+  print_active_time (f, output_time);
+  fprintf (f, "\n");
+}
+
+/* The function generates DFA (deterministic finite state automaton)
+   for fast recognition of pipeline hazards.  No errors during
+   checking must be fixed before this function call.  */
+static void
+generate (void)
+{
+  automata_num = split_argument;
+  if (description->units_num < automata_num)
+    automata_num = description->units_num;
+  initiate_states ();
+  initiate_arcs ();
+  initiate_automata_lists ();
+  initiate_pass_states ();
+  initiate_excl_sets ();
+  initiate_presence_absence_pattern_sets ();
+  automaton_generation_time = create_ticker ();
+  create_automata ();
+  ticker_off (&automaton_generation_time);
+}
+
+
+
+/* This page mainly contains top level functions of pipeline hazards
+   description translator.  */
+
+/* The following macro value is suffix of name of description file of
+   pipeline hazards description translator.  */
+#define STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX ".dfa"
+
+/* The function returns suffix of given file name.  The returned
+   string can not be changed.  */
+static const char *
+file_name_suffix (const char *file_name)
+{
+  const char *last_period;
+
+  for (last_period = NULL; *file_name != '\0'; file_name++)
+    if (*file_name == '.')
+      last_period = file_name;
+  return (last_period == NULL ? file_name : last_period);
+}
+
+/* The function returns base name of given file name, i.e. pointer to
+   first char after last `/' (or `\' for WIN32) in given file name,
+   given file name itself if the directory name is absent.  The
+   returned string can not be changed.  */
+static const char *
+base_file_name (const char *file_name)
+{
+  int directory_name_length;
+
+  directory_name_length = strlen (file_name);
+#ifdef WIN32
+  while (directory_name_length >= 0 && file_name[directory_name_length] != '/'
+         && file_name[directory_name_length] != '\\')
+#else
+  while (directory_name_length >= 0 && file_name[directory_name_length] != '/')
+#endif
+    directory_name_length--;
+  return file_name + directory_name_length + 1;
+}
+
+/* The following is top level function to initialize the work of
+   pipeline hazards description translator.  */
+static void
+initiate_automaton_gen (int argc, char **argv)
+{
+  const char *base_name;
+  int i;
+
+  ndfa_flag = 0;
+  split_argument = 0;  /* default value */
+  no_minimization_flag = 0;
+  time_flag = 0;
+  stats_flag = 0;
+  v_flag = 0;
+  w_flag = 0;
+  progress_flag = 0;
+  for (i = 2; i < argc; i++)
+    if (strcmp (argv [i], NO_MINIMIZATION_OPTION) == 0)
+      no_minimization_flag = 1;
+    else if (strcmp (argv [i], TIME_OPTION) == 0)
+      time_flag = 1;
+    else if (strcmp (argv [i], STATS_OPTION) == 0)
+      stats_flag = 1;
+    else if (strcmp (argv [i], V_OPTION) == 0)
+      v_flag = 1;
+    else if (strcmp (argv [i], W_OPTION) == 0)
+      w_flag = 1;
+    else if (strcmp (argv [i], NDFA_OPTION) == 0)
+      ndfa_flag = 1;
+    else if (strcmp (argv [i], PROGRESS_OPTION) == 0)
+      progress_flag = 1;
+    else if (strcmp (argv [i], "-split") == 0)
+      {
+	if (i + 1 >= argc)
+	  fatal ("-split has no argument.");
+	fatal ("option `-split' has not been implemented yet\n");
+	/* split_argument = atoi (argument_vect [i + 1]); */
+      }
+
+  /* Initialize IR storage.  */
+  obstack_init (&irp);
+  initiate_automaton_decl_table ();
+  initiate_insn_decl_table ();
+  initiate_decl_table ();
+  output_file = stdout;
+  output_description_file = NULL;
+  base_name = base_file_name (argv[1]);
+  obstack_grow (&irp, base_name,
+		strlen (base_name) - strlen (file_name_suffix (base_name)));
+  obstack_grow (&irp, STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX,
+		strlen (STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX) + 1);
+  obstack_1grow (&irp, '\0');
+  output_description_file_name = obstack_base (&irp);
+  obstack_finish (&irp);
+}
+
+/* The following function checks existence at least one arc marked by
+   each insn.  */
+static void
+check_automata_insn_issues (void)
+{
+  automaton_t automaton;
+  ainsn_t ainsn, reserv_ainsn;
+
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      for (ainsn = automaton->ainsn_list;
+	   ainsn != NULL;
+	   ainsn = ainsn->next_ainsn)
+	if (ainsn->first_insn_with_same_reservs && !ainsn->arc_exists_p)
+	  {
+	    for (reserv_ainsn = ainsn;
+		 reserv_ainsn != NULL;
+		 reserv_ainsn = reserv_ainsn->next_same_reservs_insn)
+	      if (automaton->corresponding_automaton_decl != NULL)
+		{
+		  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
+		      (0, "Automaton `%s': Insn `%s' will never be issued",
+		       automaton->corresponding_automaton_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",
+			     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;
+
+/* 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);
+}
+
+/* The following function forms list of important automata (whose
+   states may be changed after the insn issue) for each insn.  */
+static void
+form_important_insn_automata_lists (void)
+{
+  automaton_t automaton;
+  decl_t decl;
+  ainsn_t ainsn;
+  arc_t arc;
+  int i;
+  size_t n;
+
+  automaton_states = 0;
+  /* Mark important ainsns.  */
+  for (automaton = description->first_automaton;
+       automaton != NULL;
+       automaton = automaton->next_automaton)
+    {
+      VEC_truncate (state_t, automaton_states, 0);
+      pass_states (automaton, add_automaton_state);
+      for (n = 0; n < VEC_length (state_t, automaton_states); n++)
+	{
+	  state_t s = VEC_index (state_t, automaton_states, n);
+	  for (arc = first_out_arc (s);
+	       arc != NULL;
+	       arc = next_out_arc (arc))
+	    if (arc->to_state != s)
+	      {
+		gcc_assert (arc->insn->first_insn_with_same_reservs);
+		for (ainsn = arc->insn;
+		     ainsn != NULL;
+		     ainsn = ainsn->next_same_reservs_insn)
+		  ainsn->important_p = TRUE;
+	      }
+	}
+    }
+  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 (decl->mode == dm_insn_reserv)
+	{
+	  automata_list_start ();
+	  for (automaton = description->first_automaton;
+	       automaton != NULL;
+	       automaton = automaton->next_automaton)
+	    for (ainsn = automaton->ainsn_list;
+		 ainsn != NULL;
+		 ainsn = ainsn->next_ainsn)
+	      if (ainsn->important_p
+		  && ainsn->insn_reserv_decl == DECL_INSN_RESERV (decl))
+		{
+		  automata_list_add (automaton);
+		  break;
+		}
+	  DECL_INSN_RESERV (decl)->important_automata_list
+	    = automata_list_finish ();
+	}
+    }
+}
+
+
+/* The following is top level function to generate automat(a,on) for
+   fast recognition of pipeline hazards.  */
+static void
+expand_automata (void)
+{
+  int i;
+
+  description = XCREATENODEVAR (struct description,
+				sizeof (struct description)
+				/* One entry for cycle advancing insn.  */
+				+ sizeof (decl_t) * VEC_length (decl_t, decls));
+  description->decls_num = VEC_length (decl_t, decls);
+  description->query_units_num = 0;
+  for (i = 0; i < description->decls_num; i++)
+    {
+      description->decls [i] = VEC_index (decl_t, decls, i);
+      if (description->decls [i]->mode == dm_unit
+	  && DECL_UNIT (description->decls [i])->query_p)
+        DECL_UNIT (description->decls [i])->query_num
+	  = description->query_units_num++;
+    }
+  all_time = create_ticker ();
+  check_time = create_ticker ();
+  if (progress_flag)
+    fprintf (stderr, "Check description...");
+  check_all_description ();
+  if (progress_flag)
+    fprintf (stderr, "done\n");
+  ticker_off (&check_time);
+  generation_time = create_ticker ();
+  if (!have_error)
+    {
+      transform_insn_regexps ();
+      check_unit_distributions_to_automata ();
+    }
+  if (!have_error)
+    {
+      generate ();
+      check_automata_insn_issues ();
+    }
+  if (!have_error)
+    {
+      form_important_insn_automata_lists ();
+    }
+  ticker_off (&generation_time);
+}
+
+/* The following is top level function to output PHR and to finish
+   work with pipeline description translator.  */
+static void
+write_automata (void)
+{
+  output_time = create_ticker ();
+  if (progress_flag)
+    fprintf (stderr, "Forming and outputting automata tables...");
+  output_tables ();
+  if (progress_flag)
+    {
+      fprintf (stderr, "done\n");
+      fprintf (stderr, "Output functions to work with automata...");
+    }
+  output_chip_definitions ();
+  output_max_insn_queue_index_def ();
+  output_internal_min_issue_delay_func ();
+  output_internal_trans_func ();
+  /* Cache of insn dfa codes: */
+  fprintf (output_file, "\nstatic int *%s;\n", DFA_INSN_CODES_VARIABLE_NAME);
+  fprintf (output_file, "\nstatic int %s;\n\n",
+	   DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
+  output_dfa_insn_code_func ();
+  output_trans_func ();
+  output_min_issue_delay_func ();
+  output_internal_dead_lock_func ();
+  output_dead_lock_func ();
+  output_size_func ();
+  output_internal_reset_func ();
+  output_reset_func ();
+  output_min_insn_conflict_delay_func ();
+  output_default_latencies ();
+  output_internal_insn_latency_func ();
+  output_insn_latency_func ();
+  output_internal_maximal_insn_latency_func ();
+  output_maximal_insn_latency_func ();
+  output_print_reservation_func ();
+  /* Output function get_cpu_unit_code.  */
+  fprintf (output_file, "\n#if %s\n\n", CPU_UNITS_QUERY_MACRO_NAME);
+  output_get_cpu_unit_code_func ();
+  output_cpu_unit_reservation_p ();
+  output_insn_has_dfa_reservation_p ();
+  fprintf (output_file, "\n#endif /* #if %s */\n\n",
+	   CPU_UNITS_QUERY_MACRO_NAME);
+  output_dfa_clean_insn_cache_func ();
+  output_dfa_start_func ();
+  output_dfa_finish_func ();
+  if (progress_flag)
+    fprintf (stderr, "done\n");
+  if (v_flag)
+    {
+      output_description_file = fopen (output_description_file_name, "w");
+      if (output_description_file == NULL)
+	{
+	  perror (output_description_file_name);
+	  exit (FATAL_EXIT_CODE);
+	}
+      if (progress_flag)
+	fprintf (stderr, "Output automata description...");
+      output_description ();
+      output_automaton_descriptions ();
+      if (progress_flag)
+	fprintf (stderr, "done\n");
+      output_statistics (output_description_file);
+    }
+  if (stats_flag)
+    output_statistics (stderr);
+  ticker_off (&output_time);
+  if (time_flag)
+    output_time_statistics (stderr);
+  finish_states ();
+  finish_arcs ();
+  finish_automata_lists ();
+  if (time_flag)
+    {
+      fprintf (stderr, "Summary:\n");
+      fprintf (stderr, "  check time ");
+      print_active_time (stderr, check_time);
+      fprintf (stderr, ", generation time ");
+      print_active_time (stderr, generation_time);
+      fprintf (stderr, ", all time ");
+      print_active_time (stderr, all_time);
+      fprintf (stderr, "\n");
+    }
+  /* Finish all work.  */
+  if (output_description_file != NULL)
+    {
+      fflush (output_description_file);
+      if (ferror (stdout) != 0)
+	fatal ("Error in writing DFA description file %s: %s",
+               output_description_file_name, xstrerror (errno));
+      fclose (output_description_file);
+    }
+  finish_automaton_decl_table ();
+  finish_insn_decl_table ();
+  finish_decl_table ();
+  obstack_free (&irp, NULL);
+  if (have_error && output_description_file != NULL)
+    remove (output_description_file_name);
+}
+
+int
+main (int argc, char **argv)
+{
+  rtx desc;
+
+  progname = "genautomata";
+
+  if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
+    return (FATAL_EXIT_CODE);
+
+  initiate_automaton_gen (argc, argv);
+  while (1)
+    {
+      int lineno;
+      int insn_code_number;
+
+      desc = read_md_rtx (&lineno, &insn_code_number);
+      if (desc == NULL)
+	break;
+
+      switch (GET_CODE (desc))
+	{
+	case DEFINE_CPU_UNIT:
+	  gen_cpu_unit (desc);
+	  break;
+
+	case DEFINE_QUERY_CPU_UNIT:
+	  gen_query_cpu_unit (desc);
+	  break;
+
+	case DEFINE_BYPASS:
+	  gen_bypass (desc);
+	  break;
+
+	case EXCLUSION_SET:
+	  gen_excl_set (desc);
+	  break;
+
+	case PRESENCE_SET:
+	  gen_presence_set (desc);
+	  break;
+
+	case FINAL_PRESENCE_SET:
+	  gen_final_presence_set (desc);
+	  break;
+
+	case ABSENCE_SET:
+	  gen_absence_set (desc);
+	  break;
+
+	case FINAL_ABSENCE_SET:
+	  gen_final_absence_set (desc);
+	  break;
+
+	case DEFINE_AUTOMATON:
+	  gen_automaton (desc);
+	  break;
+
+	case AUTOMATA_OPTION:
+	  gen_automata_option (desc);
+	  break;
+
+	case DEFINE_RESERVATION:
+	  gen_reserv (desc);
+	  break;
+
+	case DEFINE_INSN_RESERVATION:
+	  gen_insn_reserv (desc);
+	  break;
+
+	default:
+	  break;
+	}
+    }
+
+  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 ();
+    }
+
+  fflush (stdout);
+  return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
+}