/* Pipeline hazard description translator.
- Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
Written by Vladimir Makarov <vmakarov@redhat.com>
-
-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.
`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:
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 store_alt_unit_usage PARAMS ((regexp_t, regexp_t, int, 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;
allocator when varray is used only. */
/* Start work with vla. */
-#define VLA_PTR_CREATE(vla, allocated_length, name) \
+#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 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'). */
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;
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. */
&(_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__); \
&(_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__); \
&(_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];
/* 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,
__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,
/* Create IR structure (node). */
static void *
-create_node (size)
- size_t size;
+create_node (size_t size)
{
void *result;
/* 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);
/* 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;
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;
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;
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)
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;
}
}
-/* 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;
}
}
-/* 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;
}
}
-/* 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;
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;
{
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;
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;
}
}
-/* 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));
}
/* Parse an element in STR. */
static regexp_t
-gen_regexp_el (str)
- char *str;
+gen_regexp_el (char *str)
{
regexp_t regexp;
int len;
/* 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;
/* 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;
/* 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;
/* 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;
/* Parse construction reservation STR. */
static regexp_t
-gen_regexp (str)
- char *str;
+gen_regexp (char *str)
{
reserv_str = str;
return gen_regexp_sequence (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;
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;
/* 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;
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);
}
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;
}
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;
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;
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,
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);
}
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);
}
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;
}
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;
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;
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,
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);
}
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
same key as given declaration node. */
static decl_t
-insert_decl (decl)
- decl_t decl;
+insert_decl (decl_t decl)
{
void **entry_ptr;
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;
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);
`initiate_declaration_table' is possible immediately after this
function call. */
static void
-finish_decl_table ()
+finish_decl_table (void)
{
htab_delete (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;
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;
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;
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;
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;
/* 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;
/* 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;
{
unit_set_el_t unit_set_el_list;
unit_set_el_t unit_set_el_list_2;
-
+
unit_set_el_list
= process_excls (DECL_EXCL (decl)->names,
DECL_EXCL (decl)->first_list_length, decl->pos);
{
unit_set_el_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,
{
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,
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;
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 <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
+ REGEXP_SEQUENCE (regexp)->regexps [i]
+ = process_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
+ break;
+ case rm_allof:
+ for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
+ REGEXP_ALLOF (regexp)->regexps [i]
+ = process_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
+ break;
+ case rm_oneof:
+ for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
+ REGEXP_ONEOF (regexp)->regexps [i]
+ = process_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
+ break;
+ case rm_repeat:
+ REGEXP_REPEAT (regexp)->regexp
+ = process_regexp (REGEXP_REPEAT (regexp)->regexp);
+ break;
+ case rm_nothing:
+ break;
+ default:
+ gcc_unreachable ();
}
- else if (regexp->mode == rm_sequence)
- for (i = 0; i <REGEXP_SEQUENCE (regexp)->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;
}
define_insn_reservation with the aid of function
`process_regexp'. */
static void
-process_regexp_decls ()
+process_regexp_decls (void)
{
decl_t decl;
int i;
following function must be called only after `process_decls',
`process_regexp_decls'. */
static void
-check_usage ()
+check_usage (void)
{
decl_t decl;
int i;
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;
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 <REGEXP_SEQUENCE (regexp)->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;
{
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);
}
/* 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
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,
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 <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
{
process_regexp_cycles (REGEXP_SEQUENCE (regexp)->regexps [i],
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;
/* The following function calls functions for checking all
description. */
static void
-check_all_description ()
+check_all_description (void)
{
process_decls ();
check_automaton_usage ();
/* The following function creates ticker and makes it active. */
static ticker_t
-create_ticker ()
+create_ticker (void)
{
ticker_t 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;
/* 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)
{
/* 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;
*/
static void
-print_active_time (f, ticker)
- FILE *f;
- ticker_t ticker;
+print_active_time (FILE *f, ticker_t ticker)
{
int msecs;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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)
/* 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;
/* 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)
/* 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)
{
}
/* Allocate new reservation set. */
static reserv_sets_t
-alloc_empty_reserv_sets ()
+alloc_empty_reserv_sets (void)
{
reserv_sets_t result;
/* 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;
/* 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;
/* 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;
}
/* 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);
}
/* 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);
}
/* 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--)
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++)
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++)
/* 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++)
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;
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;
}
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)
/* 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;
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);
/* 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);
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;
/* 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;
/* Insert STATE into the state table. */
static state_t
-insert_state (state)
- state_t state;
+insert_state (state_t state)
{
void **entry_ptr;
/* 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);
}
/* 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);
}
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);
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;
/* Initialization of the abstract data. */
static void
-initiate_states ()
+initiate_states (void)
{
decl_t decl;
int i;
/* Finishing work with the abstract data. */
static void
-finish_states ()
+finish_states (void)
{
VLA_PTR_DELETE (units_container);
htab_delete (state_table);
/* 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;
/* 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
/* 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;
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;
/* 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)
{
}
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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,
/* 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;
/* 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;
/* Finishing work with the abstract data. */
static void
-finish_automata_lists ()
+finish_automata_lists (void)
{
htab_delete (automata_list_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;
/* 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;
/* 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;
/* 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;
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;
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])
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;
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])
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 <REGEXP_SEQUENCE (regexp)->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;
}
/* 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;
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)
...+(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)
{
}
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
}
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
}
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
...+(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)
{
}
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));
}
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));
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;
{
allof_length = 0;
for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
- if (REGEXP_ALLOF (regexp)->regexps [j]->mode == rm_sequence
- && (i < (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
- ->regexps [j])->regexps_num)))
- {
- allof_op
- = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)->regexps [j])
- ->regexps [i]);
- allof_length++;
- }
- else if (i == 0
- && (REGEXP_ALLOF (regexp)->regexps [j]->mode
- == rm_unit
- || (REGEXP_ALLOF (regexp)->regexps [j]->mode
- == rm_nothing)))
+ switch (REGEXP_ALLOF (regexp)->regexps [j]->mode)
{
- 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
/* 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;
/* 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];
= 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);
}
\f
CYCLE in REGEXP alternative with ALT_NUM. The structure is made
accessed through cycle_alt_unit_usages. */
static void
-store_alt_unit_usage (regexp, unit, cycle, alt_num)
- regexp_t regexp;
- regexp_t unit;
- int cycle;
- int alt_num;
+store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle,
+ int alt_num)
{
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
- || alt_num >= REGEXP_ONEOF (regexp)->regexps_num)
- abort ();
+ gcc_assert (regexp && regexp->mode == rm_oneof
+ && alt_num < REGEXP_ONEOF (regexp)->regexps_num);
unit_decl = REGEXP_UNIT (unit)->unit_decl;
old_length = VLA_PTR_LENGTH (cycle_alt_unit_usages);
length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num;
/* 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, cycle;
regexp_t seq, allof, unit;
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)
- store_alt_unit_usage (regexp, unit, j, i);
- 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)
- store_alt_unit_usage (regexp, allof, j, i);
- else if (allof->mode != rm_nothing)
- abort ();
- }
- else if (seq->mode == rm_allof)
- for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
- {
- unit = REGEXP_ALLOF (seq)->regexps [k];
- if (unit->mode == rm_unit)
- store_alt_unit_usage (regexp, unit, 0, i);
- else if (unit->mode != rm_nothing)
- abort ();
- }
- else if (seq->mode == rm_unit)
- store_alt_unit_usage (regexp, seq, 0, i);
- else if (seq->mode != rm_nothing)
- abort ();
+ }
+ 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++)
/* 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++)
{
(DECL_INSN_RESERV (decl)->name,
DECL_INSN_RESERV (decl)->transformed_regexp);
}
- fprintf (stderr, "done\n");
+ if (progress_flag)
+ fprintf (stderr, "done\n");
}
\f
/* 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;
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;
}
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. */
/* 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;
/* 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;
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();
/* 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;
= 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)
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);
/* 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;
}
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;
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;
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;
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. */
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;
/* 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;
&state_stack))
{
states_n++;
- if (states_n % 100 == 0)
- fprintf (stderr, "*");
+ if (progress_flag && states_n % 100 == 0)
+ fprintf (stderr, ".");
}
}
}
/* 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;
/* 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);
/* The function initializes code for passing of all states. */
static void
-initiate_pass_states ()
+initiate_pass_states (void)
{
curr_state_graph_pass_num = 0;
}
/* 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);
}
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;
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;
}
/* 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;
/* 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;
/* 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
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;
/* 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;
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;
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)
/* 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;
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),
/* 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;
}
}
/* 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
/* 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;
/* 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;
/* 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;
/* 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;
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;
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;
/* 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++;
/* 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);
/* 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;
/* 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;
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;
/* 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;
/* 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;
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
{
/* 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;
/* 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))
/* 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;
{
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
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);
}
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;
/* 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];
/* 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;
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);
/* 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++)
{
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');
/* 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);
}
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");
`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))
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;
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;
/* 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;
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
/* 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);
}
/* Output definition of the structure representing current DFA(s)
state(s). */
static void
-output_chip_definitions ()
+output_chip_definitions (void)
{
automaton_t automaton;
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;
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)
/* 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));
/* 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;
/* 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))
{
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;
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;
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)
}
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)
/* 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;
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;
/* 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;
/* 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;
/* 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);
}
/* 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;
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);
}
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;
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,
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;
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);
/* 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;
}
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;
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);
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)
/* 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;
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
/* 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;
/* The function outputs all tables representing DFA(s) used for fast
pipeline hazards recognition. */
static void
-output_tables ()
+output_tables (void)
{
automaton_t automaton;
`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;
}
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);
}
/* 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;
/* 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;
/* 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);
/* 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;
/* 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);
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,
/* 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)
{
/* 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 dfa_insn_code_enlarge PARAMS ((int));\n\
static void\n\
-dfa_insn_code_enlarge (uid)\n\
- int uid;\n{\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_VARIABLE_NAME);
+ DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+ DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+ DFA_INSN_CODES_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
+ DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+ DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
+ DFA_INSN_CODES_VARIABLE_NAME);
fprintf (output_file, "\
-static inline int %s PARAMS ((rtx));\n\
-static inline int\n%s (%s)\n\
- rtx %s;\n{\n\
- int uid = INSN_UID (%s);\n\
- int %s;\n\n",
- DFA_INSN_CODE_FUNC_NAME, DFA_INSN_CODE_FUNC_NAME,
- INSN_PARAMETER_NAME, INSN_PARAMETER_NAME,
- INSN_PARAMETER_NAME,
- INTERNAL_INSN_CODE_NAME);
+static inline int\n%s (rtx %s)\n\
+{\n\
+ int uid = INSN_UID (%s);\n\
+ int %s;\n\n",
+ DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME,
+ INSN_PARAMETER_NAME, INTERNAL_INSN_CODE_NAME);
fprintf (output_file,
" if (uid >= %s)\n dfa_insn_code_enlarge (uid);\n\n",
/* 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);
/* 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;
/* 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);
/* 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,
/* 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,
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;
/* 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,
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);
/* 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;
{
decl = description->decls[i];
if (DECL_INSN_RESERV (decl)->default_latency > UCHAR_MAX
- && tabletype[0] != 'i') /* don't shrink it */
+ && 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 %s PARAMS ((int, int, rtx, rtx));\n",
- INTERNAL_INSN_LATENCY_FUNC_NAME);
- fprintf (output_file, "static int\n%s (%s, %s, %s, %s)",
+
+ 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 ATTRIBUTE_UNUSED;\n\tint %s ATTRIBUTE_UNUSED;\n",
- INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME);
- fprintf (output_file,
- "\trtx %s ATTRIBUTE_UNUSED;\n\trtx %s ATTRIBUTE_UNUSED;\n{\n",
- INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
+ fprintf (output_file, "{\n");
if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
{
if ((col = (col+1) % 8) == 0)
fputs ("\n ", output_file);
decl = description->decls[i];
- if (j++ != DECL_INSN_RESERV (decl)->insn_num)
- abort ();
+ gcc_assert (j++ == DECL_INSN_RESERV (decl)->insn_num);
fprintf (output_file, "% 4d,",
DECL_INSN_RESERV (decl)->default_latency);
}
- if (j != DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num)
- abort ();
+ 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",
bypass != NULL;
bypass = bypass->next)
{
- if (bypass->in_insn_reserv->insn_num
- == DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num)
- abort ();
+ 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)
/* 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,
/* The function outputs PHR interface function `print_reservation'. */
static void
-output_print_reservation_func ()
+output_print_reservation_func (void)
{
decl_t decl;
int i, j;
fprintf (output_file,
- "void\n%s (%s, %s)\n\tFILE *%s;\n\trtx %s ATTRIBUTE_UNUSED;\n{\n",
+ "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);
if (DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num == 0)
decl = description->decls [i];
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
{
- if (j++ != DECL_INSN_RESERV (decl)->insn_num)
- abort ();
+ 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 ();
}
}
- if (j != DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num)
- abort ();
-
+ 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);
/* 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;
/* 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++)
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;
/* 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",
/* 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);
}
/* 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 ();
/* 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;
/* 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;
/* 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;
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: ",
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");
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");
}
/* 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);
/* 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;
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;
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)
/* 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;
/* 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;
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);
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);
/* 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);
/* 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;
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;
/* 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;
/* 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;
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);
/* 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);
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)
/* 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;
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);
}
\f
/* 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;
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);
}
\f
/* 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;
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);
}
\f
/* 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];
make_internal_attr (attr_printf (sizeof ("*")
+ strlen (BYPASS_P_FUNC_NAME) + 1,
"*%s", BYPASS_P_FUNC_NAME),
- result_rtx, 0);
+ result_rtx, ATTR_NONE);
}
\f
/* 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;
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;
/* 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;
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;
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)
/* 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;
/* 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);
}
/* 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;
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)
/* 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;
}
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)
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 ();
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");
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);
OSDN Git Service
