X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgenautomata.c;h=ac1f69cb285a729a8cfbe9d9c7cbf291d17703af;hb=9e6a09670c3950ecdee85b34f7501049d5417d34;hp=384405834a349096605c367bf2158c8192249b2b;hpb=801a09b395323f7c2f4c02fd221707ef783d7292;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/genautomata.c b/gcc/genautomata.c index 384405834a3..ac1f69cb285 100644 --- a/gcc/genautomata.c +++ b/gcc/genautomata.c @@ -1,27 +1,28 @@ /* Pipeline hazard description translator. - Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 + Free Software Foundation, Inc. Written by Vladimir Makarov - -This file is part of GNU CC. -GNU CC is free software; you can redistribute it and/or modify it +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 2, or (at your option) any later version. -GNU CC is distributed in the hope that it will be useful, but WITHOUT +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 GNU CC; see the file COPYING. If not, write to the Free +along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* References: - + 1. Detecting pipeline structural hazards quickly. T. Proebsting, C. Fraser. Proceedings of ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 280--286, 1994. @@ -73,7 +74,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA `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: @@ -215,322 +216,321 @@ typedef struct state_ainsn_table *state_ainsn_table_t; described on the file top because the functions are called from function `main'. */ -static void *create_node PARAMS ((size_t)); -static void *copy_node PARAMS ((const void *, size_t)); -static char *check_name PARAMS ((char *, pos_t)); -static char *next_sep_el PARAMS ((char **, int, int)); -static int n_sep_els PARAMS ((char *, int, int)); -static char **get_str_vect PARAMS ((char *, int *, int, int)); -static void gen_presence_absence_set PARAMS ((rtx, int, int)); -static regexp_t gen_regexp_el PARAMS ((char *)); -static regexp_t gen_regexp_repeat PARAMS ((char *)); -static regexp_t gen_regexp_allof PARAMS ((char *)); -static regexp_t gen_regexp_oneof PARAMS ((char *)); -static regexp_t gen_regexp_sequence PARAMS ((char *)); -static regexp_t gen_regexp PARAMS ((char *)); - -static unsigned string_hash PARAMS ((const char *)); -static unsigned automaton_decl_hash PARAMS ((const void *)); -static int automaton_decl_eq_p PARAMS ((const void *, - const void *)); -static decl_t insert_automaton_decl PARAMS ((decl_t)); -static decl_t find_automaton_decl PARAMS ((char *)); -static void initiate_automaton_decl_table PARAMS ((void)); -static void finish_automaton_decl_table PARAMS ((void)); - -static hashval_t insn_decl_hash PARAMS ((const void *)); -static int insn_decl_eq_p PARAMS ((const void *, - const void *)); -static decl_t insert_insn_decl PARAMS ((decl_t)); -static decl_t find_insn_decl PARAMS ((char *)); -static void initiate_insn_decl_table PARAMS ((void)); -static void finish_insn_decl_table PARAMS ((void)); - -static hashval_t decl_hash PARAMS ((const void *)); -static int decl_eq_p PARAMS ((const void *, - const void *)); -static decl_t insert_decl PARAMS ((decl_t)); -static decl_t find_decl PARAMS ((char *)); -static void initiate_decl_table PARAMS ((void)); -static void finish_decl_table PARAMS ((void)); - -static unit_set_el_t process_excls PARAMS ((char **, int, pos_t)); -static void add_excls PARAMS ((unit_set_el_t, unit_set_el_t, - pos_t)); +static void *create_node (size_t); +static void *copy_node (const void *, size_t); +static char *check_name (char *, pos_t); +static char *next_sep_el (char **, int, int); +static int n_sep_els (char *, int, int); +static char **get_str_vect (char *, int *, int, int); +static void gen_presence_absence_set (rtx, int, int); +static regexp_t gen_regexp_el (char *); +static regexp_t gen_regexp_repeat (char *); +static regexp_t gen_regexp_allof (char *); +static regexp_t gen_regexp_oneof (char *); +static regexp_t gen_regexp_sequence (char *); +static regexp_t gen_regexp (char *); + +static unsigned string_hash (const char *); +static unsigned automaton_decl_hash (const void *); +static int automaton_decl_eq_p (const void *, + const void *); +static decl_t insert_automaton_decl (decl_t); +static decl_t find_automaton_decl (char *); +static void initiate_automaton_decl_table (void); +static void finish_automaton_decl_table (void); + +static hashval_t insn_decl_hash (const void *); +static int insn_decl_eq_p (const void *, + const void *); +static decl_t insert_insn_decl (decl_t); +static decl_t find_insn_decl (char *); +static void initiate_insn_decl_table (void); +static void finish_insn_decl_table (void); + +static hashval_t decl_hash (const void *); +static int decl_eq_p (const void *, + const void *); +static decl_t insert_decl (decl_t); +static decl_t find_decl (char *); +static void initiate_decl_table (void); +static void finish_decl_table (void); + +static unit_set_el_t process_excls (char **, int, pos_t); +static void add_excls (unit_set_el_t, unit_set_el_t, + pos_t); static unit_set_el_t process_presence_absence_names - PARAMS ((char **, int, pos_t, - int, int)); + (char **, int, pos_t, + int, int); static pattern_set_el_t process_presence_absence_patterns - PARAMS ((char ***, int, pos_t, - int, int)); -static void add_presence_absence PARAMS ((unit_set_el_t, - pattern_set_el_t, - pos_t, int, int)); -static void process_decls PARAMS ((void)); -static struct bypass_decl *find_bypass PARAMS ((struct bypass_decl *, - struct insn_reserv_decl *)); -static void check_automaton_usage PARAMS ((void)); -static regexp_t process_regexp PARAMS ((regexp_t)); -static void process_regexp_decls PARAMS ((void)); -static void check_usage PARAMS ((void)); -static int loop_in_regexp PARAMS ((regexp_t, decl_t)); -static void check_loops_in_regexps PARAMS ((void)); -static void process_regexp_cycles PARAMS ((regexp_t, int, int, - int *, int *)); -static void evaluate_max_reserv_cycles PARAMS ((void)); -static void check_all_description PARAMS ((void)); - -static ticker_t create_ticker PARAMS ((void)); -static void ticker_off PARAMS ((ticker_t *)); -static void ticker_on PARAMS ((ticker_t *)); -static int active_time PARAMS ((ticker_t)); -static void print_active_time PARAMS ((FILE *, ticker_t)); - -static void add_advance_cycle_insn_decl PARAMS ((void)); - -static alt_state_t get_free_alt_state PARAMS ((void)); -static void free_alt_state PARAMS ((alt_state_t)); -static void free_alt_states PARAMS ((alt_state_t)); -static int alt_state_cmp PARAMS ((const void *alt_state_ptr_1, - const void *alt_state_ptr_2)); -static alt_state_t uniq_sort_alt_states PARAMS ((alt_state_t)); -static int alt_states_eq PARAMS ((alt_state_t, alt_state_t)); -static void initiate_alt_states PARAMS ((void)); -static void finish_alt_states PARAMS ((void)); - -static reserv_sets_t alloc_empty_reserv_sets PARAMS ((void)); -static unsigned reserv_sets_hash_value PARAMS ((reserv_sets_t)); -static int reserv_sets_cmp PARAMS ((reserv_sets_t, reserv_sets_t)); -static int reserv_sets_eq PARAMS ((reserv_sets_t, reserv_sets_t)); -static void set_unit_reserv PARAMS ((reserv_sets_t, int, int)); -static int test_unit_reserv PARAMS ((reserv_sets_t, int, int)); -static int it_is_empty_reserv_sets PARAMS ((reserv_sets_t)) + (char ***, int, pos_t, + int, int); +static void add_presence_absence (unit_set_el_t, + pattern_set_el_t, + pos_t, int, int); +static void process_decls (void); +static struct bypass_decl *find_bypass (struct bypass_decl *, + struct insn_reserv_decl *); +static void check_automaton_usage (void); +static regexp_t process_regexp (regexp_t); +static void process_regexp_decls (void); +static void check_usage (void); +static int loop_in_regexp (regexp_t, decl_t); +static void check_loops_in_regexps (void); +static void process_regexp_cycles (regexp_t, int, int, + int *, int *); +static void evaluate_max_reserv_cycles (void); +static void check_all_description (void); + +static ticker_t create_ticker (void); +static void ticker_off (ticker_t *); +static void ticker_on (ticker_t *); +static int active_time (ticker_t); +static void print_active_time (FILE *, ticker_t); + +static void add_advance_cycle_insn_decl (void); + +static alt_state_t get_free_alt_state (void); +static void free_alt_state (alt_state_t); +static void free_alt_states (alt_state_t); +static int alt_state_cmp (const void *alt_state_ptr_1, + const void *alt_state_ptr_2); +static alt_state_t uniq_sort_alt_states (alt_state_t); +static int alt_states_eq (alt_state_t, alt_state_t); +static void initiate_alt_states (void); +static void finish_alt_states (void); + +static reserv_sets_t alloc_empty_reserv_sets (void); +static unsigned reserv_sets_hash_value (reserv_sets_t); +static int reserv_sets_cmp (reserv_sets_t, reserv_sets_t); +static int reserv_sets_eq (reserv_sets_t, reserv_sets_t); +static void set_unit_reserv (reserv_sets_t, int, int); +static int test_unit_reserv (reserv_sets_t, int, int); +static int it_is_empty_reserv_sets (reserv_sets_t) ATTRIBUTE_UNUSED; -static int reserv_sets_are_intersected PARAMS ((reserv_sets_t, reserv_sets_t)); -static void reserv_sets_shift PARAMS ((reserv_sets_t, reserv_sets_t)); -static void reserv_sets_or PARAMS ((reserv_sets_t, reserv_sets_t, - reserv_sets_t)); -static void reserv_sets_and PARAMS ((reserv_sets_t, reserv_sets_t, - reserv_sets_t)) +static int reserv_sets_are_intersected (reserv_sets_t, reserv_sets_t); +static void reserv_sets_shift (reserv_sets_t, reserv_sets_t); +static void reserv_sets_or (reserv_sets_t, reserv_sets_t, + reserv_sets_t); +static void reserv_sets_and (reserv_sets_t, reserv_sets_t, + reserv_sets_t) ATTRIBUTE_UNUSED; -static void output_cycle_reservs PARAMS ((FILE *, reserv_sets_t, - int, int)); -static void output_reserv_sets PARAMS ((FILE *, reserv_sets_t)); -static state_t get_free_state PARAMS ((int, automaton_t)); -static void free_state PARAMS ((state_t)); -static hashval_t state_hash PARAMS ((const void *)); -static int state_eq_p PARAMS ((const void *, const void *)); -static state_t insert_state PARAMS ((state_t)); -static void set_state_reserv PARAMS ((state_t, int, int)); -static int intersected_state_reservs_p PARAMS ((state_t, state_t)); -static state_t states_union PARAMS ((state_t, state_t, reserv_sets_t)); -static state_t state_shift PARAMS ((state_t, reserv_sets_t)); -static void initiate_states PARAMS ((void)); -static void finish_states PARAMS ((void)); - -static void free_arc PARAMS ((arc_t)); -static void remove_arc PARAMS ((state_t, arc_t)); -static arc_t find_arc PARAMS ((state_t, state_t, ainsn_t)); -static arc_t add_arc PARAMS ((state_t, state_t, ainsn_t, int)); -static arc_t first_out_arc PARAMS ((state_t)); -static arc_t next_out_arc PARAMS ((arc_t)); -static void initiate_arcs PARAMS ((void)); -static void finish_arcs PARAMS ((void)); - -static automata_list_el_t get_free_automata_list_el PARAMS ((void)); -static void free_automata_list_el PARAMS ((automata_list_el_t)); -static void free_automata_list PARAMS ((automata_list_el_t)); -static hashval_t automata_list_hash PARAMS ((const void *)); -static int automata_list_eq_p PARAMS ((const void *, const void *)); -static void initiate_automata_lists PARAMS ((void)); -static void automata_list_start PARAMS ((void)); -static void automata_list_add PARAMS ((automaton_t)); -static automata_list_el_t automata_list_finish PARAMS ((void)); -static void finish_automata_lists PARAMS ((void)); - -static void initiate_excl_sets PARAMS ((void)); -static reserv_sets_t get_excl_set PARAMS ((reserv_sets_t)); - -static pattern_reserv_t form_reserv_sets_list PARAMS ((pattern_set_el_t)); -static void initiate_presence_absence_pattern_sets PARAMS ((void)); -static int check_presence_pattern_sets PARAMS ((reserv_sets_t, - reserv_sets_t, int)); -static int check_absence_pattern_sets PARAMS ((reserv_sets_t, reserv_sets_t, - int)); - -static regexp_t copy_insn_regexp PARAMS ((regexp_t)); -static regexp_t transform_1 PARAMS ((regexp_t)); -static regexp_t transform_2 PARAMS ((regexp_t)); -static regexp_t transform_3 PARAMS ((regexp_t)); +static void output_cycle_reservs (FILE *, reserv_sets_t, + int, int); +static void output_reserv_sets (FILE *, reserv_sets_t); +static state_t get_free_state (int, automaton_t); +static void free_state (state_t); +static hashval_t state_hash (const void *); +static int state_eq_p (const void *, const void *); +static state_t insert_state (state_t); +static void set_state_reserv (state_t, int, int); +static int intersected_state_reservs_p (state_t, state_t); +static state_t states_union (state_t, state_t, reserv_sets_t); +static state_t state_shift (state_t, reserv_sets_t); +static void initiate_states (void); +static void finish_states (void); + +static void free_arc (arc_t); +static void remove_arc (state_t, arc_t); +static arc_t find_arc (state_t, state_t, ainsn_t); +static arc_t add_arc (state_t, state_t, ainsn_t, int); +static arc_t first_out_arc (state_t); +static arc_t next_out_arc (arc_t); +static void initiate_arcs (void); +static void finish_arcs (void); + +static automata_list_el_t get_free_automata_list_el (void); +static void free_automata_list_el (automata_list_el_t); +static void free_automata_list (automata_list_el_t); +static hashval_t automata_list_hash (const void *); +static int automata_list_eq_p (const void *, const void *); +static void initiate_automata_lists (void); +static void automata_list_start (void); +static void automata_list_add (automaton_t); +static automata_list_el_t automata_list_finish (void); +static void finish_automata_lists (void); + +static void initiate_excl_sets (void); +static reserv_sets_t get_excl_set (reserv_sets_t); + +static pattern_reserv_t form_reserv_sets_list (pattern_set_el_t); +static void initiate_presence_absence_pattern_sets (void); +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 regexp_t copy_insn_regexp (regexp_t); +static regexp_t transform_1 (regexp_t); +static regexp_t transform_2 (regexp_t); +static regexp_t transform_3 (regexp_t); static regexp_t regexp_transform_func - PARAMS ((regexp_t, regexp_t (*) (regexp_t))); -static regexp_t transform_regexp PARAMS ((regexp_t)); -static void transform_insn_regexps PARAMS ((void)); - -static void check_unit_distribution_in_reserv PARAMS ((const char *, regexp_t, - regexp_t, int)); -static void check_regexp_units_distribution PARAMS ((const char *, regexp_t)); -static void check_unit_distributions_to_automata PARAMS ((void)); - -static int process_seq_for_forming_states PARAMS ((regexp_t, automaton_t, - int)); -static void finish_forming_alt_state PARAMS ((alt_state_t, - automaton_t)); -static void process_alts_for_forming_states PARAMS ((regexp_t, - automaton_t, int)); -static void create_alt_states PARAMS ((automaton_t)); - -static void form_ainsn_with_same_reservs PARAMS ((automaton_t)); - -static reserv_sets_t form_reservs_matter PARAMS ((automaton_t)); -static void make_automaton PARAMS ((automaton_t)); -static void form_arcs_marked_by_insn PARAMS ((state_t)); -static int create_composed_state PARAMS ((state_t, arc_t, vla_ptr_t *)); -static void NDFA_to_DFA PARAMS ((automaton_t)); -static void pass_state_graph PARAMS ((state_t, void (*) (state_t))); -static void pass_states PARAMS ((automaton_t, - void (*) (state_t))); -static void initiate_pass_states PARAMS ((void)); -static void add_achieved_state PARAMS ((state_t)); -static int set_out_arc_insns_equiv_num PARAMS ((state_t, int)); -static void clear_arc_insns_equiv_num PARAMS ((state_t)); -static void copy_equiv_class PARAMS ((vla_ptr_t *to, - const vla_ptr_t *from)); -static int first_cycle_unit_presence PARAMS ((state_t, int)); -static int state_is_differed PARAMS ((state_t, state_t, int, int)); -static state_t init_equiv_class PARAMS ((state_t *states, int)); -static int partition_equiv_class PARAMS ((state_t *, int, - vla_ptr_t *, int *)); -static void evaluate_equiv_classes PARAMS ((automaton_t, vla_ptr_t *)); -static void merge_states PARAMS ((automaton_t, vla_ptr_t *)); -static void set_new_cycle_flags PARAMS ((state_t)); -static void minimize_DFA PARAMS ((automaton_t)); -static void incr_states_and_arcs_nums PARAMS ((state_t)); -static void count_states_and_arcs PARAMS ((automaton_t, int *, int *)); -static void build_automaton PARAMS ((automaton_t)); - -static void set_order_state_num PARAMS ((state_t)); -static void enumerate_states PARAMS ((automaton_t)); - -static ainsn_t insert_ainsn_into_equiv_class PARAMS ((ainsn_t, ainsn_t)); -static void delete_ainsn_from_equiv_class PARAMS ((ainsn_t)); -static void process_insn_equiv_class PARAMS ((ainsn_t, arc_t *)); -static void process_state_for_insn_equiv_partition PARAMS ((state_t)); -static void set_insn_equiv_classes PARAMS ((automaton_t)); - -static double estimate_one_automaton_bound PARAMS ((void)); -static int compare_max_occ_cycle_nums PARAMS ((const void *, - const void *)); -static void units_to_automata_heuristic_distr PARAMS ((void)); -static ainsn_t create_ainsns PARAMS ((void)); -static void units_to_automata_distr PARAMS ((void)); -static void create_automata PARAMS ((void)); - -static void form_regexp PARAMS ((regexp_t)); -static const char *regexp_representation PARAMS ((regexp_t)); -static void finish_regexp_representation PARAMS ((void)); - -static void output_range_type PARAMS ((FILE *, long int, long int)); -static int longest_path_length PARAMS ((state_t)); -static void process_state_longest_path_length PARAMS ((state_t)); -static void output_dfa_max_issue_rate PARAMS ((void)); -static void output_vect PARAMS ((vect_el_t *, int)); -static void output_chip_member_name PARAMS ((FILE *, automaton_t)); -static void output_temp_chip_member_name PARAMS ((FILE *, automaton_t)); -static void output_translate_vect_name PARAMS ((FILE *, automaton_t)); -static void output_trans_full_vect_name PARAMS ((FILE *, automaton_t)); -static void output_trans_comb_vect_name PARAMS ((FILE *, automaton_t)); -static void output_trans_check_vect_name PARAMS ((FILE *, automaton_t)); -static void output_trans_base_vect_name PARAMS ((FILE *, automaton_t)); -static void output_state_alts_full_vect_name PARAMS ((FILE *, automaton_t)); -static void output_state_alts_comb_vect_name PARAMS ((FILE *, automaton_t)); -static void output_state_alts_check_vect_name PARAMS ((FILE *, automaton_t)); -static void output_state_alts_base_vect_name PARAMS ((FILE *, automaton_t)); -static void output_min_issue_delay_vect_name PARAMS ((FILE *, automaton_t)); -static void output_dead_lock_vect_name PARAMS ((FILE *, automaton_t)); -static void output_reserved_units_table_name PARAMS ((FILE *, automaton_t)); -static void output_state_member_type PARAMS ((FILE *, automaton_t)); -static void output_chip_definitions PARAMS ((void)); -static void output_translate_vect PARAMS ((automaton_t)); -static int comb_vect_p PARAMS ((state_ainsn_table_t)); -static state_ainsn_table_t create_state_ainsn_table PARAMS ((automaton_t)); + (regexp_t, regexp_t (*) (regexp_t)); +static regexp_t transform_regexp (regexp_t); +static void transform_insn_regexps (void); + +static void store_alt_unit_usage (regexp_t, regexp_t, int, int); +static void check_regexp_units_distribution (const char *, regexp_t); +static void check_unit_distributions_to_automata (void); + +static int process_seq_for_forming_states (regexp_t, automaton_t, + int); +static void finish_forming_alt_state (alt_state_t, + automaton_t); +static void process_alts_for_forming_states (regexp_t, + automaton_t, int); +static void create_alt_states (automaton_t); + +static void form_ainsn_with_same_reservs (automaton_t); + +static reserv_sets_t form_reservs_matter (automaton_t); +static void make_automaton (automaton_t); +static void form_arcs_marked_by_insn (state_t); +static int create_composed_state (state_t, arc_t, vla_ptr_t *); +static void NDFA_to_DFA (automaton_t); +static void pass_state_graph (state_t, void (*) (state_t)); +static void pass_states (automaton_t, + void (*) (state_t)); +static void initiate_pass_states (void); +static void add_achieved_state (state_t); +static int set_out_arc_insns_equiv_num (state_t, int); +static void clear_arc_insns_equiv_num (state_t); +static void copy_equiv_class (vla_ptr_t *to, + const vla_ptr_t *from); +static int first_cycle_unit_presence (state_t, int); +static int state_is_differed (state_t, state_t, int, int); +static state_t init_equiv_class (state_t *states, int); +static int partition_equiv_class (state_t *, int, + vla_ptr_t *, int *); +static void evaluate_equiv_classes (automaton_t, vla_ptr_t *); +static void merge_states (automaton_t, vla_ptr_t *); +static void set_new_cycle_flags (state_t); +static void minimize_DFA (automaton_t); +static void incr_states_and_arcs_nums (state_t); +static void count_states_and_arcs (automaton_t, int *, int *); +static void build_automaton (automaton_t); + +static void set_order_state_num (state_t); +static void enumerate_states (automaton_t); + +static ainsn_t insert_ainsn_into_equiv_class (ainsn_t, ainsn_t); +static void delete_ainsn_from_equiv_class (ainsn_t); +static void process_insn_equiv_class (ainsn_t, arc_t *); +static void process_state_for_insn_equiv_partition (state_t); +static void set_insn_equiv_classes (automaton_t); + +static double estimate_one_automaton_bound (void); +static int compare_max_occ_cycle_nums (const void *, + const void *); +static void units_to_automata_heuristic_distr (void); +static ainsn_t create_ainsns (void); +static void units_to_automata_distr (void); +static void create_automata (void); + +static void form_regexp (regexp_t); +static const char *regexp_representation (regexp_t); +static void finish_regexp_representation (void); + +static void output_range_type (FILE *, long int, long int); +static int longest_path_length (state_t); +static void process_state_longest_path_length (state_t); +static void output_dfa_max_issue_rate (void); +static void output_vect (vect_el_t *, int); +static void output_chip_member_name (FILE *, automaton_t); +static void output_temp_chip_member_name (FILE *, automaton_t); +static void output_translate_vect_name (FILE *, automaton_t); +static void output_trans_full_vect_name (FILE *, automaton_t); +static void output_trans_comb_vect_name (FILE *, automaton_t); +static void output_trans_check_vect_name (FILE *, automaton_t); +static void output_trans_base_vect_name (FILE *, automaton_t); +static void output_state_alts_full_vect_name (FILE *, automaton_t); +static void output_state_alts_comb_vect_name (FILE *, automaton_t); +static void output_state_alts_check_vect_name (FILE *, automaton_t); +static void output_state_alts_base_vect_name (FILE *, automaton_t); +static void output_min_issue_delay_vect_name (FILE *, automaton_t); +static void output_dead_lock_vect_name (FILE *, automaton_t); +static void output_reserved_units_table_name (FILE *, automaton_t); +static void output_state_member_type (FILE *, automaton_t); +static void output_chip_definitions (void); +static void output_translate_vect (automaton_t); +static int comb_vect_p (state_ainsn_table_t); +static state_ainsn_table_t create_state_ainsn_table (automaton_t); static void output_state_ainsn_table - PARAMS ((state_ainsn_table_t, char *, void (*) (FILE *, automaton_t), - void (*) (FILE *, automaton_t), void (*) (FILE *, automaton_t), - void (*) (FILE *, automaton_t))); -static void add_vect PARAMS ((state_ainsn_table_t, - int, vect_el_t *, int)); -static int out_state_arcs_num PARAMS ((state_t)); -static int compare_transition_els_num PARAMS ((const void *, const void *)); -static void add_vect_el PARAMS ((vla_hwint_t *, - ainsn_t, int)); -static void add_states_vect_el PARAMS ((state_t)); -static void output_trans_table PARAMS ((automaton_t)); -static void output_state_alts_table PARAMS ((automaton_t)); -static int min_issue_delay_pass_states PARAMS ((state_t, ainsn_t)); -static int min_issue_delay PARAMS ((state_t, ainsn_t)); -static void initiate_min_issue_delay_pass_states PARAMS ((void)); -static void output_min_issue_delay_table PARAMS ((automaton_t)); -static void output_dead_lock_vect PARAMS ((automaton_t)); -static void output_reserved_units_table PARAMS ((automaton_t)); -static void output_tables PARAMS ((void)); -static void output_max_insn_queue_index_def PARAMS ((void)); -static void output_insn_code_cases PARAMS ((void (*) (automata_list_el_t))); -static void output_automata_list_min_issue_delay_code PARAMS ((automata_list_el_t)); -static void output_internal_min_issue_delay_func PARAMS ((void)); -static void output_automata_list_transition_code PARAMS ((automata_list_el_t)); -static void output_internal_trans_func PARAMS ((void)); -static void output_internal_insn_code_evaluation PARAMS ((const char *, - const char *, int)); -static void output_dfa_insn_code_func PARAMS ((void)); -static void output_trans_func PARAMS ((void)); -static void output_automata_list_state_alts_code PARAMS ((automata_list_el_t)); -static void output_internal_state_alts_func PARAMS ((void)); -static void output_state_alts_func PARAMS ((void)); -static void output_min_issue_delay_func PARAMS ((void)); -static void output_internal_dead_lock_func PARAMS ((void)); -static void output_dead_lock_func PARAMS ((void)); -static void output_internal_reset_func PARAMS ((void)); -static void output_size_func PARAMS ((void)); -static void output_reset_func PARAMS ((void)); -static void output_min_insn_conflict_delay_func PARAMS ((void)); -static void output_internal_insn_latency_func PARAMS ((void)); -static void output_insn_latency_func PARAMS ((void)); -static void output_print_reservation_func PARAMS ((void)); -static int units_cmp PARAMS ((const void *, - const void *)); -static void output_get_cpu_unit_code_func PARAMS ((void)); -static void output_cpu_unit_reservation_p PARAMS ((void)); -static void output_dfa_clean_insn_cache_func PARAMS ((void)); -static void output_dfa_start_func PARAMS ((void)); -static void output_dfa_finish_func PARAMS ((void)); - -static void output_regexp PARAMS ((regexp_t )); -static void output_unit_set_el_list PARAMS ((unit_set_el_t)); -static void output_pattern_set_el_list PARAMS ((pattern_set_el_t)); -static void output_description PARAMS ((void)); -static void output_automaton_name PARAMS ((FILE *, automaton_t)); -static void output_automaton_units PARAMS ((automaton_t)); -static void add_state_reservs PARAMS ((state_t)); -static void output_state_arcs PARAMS ((state_t)); -static int state_reservs_cmp PARAMS ((const void *, - const void *)); -static void remove_state_duplicate_reservs PARAMS ((void)); -static void output_state PARAMS ((state_t)); -static void output_automaton_descriptions PARAMS ((void)); -static void output_statistics PARAMS ((FILE *)); -static void output_time_statistics PARAMS ((FILE *)); -static void generate PARAMS ((void)); - -static void make_insn_alts_attr PARAMS ((void)); -static void make_internal_dfa_insn_code_attr PARAMS ((void)); -static void make_default_insn_latency_attr PARAMS ((void)); -static void make_bypass_attr PARAMS ((void)); -static const char *file_name_suffix PARAMS ((const char *)); -static const char *base_file_name PARAMS ((const char *)); -static void check_automata_insn_issues PARAMS ((void)); -static void add_automaton_state PARAMS ((state_t)); -static void form_important_insn_automata_lists PARAMS ((void)); + (state_ainsn_table_t, char *, void (*) (FILE *, automaton_t), + void (*) (FILE *, automaton_t), void (*) (FILE *, automaton_t), + void (*) (FILE *, automaton_t)); +static void add_vect (state_ainsn_table_t, + int, vect_el_t *, int); +static int out_state_arcs_num (state_t); +static int compare_transition_els_num (const void *, const void *); +static void add_vect_el (vla_hwint_t *, + ainsn_t, int); +static void add_states_vect_el (state_t); +static void output_trans_table (automaton_t); +static void output_state_alts_table (automaton_t); +static int min_issue_delay_pass_states (state_t, ainsn_t); +static int min_issue_delay (state_t, ainsn_t); +static void initiate_min_issue_delay_pass_states (void); +static void output_min_issue_delay_table (automaton_t); +static void output_dead_lock_vect (automaton_t); +static void output_reserved_units_table (automaton_t); +static void output_tables (void); +static void output_max_insn_queue_index_def (void); +static void output_insn_code_cases (void (*) (automata_list_el_t)); +static void output_automata_list_min_issue_delay_code (automata_list_el_t); +static void output_internal_min_issue_delay_func (void); +static void output_automata_list_transition_code (automata_list_el_t); +static void output_internal_trans_func (void); +static void output_internal_insn_code_evaluation (const char *, + const char *, int); +static void output_dfa_insn_code_func (void); +static void output_trans_func (void); +static void output_automata_list_state_alts_code (automata_list_el_t); +static void output_internal_state_alts_func (void); +static void output_state_alts_func (void); +static void output_min_issue_delay_func (void); +static void output_internal_dead_lock_func (void); +static void output_dead_lock_func (void); +static void output_internal_reset_func (void); +static void output_size_func (void); +static void output_reset_func (void); +static void output_min_insn_conflict_delay_func (void); +static void output_internal_insn_latency_func (void); +static void output_insn_latency_func (void); +static void output_print_reservation_func (void); +static int units_cmp (const void *, + const void *); +static void output_get_cpu_unit_code_func (void); +static void output_cpu_unit_reservation_p (void); +static void output_dfa_clean_insn_cache_func (void); +static void output_dfa_start_func (void); +static void output_dfa_finish_func (void); + +static void output_regexp (regexp_t ); +static void output_unit_set_el_list (unit_set_el_t); +static void output_pattern_set_el_list (pattern_set_el_t); +static void output_description (void); +static void output_automaton_name (FILE *, automaton_t); +static void output_automaton_units (automaton_t); +static void add_state_reservs (state_t); +static void output_state_arcs (state_t); +static int state_reservs_cmp (const void *, + const void *); +static void remove_state_duplicate_reservs (void); +static void output_state (state_t); +static void output_automaton_descriptions (void); +static void output_statistics (FILE *); +static void output_time_statistics (FILE *); +static void generate (void); + +static void make_insn_alts_attr (void); +static void make_internal_dfa_insn_code_attr (void); +static void make_default_insn_latency_attr (void); +static void make_bypass_attr (void); +static const char *file_name_suffix (const char *); +static const char *base_file_name (const char *); +static void check_automata_insn_issues (void); +static void add_automaton_state (state_t); +static void form_important_insn_automata_lists (void); /* Undefined position. */ static pos_t no_pos = 0; @@ -546,14 +546,14 @@ static struct obstack irp; allocator when varray is used only. */ /* Start work with vla. */ -#define VLA_PTR_CREATE(vla, allocated_length, name) \ - do \ - { \ - vla_ptr_t *const vla_ptr = &(vla); \ - \ - VARRAY_GENERIC_PTR_INIT (vla_ptr->varray, allocated_length, name);\ - vla_ptr->length = 0; \ - } \ +#define VLA_PTR_CREATE(vla, allocated_length, name) \ + do \ + { \ + vla_ptr_t *const _vla_ptr = &(vla); \ + \ + VARRAY_GENERIC_PTR_INIT (_vla_ptr->varray, allocated_length, name);\ + _vla_ptr->length = 0; \ + } \ while (0) /* Finish work with the vla. */ @@ -576,23 +576,23 @@ static struct obstack irp; undefined. */ #define VLA_PTR_EXPAND(vla, n) \ do { \ - vla_ptr_t *const expand_vla_ptr = &(vla); \ - const size_t new_length = (n) + expand_vla_ptr->length; \ + vla_ptr_t *const _expand_vla_ptr = &(vla); \ + const size_t _new_length = (n) + _expand_vla_ptr->length; \ \ - if (VARRAY_SIZE (expand_vla_ptr->varray) < new_length) \ - VARRAY_GROW (expand_vla_ptr->varray, \ - (new_length - expand_vla_ptr->length < 128 \ - ? expand_vla_ptr->length + 128 : new_length)); \ - expand_vla_ptr->length = new_length; \ + if (VARRAY_SIZE (_expand_vla_ptr->varray) < _new_length) \ + VARRAY_GROW (_expand_vla_ptr->varray, \ + (_new_length - _expand_vla_ptr->length < 128 \ + ? _expand_vla_ptr->length + 128 : _new_length)); \ + _expand_vla_ptr->length = _new_length; \ } while (0) /* Add element to the end of the vla. */ -#define VLA_PTR_ADD(vla, ptr) \ - do { \ - vla_ptr_t *const vla_ptr = &(vla); \ - \ - VLA_PTR_EXPAND (*vla_ptr, 1); \ - VARRAY_GENERIC_PTR (vla_ptr->varray, vla_ptr->length - 1) = (ptr);\ +#define VLA_PTR_ADD(vla, ptr) \ + do { \ + vla_ptr_t *const _vla_ptr = &(vla); \ + \ + VLA_PTR_EXPAND (*_vla_ptr, 1); \ + VARRAY_GENERIC_PTR (_vla_ptr->varray, _vla_ptr->length - 1) = (ptr);\ } while (0) /* Length of the vla in elements. */ @@ -607,10 +607,10 @@ static struct obstack irp; #define VLA_HWINT_CREATE(vla, allocated_length, name) \ do { \ - vla_hwint_t *const vla_ptr = &(vla); \ + vla_hwint_t *const _vla_ptr = &(vla); \ \ - VARRAY_WIDE_INT_INIT (vla_ptr->varray, allocated_length, name); \ - vla_ptr->length = 0; \ + VARRAY_WIDE_INT_INIT (_vla_ptr->varray, allocated_length, name); \ + _vla_ptr->length = 0; \ } while (0) #define VLA_HWINT_DELETE(vla) VARRAY_FREE ((vla).varray) @@ -621,22 +621,22 @@ static struct obstack irp; #define VLA_HWINT_EXPAND(vla, n) \ do { \ - vla_hwint_t *const expand_vla_ptr = &(vla); \ - const size_t new_length = (n) + expand_vla_ptr->length; \ + vla_hwint_t *const _expand_vla_ptr = &(vla); \ + const size_t _new_length = (n) + _expand_vla_ptr->length; \ \ - if (VARRAY_SIZE (expand_vla_ptr->varray) < new_length) \ - VARRAY_GROW (expand_vla_ptr->varray, \ - (new_length - expand_vla_ptr->length < 128 \ - ? expand_vla_ptr->length + 128 : new_length)); \ - expand_vla_ptr->length = new_length; \ + if (VARRAY_SIZE (_expand_vla_ptr->varray) < _new_length) \ + VARRAY_GROW (_expand_vla_ptr->varray, \ + (_new_length - _expand_vla_ptr->length < 128 \ + ? _expand_vla_ptr->length + 128 : _new_length)); \ + _expand_vla_ptr->length = _new_length; \ } while (0) #define VLA_HWINT_ADD(vla, ptr) \ do { \ - vla_hwint_t *const vla_ptr = &(vla); \ + vla_hwint_t *const _vla_ptr = &(vla); \ \ - VLA_HWINT_EXPAND (*vla_ptr, 1); \ - VARRAY_WIDE_INT (vla_ptr->varray, vla_ptr->length - 1) = (ptr); \ + VLA_HWINT_EXPAND (*_vla_ptr, 1); \ + VARRAY_WIDE_INT (_vla_ptr->varray, _vla_ptr->length - 1) = (ptr); \ } while (0) #define VLA_HWINT_LENGTH(vla) ((vla).length) @@ -659,6 +659,8 @@ static struct obstack irp; #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'). */ @@ -681,6 +683,10 @@ static int time_flag; 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; @@ -763,6 +769,9 @@ struct unit_decl /* 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. */ @@ -1201,7 +1210,7 @@ struct ainsn 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_equialence_num; + 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. */ @@ -1305,14 +1314,14 @@ struct state_ainsn_table &(_decl)->decl.bypass; })) #define DECL_AUTOMATON(d) __extension__ \ -(({ struct decl *const _decl = (d); \ +(({ struct decl *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__ \ -(({ struct decl *const _decl = (d); \ +(({ struct decl *const _decl = (d); \ if (_decl->mode != dm_excl) \ decl_mode_check_failed (_decl->mode, "dm_excl", \ __FILE__, __LINE__, __FUNCTION__); \ @@ -1326,7 +1335,7 @@ struct state_ainsn_table &(_decl)->decl.presence; })) #define DECL_ABSENCE(d) __extension__ \ -(({ struct decl *const _decl = (d); \ +(({ struct decl *const _decl = (d); \ if (_decl->mode != dm_absence) \ decl_mode_check_failed (_decl->mode, "dm_absence", \ __FILE__, __LINE__, __FUNCTION__); \ @@ -1340,20 +1349,19 @@ struct state_ainsn_table &(_decl)->decl.reserv; })) #define DECL_INSN_RESERV(d) __extension__ \ -(({ struct decl *const _decl = (d); \ +(({ struct decl *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 PARAMS ((enum decl_mode)); -static void decl_mode_check_failed PARAMS ((enum decl_mode, const char *, - const char *, int, const char *)); +static const char *decl_name (enum decl_mode); +static void decl_mode_check_failed (enum decl_mode, const char *, + const char *, int, const char *); /* Return string representation of declaration mode MODE. */ static const char * -decl_name (mode) - enum decl_mode mode; +decl_name (enum decl_mode mode) { static char str [100]; @@ -1381,12 +1389,8 @@ decl_name (mode) /* The function prints message about unexpected declaration and finish the program. */ static void -decl_mode_check_failed (mode, expected_mode_str, file, line, func) - enum decl_mode mode; - const char *expected_mode_str; - const char *file; - int line; - const char *func; +decl_mode_check_failed (enum decl_mode mode, const char *expected_mode_str, + const char *file, int line, const char *func) { fprintf (stderr, @@ -1438,47 +1442,43 @@ decl_mode_check_failed (mode, expected_mode_str, file, line, func) __FILE__, __LINE__, __FUNCTION__); \ &(_regexp)->regexp.oneof; })) -static const char *regexp_name PARAMS ((enum regexp_mode)); -static void regexp_mode_check_failed PARAMS ((enum regexp_mode, const char *, - const char *, int, - const char *)); +static const char *regexp_name (enum regexp_mode); +static void regexp_mode_check_failed (enum regexp_mode, const char *, + const char *, int, + const char *); /* Return string representation of regexp mode MODE. */ static const char * -regexp_name (mode) - enum regexp_mode mode; +regexp_name (enum regexp_mode mode) { - static char str [100]; - - if (mode == rm_unit) - return "rm_unit"; - else if (mode == rm_reserv) - return "rm_reserv"; - else if (mode == rm_nothing) - return "rm_nothing"; - else if (mode == rm_sequence) - return "rm_sequence"; - else if (mode == rm_repeat) - return "rm_repeat"; - else if (mode == rm_allof) - return "rm_allof"; - else if (mode == rm_oneof) - return "rm_oneof"; - else - sprintf (str, "unknown (%d)", (int) mode); - return str; + 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 (mode, expected_mode_str, file, line, func) - enum regexp_mode mode; - const char *expected_mode_str; - const char *file; - int line; - const char *func; +regexp_mode_check_failed (enum regexp_mode mode, + const char *expected_mode_str, + const char *file, int line, const char *func) { fprintf (stderr, @@ -1509,8 +1509,7 @@ regexp_mode_check_failed (mode, expected_mode_str, file, line, func) /* Create IR structure (node). */ static void * -create_node (size) - size_t size; +create_node (size_t size) { void *result; @@ -1524,9 +1523,7 @@ create_node (size) /* Copy IR structure (node). */ static void * -copy_node (from, size) - const void *from; - size_t size; +copy_node (const void *from, size_t size) { void *const result = create_node (size); memcpy (result, from, size); @@ -1535,9 +1532,7 @@ copy_node (from, size) /* The function checks that NAME does not contain quotes (`"'). */ static char * -check_name (name, pos) - char * name; - pos_t pos ATTRIBUTE_UNUSED; +check_name (char * name, pos_t pos ATTRIBUTE_UNUSED) { const char *str; @@ -1557,10 +1552,7 @@ static vla_ptr_t decls; after the string scanned, or the end-of-string. Return NULL if at end of string. */ static char * -next_sep_el (pstr, sep, par_flag) - char **pstr; - int sep; - int par_flag; +next_sep_el (char **pstr, int sep, int par_flag) { char *out_str; char *p; @@ -1608,10 +1600,7 @@ next_sep_el (pstr, sep, par_flag) nonzero value. Return 0 for the null string, -1 if parentheses is not balanced. */ static int -n_sep_els (s, sep, par_flag) - char *s; - int sep; - int par_flag; +n_sep_els (char *s, int sep, int par_flag) { int n; int pars_num; @@ -1634,17 +1623,14 @@ n_sep_els (s, sep, par_flag) 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 parantheses are not balanced. */ + Return 0 for the null string, -1 if parentheses are not balanced. */ static char ** -get_str_vect (str, els_num, sep, paren_p) - char *str; - int *els_num; - int sep; - int paren_p; +get_str_vect (char *str, int *els_num, int sep, int paren_p) { int i; char **vect; char **pstr; + char *trail; *els_num = n_sep_els (str, sep, paren_p); if (*els_num <= 0) @@ -1655,19 +1641,18 @@ get_str_vect (str, els_num, sep, paren_p) pstr = &str; for (i = 0; i < *els_num; i++) vect [i] = next_sep_el (pstr, sep, paren_p); - if (next_sep_el (pstr, sep, paren_p) != NULL) - abort (); + trail = next_sep_el (pstr, sep, paren_p); + gcc_assert (!trail); vect [i] = NULL; return vect; } -/* Process a DEFINE_CPU_UNIT. +/* 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'. */ void -gen_cpu_unit (def) - rtx def; +gen_cpu_unit (rtx def) { decl_t decl; char **str_cpu_units; @@ -1693,13 +1678,12 @@ gen_cpu_unit (def) } } -/* Process a DEFINE_QUERY_CPU_UNIT. +/* 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'. */ void -gen_query_cpu_unit (def) - rtx def; +gen_query_cpu_unit (rtx def) { decl_t decl; char **str_cpu_units; @@ -1723,14 +1707,13 @@ gen_query_cpu_unit (def) } } -/* Process a DEFINE_BYPASS. +/* 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'. */ void -gen_bypass (def) - rtx def; +gen_bypass (rtx def) { decl_t decl; char **out_insns; @@ -1760,14 +1743,13 @@ gen_bypass (def) } } -/* Process an EXCLUSION_SET. +/* 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'. */ void -gen_excl_set (def) - rtx def; +gen_excl_set (rtx def) { decl_t decl; char **first_str_cpu_units; @@ -1807,10 +1789,7 @@ gen_excl_set (def) We fill a struct unit_pattern_rel_decl with information used later by `expand_automata'. */ static void -gen_presence_absence_set (def, presence_p, final_p) - rtx def; - int presence_p; - int final_p; +gen_presence_absence_set (rtx def, int presence_p, int final_p) { decl_t decl; char **str_cpu_units; @@ -1845,8 +1824,7 @@ gen_presence_absence_set (def, presence_p, final_p) { str_patterns [i] = get_str_vect ((char *) str_patterns [i], &length, ' ', FALSE); - if (str_patterns [i] == NULL) - abort (); + gcc_assert (str_patterns [i]); } decl = create_node (sizeof (struct decl)); decl->pos = 0; @@ -1872,62 +1850,57 @@ gen_presence_absence_set (def, presence_p, final_p) num_dfa_decls++; } -/* Process a PRESENCE_SET. - +/* 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'. */ - void -gen_presence_set (def) - rtx def; +void +gen_presence_set (rtx def) { gen_presence_absence_set (def, TRUE, FALSE); } - -/* Process a FINAL_PRESENCE_SET. + +/* 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'. */ void -gen_final_presence_set (def) - rtx def; +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'. */ void -gen_absence_set (def) - rtx def; +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'. */ void -gen_final_absence_set (def) - rtx def; +gen_final_absence_set (rtx def) { gen_presence_absence_set (def, FALSE, TRUE); } - -/* Process a DEFINE_AUTOMATON. + +/* 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'. */ void -gen_automaton (def) - rtx def; +gen_automaton (rtx def) { decl_t decl; char **str_automata; @@ -1949,24 +1922,25 @@ gen_automaton (def) } } -/* Process an AUTOMATA_OPTION. +/* Process an AUTOMATA_OPTION. This gives information how to generate finite state automaton used for recognizing pipeline hazards. */ void -gen_automata_option (def) - rtx def; +gen_automata_option (rtx def) { - if (strcmp ((char *) XSTR (def, 0), NO_MINIMIZATION_OPTION + 1) == 0) + if (strcmp (XSTR (def, 0), NO_MINIMIZATION_OPTION + 1) == 0) no_minimization_flag = 1; - else if (strcmp ((char *) XSTR (def, 0), TIME_OPTION + 1) == 0) + else if (strcmp (XSTR (def, 0), TIME_OPTION + 1) == 0) time_flag = 1; - else if (strcmp ((char *) XSTR (def, 0), V_OPTION + 1) == 0) + else if (strcmp (XSTR (def, 0), V_OPTION + 1) == 0) v_flag = 1; - else if (strcmp ((char *) XSTR (def, 0), W_OPTION + 1) == 0) + else if (strcmp (XSTR (def, 0), W_OPTION + 1) == 0) w_flag = 1; - else if (strcmp ((char *) XSTR (def, 0), NDFA_OPTION + 1) == 0) + 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)); } @@ -1980,8 +1954,7 @@ static char *reserv_str; /* Parse an element in STR. */ static regexp_t -gen_regexp_el (str) - char *str; +gen_regexp_el (char *str) { regexp_t regexp; int len; @@ -2010,8 +1983,7 @@ gen_regexp_el (str) /* Parse construction `repeat' in STR. */ static regexp_t -gen_regexp_repeat (str) - char *str; +gen_regexp_repeat (char *str) { regexp_t regexp; regexp_t repeat; @@ -2044,8 +2016,7 @@ gen_regexp_repeat (str) /* Parse reservation STR which possibly contains separator '+'. */ static regexp_t -gen_regexp_allof (str) - char *str; +gen_regexp_allof (char *str) { regexp_t allof; char **allof_vect; @@ -2071,8 +2042,7 @@ gen_regexp_allof (str) /* Parse reservation STR which possibly contains separator '|'. */ static regexp_t -gen_regexp_oneof (str) - char *str; +gen_regexp_oneof (char *str) { regexp_t oneof; char **oneof_vect; @@ -2098,8 +2068,7 @@ gen_regexp_oneof (str) /* Parse reservation STR which possibly contains separator ','. */ static regexp_t -gen_regexp_sequence (str) - char *str; +gen_regexp_sequence (char *str) { regexp_t sequence; char **sequence_vect; @@ -2124,8 +2093,7 @@ gen_regexp_sequence (str) /* Parse construction reservation STR. */ static regexp_t -gen_regexp (str) - char *str; +gen_regexp (char *str) { reserv_str = str; return gen_regexp_sequence (str);; @@ -2137,8 +2105,7 @@ gen_regexp (str) in a struct reserv_decl with information used later by `expand_automata'. */ void -gen_reserv (def) - rtx def; +gen_reserv (rtx def) { decl_t decl; @@ -2157,8 +2124,7 @@ gen_reserv (def) insn. We fill a struct insn_reserv_decl with information used later by `expand_automata'. */ void -gen_insn_reserv (def) - rtx def; +gen_insn_reserv (rtx def) { decl_t decl; @@ -2178,8 +2144,7 @@ gen_insn_reserv (def) /* The function evaluates hash value (0..UINT_MAX) of string. */ static unsigned -string_hash (string) - const char *string; +string_hash (const char *string) { unsigned result, i; @@ -2199,13 +2164,12 @@ string_hash (string) 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 (automaton_decl) - const void *automaton_decl; +automaton_decl_hash (const void *automaton_decl) { const decl_t decl = (decl_t) automaton_decl; - if (decl->mode == dm_automaton && DECL_AUTOMATON (decl)->name == NULL) - abort (); + gcc_assert (decl->mode != dm_automaton + || DECL_AUTOMATON (decl)->name); return string_hash (DECL_AUTOMATON (decl)->name); } @@ -2214,16 +2178,16 @@ automaton_decl_hash (automaton_decl) function returns 1 if the declarations have the same key, 0 otherwise. */ static int -automaton_decl_eq_p (automaton_decl_1, automaton_decl_2) - const void* automaton_decl_1; - const void* automaton_decl_2; +automaton_decl_eq_p (const void* automaton_decl_1, + const void* automaton_decl_2) { const decl_t decl1 = (decl_t) automaton_decl_1; const decl_t decl2 = (decl_t) automaton_decl_2; - if (decl1->mode != dm_automaton || DECL_AUTOMATON (decl1)->name == NULL - || decl2->mode != dm_automaton || DECL_AUTOMATON (decl2)->name == NULL) - abort (); + 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; } @@ -2238,8 +2202,7 @@ static htab_t automaton_decl_table; declaration node in the table with the same key as given automaton declaration node. */ static decl_t -insert_automaton_decl (automaton_decl) - decl_t automaton_decl; +insert_automaton_decl (decl_t automaton_decl) { void **entry_ptr; @@ -2259,8 +2222,7 @@ static struct decl work_automaton_decl; 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 (name) - char *name; +find_automaton_decl (char *name) { void *entry; @@ -2275,7 +2237,7 @@ find_automaton_decl (name) 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 () +initiate_automaton_decl_table (void) { work_automaton_decl.mode = dm_automaton; automaton_decl_table = htab_create (10, automaton_decl_hash, @@ -2286,7 +2248,7 @@ initiate_automaton_decl_table () function `initiate_automaton_decl_table' is possible immediately after this function call. */ static void -finish_automaton_decl_table () +finish_automaton_decl_table (void) { htab_delete (automaton_decl_table); } @@ -2303,13 +2265,12 @@ finish_automaton_decl_table () 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 (insn_decl) - const void *insn_decl; +insn_decl_hash (const void *insn_decl) { const decl_t decl = (decl_t) insn_decl; - if (decl->mode != dm_insn_reserv || DECL_INSN_RESERV (decl)->name == NULL) - abort (); + gcc_assert (decl->mode == dm_insn_reserv + && DECL_INSN_RESERV (decl)->name); return string_hash (DECL_INSN_RESERV (decl)->name); } @@ -2317,17 +2278,15 @@ insn_decl_hash (insn_decl) 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 (insn_decl_1, insn_decl_2) - const void *insn_decl_1; - const void *insn_decl_2; +insn_decl_eq_p (const void *insn_decl_1, const void *insn_decl_2) { const decl_t decl1 = (decl_t) insn_decl_1; const decl_t decl2 = (decl_t) insn_decl_2; - if (decl1->mode != dm_insn_reserv || DECL_INSN_RESERV (decl1)->name == NULL - || decl2->mode != dm_insn_reserv - || DECL_INSN_RESERV (decl2)->name == NULL) - abort (); + 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; } @@ -2342,8 +2301,7 @@ static htab_t insn_decl_table; 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 (insn_decl) - decl_t insn_decl; +insert_insn_decl (decl_t insn_decl) { void **entry_ptr; @@ -2363,8 +2321,7 @@ static struct decl work_insn_decl; 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 (name) - char *name; +find_insn_decl (char *name) { void *entry; @@ -2379,7 +2336,7 @@ find_insn_decl (name) 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 () +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, @@ -2390,7 +2347,7 @@ initiate_insn_decl_table () function `initiate_insn_decl_table' is possible immediately after this function call. */ static void -finish_insn_decl_table () +finish_insn_decl_table (void) { htab_delete (insn_decl_table); } @@ -2406,34 +2363,29 @@ finish_insn_decl_table () is used by abstract data `hashtab'. The function returns hash value (0..UINT_MAX) of given declaration. */ static hashval_t -decl_hash (decl) - const void *decl; +decl_hash (const void *decl) { const decl_t d = (const decl_t) decl; - if ((d->mode != dm_unit || DECL_UNIT (d)->name == NULL) - && (d->mode != dm_reserv || DECL_RESERV (d)->name == NULL)) - abort (); + 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 + 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 (decl_1, decl_2) - const void *decl_1; - const void *decl_2; +decl_eq_p (const void *decl_1, const void *decl_2) { const decl_t d1 = (const decl_t) decl_1; const decl_t d2 = (const decl_t) decl_2; - if (((d1->mode != dm_unit || DECL_UNIT (d1)->name == NULL) - && (d1->mode != dm_reserv || DECL_RESERV (d1)->name == NULL)) - || ((d2->mode != dm_unit || DECL_UNIT (d2)->name == NULL) - && (d2->mode != dm_reserv || DECL_RESERV (d2)->name == NULL))) - abort (); + 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 @@ -2450,8 +2402,7 @@ static htab_t decl_table; same key as given declaration node. */ static decl_t -insert_decl (decl) - decl_t decl; +insert_decl (decl_t decl) { void **entry_ptr; @@ -2470,8 +2421,7 @@ static struct decl work_decl; returns node found in the table, NULL if such node does not exist in the table. */ static decl_t -find_decl (name) - char *name; +find_decl (char *name) { void *entry; @@ -2486,7 +2436,7 @@ find_decl (name) The function must be called only once before any work with the declaration table. */ static void -initiate_decl_table () +initiate_decl_table (void) { work_decl.mode = dm_unit; decl_table = htab_create (10, decl_hash, decl_eq_p, (htab_del) 0); @@ -2496,7 +2446,7 @@ initiate_decl_table () `initiate_declaration_table' is possible immediately after this function call. */ static void -finish_decl_table () +finish_decl_table (void) { htab_delete (decl_table); } @@ -2508,10 +2458,7 @@ finish_decl_table () /* Checking NAMES in an exclusion clause vector and returning formed unit_set_el_list. */ static unit_set_el_t -process_excls (names, num, excl_pos) - char **names; - int num; - pos_t excl_pos ATTRIBUTE_UNUSED; +process_excls (char **names, int num, pos_t excl_pos ATTRIBUTE_UNUSED) { unit_set_el_t el_list; unit_set_el_t last_el; @@ -2549,10 +2496,8 @@ process_excls (names, num, excl_pos) list of the each element from DEST_LIST. Checking situation "unit excludes itself". */ static void -add_excls (dest_list, source_list, excl_pos) - unit_set_el_t dest_list; - unit_set_el_t source_list; - pos_t excl_pos ATTRIBUTE_UNUSED; +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; @@ -2599,12 +2544,9 @@ add_excls (dest_list, source_list, excl_pos) formed unit_set_el_list. The function is called only after processing all exclusion sets. */ static unit_set_el_t -process_presence_absence_names (names, num, req_pos, presence_p, final_p) - char **names; - int num; - pos_t req_pos ATTRIBUTE_UNUSED; - int presence_p; - int final_p; +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; @@ -2654,12 +2596,9 @@ process_presence_absence_names (names, num, req_pos, presence_p, final_p) 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 (patterns, num, req_pos, presence_p, final_p) - char ***patterns; - int num; - pos_t req_pos ATTRIBUTE_UNUSED; - int presence_p; - int final_p; +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; @@ -2728,12 +2667,10 @@ process_presence_absence_patterns (patterns, num, req_pos, presence_p, final_p) automata". Remember that we process absence sets only after all presence sets. */ static void -add_presence_absence (dest_list, pattern_list, req_pos, presence_p, final_p) - unit_set_el_t dest_list; - pattern_set_el_t pattern_list; - pos_t req_pos ATTRIBUTE_UNUSED; - int presence_p; - int final_p; +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; @@ -2849,9 +2786,8 @@ add_presence_absence (dest_list, pattern_list, req_pos, presence_p, final_p) /* The function searches for bypass with given IN_INSN_RESERV in given BYPASS_LIST. */ static struct bypass_decl * -find_bypass (bypass_list, in_insn_reserv) - struct bypass_decl *bypass_list; - struct insn_reserv_decl *in_insn_reserv; +find_bypass (struct bypass_decl *bypass_list, + struct insn_reserv_decl *in_insn_reserv) { struct bypass_decl *bypass; @@ -2864,7 +2800,7 @@ find_bypass (bypass_list, in_insn_reserv) /* The function processes pipeline description declarations, checks their correctness, and forms exclusion/presence/absence sets. */ static void -process_decls () +process_decls (void) { decl_t decl; decl_t automaton_decl; @@ -3038,7 +2974,7 @@ process_decls () { 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); @@ -3061,7 +2997,7 @@ process_decls () { 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, @@ -3085,7 +3021,7 @@ process_decls () { 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, @@ -3106,7 +3042,7 @@ process_decls () 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 () +check_automaton_usage (void) { decl_t decl; int i; @@ -3132,55 +3068,66 @@ check_automaton_usage () Remember that reserv_regexp does not exist before the function call. */ static regexp_t -process_regexp (regexp) - regexp_t regexp; +process_regexp (regexp_t regexp) { decl_t decl_in_table; regexp_t new_regexp; int i; - - if (regexp->mode == rm_unit) + + 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 if (decl_in_table->mode == dm_unit) - { - DECL_UNIT (decl_in_table)->unit_is_used = 1; - REGEXP_UNIT (regexp)->unit_decl = DECL_UNIT (decl_in_table); - } - else if (decl_in_table->mode == dm_reserv) - { - DECL_RESERV (decl_in_table)->reserv_is_used = 1; - new_regexp = create_node (sizeof (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; - } else - abort (); + 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 = create_node (sizeof (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 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 (); } - else if (regexp->mode == rm_sequence) - for (i = 0; i regexps_num; i++) - REGEXP_SEQUENCE (regexp)->regexps [i] - = process_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]); - else if (regexp->mode == rm_allof) - for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++) - REGEXP_ALLOF (regexp)->regexps [i] - = process_regexp (REGEXP_ALLOF (regexp)->regexps [i]); - else if (regexp->mode == rm_oneof) - for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++) - REGEXP_ONEOF (regexp)->regexps [i] - = process_regexp (REGEXP_ONEOF (regexp)->regexps [i]); - else if (regexp->mode == rm_repeat) - REGEXP_REPEAT (regexp)->regexp - = process_regexp (REGEXP_REPEAT (regexp)->regexp); - else if (regexp->mode != rm_nothing) - abort (); return regexp; } @@ -3188,7 +3135,7 @@ process_regexp (regexp) define_insn_reservation with the aid of function `process_regexp'. */ static void -process_regexp_decls () +process_regexp_decls (void) { decl_t decl; int i; @@ -3210,7 +3157,7 @@ process_regexp_decls () following function must be called only after `process_decls', `process_regexp_decls'. */ static void -check_usage () +check_usage (void) { decl_t decl; int i; @@ -3243,18 +3190,18 @@ static int curr_loop_pass_num; contains given decl or reservations in given regexp refers for given decl. */ static int -loop_in_regexp (regexp, start_decl) - regexp_t regexp; - decl_t start_decl; +loop_in_regexp (regexp_t regexp, decl_t start_decl) { int i; if (regexp == NULL) return 0; - if (regexp->mode == rm_unit) - return 0; - else if (regexp->mode == rm_reserv) + 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; @@ -3269,42 +3216,40 @@ loop_in_regexp (regexp, start_decl) return loop_in_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp, start_decl); } - } - else if (regexp->mode == rm_sequence) - { + + case rm_sequence: for (i = 0; i regexps_num; i++) if (loop_in_regexp (REGEXP_SEQUENCE (regexp)->regexps [i], start_decl)) return 1; return 0; - } - else if (regexp->mode == rm_allof) - { + + 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; - } - else if (regexp->mode == rm_oneof) - { + + 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; - } - else if (regexp->mode == rm_repeat) - return loop_in_regexp (REGEXP_REPEAT (regexp)->regexp, start_decl); - else - { - if (regexp->mode != rm_nothing) - abort (); + + 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 () +check_loops_in_regexps (void) { decl_t decl; int i; @@ -3319,14 +3264,13 @@ check_loops_in_regexps () { 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)) { - if (DECL_RESERV (decl)->regexp == NULL) - abort (); + gcc_assert (DECL_RESERV (decl)->regexp); error ("cycle in definition of reservation `%s'", DECL_RESERV (decl)->name); } @@ -3337,16 +3281,15 @@ check_loops_in_regexps () /* The function recursively processes IR of reservation and defines max and min cycle for reservation of unit. */ static void -process_regexp_cycles (regexp, max_start_cycle, min_start_cycle, - max_finish_cycle, min_finish_cycle) - regexp_t regexp; - int max_start_cycle, min_start_cycle; - int *max_finish_cycle, *min_finish_cycle; +process_regexp_cycles (regexp_t regexp, int max_start_cycle, + int min_start_cycle, int *max_finish_cycle, + int *min_finish_cycle) { int i; - if (regexp->mode == rm_unit) + 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 @@ -3354,13 +3297,15 @@ process_regexp_cycles (regexp, max_start_cycle, min_start_cycle, REGEXP_UNIT (regexp)->unit_decl->min_occ_cycle_num = min_start_cycle; *max_finish_cycle = max_start_cycle; *min_finish_cycle = min_start_cycle; - } - else if (regexp->mode == rm_reserv) - process_regexp_cycles (REGEXP_RESERV (regexp)->reserv_decl->regexp, - max_start_cycle, min_start_cycle, - max_finish_cycle, min_finish_cycle); - else if (regexp->mode == rm_repeat) - { + 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, @@ -3369,9 +3314,9 @@ process_regexp_cycles (regexp, max_start_cycle, min_start_cycle, max_start_cycle = *max_finish_cycle + 1; min_start_cycle = *min_finish_cycle + 1; } - } - else if (regexp->mode == rm_sequence) - { + break; + + case rm_sequence: for (i = 0; i regexps_num; i++) { process_regexp_cycles (REGEXP_SEQUENCE (regexp)->regexps [i], @@ -3380,56 +3325,62 @@ process_regexp_cycles (regexp, max_start_cycle, min_start_cycle, max_start_cycle = *max_finish_cycle + 1; min_start_cycle = *min_finish_cycle + 1; } - } - else if (regexp->mode == rm_allof) - { - int max_cycle = 0; - int min_cycle = 0; + break; - 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; - } - else if (regexp->mode == rm_oneof) - { - int max_cycle = 0; - int min_cycle = 0; + 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; - 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; - } - else - { - if (regexp->mode != rm_nothing) - abort (); + 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 () +evaluate_max_reserv_cycles (void) { int max_insn_cycles_num; int min_insn_cycles_num; @@ -3454,7 +3405,7 @@ evaluate_max_reserv_cycles () /* The following function calls functions for checking all description. */ static void -check_all_description () +check_all_description (void) { process_decls (); check_automaton_usage (); @@ -3474,7 +3425,7 @@ check_all_description () /* The following function creates ticker and makes it active. */ static ticker_t -create_ticker () +create_ticker (void) { ticker_t ticker; @@ -3485,8 +3436,7 @@ create_ticker () /* The following function switches off given ticker. */ static void -ticker_off (ticker) - ticker_t *ticker; +ticker_off (ticker_t *ticker) { if (ticker->incremented_off_time == 0) ticker->incremented_off_time = get_run_time () + 1; @@ -3494,8 +3444,7 @@ ticker_off (ticker) /* The following function switches on given ticker. */ static void -ticker_on (ticker) - ticker_t *ticker; +ticker_on (ticker_t *ticker) { if (ticker->incremented_off_time != 0) { @@ -3508,8 +3457,7 @@ ticker_on (ticker) /* The following function returns current time in milliseconds since the moment when given ticker was created. */ static int -active_time (ticker) - ticker_t ticker; +active_time (ticker_t ticker) { if (ticker.incremented_off_time != 0) return ticker.incremented_off_time - 1 - ticker.modified_creation_time; @@ -3534,9 +3482,7 @@ active_time (ticker) */ static void -print_active_time (f, ticker) - FILE *f; - ticker_t ticker; +print_active_time (FILE *f, ticker_t ticker) { int msecs; @@ -3584,7 +3530,7 @@ 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 () +add_advance_cycle_insn_decl (void) { advance_cycle_insn_decl = create_node (sizeof (struct decl)); advance_cycle_insn_decl->mode = dm_insn_reserv; @@ -3615,8 +3561,8 @@ static int allocated_alt_states_num = 0; /* 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 () +static alt_state_t +get_free_alt_state (void) { alt_state_t result; @@ -3640,8 +3586,7 @@ get_free_alt_state () /* The function frees node ALT_STATE. */ static void -free_alt_state (alt_state) - alt_state_t alt_state; +free_alt_state (alt_state_t alt_state) { if (alt_state == NULL) return; @@ -3651,8 +3596,7 @@ free_alt_state (alt_state) /* The function frees list started with node ALT_STATE_LIST. */ static void -free_alt_states (alt_states_list) - alt_state_t alt_states_list; +free_alt_states (alt_state_t alt_states_list) { alt_state_t curr_alt_state; alt_state_t next_alt_state; @@ -3668,9 +3612,7 @@ free_alt_states (alt_states_list) /* The function compares unique numbers of alt states. */ static int -alt_state_cmp (alt_state_ptr_1, alt_state_ptr_2) - const void *alt_state_ptr_1; - const void *alt_state_ptr_2; +alt_state_cmp (const void *alt_state_ptr_1, const void *alt_state_ptr_2) { if ((*(alt_state_t *) alt_state_ptr_1)->state->unique_num == (*(alt_state_t *) alt_state_ptr_2)->state->unique_num) @@ -3685,9 +3627,8 @@ alt_state_cmp (alt_state_ptr_1, alt_state_ptr_2) /* 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_states_list) - alt_state_t alt_states_list; +static alt_state_t +uniq_sort_alt_states (alt_state_t alt_states_list) { alt_state_t curr_alt_state; vla_ptr_t alt_states; @@ -3733,9 +3674,7 @@ uniq_sort_alt_states (alt_states_list) /* 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_states_1, alt_states_2) - alt_state_t alt_states_1; - alt_state_t alt_states_2; +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) @@ -3748,14 +3687,14 @@ alt_states_eq (alt_states_1, alt_states_2) /* Initialization of the abstract data. */ static void -initiate_alt_states () +initiate_alt_states (void) { first_free_alt_state = NULL; } /* Finishing work with the abstract data. */ static void -finish_alt_states () +finish_alt_states (void) { } @@ -3823,7 +3762,7 @@ static int allocated_states_num = 0; /* Allocate new reservation set. */ static reserv_sets_t -alloc_empty_reserv_sets () +alloc_empty_reserv_sets (void) { reserv_sets_t result; @@ -3836,8 +3775,7 @@ alloc_empty_reserv_sets () /* Hash value of reservation set. */ static unsigned -reserv_sets_hash_value (reservs) - reserv_sets_t reservs; +reserv_sets_hash_value (reserv_sets_t reservs) { set_el_t hash_value; unsigned result; @@ -3871,16 +3809,13 @@ reserv_sets_hash_value (reservs) /* Comparison of given reservation sets. */ static int -reserv_sets_cmp (reservs_1, reservs_2) - reserv_sets_t reservs_1; - reserv_sets_t reservs_2; +reserv_sets_cmp (reserv_sets_t reservs_1, reserv_sets_t reservs_2) { int reservs_num; set_el_t *reserv_ptr_1; set_el_t *reserv_ptr_2; - if (reservs_1 == NULL || reservs_2 == NULL) - abort (); + gcc_assert (reservs_1 && reservs_2); reservs_num = els_in_reservs; reserv_ptr_1 = reservs_1; reserv_ptr_2 = reservs_2; @@ -3900,9 +3835,7 @@ reserv_sets_cmp (reservs_1, reservs_2) /* The function checks equality of the reservation sets. */ static int -reserv_sets_eq (reservs_1, reservs_2) - reserv_sets_t reservs_1; - reserv_sets_t reservs_2; +reserv_sets_eq (reserv_sets_t reservs_1, reserv_sets_t reservs_2) { return reserv_sets_cmp (reservs_1, reservs_2) == 0; } @@ -3910,13 +3843,9 @@ reserv_sets_eq (reservs_1, reservs_2) /* Set up in the reservation set that unit with UNIT_NUM is used on CYCLE_NUM. */ static void -set_unit_reserv (reservs, cycle_num, unit_num) - reserv_sets_t reservs; - int cycle_num; - int unit_num; +set_unit_reserv (reserv_sets_t reservs, int cycle_num, int unit_num) { - if (cycle_num >= max_cycles_num) - abort (); + gcc_assert (cycle_num < max_cycles_num); SET_BIT (reservs, cycle_num * els_in_cycle_reserv * sizeof (set_el_t) * CHAR_BIT + unit_num); } @@ -3924,13 +3853,9 @@ set_unit_reserv (reservs, cycle_num, unit_num) /* Set up in the reservation set RESERVS that unit with UNIT_NUM is used on CYCLE_NUM. */ static int -test_unit_reserv (reservs, cycle_num, unit_num) - reserv_sets_t reservs; - int cycle_num; - int unit_num; +test_unit_reserv (reserv_sets_t reservs, int cycle_num, int unit_num) { - if (cycle_num >= max_cycles_num) - abort (); + 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); } @@ -3938,14 +3863,12 @@ test_unit_reserv (reservs, cycle_num, unit_num) /* The function checks that the reservation set represents no one unit reservation. */ static int -it_is_empty_reserv_sets (operand) - reserv_sets_t operand; +it_is_empty_reserv_sets (reserv_sets_t operand) { set_el_t *reserv_ptr; int reservs_num; - if (operand == NULL) - abort (); + gcc_assert (operand); for (reservs_num = els_in_reservs, reserv_ptr = operand; reservs_num != 0; reserv_ptr++, reservs_num--) @@ -3958,17 +3881,15 @@ it_is_empty_reserv_sets (operand) i.e. there is a unit reservation on a cycle in both reservation sets. */ static int -reserv_sets_are_intersected (operand_1, operand_2) - reserv_sets_t operand_1; - reserv_sets_t operand_2; +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; - if (operand_1 == NULL || operand_2 == NULL) - abort (); + 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++) @@ -4003,31 +3924,25 @@ reserv_sets_are_intersected (operand_1, operand_2) cpu cycle. The remaining bits of OPERAND (representing the last cycle unit reservations) are not changed. */ static void -reserv_sets_shift (result, operand) - reserv_sets_t result; - reserv_sets_t operand; +reserv_sets_shift (reserv_sets_t result, reserv_sets_t operand) { int i; - if (result == NULL || operand == NULL || result == operand) - abort (); + 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 (result, operand_1, operand_2) - reserv_sets_t result; - reserv_sets_t operand_1; - reserv_sets_t operand_2; +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; - if (result == NULL || operand_1 == NULL || operand_2 == NULL) - abort (); + 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++) @@ -4036,17 +3951,14 @@ reserv_sets_or (result, operand_1, operand_2) /* AND of the reservation sets. */ static void -reserv_sets_and (result, operand_1, operand_2) - reserv_sets_t result; - reserv_sets_t operand_1; - reserv_sets_t operand_2; +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; - if (result == NULL || operand_1 == NULL || operand_2 == NULL) - abort (); + 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++) @@ -4057,11 +3969,8 @@ reserv_sets_and (result, operand_1, operand_2) cycle START_CYCLE in the reservation set. The function uses repeat construction if REPETITION_NUM > 1. */ static void -output_cycle_reservs (f, reservs, start_cycle, repetition_num) - FILE *f; - reserv_sets_t reservs; - int start_cycle; - int repetition_num; +output_cycle_reservs (FILE *f, reserv_sets_t reservs, int start_cycle, + int repetition_num) { int unit_num; int reserved_units_num; @@ -4071,8 +3980,7 @@ output_cycle_reservs (f, reservs, start_cycle, repetition_num) if (TEST_BIT (reservs, start_cycle * els_in_cycle_reserv * sizeof (set_el_t) * CHAR_BIT + unit_num)) reserved_units_num++; - if (repetition_num <= 0) - abort (); + gcc_assert (repetition_num > 0); if (repetition_num != 1 && reserved_units_num > 1) fprintf (f, "("); reserved_units_num = 0; @@ -4089,8 +3997,7 @@ output_cycle_reservs (f, reservs, start_cycle, repetition_num) } if (reserved_units_num == 0) fprintf (f, NOTHING_NAME); - if (repetition_num <= 0) - abort (); + gcc_assert (repetition_num > 0); if (repetition_num != 1 && reserved_units_num > 1) fprintf (f, ")"); if (repetition_num != 1) @@ -4100,9 +4007,7 @@ output_cycle_reservs (f, reservs, start_cycle, repetition_num) /* The function outputs string representation of units reservation in the reservation set. */ static void -output_reserv_sets (f, reservs) - FILE *f; - reserv_sets_t reservs; +output_reserv_sets (FILE *f, reserv_sets_t reservs) { int start_cycle = 0; int cycle; @@ -4142,14 +4047,11 @@ output_reserv_sets (f, reservs) 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 (with_reservs, automaton) - int with_reservs; - automaton_t automaton; +get_free_state (int with_reservs, automaton_t automaton) { state_t result; - if (max_cycles_num <= 0 || automaton == NULL) - abort (); + gcc_assert (max_cycles_num > 0 && automaton); if (VLA_PTR_LENGTH (free_states) != 0) { result = VLA_PTR (free_states, VLA_PTR_LENGTH (free_states) - 1); @@ -4185,8 +4087,7 @@ get_free_state (with_reservs, automaton) /* The function frees node STATE. */ static void -free_state (state) - state_t state; +free_state (state_t state) { free_alt_states (state->component_states); VLA_PTR_ADD (free_states, state); @@ -4197,8 +4098,7 @@ free_state (state) 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 (state) - const void *state; +state_hash (const void *state) { unsigned int hash_value; alt_state_t alt_state; @@ -4223,9 +4123,7 @@ state_hash (state) /* Return nonzero value if the states are the same. */ static int -state_eq_p (state_1, state_2) - const void *state_1; - const void *state_2; +state_eq_p (const void *state_1, const void *state_2) { alt_state_t alt_state_1; alt_state_t alt_state_2; @@ -4256,8 +4154,7 @@ state_eq_p (state_1, state_2) /* Insert STATE into the state table. */ static state_t -insert_state (state) - state_t state; +insert_state (state_t state) { void **entry_ptr; @@ -4270,10 +4167,7 @@ insert_state (state) /* Add reservation of unit with UNIT_NUM on cycle CYCLE_NUM to deterministic STATE. */ static void -set_state_reserv (state, cycle_num, unit_num) - state_t state; - int cycle_num; - int unit_num; +set_state_reserv (state_t state, int cycle_num, int unit_num) { set_unit_reserv (state->reservs, cycle_num, unit_num); } @@ -4281,12 +4175,9 @@ set_state_reserv (state, 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 (state1, state2) - state_t state1; - state_t state2; +intersected_state_reservs_p (state_t state1, state_t state2) { - if (state1->automaton != state2->automaton) - abort (); + gcc_assert (state1->automaton == state2->automaton); return reserv_sets_are_intersected (state1->reservs, state2->reservs); } @@ -4294,16 +4185,12 @@ intersected_state_reservs_p (state1, state2) representing the automaton state which is union of reservations of the deterministic states masked by RESERVS. */ static state_t -states_union (state1, state2, reservs) - state_t state1; - state_t state2; - reserv_sets_t reservs; +states_union (state_t state1, state_t state2, reserv_sets_t reservs) { state_t result; state_t state_in_table; - if (state1->automaton != state2->automaton) - abort (); + 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); @@ -4320,9 +4207,7 @@ states_union (state1, state2, reservs) represent the automaton state is obtained from deterministic STATE by advancing cpu cycle and masking by RESERVS. */ static state_t -state_shift (state, reservs) - state_t state; - reserv_sets_t reservs; +state_shift (state_t state, reserv_sets_t reservs) { state_t result; state_t state_in_table; @@ -4341,7 +4226,7 @@ state_shift (state, reservs) /* Initialization of the abstract data. */ static void -initiate_states () +initiate_states (void) { decl_t decl; int i; @@ -4370,7 +4255,7 @@ initiate_states () /* Finishing work with the abstract data. */ static void -finish_states () +finish_states (void) { VLA_PTR_DELETE (units_container); htab_delete (state_table); @@ -4393,8 +4278,7 @@ static int allocated_arcs_num = 0; /* The function frees node ARC. */ static void -free_arc (arc) - arc_t arc; +free_arc (arc_t arc) { arc->next_out_arc = first_free_arc; first_free_arc = arc; @@ -4402,22 +4286,18 @@ free_arc (arc) /* The function removes and frees ARC staring from FROM_STATE. */ static void -remove_arc (from_state, arc) - state_t from_state; - arc_t arc; +remove_arc (state_t from_state, arc_t arc) { arc_t prev_arc; arc_t curr_arc; - if (arc == NULL) - abort (); + 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; - if (curr_arc == NULL) - abort (); + gcc_assert (curr_arc); if (prev_arc == NULL) from_state->first_out_arc = arc->next_out_arc; else @@ -4428,10 +4308,7 @@ remove_arc (from_state, arc) /* The functions returns arc with given characteristics (or NULL if the arc does not exist). */ static arc_t -find_arc (from_state, to_state, insn) - state_t from_state; - state_t to_state; - ainsn_t insn; +find_arc (state_t from_state, state_t to_state, ainsn_t insn) { arc_t arc; @@ -4445,11 +4322,8 @@ find_arc (from_state, to_state, insn) and with given STATE_ALTS. The function returns added arc (or already existing arc). */ static arc_t -add_arc (from_state, to_state, ainsn, state_alts) - state_t from_state; - state_t to_state; - ainsn_t ainsn; - int state_alts; +add_arc (state_t from_state, state_t to_state, ainsn_t ainsn, + int state_alts) { arc_t new_arc; @@ -4483,30 +4357,28 @@ add_arc (from_state, to_state, ainsn, state_alts) /* The function returns the first arc starting from STATE. */ static arc_t -first_out_arc (state) - state_t state; +first_out_arc (state_t state) { return state->first_out_arc; } /* The function returns next out arc after ARC. */ static arc_t -next_out_arc (arc) - arc_t arc; +next_out_arc (arc_t arc) { return arc->next_out_arc; } /* Initialization of the abstract data. */ static void -initiate_arcs () +initiate_arcs (void) { first_free_arc = NULL; } /* Finishing work with the abstract data. */ static void -finish_arcs () +finish_arcs (void) { } @@ -4525,8 +4397,8 @@ 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 () +static automata_list_el_t +get_free_automata_list_el (void) { automata_list_el_t result; @@ -4545,8 +4417,7 @@ get_free_automata_list_el () /* The function frees node AUTOMATA_LIST_EL. */ static void -free_automata_list_el (automata_list_el) - automata_list_el_t automata_list_el; +free_automata_list_el (automata_list_el_t automata_list_el) { if (automata_list_el == NULL) return; @@ -4556,8 +4427,7 @@ free_automata_list_el (automata_list_el) /* The function frees list AUTOMATA_LIST. */ static void -free_automata_list (automata_list) - automata_list_el_t automata_list; +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; @@ -4573,8 +4443,7 @@ free_automata_list (automata_list) /* Hash value of AUTOMATA_LIST. */ static hashval_t -automata_list_hash (automata_list) - const void *automata_list; +automata_list_hash (const void *automata_list) { unsigned int hash_value; automata_list_el_t curr_automata_list_el; @@ -4591,9 +4460,7 @@ automata_list_hash (automata_list) /* Return nonzero value if the automata_lists are the same. */ static int -automata_list_eq_p (automata_list_1, automata_list_2) - const void *automata_list_1; - const void *automata_list_2; +automata_list_eq_p (const void *automata_list_1, const void *automata_list_2) { automata_list_el_t automata_list_el_1; automata_list_el_t automata_list_el_2; @@ -4610,7 +4477,7 @@ automata_list_eq_p (automata_list_1, automata_list_2) /* Initialization of the abstract data. */ static void -initiate_automata_lists () +initiate_automata_lists (void) { first_free_automata_list_el = NULL; automata_list_table = htab_create (1500, automata_list_hash, @@ -4620,15 +4487,14 @@ initiate_automata_lists () /* The following function starts new automata list and makes it the current one. */ static void -automata_list_start () +automata_list_start (void) { current_automata_list = NULL; } /* The following function adds AUTOMATON to the current list. */ static void -automata_list_add (automaton) - automaton_t automaton; +automata_list_add (automaton_t automaton) { automata_list_el_t el; @@ -4641,7 +4507,7 @@ automata_list_add (automaton) /* The following function finishes forming the current list, inserts it into the table and returns it. */ static automata_list_el_t -automata_list_finish () +automata_list_finish (void) { void **entry_ptr; @@ -4659,7 +4525,7 @@ automata_list_finish () /* Finishing work with the abstract data. */ static void -finish_automata_lists () +finish_automata_lists (void) { htab_delete (automata_list_table); } @@ -4681,7 +4547,7 @@ 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 () +initiate_excl_sets (void) { decl_t decl; reserv_sets_t unit_excl_set; @@ -4719,8 +4585,7 @@ initiate_excl_sets () /* 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 (in_set) - reserv_sets_t in_set; +get_excl_set (reserv_sets_t in_set) { int excl_char_num; int chars_num; @@ -4762,8 +4627,7 @@ 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_list) - pattern_set_el_t pattern_list; +form_reserv_sets_list (pattern_set_el_t pattern_list) { pattern_set_el_t el; pattern_reserv_t first, curr, prev; @@ -4792,7 +4656,7 @@ form_reserv_sets_list (pattern_list) /* The following function forms the array containing presence and absence pattern sets for each unit. */ static void -initiate_presence_absence_pattern_sets () +initiate_presence_absence_pattern_sets (void) { decl_t decl; int i; @@ -4831,9 +4695,9 @@ initiate_presence_absence_pattern_sets () sets for units in ORIGIONAL_SET. The function returns TRUE if it is ok. */ static int -check_presence_pattern_sets (checked_set, origional_set, final_p) - reserv_sets_t checked_set, origional_set; - int final_p; +check_presence_pattern_sets (reserv_sets_t checked_set, + reserv_sets_t origional_set, + int final_p) { int char_num; int chars_num; @@ -4842,7 +4706,7 @@ check_presence_pattern_sets (checked_set, origional_set, final_p) 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 *) origional_set) [char_num]) @@ -4880,9 +4744,9 @@ check_presence_pattern_sets (checked_set, origional_set, final_p) sets for units in ORIGIONAL_SET. The function returns TRUE if it is ok. */ static int -check_absence_pattern_sets (checked_set, origional_set, final_p) - reserv_sets_t checked_set, origional_set; - int final_p; +check_absence_pattern_sets (reserv_sets_t checked_set, + reserv_sets_t origional_set, + int final_p) { int char_num; int chars_num; @@ -4890,7 +4754,7 @@ check_absence_pattern_sets (checked_set, origional_set, final_p) 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 *) origional_set) [char_num]) @@ -4931,54 +4795,60 @@ check_absence_pattern_sets (checked_set, origional_set, final_p) defined by define_reservation by corresponding value during making the copy. */ static regexp_t -copy_insn_regexp (regexp) - regexp_t regexp; +copy_insn_regexp (regexp_t regexp) { regexp_t result; int i; - if (regexp->mode == rm_reserv) - result = copy_insn_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp); - else if (regexp->mode == rm_unit) - result = copy_node (regexp, sizeof (struct regexp)); - else if (regexp->mode == rm_repeat) + switch (regexp->mode) { + case rm_reserv: + result = copy_insn_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp); + break; + + case rm_unit: + result = copy_node (regexp, sizeof (struct regexp)); + break; + + case rm_repeat: result = copy_node (regexp, sizeof (struct regexp)); REGEXP_REPEAT (result)->regexp = copy_insn_regexp (REGEXP_REPEAT (regexp)->regexp); - } - else if (regexp->mode == rm_sequence) - { + break; + + case rm_sequence: result = copy_node (regexp, sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_SEQUENCE (regexp)->regexps_num - 1)); for (i = 0; i regexps_num; i++) REGEXP_SEQUENCE (result)->regexps [i] = copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]); - } - else if (regexp->mode == rm_allof) - { + break; + + case rm_allof: result = copy_node (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]); - } - else if (regexp->mode == rm_oneof) - { + break; + + case rm_oneof: result = copy_node (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]); - } - else - { - if (regexp->mode != rm_nothing) - abort (); + break; + + case rm_nothing: result = copy_node (regexp, sizeof (struct regexp)); + break; + + default: + gcc_unreachable (); } return result; } @@ -4990,8 +4860,7 @@ static int regexp_transformed_p; /* The function makes transformation A*N -> A, A, ... */ static regexp_t -transform_1 (regexp) - regexp_t regexp; +transform_1 (regexp_t regexp) { int i; int repeat_num; @@ -5001,8 +4870,7 @@ transform_1 (regexp) if (regexp->mode == rm_repeat) { repeat_num = REGEXP_REPEAT (regexp)->repeat_num; - if (repeat_num <= 1) - abort (); + gcc_assert (repeat_num > 1); operand = REGEXP_REPEAT (regexp)->regexp; pos = regexp->mode; regexp = create_node (sizeof (struct regexp) + sizeof (regexp_t) @@ -5022,8 +4890,7 @@ transform_1 (regexp) ...+(A+B+...)+C+... -> ...+A+B+...+C+... ...|(A|B|...)|C|... -> ...|A|B|...|C|... */ static regexp_t -transform_2 (regexp) - regexp_t regexp; +transform_2 (regexp_t regexp) { if (regexp->mode == rm_sequence) { @@ -5041,9 +4908,8 @@ transform_2 (regexp) } if (i < REGEXP_SEQUENCE (regexp)->regexps_num) { - if ( REGEXP_SEQUENCE (sequence)->regexps_num <= 1 - || REGEXP_SEQUENCE (regexp)->regexps_num <= 1) - abort (); + gcc_assert (REGEXP_SEQUENCE (sequence)->regexps_num > 1 + && REGEXP_SEQUENCE (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_SEQUENCE (regexp)->regexps_num @@ -5086,9 +4952,8 @@ transform_2 (regexp) } if (i < REGEXP_ALLOF (regexp)->regexps_num) { - if (REGEXP_ALLOF (allof)->regexps_num <= 1 - || REGEXP_ALLOF (regexp)->regexps_num <= 1) - abort (); + gcc_assert (REGEXP_ALLOF (allof)->regexps_num > 1 + && REGEXP_ALLOF (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_ALLOF (regexp)->regexps_num @@ -5130,9 +4995,8 @@ transform_2 (regexp) } if (i < REGEXP_ONEOF (regexp)->regexps_num) { - if (REGEXP_ONEOF (oneof)->regexps_num <= 1 - || REGEXP_ONEOF (regexp)->regexps_num <= 1) - abort (); + gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1 + && REGEXP_ONEOF (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_ONEOF (regexp)->regexps_num @@ -5167,8 +5031,7 @@ transform_2 (regexp) ...+(A,B,...)+C+... -> (...+A+C+...),B,... ...+(A,B,...)+(C,D,...) -> (A+C),(B+D),... */ static regexp_t -transform_3 (regexp) - regexp_t regexp; +transform_3 (regexp_t regexp) { if (regexp->mode == rm_sequence) { @@ -5187,9 +5050,8 @@ transform_3 (regexp) } if (i < REGEXP_SEQUENCE (regexp)->regexps_num) { - if (REGEXP_ONEOF (oneof)->regexps_num <= 1 - || REGEXP_SEQUENCE (regexp)->regexps_num <= 1) - abort (); + gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1 + && REGEXP_SEQUENCE (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_ONEOF (oneof)->regexps_num - 1)); @@ -5240,9 +5102,8 @@ transform_3 (regexp) } if (i < REGEXP_ALLOF (regexp)->regexps_num) { - if (REGEXP_ONEOF (oneof)->regexps_num <= 1 - || REGEXP_ALLOF (regexp)->regexps_num <= 1) - abort (); + gcc_assert (REGEXP_ONEOF (oneof)->regexps_num > 1 + && REGEXP_ALLOF (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (REGEXP_ONEOF (oneof)->regexps_num - 1)); @@ -5276,23 +5137,28 @@ transform_3 (regexp) if (regexp->mode == rm_allof) for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++) { - if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_sequence) + 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; - } - else if (REGEXP_ALLOF (regexp)->regexps [i]->mode != rm_unit - && REGEXP_ALLOF (regexp)->regexps [i]->mode != rm_nothing) - { - max_seq_length = 0; break; + + case rm_unit: + case rm_nothing: + break; + + default: + max_seq_length = 0; + goto break_for; } } + break_for: if (max_seq_length != 0) { - if (max_seq_length == 1 || REGEXP_ALLOF (regexp)->regexps_num <= 1) - abort (); + gcc_assert (max_seq_length != 1 + && REGEXP_ALLOF (regexp)->regexps_num > 1); result = create_node (sizeof (struct regexp) + sizeof (regexp_t) * (max_seq_length - 1)); result->mode = rm_sequence; @@ -5302,24 +5168,31 @@ transform_3 (regexp) { 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))) + switch (REGEXP_ALLOF (regexp)->regexps [j]->mode) { - allof_op - = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)->regexps [j]) - ->regexps [i]); - 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]; - allof_length++; + 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 @@ -5368,39 +5241,52 @@ transform_3 (regexp) /* The function traverses IR of reservation and applies transformations implemented by FUNC. */ static regexp_t -regexp_transform_func (regexp, func) - regexp_t regexp; - regexp_t (*func) PARAMS ((regexp_t regexp)); +regexp_transform_func (regexp_t regexp, regexp_t (*func) (regexp_t regexp)) { int i; - if (regexp->mode == 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); - else if (regexp->mode == 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); - else if (regexp->mode == 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); - else if (regexp->mode == rm_repeat) - REGEXP_REPEAT (regexp)->regexp - = regexp_transform_func (REGEXP_REPEAT (regexp)->regexp, func); - else if (regexp->mode != rm_nothing && regexp->mode != rm_unit) - abort (); + 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) - regexp_t regexp; +transform_regexp (regexp_t regexp) { - regexp = regexp_transform_func (regexp, transform_1); + regexp = regexp_transform_func (regexp, transform_1); do { regexp_transformed_p = 0; @@ -5414,15 +5300,15 @@ transform_regexp (regexp) /* The function applies all transformations for reservations of all insn declarations. */ static void -transform_insn_regexps () +transform_insn_regexps (void) { decl_t decl; int i; transform_time = create_ticker (); add_advance_cycle_insn_decl (); - fprintf (stderr, "Reservation transformation..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "Reservation transformation..."); for (i = 0; i < description->decls_num; i++) { decl = description->decls [i]; @@ -5431,9 +5317,9 @@ transform_insn_regexps () = transform_regexp (copy_insn_regexp (DECL_INSN_RESERV (decl)->regexp)); } - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); ticker_off (&transform_time); - fflush (stderr); } @@ -5442,141 +5328,194 @@ transform_insn_regexps () about units to automata distribution has been output. */ static int annotation_message_reported_p; -/* The function processes all alternative reservations on CYCLE in - given REGEXP of insn reservation with INSN_RESERV_NAME to check the - UNIT (or another unit from the same automaton) is not reserved on - the all alternatives. If it is true, the function outputs message - about the rule violation. */ +/* The following structure describes usage of a unit in a reservation. */ +struct unit_usage +{ + unit_decl_t unit_decl; + /* The following forms a list of units used on the same cycle in the + same alternative. */ + struct unit_usage *next; +}; + +/* 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 vla_ptr_t 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 -check_unit_distribution_in_reserv (insn_reserv_name, unit, regexp, cycle) - const char *insn_reserv_name; - regexp_t unit; - regexp_t regexp; - int cycle; +store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle, + int alt_num) { - int i, k; - regexp_t seq, allof; + size_t i, length, old_length; unit_decl_t unit_decl; + struct unit_usage *unit_usage_ptr; + int index; - if (regexp == NULL || regexp->mode != rm_oneof) - abort (); + gcc_assert (regexp && regexp->mode == rm_oneof + && alt_num < REGEXP_ONEOF (regexp)->regexps_num); unit_decl = REGEXP_UNIT (unit)->unit_decl; - for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--) + old_length = VLA_PTR_LENGTH (cycle_alt_unit_usages); + length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num; + if (old_length < length) { - seq = REGEXP_ONEOF (regexp)->regexps [i]; - if (seq->mode == rm_sequence) - { - if (cycle >= REGEXP_SEQUENCE (seq)->regexps_num) - continue; - allof = REGEXP_SEQUENCE (seq)->regexps [cycle]; - if (allof->mode == rm_allof) - { - for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++) - if (REGEXP_ALLOF (allof)->regexps [k]->mode == rm_unit - && (REGEXP_UNIT (REGEXP_ALLOF (allof)->regexps [k]) - ->unit_decl->automaton_decl - == unit_decl->automaton_decl)) - break; - if (k >= REGEXP_ALLOF (allof)->regexps_num) - break; - } - else if (allof->mode == rm_unit - && (REGEXP_UNIT (allof)->unit_decl->automaton_decl - != unit_decl->automaton_decl)) - break; - } - else if (cycle != 0) - continue; - else if (seq->mode == rm_allof) - { - for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++) - if (REGEXP_ALLOF (seq)->regexps [k]->mode == rm_unit - && (REGEXP_UNIT (REGEXP_ALLOF (seq)->regexps [k]) - ->unit_decl->automaton_decl == unit_decl->automaton_decl)) - break; - if (k >= REGEXP_ALLOF (seq)->regexps_num) - break; - } - else if (seq->mode == rm_unit - && (REGEXP_UNIT (seq)->unit_decl->automaton_decl - != unit_decl->automaton_decl)) - break; - } - if (i >= 0) - { - if (!annotation_message_reported_p) - { - fprintf (stderr, "\n"); - error ("The following units do not satisfy units-automata distribution rule"); - error (" (A unit of given unit automaton should be on each reserv. altern.)"); - annotation_message_reported_p = TRUE; - } - error ("Unit %s, reserv. %s, cycle %d", - unit_decl->name, insn_reserv_name, cycle); + VLA_PTR_EXPAND (cycle_alt_unit_usages, length - old_length); + for (i = old_length; i < length; i++) + VLA_PTR (cycle_alt_unit_usages, i) = NULL; } + obstack_blank (&unit_usages, sizeof (struct unit_usage)); + unit_usage_ptr = (struct unit_usage *) obstack_base (&unit_usages); + obstack_finish (&unit_usages); + unit_usage_ptr->unit_decl = unit_decl; + index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num; + unit_usage_ptr->next = VLA_PTR (cycle_alt_unit_usages, index); + VLA_PTR (cycle_alt_unit_usages, index) = unit_usage_ptr; + unit_decl->last_distribution_check_cycle = -1; /* undefined */ } /* The function processes given REGEXP to find units with the wrong distribution. */ static void -check_regexp_units_distribution (insn_reserv_name, regexp) - const char *insn_reserv_name; - regexp_t regexp; +check_regexp_units_distribution (const char *insn_reserv_name, + regexp_t regexp) { - int i, j, k; + int i, j, k, cycle; regexp_t seq, allof, unit; + struct unit_usage *unit_usage_ptr, *other_unit_usage_ptr; if (regexp == NULL || regexp->mode != rm_oneof) return; + /* Store all unit usages in the regexp: */ + obstack_init (&unit_usages); + VLA_PTR_CREATE (cycle_alt_unit_usages, 100, "unit usages on cycles"); for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--) { seq = REGEXP_ONEOF (regexp)->regexps [i]; - if (seq->mode == rm_sequence) - for (j = 0; j < REGEXP_SEQUENCE (seq)->regexps_num; j++) - { - allof = REGEXP_SEQUENCE (seq)->regexps [j]; - if (allof->mode == rm_allof) - for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++) + 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) { - unit = REGEXP_ALLOF (allof)->regexps [k]; - if (unit->mode == rm_unit) - check_unit_distribution_in_reserv (insn_reserv_name, unit, - regexp, j); - else if (unit->mode != rm_nothing) - abort (); + 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 (); } - else if (allof->mode == rm_unit) - check_unit_distribution_in_reserv (insn_reserv_name, allof, - regexp, j); - else if (allof->mode != rm_nothing) - abort (); - } - else if (seq->mode == rm_allof) - for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++) + } + 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) VLA_PTR_LENGTH (cycle_alt_unit_usages); i++) + { + cycle = i / REGEXP_ONEOF (regexp)->regexps_num; + for (unit_usage_ptr = VLA_PTR (cycle_alt_unit_usages, i); + unit_usage_ptr != NULL; + unit_usage_ptr = unit_usage_ptr->next) + if (cycle != unit_usage_ptr->unit_decl->last_distribution_check_cycle) { - unit = REGEXP_ALLOF (seq)->regexps [k]; - if (unit->mode == rm_unit) - check_unit_distribution_in_reserv (insn_reserv_name, unit, - regexp, 0); - else if (unit->mode != rm_nothing) - abort (); + unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle; + for (k = cycle * REGEXP_ONEOF (regexp)->regexps_num; + k < (int) VLA_PTR_LENGTH (cycle_alt_unit_usages) + && k == cycle * REGEXP_ONEOF (regexp)->regexps_num; + k++) + { + for (other_unit_usage_ptr = VLA_PTR (cycle_alt_unit_usages, k); + other_unit_usage_ptr != NULL; + other_unit_usage_ptr = other_unit_usage_ptr->next) + if (unit_usage_ptr->unit_decl->automaton_decl + == other_unit_usage_ptr->unit_decl->automaton_decl) + break; + if (other_unit_usage_ptr == NULL + && VLA_PTR (cycle_alt_unit_usages, k) != NULL) + break; + } + if (k < (int) VLA_PTR_LENGTH (cycle_alt_unit_usages) + && k == cycle * REGEXP_ONEOF (regexp)->regexps_num) + { + if (!annotation_message_reported_p) + { + fprintf (stderr, "\n"); + error ("The following units do not satisfy units-automata distribution rule"); + error (" (A unit of given unit automaton should be on each reserv. altern.)"); + annotation_message_reported_p = TRUE; + } + error ("Unit %s, reserv. %s, cycle %d", + unit_usage_ptr->unit_decl->name, insn_reserv_name, + cycle); + } } - else if (seq->mode == rm_unit) - check_unit_distribution_in_reserv (insn_reserv_name, seq, regexp, 0); - else if (seq->mode != rm_nothing) - abort (); } + VLA_PTR_DELETE (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 () +check_unit_distributions_to_automata (void) { decl_t decl; int i; - fprintf (stderr, "Check unit distributions to automata..."); + if (progress_flag) + fprintf (stderr, "Check unit distributions to automata..."); annotation_message_reported_p = FALSE; for (i = 0; i < description->decls_num; i++) { @@ -5586,7 +5525,8 @@ check_unit_distributions_to_automata () (DECL_INSN_RESERV (decl)->name, DECL_INSN_RESERV (decl)->transformed_regexp); } - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); } @@ -5600,65 +5540,64 @@ 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, automaton, curr_cycle) - regexp_t regexp; - automaton_t automaton; - int curr_cycle; +process_seq_for_forming_states (regexp_t regexp, automaton_t automaton, + int curr_cycle) { int i; if (regexp == NULL) return curr_cycle; - else if (regexp->mode == rm_unit) + + 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; - } - else if (regexp->mode == rm_sequence) - { + + 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; - } - else if (regexp->mode == 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; - } - else - { - if (regexp->mode != rm_nothing) - abort (); + 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, automaton) - alt_state_t alt_state; - automaton_t automaton ATTRIBUTE_UNUSED; +finish_forming_alt_state (alt_state_t alt_state, + automaton_t automaton ATTRIBUTE_UNUSED) { state_t state_in_table; state_t corresponding_state; @@ -5680,10 +5619,8 @@ static ainsn_t curr_ainsn; 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, automaton, inside_oneof_p) - regexp_t regexp; - automaton_t automaton; - int inside_oneof_p; +process_alts_for_forming_states (regexp_t regexp, automaton_t automaton, + int inside_oneof_p) { int i; @@ -5702,8 +5639,7 @@ process_alts_for_forming_states (regexp, automaton, inside_oneof_p) } else { - if (inside_oneof_p) - abort (); + 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. */ @@ -5715,8 +5651,7 @@ process_alts_for_forming_states (regexp, automaton, inside_oneof_p) /* Create nodes alt_state for all AUTOMATON insns. */ static void -create_alt_states (automaton) - automaton_t automaton; +create_alt_states (automaton_t automaton) { struct insn_reserv_decl *reserv_decl; @@ -5744,8 +5679,7 @@ create_alt_states (automaton) /* The function forms list of ainsns of AUTOMATON with the same reservation. */ static void -form_ainsn_with_same_reservs (automaton) - automaton_t automaton; +form_ainsn_with_same_reservs (automaton_t automaton) { ainsn_t curr_ainsn; size_t i; @@ -5797,8 +5731,7 @@ form_ainsn_with_same_reservs (automaton) of reservs_matter means some minimization during building the automaton. */ static reserv_sets_t -form_reservs_matter (automaton) - automaton_t automaton; +form_reservs_matter (automaton_t automaton) { int cycle, unit; reserv_sets_t reservs_matter = alloc_empty_reserv_sets(); @@ -5822,8 +5755,7 @@ form_reservs_matter (automaton) /* The following function creates all states of nondeterministic (if NDFA_FLAG has nonzero value) or deterministic AUTOMATON. */ static void -make_automaton (automaton) - automaton_t automaton; +make_automaton (automaton_t automaton) { ainsn_t ainsn; struct insn_reserv_decl *insn_reserv_decl; @@ -5874,8 +5806,8 @@ make_automaton (automaton) = 1; VLA_PTR_ADD (state_stack, state2); states_n++; - if (states_n % 100 == 0) - fprintf (stderr, "*"); + if (progress_flag && states_n % 100 == 0) + fprintf (stderr, "."); } added_arc = add_arc (state, state2, ainsn, 1); if (!ndfa_flag) @@ -5905,11 +5837,10 @@ make_automaton (automaton) state2->it_was_placed_in_stack_for_NDFA_forming = 1; VLA_PTR_ADD (state_stack, state2); states_n++; - if (states_n % 100 == 0) - fprintf (stderr, "*"); + if (progress_flag && states_n % 100 == 0) + fprintf (stderr, "."); } - if (advance_cycle_ainsn == NULL) - abort (); + gcc_assert (advance_cycle_ainsn); add_arc (state, state2, advance_cycle_ainsn, 1); } VLA_PTR_DELETE (state_stack); @@ -5917,8 +5848,7 @@ make_automaton (automaton) /* Foms lists of all arcs of STATE marked by the same ainsn. */ static void -form_arcs_marked_by_insn (state) - state_t state; +form_arcs_marked_by_insn (state_t state) { decl_t decl; arc_t arc; @@ -5932,8 +5862,7 @@ form_arcs_marked_by_insn (state) } for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) { - if (arc->insn == NULL) - abort (); + 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; @@ -5945,10 +5874,8 @@ form_arcs_marked_by_insn (state) same insn. If the composed state is not in STATE_STACK yet, it is pushed into STATE_STACK. */ static int -create_composed_state (original_state, arcs_marked_by_insn, state_stack) - state_t original_state; - arc_t arcs_marked_by_insn; - vla_ptr_t *state_stack; +create_composed_state (state_t original_state, arc_t arcs_marked_by_insn, + vla_ptr_t *state_stack) { state_t state; alt_state_t alt_state, curr_alt_state; @@ -5967,8 +5894,7 @@ create_composed_state (original_state, arcs_marked_by_insn, state_stack) state = arcs_marked_by_insn->to_state; else { - if (!ndfa_flag) - abort (); + gcc_assert (ndfa_flag); /* Create composed state. */ state = get_free_state (0, arcs_marked_by_insn->to_state->automaton); curr_alt_state = NULL; @@ -5990,8 +5916,7 @@ create_composed_state (original_state, arcs_marked_by_insn, state_stack) new_alt_state = get_free_alt_state (); new_alt_state->next_alt_state = curr_alt_state; new_alt_state->state = alt_state->state; - if (alt_state->state->component_states != NULL) - abort (); + gcc_assert (!alt_state->state->component_states); curr_alt_state = new_alt_state; } /* There are not identical sets in the alt state list. */ @@ -6008,15 +5933,14 @@ create_composed_state (original_state, arcs_marked_by_insn, state_stack) state_in_table = insert_state (state); if (state_in_table != state) { - if (!state_in_table->it_was_placed_in_stack_for_DFA_forming) - abort (); + gcc_assert + (state_in_table->it_was_placed_in_stack_for_DFA_forming); free_state (state); state = state_in_table; } else { - if (state->it_was_placed_in_stack_for_DFA_forming) - abort (); + 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; @@ -6050,8 +5974,7 @@ create_composed_state (original_state, arcs_marked_by_insn, state_stack) /* The function transforms nondeterministic AUTOMATON into deterministic. */ static void -NDFA_to_DFA (automaton) - automaton_t automaton; +NDFA_to_DFA (automaton_t automaton) { state_t start_state; state_t state; @@ -6080,8 +6003,8 @@ NDFA_to_DFA (automaton) &state_stack)) { states_n++; - if (states_n % 100 == 0) - fprintf (stderr, "*"); + if (progress_flag && states_n % 100 == 0) + fprintf (stderr, "."); } } } @@ -6095,9 +6018,7 @@ 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 (start_state, applied_func) - state_t start_state; - void (*applied_func) PARAMS ((state_t state)); +pass_state_graph (state_t start_state, void (*applied_func) (state_t state)) { arc_t arc; @@ -6114,9 +6035,7 @@ pass_state_graph (start_state, applied_func) /* This recursive function passes all states of AUTOMATON and applies APPLIED_FUNC to them. */ static void -pass_states (automaton, applied_func) - automaton_t automaton; - void (*applied_func) PARAMS ((state_t state)); +pass_states (automaton_t automaton, void (*applied_func) (state_t state)) { curr_state_graph_pass_num++; pass_state_graph (automaton->start_state, applied_func); @@ -6124,7 +6043,7 @@ pass_states (automaton, applied_func) /* The function initializes code for passing of all states. */ static void -initiate_pass_states () +initiate_pass_states (void) { curr_state_graph_pass_num = 0; } @@ -6136,8 +6055,7 @@ static vla_ptr_t all_achieved_states; /* This function is called by function pass_states to add an achieved STATE. */ static void -add_achieved_state (state) - state_t state; +add_achieved_state (state_t state) { VLA_PTR_ADD (all_achieved_states, state); } @@ -6147,9 +6065,7 @@ add_achieved_state (state) nonzero value) or by equiv_class_num_2 of the destination state. The function returns number of out arcs of STATE. */ static int -set_out_arc_insns_equiv_num (state, odd_iteration_flag) - state_t state; - int odd_iteration_flag; +set_out_arc_insns_equiv_num (state_t state, int odd_iteration_flag) { int state_out_arcs_num; arc_t arc; @@ -6157,18 +6073,16 @@ set_out_arc_insns_equiv_num (state, odd_iteration_flag) state_out_arcs_num = 0; for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) { - if (arc->insn->insn_reserv_decl->equiv_class_num != 0 - || arc->insn->insn_reserv_decl->state_alts != 0) - abort (); + gcc_assert (!arc->insn->insn_reserv_decl->equiv_class_num + && !arc->insn->insn_reserv_decl->state_alts); state_out_arcs_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); arc->insn->insn_reserv_decl->state_alts = arc->state_alts; - if (arc->insn->insn_reserv_decl->equiv_class_num == 0 - || arc->insn->insn_reserv_decl->state_alts <= 0) - abort (); + gcc_assert (arc->insn->insn_reserv_decl->equiv_class_num + && arc->insn->insn_reserv_decl->state_alts > 0); } return state_out_arcs_num; } @@ -6176,8 +6090,7 @@ set_out_arc_insns_equiv_num (state, odd_iteration_flag) /* 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) - state_t state; +clear_arc_insns_equiv_num (state_t state) { arc_t arc; @@ -6191,9 +6104,7 @@ clear_arc_insns_equiv_num (state) /* The function copies pointers to equivalent states from vla FROM into vla TO. */ static void -copy_equiv_class (to, from) - vla_ptr_t *to; - const vla_ptr_t *from; +copy_equiv_class (vla_ptr_t *to, const vla_ptr_t *from) { state_t *class_ptr; @@ -6207,19 +6118,21 @@ copy_equiv_class (to, from) /* The following function returns TRUE if STATE reserves the unit with UNIT_NUM on the first cycle. */ static int -first_cycle_unit_presence (state, unit_num) - state_t state; - int unit_num; +first_cycle_unit_presence (state_t state, int unit_num) { - int presence_p; + alt_state_t alt_state; if (state->component_states == NULL) - presence_p = test_unit_reserv (state->reservs, 0, unit_num); + return test_unit_reserv (state->reservs, 0, unit_num); else - presence_p - = test_unit_reserv (state->component_states->state->reservs, - 0, unit_num); - return presence_p; + { + 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; } /* The function returns nonzero value if STATE is not equivalent to @@ -6228,11 +6141,8 @@ first_cycle_unit_presence (state, unit_num) output arcs. Iteration of making equivalence partition is defined by ODD_ITERATION_FLAG. */ static int -state_is_differed (state, another_state, another_state_out_arcs_num, - odd_iteration_flag) - state_t state, another_state; - int another_state_out_arcs_num; - int odd_iteration_flag; +state_is_differed (state_t state, state_t another_state, + int another_state_out_arcs_num, int odd_iteration_flag) { arc_t arc; int state_out_arcs_num; @@ -6267,9 +6177,7 @@ state_is_differed (state, another_state, another_state_out_arcs_num, /* The function makes initial partition of STATES on equivalent classes. */ static state_t -init_equiv_class (states, states_num) - state_t *states; - int states_num; +init_equiv_class (state_t *states, int states_num) { state_t *state_ptr; state_t result_equiv_class; @@ -6292,12 +6200,9 @@ init_equiv_class (states, states_num) assigns it to the state equivalence number. If the class has been partitioned, the function returns nonzero value. */ static int -partition_equiv_class (equiv_class_ptr, odd_iteration_flag, - next_iteration_classes, new_equiv_class_num_ptr) - state_t *equiv_class_ptr; - int odd_iteration_flag; - vla_ptr_t *next_iteration_classes; - int *new_equiv_class_num_ptr; +partition_equiv_class (state_t *equiv_class_ptr, int odd_iteration_flag, + vla_ptr_t *next_iteration_classes, + int *new_equiv_class_num_ptr) { state_t new_equiv_class; int partition_p; @@ -6308,8 +6213,7 @@ partition_equiv_class (equiv_class_ptr, odd_iteration_flag, int out_arcs_num; partition_p = 0; - if (*equiv_class_ptr == NULL) - abort (); + gcc_assert (*equiv_class_ptr); for (first_state = *equiv_class_ptr; first_state != NULL; first_state = new_equiv_class) @@ -6355,9 +6259,7 @@ partition_equiv_class (equiv_class_ptr, odd_iteration_flag, /* The function finds equivalent states of AUTOMATON. */ static void -evaluate_equiv_classes (automaton, equiv_classes) - automaton_t automaton; - vla_ptr_t *equiv_classes; +evaluate_equiv_classes (automaton_t automaton, vla_ptr_t *equiv_classes) { state_t new_equiv_class; int new_equiv_class_num; @@ -6366,7 +6268,7 @@ evaluate_equiv_classes (automaton, equiv_classes) vla_ptr_t next_iteration_classes; state_t *equiv_class_ptr; state_t *state_ptr; - + VLA_PTR_CREATE (all_achieved_states, 1500, "all achieved states"); pass_states (automaton, add_achieved_state); new_equiv_class = init_equiv_class (VLA_PTR_BEGIN (all_achieved_states), @@ -6403,9 +6305,7 @@ evaluate_equiv_classes (automaton, equiv_classes) /* The function merges equivalent states of AUTOMATON. */ static void -merge_states (automaton, equiv_classes) - automaton_t automaton; - vla_ptr_t *equiv_classes; +merge_states (automaton_t automaton, vla_ptr_t *equiv_classes) { state_t *equiv_class_ptr; state_t curr_state; @@ -6452,7 +6352,7 @@ merge_states (automaton, equiv_classes) } } /* Its is important that alt states were sorted before and - after merging to have the same quering results. */ + after merging to have the same querying results. */ new_state->component_states = uniq_sort_alt_states (alt_states); } else @@ -6502,8 +6402,7 @@ merge_states (automaton, equiv_classes) /* 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) - state_t state; +set_new_cycle_flags (state_t state) { arc_t arc; @@ -6516,8 +6415,7 @@ set_new_cycle_flags (state) /* The top level function for minimization of deterministic AUTOMATON. */ static void -minimize_DFA (automaton) - automaton_t automaton; +minimize_DFA (automaton_t automaton) { vla_ptr_t equiv_classes; @@ -6536,8 +6434,7 @@ 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) - state_t state; +incr_states_and_arcs_nums (state_t state) { arc_t arc; @@ -6548,10 +6445,8 @@ incr_states_and_arcs_nums (state) /* The function counts states and arcs of AUTOMATON. */ static void -count_states_and_arcs (automaton, states_num, arcs_num) - automaton_t automaton; - int *states_num; - int *arcs_num; +count_states_and_arcs (automaton_t automaton, int *states_num, + int *arcs_num) { curr_counted_states_num = 0; curr_counted_arcs_num = 0; @@ -6564,32 +6459,41 @@ count_states_and_arcs (automaton, states_num, arcs_num) recognition after checking and simplifying IR of the description. */ static void -build_automaton (automaton) - automaton_t automaton; +build_automaton (automaton_t automaton) { int states_num; int arcs_num; ticker_on (&NDFA_time); - if (automaton->corresponding_automaton_decl == NULL) - fprintf (stderr, "Create anonymous automaton (1 star is 100 new states):"); - else - fprintf (stderr, "Create automaton `%s' (1 star is 100 new states):", - automaton->corresponding_automaton_decl->name); + 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); - fprintf (stderr, " done\n"); + 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 (automaton->corresponding_automaton_decl == NULL) - fprintf (stderr, "Make anonymous DFA (1 star is 100 new states):"); - else - fprintf (stderr, "Make DFA `%s' (1 star is 100 new states):", - automaton->corresponding_automaton_decl->name); + 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); - fprintf (stderr, " done\n"); + 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; @@ -6597,13 +6501,17 @@ build_automaton (automaton) if (!no_minimization_flag) { ticker_on (&minimize_time); - if (automaton->corresponding_automaton_decl == NULL) - fprintf (stderr, "Minimize anonymous DFA..."); - else - fprintf (stderr, "Minimize DFA `%s'...", - automaton->corresponding_automaton_decl->name); + 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); - fprintf (stderr, "done\n"); + 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; @@ -6622,8 +6530,7 @@ static int curr_state_order_num; /* The function is called by function `pass_states' for enumerating states. */ static void -set_order_state_num (state) - state_t state; +set_order_state_num (state_t state) { state->order_state_num = curr_state_order_num; curr_state_order_num++; @@ -6631,8 +6538,7 @@ set_order_state_num (state) /* The function enumerates all states of AUTOMATON. */ static void -enumerate_states (automaton) - automaton_t automaton; +enumerate_states (automaton_t automaton) { curr_state_order_num = 0; pass_states (automaton, set_order_state_num); @@ -6647,9 +6553,8 @@ enumerate_states (automaton) /* The function inserts AINSN into cyclic list CYCLIC_EQUIV_CLASS_INSN_LIST of ainsns. */ static ainsn_t -insert_ainsn_into_equiv_class (ainsn, cyclic_equiv_class_insn_list) - ainsn_t ainsn; - ainsn_t cyclic_equiv_class_insn_list; +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; @@ -6665,8 +6570,7 @@ insert_ainsn_into_equiv_class (ainsn, cyclic_equiv_class_insn_list) /* The function deletes equiv_class_insn into cyclic list of equivalent ainsns. */ static void -delete_ainsn_from_equiv_class (equiv_class_insn) - ainsn_t equiv_class_insn; +delete_ainsn_from_equiv_class (ainsn_t equiv_class_insn) { ainsn_t curr_equiv_class_insn; ainsn_t prev_equiv_class_insn; @@ -6685,17 +6589,14 @@ delete_ainsn_from_equiv_class (equiv_class_insn) ainsns. INSN_ARCS_ARRAY is table: code of insn -> out arc of the state. */ static void -process_insn_equiv_class (ainsn, insn_arcs_array) - ainsn_t ainsn; - arc_t *insn_arcs_array; +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; - if (insn_arcs_array [ainsn->insn_reserv_decl->insn_num] == NULL) - abort (); + 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; @@ -6718,8 +6619,7 @@ process_insn_equiv_class (ainsn, insn_arcs_array) /* The function processes STATE in order to find equivalent ainsns. */ static void -process_state_for_insn_equiv_partition (state) - state_t state; +process_state_for_insn_equiv_partition (state_t state) { arc_t arc; arc_t *insn_arcs_array; @@ -6741,8 +6641,7 @@ process_state_for_insn_equiv_partition (state) /* The function searches for equivalent ainsns of AUTOMATON. */ static void -set_insn_equiv_classes (automaton) - automaton_t automaton; +set_insn_equiv_classes (automaton_t automaton) { ainsn_t ainsn; ainsn_t first_insn; @@ -6768,9 +6667,8 @@ set_insn_equiv_classes (automaton) if (ainsn->insn_equiv_class_num < 0) { first_insn = ainsn; - if (!first_insn->first_insn_with_same_reservs) - abort (); - first_insn->first_ainsn_with_given_equialence_num = 1; + gcc_assert (first_insn->first_insn_with_same_reservs); + first_insn->first_ainsn_with_given_equivalence_num = 1; curr_insn = first_insn; do { @@ -6804,7 +6702,7 @@ set_insn_equiv_classes (automaton) /* The function estimate size of the single DFA used by PHR (pipeline hazards recognizer). */ static double -estimate_one_automaton_bound () +estimate_one_automaton_bound (void) { decl_t decl; double one_automaton_estimation_bound; @@ -6831,9 +6729,8 @@ estimate_one_automaton_bound () /* The function compares unit declarations according to their maximal cycle in reservations. */ static int -compare_max_occ_cycle_nums (unit_decl_1, unit_decl_2) - const void *unit_decl_1; - const void *unit_decl_2; +compare_max_occ_cycle_nums (const void *unit_decl_1, + const void *unit_decl_2) { if ((DECL_UNIT (*(decl_t *) unit_decl_1)->max_occ_cycle_num) < (DECL_UNIT (*(decl_t *) unit_decl_2)->max_occ_cycle_num)) @@ -6848,7 +6745,7 @@ compare_max_occ_cycle_nums (unit_decl_1, unit_decl_2) /* The function makes heuristic assigning automata to units. Actually efficacy of the algorithm has been checked yet??? */ static void -units_to_automata_heuristic_distr () +units_to_automata_heuristic_distr (void) { double estimation_bound; decl_t decl; @@ -6881,8 +6778,7 @@ units_to_automata_heuristic_distr () { rest_units_num = ((decl_t *) VLA_PTR_LAST (unit_decls) - unit_decl_ptr + 1); - if (automata_num - automaton_num - 1 > rest_units_num) - abort (); + 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 @@ -6896,8 +6792,7 @@ units_to_automata_heuristic_distr () bound_value *= DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num; DECL_UNIT (*unit_decl_ptr)->corresponding_automaton_num = automaton_num; } - if (automaton_num != automata_num - 1) - abort (); + gcc_assert (automaton_num == automata_num - 1); VLA_PTR_DELETE (unit_decls); } @@ -6905,7 +6800,7 @@ units_to_automata_heuristic_distr () insn is simply insn for given automaton which makes reservation only of units of the automaton. */ static ainsn_t -create_ainsns () +create_ainsns (void) { decl_t decl; ainsn_t first_ainsn; @@ -6937,11 +6832,11 @@ create_ainsns () /* The function assigns automata to units according to constructions `define_automaton' in the description. */ static void -units_to_automata_distr () +units_to_automata_distr (void) { decl_t decl; int i; - + for (i = 0; i < description->decls_num; i++) { decl = description->decls [i]; @@ -6963,7 +6858,7 @@ units_to_automata_distr () /* The function creates DFA(s) for fast pipeline hazards recognition after checking and simplifying IR of the description. */ static void -create_automata () +create_automata (void) { automaton_t curr_automaton; automaton_t prev_automaton; @@ -7036,14 +6931,18 @@ create_automata () curr_automaton != NULL; curr_automaton = curr_automaton->next_automaton) { - 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); + 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); - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); build_automaton (curr_automaton); enumerate_states (curr_automaton); ticker_on (&equiv_time); @@ -7062,28 +6961,32 @@ create_automata () /* This recursive function forms string representation of regexp (without tailing '\0'). */ static void -form_regexp (regexp) - regexp_t regexp; +form_regexp (regexp_t regexp) { int i; - - if (regexp->mode == rm_unit || regexp->mode == rm_reserv) - { - const char *name = (regexp->mode == rm_unit - ? REGEXP_UNIT (regexp)->name - : REGEXP_RESERV (regexp)->name); - obstack_grow (&irp, name, strlen (name)); - } - else if (regexp->mode == rm_sequence) - for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++) + switch (regexp->mode) + { + case rm_unit: case rm_reserv: { - if (i != 0) - obstack_1grow (&irp, ','); - form_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]); + const char *name = (regexp->mode == rm_unit + ? REGEXP_UNIT (regexp)->name + : REGEXP_RESERV (regexp)->name); + + obstack_grow (&irp, name, strlen (name)); + break; } - else if (regexp->mode == rm_allof) - { + + 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++) { @@ -7098,45 +7001,52 @@ form_regexp (regexp) obstack_1grow (&irp, ')'); } obstack_1grow (&irp, ')'); - } - else if (regexp->mode == 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) + 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; } - else if (regexp->mode == 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)); - } - else if (regexp->mode == rm_nothing) - obstack_grow (&irp, NOTHING_NAME, strlen (NOTHING_NAME)); - else - abort (); + + 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) - regexp_t regexp; +regexp_representation (regexp_t regexp) { form_regexp (regexp); obstack_1grow (&irp, '\0'); @@ -7146,10 +7056,10 @@ regexp_representation (regexp) /* The function frees memory allocated for last formed string representation of regexp. */ static void -finish_regexp_representation () +finish_regexp_representation (void) { int length = obstack_object_size (&irp); - + obstack_blank_fast (&irp, -length); } @@ -7165,10 +7075,8 @@ finish_regexp_representation () approximation. */ static void -output_range_type (f, min_range_value, max_range_value) - FILE *f; - long int min_range_value; - long int max_range_value; +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"); @@ -7193,20 +7101,21 @@ output_range_type (f, min_range_value, max_range_value) `cycle advance' arcs. */ static int -longest_path_length (state) - state_t state; +longest_path_length (state_t state) { arc_t arc; int length, result; - - if (state->longest_path_length == ON_THE_PATH) - /* We don't expect the path cycle here. Our graph may contain - only cycles with one state on the path not containing `cycle - advance' arcs -- see comment below. */ - abort (); - else if (state->longest_path_length != UNDEFINED_LONGEST_PATH_LENGTH) - /* We already visited the state. */ - return state->longest_path_length; + + if (state->longest_path_length != UNDEFINED_LONGEST_PATH_LENGTH) + { + /* We don't expect the path cycle here. Our graph may contain + only cycles with one state on the path not containing `cycle + advance' arcs -- see comment below. */ + gcc_assert (state->longest_path_length != ON_THE_PATH); + + /* We already visited the state. */ + return state->longest_path_length; + } result = 0; for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) @@ -7232,8 +7141,7 @@ static int max_dfa_issue_rate; from STATE to find MAX_DFA_ISSUE_RATE. */ static void -process_state_longest_path_length (state) - state_t state; +process_state_longest_path_length (state_t state) { int value; @@ -7251,12 +7159,11 @@ process_state_longest_path_length (state) global variable and outputs its declaration. */ static void -output_dfa_max_issue_rate () +output_dfa_max_issue_rate (void) { automaton_t automaton; - if (UNDEFINED_LONGEST_PATH_LENGTH == ON_THE_PATH || ON_THE_PATH >= 0) - abort (); + gcc_assert (UNDEFINED_LONGEST_PATH_LENGTH != ON_THE_PATH && ON_THE_PATH < 0); max_dfa_issue_rate = 0; for (automaton = description->first_automaton; automaton != NULL; @@ -7269,9 +7176,7 @@ output_dfa_max_issue_rate () /* The function outputs all initialization values of VECT with length vect_length. */ static void -output_vect (vect, vect_length) - vect_el_t *vect; - int vect_length; +output_vect (vect_el_t *vect, int vect_length) { int els_on_line; @@ -7306,9 +7211,7 @@ output_vect (vect, vect_length) /* The following is name of member which represents state of a DFA for PHR. */ static void -output_chip_member_name (f, automaton) - FILE *f; - automaton_t automaton; +output_chip_member_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "automaton_state_%d", automaton->automaton_order_num); @@ -7320,9 +7223,7 @@ output_chip_member_name (f, automaton) /* The following is name of temporary variable which stores state of a DFA for PHR. */ static void -output_temp_chip_member_name (f, automaton) - FILE *f; - automaton_t automaton; +output_temp_chip_member_name (FILE *f, automaton_t automaton) { fprintf (f, "_"); output_chip_member_name (f, automaton); @@ -7335,9 +7236,7 @@ output_temp_chip_member_name (f, automaton) /* Output name of translate vector for given automaton. */ static void -output_translate_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_translate_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "translate_%d", automaton->automaton_order_num); @@ -7347,9 +7246,7 @@ output_translate_vect_name (f, automaton) /* Output name for simple transition table representation. */ static void -output_trans_full_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_trans_full_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "transitions_%d", automaton->automaton_order_num); @@ -7361,9 +7258,7 @@ output_trans_full_vect_name (f, automaton) /* Output name of comb vector of the transition table for given automaton. */ static void -output_trans_comb_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_trans_comb_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "transitions_%d", automaton->automaton_order_num); @@ -7375,9 +7270,7 @@ output_trans_comb_vect_name (f, automaton) /* Output name of check vector of the transition table for given automaton. */ static void -output_trans_check_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_trans_check_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "check_%d", automaton->automaton_order_num); @@ -7388,9 +7281,7 @@ output_trans_check_vect_name (f, automaton) /* Output name of base vector of the transition table for given automaton. */ static void -output_trans_base_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_trans_base_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "base_%d", automaton->automaton_order_num); @@ -7400,9 +7291,7 @@ output_trans_base_vect_name (f, automaton) /* Output name for simple alternatives number representation. */ static void -output_state_alts_full_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_state_alts_full_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "state_alts_%d", automaton->automaton_order_num); @@ -7414,9 +7303,7 @@ output_state_alts_full_vect_name (f, automaton) /* Output name of comb vector of the alternatives number table for given automaton. */ static void -output_state_alts_comb_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_state_alts_comb_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "state_alts_%d", automaton->automaton_order_num); @@ -7428,9 +7315,7 @@ output_state_alts_comb_vect_name (f, automaton) /* Output name of check vector of the alternatives number table for given automaton. */ static void -output_state_alts_check_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_state_alts_check_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "check_state_alts_%d", automaton->automaton_order_num); @@ -7442,9 +7327,7 @@ output_state_alts_check_vect_name (f, automaton) /* Output name of base vector of the alternatives number table for given automaton. */ static void -output_state_alts_base_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +output_state_alts_base_vect_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "base_state_alts_%d", automaton->automaton_order_num); @@ -7455,9 +7338,7 @@ output_state_alts_base_vect_name (f, automaton) /* Output name of simple min issue delay table representation. */ static void -output_min_issue_delay_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +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); @@ -7468,9 +7349,7 @@ output_min_issue_delay_vect_name (f, automaton) /* Output name of deadlock vector for given automaton. */ static void -output_dead_lock_vect_name (f, automaton) - FILE *f; - automaton_t automaton; +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); @@ -7480,9 +7359,7 @@ output_dead_lock_vect_name (f, automaton) /* Output name of reserved units table for AUTOMATON into file F. */ static void -output_reserved_units_table_name (f, automaton) - FILE *f; - automaton_t automaton; +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); @@ -7596,9 +7473,7 @@ output_reserved_units_table_name (f, automaton) /* Output C type which is used for representation of codes of states of AUTOMATON. */ static void -output_state_member_type (f, automaton) - FILE *f; - automaton_t automaton; +output_state_member_type (FILE *f, automaton_t automaton) { output_range_type (f, 0, automaton->achieved_states_num); } @@ -7606,7 +7481,7 @@ output_state_member_type (f, automaton) /* Output definition of the structure representing current DFA(s) state(s). */ static void -output_chip_definitions () +output_chip_definitions (void) { automaton_t automaton; @@ -7632,8 +7507,7 @@ output_chip_definitions () 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) - automaton_t automaton; +output_translate_vect (automaton_t automaton) { ainsn_t ainsn; int insn_value; @@ -7641,7 +7515,7 @@ output_translate_vect (automaton) VLA_HWINT_CREATE (translate_vect, 250, "translate vector"); VLA_HWINT_EXPAND (translate_vect, description->insns_num); - for (insn_value = 0; insn_value <= description->insns_num; insn_value++) + for (insn_value = 0; insn_value < description->insns_num; insn_value++) /* Undefined value */ VLA_HWINT (translate_vect, insn_value) = automaton->insn_equiv_classes_num; for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn) @@ -7667,8 +7541,7 @@ 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 (tab) - state_ainsn_table_t tab; +comb_vect_p (state_ainsn_table_t tab) { return (2 * VLA_HWINT_LENGTH (tab->full_vect) > 5 * VLA_HWINT_LENGTH (tab->comb_vect)); @@ -7676,8 +7549,7 @@ comb_vect_p (tab) /* The following function creates new table for AUTOMATON. */ static state_ainsn_table_t -create_state_ainsn_table (automaton) - automaton_t automaton; +create_state_ainsn_table (automaton_t automaton) { state_ainsn_table_t tab; int full_vect_length; @@ -7705,16 +7577,11 @@ create_state_ainsn_table (automaton) /* The following function outputs the best C representation of the table TAB of given TABLE_NAME. */ static void -output_state_ainsn_table (tab, table_name, output_full_vect_name_func, - output_comb_vect_name_func, - output_check_vect_name_func, - output_base_vect_name_func) - state_ainsn_table_t tab; - char *table_name; - void (*output_full_vect_name_func) PARAMS ((FILE *, automaton_t)); - void (*output_comb_vect_name_func) PARAMS ((FILE *, automaton_t)); - void (*output_check_vect_name_func) PARAMS ((FILE *, automaton_t)); - void (*output_base_vect_name_func) PARAMS ((FILE *, automaton_t)); +output_state_ainsn_table (state_ainsn_table_t tab, 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)) { @@ -7767,11 +7634,8 @@ output_state_ainsn_table (tab, table_name, output_full_vect_name_func, elements pointed by VECT to table TAB as its line with number VECT_NUM. */ static void -add_vect (tab, vect_num, vect, vect_length) - state_ainsn_table_t tab; - int vect_num; - vect_el_t *vect; - int vect_length; +add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect, + int vect_length) { int real_vect_length; vect_el_t *comb_vect_start; @@ -7784,20 +7648,19 @@ add_vect (tab, vect_num, vect, vect_length) int no_state_value; vect_el_t vect_el; int i; + unsigned long vect_mask, comb_vect_mask; - if (vect_length == 0) - abort (); + gcc_assert (vect_length); real_vect_length = tab->automaton->insn_equiv_classes_num; - if (vect [vect_length - 1] == undefined_vect_el_value) - abort (); + gcc_assert (vect [vect_length - 1] != undefined_vect_el_value); /* Form full vector in the table: */ for (i = 0; i < vect_length; i++) VLA_HWINT (tab->full_vect, i + tab->automaton->insn_equiv_classes_num * vect_num) = vect [i]; /* Form comb vector in the table: */ - if (VLA_HWINT_LENGTH (tab->comb_vect) != VLA_HWINT_LENGTH (tab->check_vect)) - abort (); + gcc_assert (VLA_HWINT_LENGTH (tab->comb_vect) + == VLA_HWINT_LENGTH (tab->check_vect)); comb_vect_start = VLA_HWINT_BEGIN (tab->comb_vect); comb_vect_els_num = VLA_HWINT_LENGTH (tab->comb_vect); for (first_unempty_vect_index = 0; @@ -7805,23 +7668,77 @@ add_vect (tab, vect_num, vect, vect_length) first_unempty_vect_index++) if (vect [first_unempty_vect_index] != undefined_vect_el_value) break; + /* Search for the place in comb vect for the inserted vect. */ - 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 (vect [vect_index] != undefined_vect_el_value - && (comb_vect_start [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; + + /* 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 (vect [vect_index] != undefined_vect_el_value + && (comb_vect_start [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 (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 + && comb_vect_start [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 ^= comb_vect_start [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) @@ -7837,25 +7754,26 @@ add_vect (tab, vect_num, vect, vect_length) } comb_vect_start = VLA_HWINT_BEGIN (tab->comb_vect); check_vect_start = VLA_HWINT_BEGIN (tab->check_vect); - if (VLA_HWINT_LENGTH (tab->comb_vect) - < (size_t) (comb_vect_index + real_vect_length)) - abort (); + gcc_assert (VLA_HWINT_LENGTH (tab->comb_vect) + >= (size_t) (comb_vect_index + real_vect_length)); /* Fill comb and check vectors. */ for (vect_index = 0; vect_index < vect_length; vect_index++) if (vect [vect_index] != undefined_vect_el_value) { - if (comb_vect_start [comb_vect_index + vect_index] - != undefined_vect_el_value) - abort (); + gcc_assert (comb_vect_start [comb_vect_index + vect_index] + == undefined_vect_el_value); comb_vect_start [comb_vect_index + vect_index] = vect [vect_index]; - if (vect [vect_index] < 0) - abort (); + gcc_assert (vect [vect_index] >= 0); if (tab->max_comb_vect_el_value < vect [vect_index]) tab->max_comb_vect_el_value = vect [vect_index]; if (tab->min_comb_vect_el_value > vect [vect_index]) tab->min_comb_vect_el_value = vect [vect_index]; check_vect_start [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) @@ -7865,8 +7783,7 @@ add_vect (tab, vect_num, vect, vect_length) /* Return number of out arcs of STATE. */ static int -out_state_arcs_num (state) - state_t state; +out_state_arcs_num (state_t state) { int result; arc_t arc; @@ -7874,9 +7791,8 @@ out_state_arcs_num (state) result = 0; for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) { - if (arc->insn == NULL) - abort (); - if (arc->insn->first_ainsn_with_given_equialence_num) + gcc_assert (arc->insn); + if (arc->insn->first_ainsn_with_given_equivalence_num) result++; } return result; @@ -7884,9 +7800,8 @@ out_state_arcs_num (state) /* Compare number of possible transitions from the states. */ static int -compare_transition_els_num (state_ptr_1, state_ptr_2) - const void *state_ptr_1; - const void *state_ptr_2; +compare_transition_els_num (const void *state_ptr_1, + const void *state_ptr_2) { int transition_els_num_1; int transition_els_num_2; @@ -7904,16 +7819,12 @@ compare_transition_els_num (state_ptr_1, state_ptr_2) /* The function adds element EL_VALUE to vector VECT for a table state x AINSN. */ static void -add_vect_el (vect, ainsn, el_value) - vla_hwint_t *vect; - ainsn_t ainsn; - int el_value; +add_vect_el (vla_hwint_t *vect, ainsn_t ainsn, int el_value) { int equiv_class_num; int vect_index; - if (ainsn == NULL) - abort (); + gcc_assert (ainsn); equiv_class_num = ainsn->insn_equiv_class_num; for (vect_index = VLA_HWINT_LENGTH (*vect); vect_index <= equiv_class_num; @@ -7928,8 +7839,7 @@ static vla_ptr_t 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) - state_t state; +add_states_vect_el (state_t state) { VLA_PTR_ADD (output_states_vect, state); } @@ -7937,8 +7847,7 @@ add_states_vect_el (state) /* Form and output vectors (comb, check, base or full vector) representing transition table of AUTOMATON. */ static void -output_trans_table (automaton) - automaton_t automaton; +output_trans_table (automaton_t automaton) { state_t *state_ptr; arc_t arc; @@ -7963,9 +7872,8 @@ output_trans_table (automaton) arc != NULL; arc = next_out_arc (arc)) { - if (arc->insn == NULL) - abort (); - if (arc->insn->first_ainsn_with_given_equialence_num) + 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); } @@ -7986,8 +7894,7 @@ output_trans_table (automaton) ainsn -> number of possible alternative reservations by the ainsn. */ static void -output_state_alts_table (automaton) - automaton_t automaton; +output_state_alts_table (automaton_t automaton) { state_t *state_ptr; arc_t arc; @@ -8013,9 +7920,8 @@ output_state_alts_table (automaton) arc != NULL; arc = next_out_arc (arc)) { - if (arc->insn == NULL) - abort (); - if (arc->insn->first_ainsn_with_given_equialence_num) + gcc_assert (arc->insn); + if (arc->insn->first_ainsn_with_given_equivalence_num) add_vect_el (&state_alts_vect, arc->insn, arc->state_alts); } add_vect (automaton->state_alts_table, (*state_ptr)->order_state_num, @@ -8039,9 +7945,7 @@ static int curr_state_pass_num; 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, ainsn) - state_t state; - ainsn_t ainsn; +min_issue_delay_pass_states (state_t state, ainsn_t ainsn) { arc_t arc; int min_insn_issue_delay, insn_issue_delay; @@ -8083,9 +7987,7 @@ min_issue_delay_pass_states (state, ainsn) The function can return negative value if we can not issue AINSN. We will report about it later. */ static int -min_issue_delay (state, ainsn) - state_t state; - ainsn_t ainsn; +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); @@ -8095,7 +7997,7 @@ min_issue_delay (state, ainsn) /* The function initiates code for finding minimal issue delay values. It should be called only once. */ static void -initiate_min_issue_delay_pass_states () +initiate_min_issue_delay_pass_states (void) { curr_state_pass_num = 0; } @@ -8104,8 +8006,7 @@ initiate_min_issue_delay_pass_states () AUTOMATON. The table is state x ainsn -> minimal issue delay of the ainsn. */ static void -output_min_issue_delay_table (automaton) - automaton_t automaton; +output_min_issue_delay_table (automaton_t automaton) { vla_hwint_t min_issue_delay_vect; vla_hwint_t compressed_min_issue_delay_vect; @@ -8129,7 +8030,7 @@ output_min_issue_delay_table (automaton) VLA_HWINT (min_issue_delay_vect, i) = 0; automaton->max_min_delay = 0; for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn) - if (ainsn->first_ainsn_with_given_equialence_num) + if (ainsn->first_ainsn_with_given_equivalence_num) { for (state_ptr = VLA_PTR_BEGIN (output_states_vect); state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect); @@ -8154,7 +8055,7 @@ output_min_issue_delay_table (automaton) fprintf (output_file, " "); output_min_issue_delay_vect_name (output_file, automaton); fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n"); - /* Compress the vector */ + /* Compress the vector. */ if (automaton->max_min_delay < 2) automaton->min_issue_delay_table_compression_factor = 8; else if (automaton->max_min_delay < 4) @@ -8198,8 +8099,7 @@ static int locked_states_num; /* Form and output vector representing the locked states of AUTOMATON. */ static void -output_dead_lock_vect (automaton) - automaton_t automaton; +output_dead_lock_vect (automaton_t automaton) { state_t *state_ptr; arc_t arc; @@ -8217,8 +8117,7 @@ output_dead_lock_vect (automaton) state_ptr++) { arc = first_out_arc (*state_ptr); - if (arc == NULL) - abort (); + gcc_assert (arc); VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num) = (next_out_arc (arc) == NULL && (arc->insn->insn_reserv_decl @@ -8244,8 +8143,7 @@ output_dead_lock_vect (automaton) /* Form and output vector representing reserved units of the states of AUTOMATON. */ static void -output_reserved_units_table (automaton) - automaton_t automaton; +output_reserved_units_table (automaton_t automaton) { state_t *curr_state_ptr; vla_hwint_t reserved_units_table; @@ -8292,7 +8190,7 @@ output_reserved_units_table (automaton) /* The function outputs all tables representing DFA(s) used for fast pipeline hazards recognition. */ static void -output_tables () +output_tables (void) { automaton_t automaton; @@ -8325,7 +8223,7 @@ output_tables () `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 () +output_max_insn_queue_index_def (void) { int i, max, latency; decl_t decl; @@ -8349,8 +8247,7 @@ output_max_insn_queue_index_def () } for (i = 0; (1 << i) <= max; i++) ; - if (i < 0) - abort (); + gcc_assert (i >= 0); fprintf (output_file, "\nint max_insn_queue_index = %d;\n\n", (1 << i) - 1); } @@ -8358,8 +8255,8 @@ output_max_insn_queue_index_def () /* The function outputs switch cases for insn reservations using function *output_automata_list_code. */ static void -output_insn_code_cases (output_automata_list_code) - void (*output_automata_list_code) PARAMS ((automata_list_el_t)); +output_insn_code_cases (void (*output_automata_list_code) + (automata_list_el_t)) { decl_t decl, decl2; int i, j; @@ -8399,8 +8296,7 @@ output_insn_code_cases (output_automata_list_code) /* 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) - automata_list_el_t automata_list; +output_automata_list_min_issue_delay_code (automata_list_el_t automata_list) { automata_list_el_t el; automaton_t automaton; @@ -8451,15 +8347,12 @@ output_automata_list_min_issue_delay_code (automata_list) /* Output function `internal_min_issue_delay'. */ static void -output_internal_min_issue_delay_func () +output_internal_min_issue_delay_func (void) { - fprintf (output_file, "static int %s PARAMS ((int, struct %s *));\n", - INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, CHIP_NAME); fprintf (output_file, - "static int\n%s (%s, %s)\n\tint %s;\n\tstruct %s *%s ATTRIBUTE_UNUSED;\n", + "static int\n%s (int %s, struct %s *%s ATTRIBUTE_UNUSED)\n", INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME, - CHIP_PARAMETER_NAME, INTERNAL_INSN_CODE_NAME, CHIP_NAME, - CHIP_PARAMETER_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); @@ -8474,8 +8367,7 @@ output_internal_min_issue_delay_func () /* 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) - automata_list_el_t automata_list; +output_automata_list_transition_code (automata_list_el_t automata_list) { automata_list_el_t el, next_el; @@ -8568,14 +8460,11 @@ output_automata_list_transition_code (automata_list) /* Output function `internal_state_transition'. */ static void -output_internal_trans_func () +output_internal_trans_func (void) { - fprintf (output_file, "static int %s PARAMS ((int, struct %s *));\n", - INTERNAL_TRANSITION_FUNC_NAME, CHIP_NAME); fprintf (output_file, - "static int\n%s (%s, %s)\n\tint %s;\n\tstruct %s *%s ATTRIBUTE_UNUSED;\n", + "static int\n%s (int %s, struct %s *%s ATTRIBUTE_UNUSED)\n", INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME, - CHIP_PARAMETER_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); @@ -8598,10 +8487,9 @@ output_internal_trans_func () where insn denotes INSN_NAME, insn_code denotes INSN_CODE_NAME, and code denotes CODE. */ static void -output_internal_insn_code_evaluation (insn_name, insn_code_name, code) - const char *insn_name; - const char *insn_code_name; - int code; +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, @@ -8613,49 +8501,62 @@ output_internal_insn_code_evaluation (insn_name, insn_code_name, code) } -/* The function outputs function `dfa_insn_code'. */ +/* This function outputs `dfa_insn_code' and its helper function + `dfa_insn_code_enlarge'. */ static void -output_dfa_insn_code_func () +output_dfa_insn_code_func (void) { - fprintf (output_file, "#ifdef __GNUC__\n__inline__\n#endif\n"); - fprintf (output_file, "static int %s PARAMS ((rtx));\n", - DFA_INSN_CODE_FUNC_NAME); - fprintf (output_file, "static int\n%s (%s)\n\trtx %s;\n", - DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME, INSN_PARAMETER_NAME); - fprintf (output_file, "{\n int %s;\n int %s;\n\n", - INTERNAL_INSN_CODE_NAME, TEMPORARY_VARIABLE_NAME); - fprintf (output_file, " if (INSN_UID (%s) >= %s)\n {\n", - INSN_PARAMETER_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME); - fprintf (output_file, " %s = %s;\n %s = 2 * INSN_UID (%s);\n", - TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME, - DFA_INSN_CODES_LENGTH_VARIABLE_NAME, INSN_PARAMETER_NAME); - fprintf (output_file, " %s = xrealloc (%s, %s * sizeof (int));\n", + /* 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 = xrealloc (%s,\n\ + %s * sizeof(int));\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_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, - " for (; %s < %s; %s++)\n %s [%s] = -1;\n }\n", - TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME, - TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME, - TEMPORARY_VARIABLE_NAME); - fprintf (output_file, " if ((%s = %s [INSN_UID (%s)]) < 0)\n {\n", - INTERNAL_INSN_CODE_NAME, DFA_INSN_CODES_VARIABLE_NAME, - INSN_PARAMETER_NAME); - fprintf (output_file, " %s = %s (%s);\n", INTERNAL_INSN_CODE_NAME, - INTERNAL_DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME); - fprintf (output_file, " %s [INSN_UID (%s)] = %s;\n", - DFA_INSN_CODES_VARIABLE_NAME, INSN_PARAMETER_NAME, - INTERNAL_INSN_CODE_NAME); - fprintf (output_file, " }\n return %s;\n}\n\n", - INTERNAL_INSN_CODE_NAME); + " 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 () +output_trans_func (void) { - fprintf (output_file, "int\n%s (%s, %s)\n\t%s %s;\n\trtx %s;\n", - TRANSITION_FUNC_NAME, STATE_NAME, INSN_PARAMETER_NAME, - STATE_TYPE_NAME, STATE_NAME, INSN_PARAMETER_NAME); + 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); @@ -8666,8 +8567,7 @@ output_trans_func () /* The function outputs a code for evaluation of alternative states number for insns which have reservations in given AUTOMATA_LIST. */ static void -output_automata_list_state_alts_code (automata_list) - automata_list_el_t automata_list; +output_automata_list_state_alts_code (automata_list_el_t automata_list) { automata_list_el_t el; automaton_t automaton; @@ -8727,15 +8627,12 @@ output_automata_list_state_alts_code (automata_list) /* Output function `internal_state_alts'. */ static void -output_internal_state_alts_func () +output_internal_state_alts_func (void) { - fprintf (output_file, "static int %s PARAMS ((int, struct %s *));\n", - INTERNAL_STATE_ALTS_FUNC_NAME, CHIP_NAME); fprintf (output_file, - "static int\n%s (%s, %s)\n\tint %s;\n\tstruct %s *%s;\n", + "static int\n%s (int %s, struct %s *%s)\n", INTERNAL_STATE_ALTS_FUNC_NAME, INTERNAL_INSN_CODE_NAME, - CHIP_PARAMETER_NAME, INTERNAL_INSN_CODE_NAME, CHIP_NAME, - CHIP_PARAMETER_NAME); + CHIP_NAME, CHIP_PARAMETER_NAME); fprintf (output_file, "{\n int %s;\n", RESULT_VARIABLE_NAME); fprintf (output_file, "\n switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME); output_insn_code_cases (output_automata_list_state_alts_code); @@ -8748,7 +8645,7 @@ output_internal_state_alts_func () /* The function outputs PHR interface function `state_alts'. */ static void -output_state_alts_func () +output_state_alts_func (void) { fprintf (output_file, "int\n%s (%s, %s)\n\t%s %s;\n\trtx %s;\n", STATE_ALTS_FUNC_NAME, STATE_NAME, INSN_PARAMETER_NAME, @@ -8762,11 +8659,11 @@ output_state_alts_func () /* Output function `min_issue_delay'. */ static void -output_min_issue_delay_func () +output_min_issue_delay_func (void) { - fprintf (output_file, "int\n%s (%s, %s)\n\t%s %s;\n\trtx %s;\n", - MIN_ISSUE_DELAY_FUNC_NAME, STATE_NAME, INSN_PARAMETER_NAME, - STATE_TYPE_NAME, STATE_NAME, INSN_PARAMETER_NAME); + 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, @@ -8776,22 +8673,19 @@ output_min_issue_delay_func () fprintf (output_file, " }\n else\n %s = %s;\n", INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME); fprintf (output_file, "\n return %s (%s, %s);\n", - INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME, + INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME, STATE_NAME); fprintf (output_file, "}\n\n"); } /* Output function `internal_dead_lock'. */ static void -output_internal_dead_lock_func () +output_internal_dead_lock_func (void) { automaton_t automaton; - fprintf (output_file, "static int %s PARAMS ((struct %s *));\n", - INTERNAL_DEAD_LOCK_FUNC_NAME, CHIP_NAME); - fprintf (output_file, "static int\n%s (%s)\n\tstruct %s *%s;\n", - INTERNAL_DEAD_LOCK_FUNC_NAME, CHIP_PARAMETER_NAME, CHIP_NAME, - CHIP_PARAMETER_NAME); + fprintf (output_file, "static int\n%s (struct %s *%s)\n", + INTERNAL_DEAD_LOCK_FUNC_NAME, CHIP_NAME, CHIP_PARAMETER_NAME); fprintf (output_file, "{\n"); for (automaton = description->first_automaton; automaton != NULL; @@ -8808,56 +8702,51 @@ output_internal_dead_lock_func () /* The function outputs PHR interface function `state_dead_lock_p'. */ static void -output_dead_lock_func () +output_dead_lock_func (void) { - fprintf (output_file, "int\n%s (%s)\n\t%s %s;\n", - DEAD_LOCK_FUNC_NAME, STATE_NAME, STATE_TYPE_NAME, STATE_NAME); + fprintf (output_file, "int\n%s (%s %s)\n", + DEAD_LOCK_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME); fprintf (output_file, "{\n return %s (%s);\n}\n\n", INTERNAL_DEAD_LOCK_FUNC_NAME, STATE_NAME); } /* Output function `internal_reset'. */ static void -output_internal_reset_func () +output_internal_reset_func (void) { - fprintf (output_file, "static void %s PARAMS ((struct %s *));\n", - INTERNAL_RESET_FUNC_NAME, CHIP_NAME); - fprintf (output_file, "static void\n%s (%s)\n\tstruct %s *%s;\n", - INTERNAL_RESET_FUNC_NAME, CHIP_PARAMETER_NAME, - CHIP_NAME, CHIP_PARAMETER_NAME); + 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 () +output_size_func (void) { - fprintf (output_file, "int\n%s ()\n", SIZE_FUNC_NAME); + 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 () +output_reset_func (void) { - fprintf (output_file, "void\n%s (%s)\n\t %s %s;\n", - RESET_FUNC_NAME, STATE_NAME, STATE_TYPE_NAME, STATE_NAME); + fprintf (output_file, "void\n%s (%s %s)\n", + RESET_FUNC_NAME, STATE_TYPE_NAME, STATE_NAME); fprintf (output_file, "{\n %s (%s);\n}\n\n", INTERNAL_RESET_FUNC_NAME, STATE_NAME); } /* Output function `min_insn_conflict_delay'. */ static void -output_min_insn_conflict_delay_func () +output_min_insn_conflict_delay_func (void) { fprintf (output_file, - "int\n%s (%s, %s, %s)\n\t%s %s;\n\trtx %s;\n\trtx %s;\n", - MIN_INSN_CONFLICT_DELAY_FUNC_NAME, - STATE_NAME, INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME, - STATE_TYPE_NAME, STATE_NAME, - INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME); - fprintf (output_file, "{\n struct %s %s;\n int %s, %s;\n", + "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, @@ -8867,8 +8756,9 @@ output_min_insn_conflict_delay_func () 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, " if (%s (%s, &%s) > 0)\n abort ();\n", + 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); @@ -8877,74 +8767,105 @@ output_min_insn_conflict_delay_func () /* Output function `internal_insn_latency'. */ static void -output_internal_insn_latency_func () +output_internal_insn_latency_func (void) { decl_t decl; struct bypass_decl *bypass; - int i; + int i, j, col; + const char *tabletype = "unsigned char"; - fprintf (output_file, "static int %s PARAMS ((int, int, rtx, rtx));\n", - INTERNAL_INSN_LATENCY_FUNC_NAME); - fprintf (output_file, "static int\n%s (%s, %s, %s, %s)", + /* 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 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\tint %s;\n\tint %s;\n", - INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME); - fprintf (output_file, - "\trtx %s ATTRIBUTE_UNUSED;\n\trtx %s ATTRIBUTE_UNUSED;\n", - INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME); - fprintf (output_file, "{\n switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME); - for (i = 0; i < description->decls_num; i++) + fprintf (output_file, "{\n"); + + if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0) { - decl = description->decls [i]; - if (decl->mode == dm_insn_reserv) - { - fprintf (output_file, " case %d:\n", - DECL_INSN_RESERV (decl)->insn_num); - if (DECL_INSN_RESERV (decl)->bypass_list == NULL) - fprintf (output_file, " return (%s != %s ? %d : 0);\n", - INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME, - DECL_INSN_RESERV (decl)->default_latency); - else - { - fprintf (output_file, " switch (%s)\n {\n", - INTERNAL_INSN2_CODE_NAME); - for (bypass = DECL_INSN_RESERV (decl)->bypass_list; - bypass != NULL; - bypass = bypass->next) - { - fprintf (output_file, " case %d:\n", - bypass->in_insn_reserv->insn_num); - if (bypass->bypass_guard_name == NULL) - fprintf (output_file, " return %d;\n", - bypass->latency); - else - fprintf (output_file, - " return (%s (%s, %s) ? %d : %d);\n", - bypass->bypass_guard_name, INSN_PARAMETER_NAME, - INSN2_PARAMETER_NAME, bypass->latency, - DECL_INSN_RESERV (decl)->default_latency); - } - fprintf (output_file, " default:\n"); - fprintf (output_file, - " return (%s != %s ? %d : 0);\n }\n", - INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME, - DECL_INSN_RESERV (decl)->default_latency); - - } - } + fputs (" return 0;\n}\n\n", output_file); + return; } - fprintf (output_file, " default:\n return 0;\n }\n}\n\n"); + + 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); + + fprintf (output_file, " if (%s >= %s || %s >= %s)\n return 0;\n", + INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME, + INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME); + + fprintf (output_file, " switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME); + for (i = 0; i < description->decls_num; i++) + if (description->decls[i]->mode == dm_insn_reserv + && DECL_INSN_RESERV (description->decls[i])->bypass_list) + { + decl = description->decls [i]; + fprintf (output_file, + " case %d:\n switch (%s)\n {\n", + DECL_INSN_RESERV (decl)->insn_num, + INTERNAL_INSN2_CODE_NAME); + for (bypass = DECL_INSN_RESERV (decl)->bypass_list; + bypass != NULL; + bypass = bypass->next) + { + gcc_assert (bypass->in_insn_reserv->insn_num + != (DECL_INSN_RESERV + (advance_cycle_insn_decl)->insn_num)); + fprintf (output_file, " case %d:\n", + bypass->in_insn_reserv->insn_num); + if (bypass->bypass_guard_name == NULL) + fprintf (output_file, " return %d;\n", + bypass->latency); + else + { + fprintf (output_file, + " if (%s (%s, %s))\n", + bypass->bypass_guard_name, INSN_PARAMETER_NAME, + INSN2_PARAMETER_NAME); + fprintf (output_file, + " return %d;\n break;\n", + bypass->latency); + } + } + fputs (" }\n break;\n", output_file); + } + + fprintf (output_file, " }\n return default_latencies[%s];\n}\n\n", + INTERNAL_INSN_CODE_NAME); } /* The function outputs PHR interface function `insn_latency'. */ static void -output_insn_latency_func () +output_insn_latency_func (void) { - fprintf (output_file, "int\n%s (%s, %s)\n\trtx %s;\n\trtx %s;\n", - INSN_LATENCY_FUNC_NAME, INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME, - INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME); + 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, @@ -8959,54 +8880,67 @@ output_insn_latency_func () /* The function outputs PHR interface function `print_reservation'. */ static void -output_print_reservation_func () +output_print_reservation_func (void) { decl_t decl; - int i; + int i, j; - fprintf (output_file, "void\n%s (%s, %s)\n\tFILE *%s;\n\trtx %s;\n", + fprintf (output_file, + "void\n%s (FILE *%s, rtx %s ATTRIBUTE_UNUSED)\n{\n", PRINT_RESERVATION_FUNC_NAME, FILE_PARAMETER_NAME, - INSN_PARAMETER_NAME, FILE_PARAMETER_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", - INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME); - fprintf (output_file, " {\n fprintf (%s, \"%s\");\n", - FILE_PARAMETER_NAME, NOTHING_NAME); - fprintf (output_file, " return;\n }\n"); - fprintf (output_file, " }\n else\n"); - fprintf (output_file, - " {\n fprintf (%s, \"%s\");\n return;\n }\n", - FILE_PARAMETER_NAME, NOTHING_NAME); - fprintf (output_file, " switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME); - for (i = 0; i < description->decls_num; i++) + + 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) { - fprintf (output_file, - " case %d:\n", DECL_INSN_RESERV (decl)->insn_num); - fprintf (output_file, - " fprintf (%s, \"%s\");\n break;\n", - FILE_PARAMETER_NAME, - regexp_representation (DECL_INSN_RESERV (decl)->regexp)); - finish_regexp_representation (); - } + gcc_assert (j == DECL_INSN_RESERV (decl)->insn_num); + j++; + + fprintf (output_file, "\n \"%s\",", + regexp_representation (DECL_INSN_RESERV (decl)->regexp)); + finish_regexp_representation (); + } } - fprintf (output_file, " default:\n fprintf (%s, \"%s\");\n }\n", - FILE_PARAMETER_NAME, NOTHING_NAME); - fprintf (output_file, "}\n\n"); + 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 (unit1, unit2) - const void *unit1, *unit2; +units_cmp (const void *unit1, const void *unit2) { const unit_decl_t u1 = *(unit_decl_t *) unit1; const unit_decl_t u2 = *(unit_decl_t *) unit2; @@ -9035,22 +8969,20 @@ units_cmp (unit1, unit2) /* The following function outputs function to obtain internal cpu unit code by the cpu unit name. */ static void -output_get_cpu_unit_code_func () +output_get_cpu_unit_code_func (void) { int i; unit_decl_t *units; - - fprintf (output_file, "int\n%s (%s)\n\tconst char *%s;\n", - GET_CPU_UNIT_CODE_FUNC_NAME, CPU_UNIT_NAME_PARAMETER_NAME, - CPU_UNIT_NAME_PARAMETER_NAME); + + 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 = (unit_decl_t *) xmalloc (sizeof (unit_decl_t) - * description->units_num); + units = xmalloc (sizeof (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++) @@ -9086,15 +9018,15 @@ output_get_cpu_unit_code_func () unit (its internal code will be passed as the function argument) in given cpu state. */ static void -output_cpu_unit_reservation_p () +output_cpu_unit_reservation_p (void) { automaton_t automaton; - fprintf (output_file, "int\n%s (%s, %s)\n\t%s %s;\n\tint %s;\n", - CPU_UNIT_RESERVATION_P_FUNC_NAME, STATE_NAME, - CPU_CODE_PARAMETER_NAME, STATE_TYPE_NAME, STATE_NAME, + 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 if (%s < 0 || %s >= %d)\n abort ();\n", + fprintf (output_file, "{\n gcc_assert (%s >= 0 && %s < %d);\n", CPU_CODE_PARAMETER_NAME, CPU_CODE_PARAMETER_NAME, description->query_units_num); for (automaton = description->first_automaton; @@ -9115,10 +9047,10 @@ output_cpu_unit_reservation_p () /* The function outputs PHR interface function `dfa_clean_insn_cache'. */ static void -output_dfa_clean_insn_cache_func () +output_dfa_clean_insn_cache_func (void) { fprintf (output_file, - "void\n%s ()\n{\n int %s;\n\n", + "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", @@ -9129,21 +9061,21 @@ output_dfa_clean_insn_cache_func () /* The function outputs PHR interface function `dfa_start'. */ static void -output_dfa_start_func () +output_dfa_start_func (void) { fprintf (output_file, - "void\n%s ()\n{\n %s = get_max_uid ();\n", + "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 = (int *) xmalloc (%s * sizeof (int));\n", + fprintf (output_file, " %s = xmalloc (%s * sizeof (int));\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 () +output_dfa_finish_func (void) { - fprintf (output_file, "void\n%s ()\n{\n free (%s);\n}\n\n", + fprintf (output_file, "void\n%s (void)\n{\n free (%s);\n}\n\n", DFA_FINISH_FUNC_NAME, DFA_INSN_CODES_VARIABLE_NAME); } @@ -9154,8 +9086,7 @@ output_dfa_finish_func () /* The function outputs string representation of IR reservation. */ static void -output_regexp (regexp) - regexp_t regexp; +output_regexp (regexp_t regexp) { fprintf (output_description_file, "%s", regexp_representation (regexp)); finish_regexp_representation (); @@ -9163,8 +9094,7 @@ output_regexp (regexp) /* Output names of units in LIST separated by comma. */ static void -output_unit_set_el_list (list) - unit_set_el_t list; +output_unit_set_el_list (unit_set_el_t list) { unit_set_el_t el; @@ -9178,8 +9108,7 @@ output_unit_set_el_list (list) /* Output patterns in LIST separated by comma. */ static void -output_pattern_set_el_list (list) - pattern_set_el_t list; +output_pattern_set_el_list (pattern_set_el_t list) { pattern_set_el_t el; int i; @@ -9197,7 +9126,7 @@ output_pattern_set_el_list (list) /* The function outputs string representation of IR define_reservation and define_insn_reservation. */ static void -output_description () +output_description (void) { decl_t decl; int i; @@ -9227,8 +9156,8 @@ output_description () DECL_UNIT (decl)->name); output_pattern_set_el_list (DECL_UNIT (decl)->final_presence_list); - fprintf (output_description_file, "\n"); - } + fprintf (output_description_file, "\n"); + } if (DECL_UNIT (decl)->absence_list != NULL) { fprintf (output_description_file, "unit %s absence_set: ", @@ -9242,8 +9171,8 @@ output_description () 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"); + } } } fprintf (output_description_file, "\n"); @@ -9252,9 +9181,8 @@ output_description () decl = description->decls [i]; if (decl->mode == dm_reserv) { - fprintf (output_description_file, "reservation "); - fprintf (output_description_file, DECL_RESERV (decl)->name); - fprintf (output_description_file, ": "); + fprintf (output_description_file, "reservation %s: ", + DECL_RESERV (decl)->name); output_regexp (DECL_RESERV (decl)->regexp); fprintf (output_description_file, "\n"); } @@ -9279,9 +9207,7 @@ output_description () /* The function outputs name of AUTOMATON. */ static void -output_automaton_name (f, automaton) - FILE *f; - automaton_t automaton; +output_automaton_name (FILE *f, automaton_t automaton) { if (automaton->corresponding_automaton_decl == NULL) fprintf (f, "#%d", automaton->automaton_order_num); @@ -9295,8 +9221,7 @@ output_automaton_name (f, automaton) /* The function outputs units name belonging to AUTOMATON. */ static void -output_automaton_units (automaton) - automaton_t automaton; +output_automaton_units (automaton_t automaton) { decl_t decl; char *name; @@ -9304,7 +9229,7 @@ output_automaton_units (automaton) int there_is_an_automaton_unit; int i; - fprintf (output_description_file, "\n Coresponding units:\n"); + fprintf (output_description_file, "\n Corresponding units:\n"); fprintf (output_description_file, " "); curr_line_length = 4; there_is_an_automaton_unit = 0; @@ -9327,7 +9252,7 @@ output_automaton_units (automaton) curr_line_length += strlen (name) + 1; fprintf (output_description_file, " "); } - fprintf (output_description_file, name); + fprintf (output_description_file, "%s", name); } } if (!there_is_an_automaton_unit) @@ -9341,8 +9266,7 @@ static vla_ptr_t state_reservs; /* The function forms `state_reservs' for STATE. */ static void -add_state_reservs (state) - state_t state; +add_state_reservs (state_t state) { alt_state_t curr_alt_state; reserv_sets_t reservs; @@ -9362,8 +9286,7 @@ add_state_reservs (state) /* The function outputs readable representation of all out arcs of STATE. */ static void -output_state_arcs (state) - state_t state; +output_state_arcs (state_t state) { arc_t arc; ainsn_t ainsn; @@ -9373,8 +9296,7 @@ output_state_arcs (state) for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc)) { ainsn = arc->insn; - if (!ainsn->first_insn_with_same_reservs) - abort (); + 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); @@ -9400,7 +9322,7 @@ output_state_arcs (state) fprintf (output_description_file, ", "); } } - fprintf (output_description_file, insn_name); + fprintf (output_description_file, "%s", insn_name); ainsn = ainsn->next_same_reservs_insn; } while (ainsn != NULL); @@ -9413,9 +9335,7 @@ output_state_arcs (state) /* The following function is used for sorting possible cpu unit reservation of a DFA state. */ static int -state_reservs_cmp (reservs_ptr_1, reservs_ptr_2) - const void *reservs_ptr_1; - const void *reservs_ptr_2; +state_reservs_cmp (const void *reservs_ptr_1, const void *reservs_ptr_2) { return reserv_sets_cmp (*(reserv_sets_t *) reservs_ptr_1, *(reserv_sets_t *) reservs_ptr_2); @@ -9424,7 +9344,7 @@ state_reservs_cmp (reservs_ptr_1, reservs_ptr_2) /* The following function is used for sorting possible cpu unit reservation of a DFA state. */ static void -remove_state_duplicate_reservs () +remove_state_duplicate_reservs (void) { reserv_sets_t *reservs_ptr; reserv_sets_t *last_formed_reservs_ptr; @@ -9448,8 +9368,7 @@ remove_state_duplicate_reservs () described by possible (current and scheduled) cpu unit reservations. */ static void -output_state (state) - state_t state; +output_state (state_t state) { reserv_sets_t *reservs_ptr; @@ -9477,7 +9396,7 @@ output_state (state) /* The following function output readable representation of DFAs used for fast recognition of pipeline hazards. */ static void -output_automaton_descriptions () +output_automaton_descriptions (void) { automaton_t automaton; @@ -9501,8 +9420,7 @@ output_automaton_descriptions () /* The function outputs statistics about work of different phases of DFA generator. */ static void -output_statistics (f) - FILE *f; +output_statistics (FILE *f) { automaton_t automaton; int states_num; @@ -9553,7 +9471,7 @@ output_statistics (f) automaton->min_issue_delay_table_compression_factor); transition_comb_vect_els += VLA_HWINT_LENGTH (automaton->trans_table->comb_vect); - transition_full_vect_els + transition_full_vect_els += VLA_HWINT_LENGTH (automaton->trans_table->full_vect); state_alts_comb_vect_els += VLA_HWINT_LENGTH (automaton->state_alts_table->comb_vect); @@ -9581,8 +9499,7 @@ output_statistics (f) /* The function output times of work of different phases of DFA generator. */ static void -output_time_statistics (f) - FILE *f; +output_time_statistics (FILE *f) { fprintf (f, "\n transformation: "); print_active_time (f, transform_time); @@ -9608,7 +9525,7 @@ output_time_statistics (f) for fast recognition of pipeline hazards. No errors during checking must be fixed before this function call. */ static void -generate () +generate (void) { automata_num = split_argument; if (description->units_num < automata_num) @@ -9629,7 +9546,7 @@ generate () /* The following function creates insn attribute whose values are number alternatives in insn reservations. */ static void -make_insn_alts_attr () +make_insn_alts_attr (void) { int i, insn_num; decl_t decl; @@ -9653,12 +9570,11 @@ make_insn_alts_attr () insn_num++; } } - if (description->insns_num != insn_num + 1) - abort (); + gcc_assert (description->insns_num == insn_num + 1); make_internal_attr (attr_printf (sizeof ("*") + strlen (INSN_ALTS_FUNC_NAME) + 1, "*%s", INSN_ALTS_FUNC_NAME), - condexp, 0); + condexp, ATTR_NONE); } @@ -9666,7 +9582,7 @@ make_insn_alts_attr () /* The following function creates attribute which is order number of insn in pipeline hazard description translator. */ static void -make_internal_dfa_insn_code_attr () +make_internal_dfa_insn_code_attr (void) { int i, insn_num; decl_t decl; @@ -9689,13 +9605,12 @@ make_internal_dfa_insn_code_attr () insn_num++; } } - if (description->insns_num != insn_num + 1) - abort (); + gcc_assert (description->insns_num == insn_num + 1); make_internal_attr (attr_printf (sizeof ("*") + strlen (INTERNAL_DFA_INSN_CODE_FUNC_NAME) + 1, "*%s", INTERNAL_DFA_INSN_CODE_FUNC_NAME), - condexp, 0); + condexp, ATTR_STATIC); } @@ -9703,7 +9618,7 @@ make_internal_dfa_insn_code_attr () /* The following function creates attribute which order number of insn in pipeline hazard description translator. */ static void -make_default_insn_latency_attr () +make_default_insn_latency_attr (void) { int i, insn_num; decl_t decl; @@ -9724,12 +9639,11 @@ make_default_insn_latency_attr () insn_num++; } } - if (description->insns_num != insn_num + 1) - abort (); + gcc_assert (description->insns_num == insn_num + 1); make_internal_attr (attr_printf (sizeof ("*") + strlen (INSN_DEFAULT_LATENCY_FUNC_NAME) + 1, "*%s", INSN_DEFAULT_LATENCY_FUNC_NAME), - condexp, 0); + condexp, ATTR_NONE); } @@ -9737,13 +9651,13 @@ make_default_insn_latency_attr () /* The following function creates attribute which returns 1 if given output insn has bypassing and 0 otherwise. */ static void -make_bypass_attr () +make_bypass_attr (void) { int i, bypass_insn; int bypass_insns_num = 0; decl_t decl; rtx result_rtx; - + for (i = 0; i < description->decls_num; i++) { decl = description->decls [i]; @@ -9778,7 +9692,7 @@ make_bypass_attr () make_internal_attr (attr_printf (sizeof ("*") + strlen (BYPASS_P_FUNC_NAME) + 1, "*%s", BYPASS_P_FUNC_NAME), - result_rtx, 0); + result_rtx, ATTR_NONE); } @@ -9793,8 +9707,7 @@ make_bypass_attr () /* The function returns suffix of given file name. The returned string can not be changed. */ static const char * -file_name_suffix (file_name) - const char *file_name; +file_name_suffix (const char *file_name) { const char *last_period; @@ -9809,8 +9722,7 @@ file_name_suffix (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 (file_name) - const char *file_name; +base_file_name (const char *file_name) { int directory_name_length; @@ -9828,9 +9740,7 @@ base_file_name (file_name) /* The following is top level function to initialize the work of pipeline hazards description translator. */ void -initiate_automaton_gen (argc, argv) - int argc; - char **argv; +initiate_automaton_gen (int argc, char **argv) { const char *base_name; int i; @@ -9841,6 +9751,7 @@ initiate_automaton_gen (argc, argv) time_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; @@ -9852,6 +9763,8 @@ initiate_automaton_gen (argc, argv) 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) @@ -9880,7 +9793,7 @@ initiate_automaton_gen (argc, argv) /* The following function checks existence at least one arc marked by each insn. */ static void -check_automata_insn_issues () +check_automata_insn_issues (void) { automaton_t automaton; ainsn_t ainsn, reserv_ainsn; @@ -9929,8 +9842,7 @@ static vla_ptr_t automaton_states; /* This function is called by function pass_states to add an achieved STATE. */ static void -add_automaton_state (state) - state_t state; +add_automaton_state (state_t state) { VLA_PTR_ADD (automaton_states, state); } @@ -9938,7 +9850,7 @@ add_automaton_state (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 () +form_important_insn_automata_lists (void) { automaton_t automaton; state_t *state_ptr; @@ -9965,8 +9877,7 @@ form_important_insn_automata_lists () arc = next_out_arc (arc)) if (arc->to_state != *state_ptr) { - if (!arc->insn->first_insn_with_same_reservs) - abort (); + gcc_assert (arc->insn->first_insn_with_same_reservs); for (ainsn = arc->insn; ainsn != NULL; ainsn = ainsn->next_same_reservs_insn) @@ -10004,7 +9915,7 @@ form_important_insn_automata_lists () /* The following is top level function to generate automat(a,on) for fast recognition of pipeline hazards. */ void -expand_automata () +expand_automata (void) { int i; @@ -10023,10 +9934,11 @@ expand_automata () } all_time = create_ticker (); check_time = create_ticker (); - fprintf (stderr, "Check description..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "Check description..."); check_all_description (); - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); ticker_off (&check_time); generation_time = create_ticker (); if (!have_error) @@ -10042,37 +9954,41 @@ expand_automata () if (!have_error) { form_important_insn_automata_lists (); - fprintf (stderr, "Generation of attributes..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "Generation of attributes..."); make_internal_dfa_insn_code_attr (); make_insn_alts_attr (); make_default_insn_latency_attr (); make_bypass_attr (); - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); } ticker_off (&generation_time); ticker_off (&all_time); - fprintf (stderr, "All other genattrtab stuff..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "All other genattrtab stuff..."); } /* The following is top level function to output PHR and to finish work with pipeline description translator. */ void -write_automata () +write_automata (void) { - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); if (have_error) fatal ("Errors in DFA description"); ticker_on (&all_time); output_time = create_ticker (); - fprintf (stderr, "Forming and outputing automata tables..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "Forming and outputting automata tables..."); output_dfa_max_issue_rate (); output_tables (); - fprintf (stderr, "done\n"); - fprintf (stderr, "Output functions to work with automata..."); - fflush (stderr); + 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 (); @@ -10107,7 +10023,8 @@ write_automata () output_dfa_clean_insn_cache_func (); output_dfa_start_func (); output_dfa_finish_func (); - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); if (v_flag) { output_description_file = fopen (output_description_file_name, "w"); @@ -10116,11 +10033,12 @@ write_automata () perror (output_description_file_name); exit (FATAL_EXIT_CODE); } - fprintf (stderr, "Output automata description..."); - fflush (stderr); + if (progress_flag) + fprintf (stderr, "Output automata description..."); output_description (); output_automaton_descriptions (); - fprintf (stderr, "done\n"); + if (progress_flag) + fprintf (stderr, "done\n"); output_statistics (output_description_file); } output_statistics (stderr);