URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [genautomata.c] - Rev 862
Go to most recent revision | Compare with Previous | Blame | View Log
/* Pipeline hazard description translator. Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. Written by Vladimir Makarov <vmakarov@redhat.com> This file is part of GCC. 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. The finite state automaton based pipeline hazard recognizer and instruction scheduler in GCC. V. Makarov. Proceedings of GCC summit, 2003. 2. Detecting pipeline structural hazards quickly. T. Proebsting, C. Fraser. Proceedings of ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 280--286, 1994. This article is a good start point to understand usage of finite state automata for pipeline hazard recognizers. But I'd recommend the 1st and 3rd article for more deep understanding. 3. Efficient Instruction Scheduling Using Finite State Automata: V. Bala and N. Rubin, Proceedings of MICRO-28. This is the best article about usage of finite state automata for pipeline hazard recognizers. The current implementation is described in the 1st article and it is different from the 3rd article in the following: 1. New operator `|' (alternative) is permitted in functional unit reservation which can be treated deterministically and non-deterministically. 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. Bypasses with the same input insn stay one after another in the list in the same order as their occurrences in the description but the bypass without a guard stays always the last in a row of bypasses with the same input insn. */ struct bypass_decl *bypass_list; /* The following fields are defined by automaton generator. */ /* The following field is the insn regexp transformed that 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, INSERT); 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, INSERT); 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, INSERT); 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 ("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 ("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 inserts BYPASS in the list of bypasses of the corresponding output insn. The order of bypasses in the list is decribed in a comment for member `bypass_list' (see above). If there is already the same bypass in the list the function reports this and does nothing. */ static void insert_bypass (struct bypass_decl *bypass) { struct bypass_decl *curr, *last; struct insn_reserv_decl *out_insn_reserv = bypass->out_insn_reserv; struct insn_reserv_decl *in_insn_reserv = bypass->in_insn_reserv; for (curr = out_insn_reserv->bypass_list, last = NULL; curr != NULL; last = curr, curr = curr->next) if (curr->in_insn_reserv == in_insn_reserv) { if ((bypass->bypass_guard_name != NULL && curr->bypass_guard_name != NULL && ! strcmp (bypass->bypass_guard_name, curr->bypass_guard_name)) || bypass->bypass_guard_name == curr->bypass_guard_name) { if (bypass->bypass_guard_name == NULL) { if (!w_flag) error ("the same bypass `%s - %s' is already defined", bypass->out_insn_name, bypass->in_insn_name); else warning ("the same bypass `%s - %s' is already defined", bypass->out_insn_name, bypass->in_insn_name); } else if (!w_flag) error ("the same bypass `%s - %s' (guard %s) is already defined", bypass->out_insn_name, bypass->in_insn_name, bypass->bypass_guard_name); else warning ("the same bypass `%s - %s' (guard %s) is already defined", bypass->out_insn_name, bypass->in_insn_name, bypass->bypass_guard_name); return; } if (curr->bypass_guard_name == NULL) break; if (curr->next == NULL || curr->next->in_insn_reserv != in_insn_reserv) { last = curr; break; } } if (last == NULL) { bypass->next = out_insn_reserv->bypass_list; out_insn_reserv->bypass_list = bypass; } else { bypass->next = last->next; last->next = bypass; } } /* The function processes pipeline description declarations, checks their correctness, and forms exclusion/presence/absence sets. */ static void 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; 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 ("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); insert_bypass (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 ("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 ("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 ("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, INSERT); 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, INSERT); 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 vector contains all decls which are automata. */ static VEC(decl_t, heap) *automaton_decls; /* The following structure describes usage of a unit in a reservation. */ struct unit_usage { unit_decl_t unit_decl; /* The following forms a list of units used on the same cycle in the same alternative. The list is ordered by the correspdoning unit declarations and there is no unit declaration duplication in the list. */ struct unit_usage *next; }; typedef struct unit_usage *unit_usage_t; DEF_VEC_P(unit_usage_t); DEF_VEC_ALLOC_P(unit_usage_t, heap); /* 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, curr, prev; int index; gcc_assert (regexp && regexp->mode == rm_oneof && alt_num < REGEXP_ONEOF (regexp)->regexps_num); unit_decl = REGEXP_UNIT (unit)->unit_decl; length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num; while (VEC_length (unit_usage_t, cycle_alt_unit_usages) < length) VEC_safe_push (unit_usage_t, heap, cycle_alt_unit_usages, 0); index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num; prev = NULL; for (curr = VEC_index (unit_usage_t, cycle_alt_unit_usages, index); curr != NULL; prev = curr, curr = curr->next) if (curr->unit_decl >= unit_decl) break; if (curr != NULL && curr->unit_decl == unit_decl) return; obstack_blank (&unit_usages, sizeof (struct unit_usage)); unit_usage_ptr = (struct unit_usage *) obstack_base (&unit_usages); obstack_finish (&unit_usages); unit_usage_ptr->unit_decl = unit_decl; unit_decl->last_distribution_check_cycle = -1; /* undefined */ unit_usage_ptr->next = curr; if (prev == NULL) VEC_replace (unit_usage_t, cycle_alt_unit_usages, index, unit_usage_ptr); else prev->next = unit_usage_ptr; } /* Return true if unit UNIT_DECL is present on the LIST. */ static bool unit_present_on_list_p (unit_usage_t list, unit_decl_t unit_decl) { while (list != NULL) { if (list->unit_decl == unit_decl) return true; list = list->next; } return false; } /* The function returns true if reservations of alternatives ALT1 and ALT2 are equal after excluding reservations of units of EXCLUDED_AUTOMATON_DECL. */ static bool equal_alternatives_p (int alt1, int alt2, int n_alts, struct automaton_decl *excluded_automaton_decl) { int i; unit_usage_t list1, list2; for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i += n_alts) { for (list1 = VEC_index (unit_usage_t, cycle_alt_unit_usages, i + alt1), list2 = VEC_index (unit_usage_t, cycle_alt_unit_usages, i + alt2);; list1 = list1->next, list2 = list2->next) { while (list1 != NULL && list1->unit_decl->automaton_decl == excluded_automaton_decl) list1 = list1->next; while (list2 != NULL && list2->unit_decl->automaton_decl == excluded_automaton_decl) list2 = list2->next; if (list1 == NULL || list2 == NULL) { if (list1 != list2) return false; else break; } if (list1->unit_decl != list2->unit_decl) return false; } } return true; } DEF_VEC_I(int); DEF_VEC_ALLOC_I(int, heap); /* The function processes given REGEXP to find units with the wrong distribution. */ static void check_regexp_units_distribution (const char *insn_reserv_name, regexp_t regexp) { int i, j, k, cycle, start, n_alts, alt, alt2; bool annotation_reservation_message_reported_p; regexp_t seq, allof, unit; struct unit_usage *unit_usage_ptr; VEC(int, heap) *marked; if (regexp == NULL || regexp->mode != rm_oneof) return; /* Store all unit usages in the regexp: */ obstack_init (&unit_usages); cycle_alt_unit_usages = VEC_alloc (unit_usage_t, heap, 10); for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--) { seq = REGEXP_ONEOF (regexp)->regexps [i]; switch (seq->mode) { 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++) 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) unit_usage_ptr->unit_decl->last_distribution_check_cycle = -1; n_alts = REGEXP_ONEOF (regexp)->regexps_num; marked = VEC_alloc (int, heap, n_alts); for (i = 0; i < n_alts; i++) VEC_safe_push (int, heap, marked, 0); annotation_reservation_message_reported_p = false; for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i++) { cycle = i / n_alts; start = cycle * n_alts; for (unit_usage_ptr = VEC_index (unit_usage_t, cycle_alt_unit_usages, i); unit_usage_ptr != NULL; unit_usage_ptr = unit_usage_ptr->next) { if (unit_usage_ptr->unit_decl->last_distribution_check_cycle == cycle) continue; unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle; for (alt = 0; alt < n_alts; alt++) if (! unit_present_on_list_p (VEC_index (unit_usage_t, cycle_alt_unit_usages, start + alt), unit_usage_ptr->unit_decl)) break; if (alt >= n_alts) continue; memset (VEC_address (int, marked), 0, n_alts * sizeof (int)); for (alt = 0; alt < n_alts; alt++) { if (! unit_present_on_list_p (VEC_index (unit_usage_t, cycle_alt_unit_usages, start + alt), unit_usage_ptr->unit_decl)) continue; for (j = 0; j < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); j++) { alt2 = j % n_alts; if (! unit_present_on_list_p (VEC_index (unit_usage_t, cycle_alt_unit_usages, start + alt2), unit_usage_ptr->unit_decl) && equal_alternatives_p (alt, alt2, n_alts, unit_usage_ptr ->unit_decl->automaton_decl)) { VEC_replace (int, marked, alt, 1); VEC_replace (int, marked, alt2, 1); } } } for (alt = 0; alt < n_alts && VEC_index (int, marked, alt); alt++) ; if (alt < n_alts && 0) { if (! annotation_message_reported_p) { fprintf (stderr, "\n"); error ("The following units do not satisfy units-automata distribution rule"); error ("(Unit presence on one alt and its absence on other alt\n"); error (" result in different other automata reservations)"); annotation_message_reported_p = TRUE; } if (! annotation_reservation_message_reported_p) { error ("Reserv %s:", insn_reserv_name); annotation_reservation_message_reported_p = true; } error (" Unit %s, cycle %d, alt %d, another alt %d", unit_usage_ptr->unit_decl->name, cycle, i % n_alts, alt); } } } VEC_free (int, heap, marked); VEC_free (unit_usage_t, heap, cycle_alt_unit_usages); obstack_free (&unit_usages, NULL); } /* The function finds units which violates units to automata distribution rule. If the units exist, report about them. */ static void check_unit_distributions_to_automata (void) { decl_t decl; int i; if (progress_flag) fprintf (stderr, "Check unit distributions to automata..."); automaton_decls = NULL; for (i = 0; i < description->decls_num; i++) { decl = description->decls [i]; if (decl->mode == dm_automaton) VEC_safe_push (decl_t, heap, automaton_decls, decl); } if (VEC_length (decl_t, automaton_decls) > 1) { annotation_message_reported_p = FALSE; for (i = 0; i < description->decls_num; i++) { decl = description->decls [i]; if (decl->mode == dm_insn_reserv) check_regexp_units_distribution (DECL_INSN_RESERV (decl)->name, DECL_INSN_RESERV (decl)->transformed_regexp); } } VEC_free (decl_t, heap, automaton_decls); if (progress_flag) fprintf (stderr, "done\n"); } /* 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); for (;;) { if (bypass->bypass_guard_name == NULL) { gcc_assert (bypass->next == NULL || (bypass->in_insn_reserv != bypass->next->in_insn_reserv)); 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", bypass->latency); } if (bypass->next == NULL || bypass->in_insn_reserv != bypass->next->in_insn_reserv) break; bypass = bypass->next; } if (bypass->bypass_guard_name != NULL) fprintf (output_file, " break;\n"); } fputs (" }\n break;\n", output_file); } fprintf (output_file, " }\n return default_latencies[%s];\n}\n\n", 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 = 0; i < VEC_length (reserv_sets_t, state_reservs); i++) { fprintf (output_description_file, " "); output_reserv_sets (output_description_file, VEC_index (reserv_sets_t, state_reservs, i)); fprintf (output_description_file, "\n"); } fprintf (output_description_file, "\n"); output_state_arcs (state); VEC_free (reserv_sets_t, heap, state_reservs); } /* 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 ("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 ("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; if (VEC_length (decl_t, decls) > 0) { expand_automata (); if (!have_error) { puts ("/* Generated automatically by the program `genautomata'\n" " from the machine description file `md'. */\n\n" "#include \"config.h\"\n" "#include \"system.h\"\n" "#include \"coretypes.h\"\n" "#include \"tm.h\"\n" "#include \"rtl.h\"\n" "#include \"tm_p.h\"\n" "#include \"insn-config.h\"\n" "#include \"recog.h\"\n" "#include \"regs.h\"\n" "#include \"real.h\"\n" "#include \"output.h\"\n" "#include \"insn-attr.h\"\n" "#include \"toplev.h\"\n" "#include \"flags.h\"\n" "#include \"function.h\"\n"); write_automata (); } } fflush (stdout); return (ferror (stdout) != 0 || have_error ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); }
Go to most recent revision | Compare with Previous | Blame | View Log