9743 lines
312 KiB
C
9743 lines
312 KiB
C
/* Pipeline hazard description translator.
|
||
Copyright (C) 2000, 2001, 2002 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
|
||
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
|
||
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
|
||
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.
|
||
|
||
This article is a good start point to understand usage of finite
|
||
state automata for pipeline hazard recognizers. But I'd
|
||
recommend the 2nd article for more deep understanding.
|
||
|
||
2. Efficient Instruction Scheduling Using Finite State Automata:
|
||
V. Bala and N. Rubin, Proceedings of MICRO-28. This is the best
|
||
article about usage of finite state automata for pipeline hazard
|
||
recognizers.
|
||
|
||
The current implementation is different from the 2nd article in the
|
||
following:
|
||
|
||
1. New operator `|' (alternative) is permitted in functional unit
|
||
reservation which can be treated deterministicly and
|
||
non-deterministicly.
|
||
|
||
2. Possibility of usage of nondeterministic automata too.
|
||
|
||
3. Possibility to query functional unit reservations for given
|
||
automaton state.
|
||
|
||
4. Several constructions to describe impossible reservations
|
||
(`exclusion_set', `presence_set', and `absence_set').
|
||
|
||
5. No reverse automata are generated. Trace instruction scheduling
|
||
requires this. It can be easily added in the future if we
|
||
really need this.
|
||
|
||
6. Union of automaton states are not generated yet. It is planned
|
||
to be implemented. Such feature is needed to make more accurate
|
||
interlock insn scheduling to get state describing functional
|
||
unit reservation in a joint CFG point.
|
||
*/
|
||
|
||
/* This file code processes constructions of machine description file
|
||
which describes automaton used for recognition of processor pipeline
|
||
hazards by insn scheduler and can be used for other tasks (such as
|
||
VLIW insn packing.
|
||
|
||
The translator functions `gen_cpu_unit', `gen_query_cpu_unit',
|
||
`gen_bypass', `gen_excl_set', `gen_presence_set',
|
||
`gen_absence_set', `gen_automaton', `gen_automata_option',
|
||
`gen_reserv', `gen_insn_reserv' are called from file
|
||
`genattrtab.c'. They transform RTL constructions describing
|
||
automata in .md file into internal representation convenient for
|
||
further processing.
|
||
|
||
The translator major function `expand_automata' processes the
|
||
description internal representation into finite state automaton.
|
||
It can be divided on:
|
||
|
||
o checking correctness of the automaton pipeline description
|
||
(major function is `check_all_description').
|
||
|
||
o generating automaton (automata) from the description (major
|
||
function is `make_automaton').
|
||
|
||
o optional transformation of nondeterministic finite state
|
||
automata into deterministic ones if the alternative operator
|
||
`|' is treated nondeterministicly in the description (major
|
||
function is NDFA_to_DFA).
|
||
|
||
o optional minimization of the finite state automata by merging
|
||
equivalent automaton states (major function is `minimize_DFA').
|
||
|
||
o forming tables (some as comb vectors) and attributes
|
||
representing the automata (functions output_..._table).
|
||
|
||
Function `write_automata' outputs the created finite state
|
||
automaton as different tables and functions which works with the
|
||
automata to inquire automaton state and to change its state. These
|
||
function are used by gcc instruction scheduler and may be some
|
||
other gcc code. */
|
||
|
||
#include "hconfig.h"
|
||
#include "system.h"
|
||
#include "rtl.h"
|
||
#include "obstack.h"
|
||
#include "errors.h"
|
||
|
||
#include <math.h>
|
||
#include "hashtab.h"
|
||
#include "varray.h"
|
||
|
||
#ifndef CHAR_BIT
|
||
#define CHAR_BIT 8
|
||
#endif
|
||
|
||
#include "genattrtab.h"
|
||
|
||
/* Positions in machine description file. Now they are not used. But
|
||
they could be used in the future for better diagnostic messages. */
|
||
typedef int pos_t;
|
||
|
||
/* The following is element of vector of current (and planned in the
|
||
future) functional unit reservations. */
|
||
typedef unsigned HOST_WIDE_INT set_el_t;
|
||
|
||
/* Reservations of function units are represented by value of the following
|
||
type. */
|
||
typedef set_el_t *reserv_sets_t;
|
||
|
||
/* The following structure represents variable length array (vla) of
|
||
pointers and HOST WIDE INTs. We could be use only varray. But we
|
||
add new lay because we add elements very frequently and this could
|
||
stress OS allocator when varray is used only. */
|
||
typedef struct {
|
||
size_t length; /* current size of vla. */
|
||
varray_type varray; /* container for vla. */
|
||
} vla_ptr_t;
|
||
|
||
typedef vla_ptr_t vla_hwint_t;
|
||
|
||
/* The following structure describes a ticker. */
|
||
struct ticker
|
||
{
|
||
/* The following member value is time of the ticker creation with
|
||
taking into account time when the ticker is off. Active time of
|
||
the ticker is current time minus the value. */
|
||
int modified_creation_time;
|
||
/* The following member value is time (incremented by one) when the
|
||
ticker was off. Zero value means that now the ticker is on. */
|
||
int incremented_off_time;
|
||
};
|
||
|
||
/* The ticker is represented by the following type. */
|
||
typedef struct ticker ticker_t;
|
||
|
||
/* The following type describes elements of output vectors. */
|
||
typedef HOST_WIDE_INT vect_el_t;
|
||
|
||
/* Forward declaration of structures of internal representation of
|
||
pipeline description based on NDFA. */
|
||
|
||
struct unit_decl;
|
||
struct bypass_decl;
|
||
struct result_decl;
|
||
struct automaton_decl;
|
||
struct unit_rel_decl;
|
||
struct reserv_decl;
|
||
struct insn_reserv_decl;
|
||
struct decl;
|
||
struct unit_regexp;
|
||
struct result_regexp;
|
||
struct reserv_regexp;
|
||
struct nothing_regexp;
|
||
struct sequence_regexp;
|
||
struct repeat_regexp;
|
||
struct allof_regexp;
|
||
struct oneof_regexp;
|
||
struct regexp;
|
||
struct description;
|
||
struct unit_set_el;
|
||
struct state;
|
||
struct alt_state;
|
||
struct arc;
|
||
struct ainsn;
|
||
struct automaton;
|
||
struct state_ainsn_table;
|
||
|
||
/* The following typedefs are for brevity. */
|
||
typedef struct unit_decl *unit_decl_t;
|
||
typedef struct decl *decl_t;
|
||
typedef struct regexp *regexp_t;
|
||
typedef struct unit_set_el *unit_set_el_t;
|
||
typedef struct alt_state *alt_state_t;
|
||
typedef struct state *state_t;
|
||
typedef struct arc *arc_t;
|
||
typedef struct ainsn *ainsn_t;
|
||
typedef struct automaton *automaton_t;
|
||
typedef struct automata_list_el *automata_list_el_t;
|
||
typedef struct state_ainsn_table *state_ainsn_table_t;
|
||
|
||
|
||
/* Prototypes of functions gen_cpu_unit, gen_query_cpu_unit,
|
||
gen_bypass, gen_excl_set, gen_presence_set, gen_absence_set,
|
||
gen_automaton, gen_automata_option, gen_reserv, gen_insn_reserv,
|
||
initiate_automaton_gen, expand_automata, write_automata are
|
||
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 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 hashval_t 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 unit_set_el_t process_presence_absence
|
||
PARAMS ((char **, int, pos_t, int));
|
||
static void add_presence_absence PARAMS ((unit_set_el_t, unit_set_el_t,
|
||
pos_t, 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 int process_regexp_cycles PARAMS ((regexp_t, 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))
|
||
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))
|
||
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));
|
||
static state_t state_shift PARAMS ((state_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 void initiate_presence_absence_sets PARAMS ((void));
|
||
static reserv_sets_t get_presence_absence_set PARAMS ((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 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 process_unit_to_form_the_same_automaton_unit_lists
|
||
PARAMS ((regexp_t, regexp_t, int));
|
||
static void form_the_same_automaton_unit_lists_from_regexp PARAMS ((regexp_t));
|
||
static void form_the_same_automaton_unit_lists PARAMS ((void));
|
||
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 void make_automaton PARAMS ((automaton_t));
|
||
static void form_arcs_marked_by_insn PARAMS ((state_t));
|
||
static void 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 state_is_differed PARAMS ((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));
|
||
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_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_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));
|
||
|
||
/* Undefined position. */
|
||
static pos_t no_pos = 0;
|
||
|
||
/* All IR is stored in the following obstack. */
|
||
static struct obstack irp;
|
||
|
||
|
||
|
||
/* This page contains code for work with variable length array (vla)
|
||
of pointers. We could be use only varray. But we add new lay
|
||
because we add elements very frequently and this could stress OS
|
||
allocator when varray is used only. */
|
||
|
||
/* Start work with vla. */
|
||
#define VLA_PTR_CREATE(vla, allocated_length, name) \
|
||
do \
|
||
{ \
|
||
vla_ptr_t *const vla_ptr = &(vla); \
|
||
\
|
||
VARRAY_GENERIC_PTR_INIT (vla_ptr->varray, allocated_length, name);\
|
||
vla_ptr->length = 0; \
|
||
} \
|
||
while (0)
|
||
|
||
/* Finish work with the vla. */
|
||
#define VLA_PTR_DELETE(vla) VARRAY_FREE ((vla).varray)
|
||
|
||
/* Return start address of the vla. */
|
||
#define VLA_PTR_BEGIN(vla) ((void *) &VARRAY_GENERIC_PTR ((vla).varray, 0))
|
||
|
||
/* Address of the last element of the vla. Do not use side effects in
|
||
the macro argument. */
|
||
#define VLA_PTR_LAST(vla) (&VARRAY_GENERIC_PTR ((vla).varray, \
|
||
(vla).length - 1))
|
||
/* Nullify the vla. */
|
||
#define VLA_PTR_NULLIFY(vla) ((vla).length = 0)
|
||
|
||
/* Shorten the vla on given number bytes. */
|
||
#define VLA_PTR_SHORTEN(vla, n) ((vla).length -= (n))
|
||
|
||
/* Expand the vla on N elements. The values of new elements are
|
||
undefined. */
|
||
#define VLA_PTR_EXPAND(vla, n) \
|
||
do { \
|
||
vla_ptr_t *const expand_vla_ptr = &(vla); \
|
||
const size_t new_length = (n) + expand_vla_ptr->length; \
|
||
\
|
||
if (VARRAY_SIZE (expand_vla_ptr->varray) < new_length) \
|
||
VARRAY_GROW (expand_vla_ptr->varray, \
|
||
(new_length - expand_vla_ptr->length < 128 \
|
||
? expand_vla_ptr->length + 128 : new_length)); \
|
||
expand_vla_ptr->length = new_length; \
|
||
} while (0)
|
||
|
||
/* Add element to the end of the vla. */
|
||
#define VLA_PTR_ADD(vla, ptr) \
|
||
do { \
|
||
vla_ptr_t *const vla_ptr = &(vla); \
|
||
\
|
||
VLA_PTR_EXPAND (*vla_ptr, 1); \
|
||
VARRAY_GENERIC_PTR (vla_ptr->varray, vla_ptr->length - 1) = (ptr);\
|
||
} while (0)
|
||
|
||
/* Length of the vla in elements. */
|
||
#define VLA_PTR_LENGTH(vla) ((vla).length)
|
||
|
||
/* N-th element of the vla. */
|
||
#define VLA_PTR(vla, n) VARRAY_GENERIC_PTR ((vla).varray, n)
|
||
|
||
|
||
/* The following macros are analogous to the previous ones but for
|
||
VLAs of HOST WIDE INTs. */
|
||
|
||
#define VLA_HWINT_CREATE(vla, allocated_length, name) \
|
||
do { \
|
||
vla_hwint_t *const vla_ptr = &(vla); \
|
||
\
|
||
VARRAY_WIDE_INT_INIT (vla_ptr->varray, allocated_length, name); \
|
||
vla_ptr->length = 0; \
|
||
} while (0)
|
||
|
||
#define VLA_HWINT_DELETE(vla) VARRAY_FREE ((vla).varray)
|
||
|
||
#define VLA_HWINT_BEGIN(vla) (&VARRAY_WIDE_INT ((vla).varray, 0))
|
||
|
||
#define VLA_HWINT_NULLIFY(vla) ((vla).length = 0)
|
||
|
||
#define VLA_HWINT_EXPAND(vla, n) \
|
||
do { \
|
||
vla_hwint_t *const expand_vla_ptr = &(vla); \
|
||
const size_t new_length = (n) + expand_vla_ptr->length; \
|
||
\
|
||
if (VARRAY_SIZE (expand_vla_ptr->varray) < new_length) \
|
||
VARRAY_GROW (expand_vla_ptr->varray, \
|
||
(new_length - expand_vla_ptr->length < 128 \
|
||
? expand_vla_ptr->length + 128 : new_length)); \
|
||
expand_vla_ptr->length = new_length; \
|
||
} while (0)
|
||
|
||
#define VLA_HWINT_ADD(vla, ptr) \
|
||
do { \
|
||
vla_hwint_t *const vla_ptr = &(vla); \
|
||
\
|
||
VLA_HWINT_EXPAND (*vla_ptr, 1); \
|
||
VARRAY_WIDE_INT (vla_ptr->varray, vla_ptr->length - 1) = (ptr); \
|
||
} while (0)
|
||
|
||
#define VLA_HWINT_LENGTH(vla) ((vla).length)
|
||
|
||
#define VLA_HWINT(vla, n) VARRAY_WIDE_INT ((vla).varray, n)
|
||
|
||
|
||
|
||
/* Options with the following names can be set up in automata_option
|
||
construction. Because the strings occur more one time we use the
|
||
macros. */
|
||
|
||
#define NO_MINIMIZATION_OPTION "-no-minimization"
|
||
|
||
#define TIME_OPTION "-time"
|
||
|
||
#define V_OPTION "-v"
|
||
|
||
#define W_OPTION "-w"
|
||
|
||
#define NDFA_OPTION "-ndfa"
|
||
|
||
/* The following flags are set up by function `initiate_automaton_gen'. */
|
||
|
||
/* Make automata with nondeterministic reservation by insns (`-ndfa'). */
|
||
static int ndfa_flag;
|
||
|
||
/* Do not make minimization of DFA (`-no-minimization'). */
|
||
static int no_minimization_flag;
|
||
|
||
/* Value of this variable is number of automata being generated. The
|
||
actual number of automata may be less this value if there is not
|
||
sufficient number of units. This value is defined by argument of
|
||
option `-split' or by constructions automaton if the value is zero
|
||
(it is default value of the argument). */
|
||
static int split_argument;
|
||
|
||
/* Flag of output time statistics (`-time'). */
|
||
static int time_flag;
|
||
|
||
/* Flag of creation of description file which contains description of
|
||
result automaton and statistics information (`-v'). */
|
||
static int v_flag;
|
||
|
||
/* Flag of generating warning instead of error for non-critical errors
|
||
(`-w'). */
|
||
static int w_flag;
|
||
|
||
|
||
/* Output file for pipeline hazard recognizer (PHR) being generated.
|
||
The value is NULL if the file is not defined. */
|
||
static FILE *output_file;
|
||
|
||
/* Description file of PHR. The value is NULL if the file is not
|
||
created. */
|
||
static FILE *output_description_file;
|
||
|
||
/* PHR description file name. */
|
||
static char *output_description_file_name;
|
||
|
||
/* Value of the following variable is node representing description
|
||
being processed. This is start point of IR. */
|
||
static struct description *description;
|
||
|
||
|
||
|
||
/* This page contains description of IR structure (nodes). */
|
||
|
||
enum decl_mode
|
||
{
|
||
dm_unit,
|
||
dm_bypass,
|
||
dm_automaton,
|
||
dm_excl,
|
||
dm_presence,
|
||
dm_absence,
|
||
dm_reserv,
|
||
dm_insn_reserv
|
||
};
|
||
|
||
/* This describes define_cpu_unit and define_query_cpu_unit (see file
|
||
rtl.def). */
|
||
struct unit_decl
|
||
{
|
||
char *name;
|
||
/* NULL if the automaton name is absent. */
|
||
char *automaton_name;
|
||
/* If the following value is not zero, the cpu unit reservation is
|
||
described in define_query_cpu_unit. */
|
||
char query_p;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* The following field value is nonzero if the unit is used in an
|
||
regexp. */
|
||
char unit_is_used;
|
||
|
||
/* The following field value is used to form cyclic lists of units
|
||
which should be in the same automaton because the unit is
|
||
reserved not on all alternatives of a regexp on a cycle. */
|
||
unit_decl_t the_same_automaton_unit;
|
||
/* The following field is TRUE if we already reported that the unit
|
||
is not in the same automaton. */
|
||
int the_same_automaton_message_reported_p;
|
||
|
||
/* The following field value is order number (0, 1, ...) of given
|
||
unit. */
|
||
int unit_num;
|
||
/* The following field value is corresponding declaration of
|
||
automaton which was given in description. If the field value is
|
||
NULL then automaton in the unit declaration was absent. */
|
||
struct automaton_decl *automaton_decl;
|
||
/* The following field value is maximal cycle number (1, ...) on
|
||
which given unit occurs in insns. Zero value means that given
|
||
unit is not used in insns. */
|
||
int max_occ_cycle_num;
|
||
/* The following list contains units which conflict with given
|
||
unit. */
|
||
unit_set_el_t excl_list;
|
||
/* The following list contains units which are required to
|
||
reservation of given unit. */
|
||
unit_set_el_t presence_list;
|
||
/* The following list contains units which should be not present in
|
||
reservation for given unit. */
|
||
unit_set_el_t absence_list;
|
||
/* The following is used only when `query_p' has nonzero value.
|
||
This is query number for the unit. */
|
||
int query_num;
|
||
|
||
/* The following fields are defined by automaton generator. */
|
||
|
||
/* The following field value is number of the automaton to which
|
||
given unit belongs. */
|
||
int corresponding_automaton_num;
|
||
};
|
||
|
||
/* This describes define_bypass (see file rtl.def). */
|
||
struct bypass_decl
|
||
{
|
||
int latency;
|
||
char *out_insn_name;
|
||
char *in_insn_name;
|
||
char *bypass_guard_name;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* output and input insns of given bypass. */
|
||
struct insn_reserv_decl *out_insn_reserv;
|
||
struct insn_reserv_decl *in_insn_reserv;
|
||
/* The next bypass for given output insn. */
|
||
struct bypass_decl *next;
|
||
};
|
||
|
||
/* This describes define_automaton (see file rtl.def). */
|
||
struct automaton_decl
|
||
{
|
||
char *name;
|
||
|
||
/* The following fields are defined by automaton generator. */
|
||
|
||
/* The following field value is nonzero if the automaton is used in
|
||
an regexp definition. */
|
||
char automaton_is_used;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* The following field value is the corresponding automaton. This
|
||
field is not NULL only if the automaton is present in unit
|
||
declarations and the automatic partition on automata is not
|
||
used. */
|
||
automaton_t corresponding_automaton;
|
||
};
|
||
|
||
/* This describes unit relations: exclusion_set, presence_set, or
|
||
absence_set (see file rtl.def). */
|
||
struct unit_rel_decl
|
||
{
|
||
int names_num;
|
||
int first_list_length;
|
||
char *names [1];
|
||
};
|
||
|
||
/* This describes define_reservation (see file rtl.def). */
|
||
struct reserv_decl
|
||
{
|
||
char *name;
|
||
regexp_t regexp;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* The following field value is nonzero if the unit is used in an
|
||
regexp. */
|
||
char reserv_is_used;
|
||
/* The following field is used to check up cycle in expression
|
||
definition. */
|
||
int loop_pass_num;
|
||
};
|
||
|
||
/* This describes define_insn_reservartion (see file rtl.def). */
|
||
struct insn_reserv_decl
|
||
{
|
||
rtx condexp;
|
||
int default_latency;
|
||
regexp_t regexp;
|
||
char *name;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* The following field value is order number (0, 1, ...) of given
|
||
insn. */
|
||
int insn_num;
|
||
/* The following field value is list of bypasses in which given insn
|
||
is output insn. */
|
||
struct bypass_decl *bypass_list;
|
||
|
||
/* The following fields are defined by automaton generator. */
|
||
|
||
/* The following field is the insn regexp transformed that
|
||
the regexp has not optional regexp, repetition regexp, and an
|
||
reservation name (i.e. reservation identifiers are changed by the
|
||
corresponding regexp) and all alternations are the topest level
|
||
of the regexp. The value can be NULL only if it is special
|
||
insn `cycle advancing'. */
|
||
regexp_t transformed_regexp;
|
||
/* The following field value is list of arcs marked given
|
||
insn. The field is used in transfromation NDFA -> DFA. */
|
||
arc_t arcs_marked_by_insn;
|
||
/* The two following fields are used during minimization of a finite state
|
||
automaton. */
|
||
/* The field value is number of equivalence class of state into
|
||
which arc marked by given insn enters from a state (fixed during
|
||
an automaton minimization). */
|
||
int equiv_class_num;
|
||
/* The field value is state_alts of arc leaving a state (fixed
|
||
during an automaton minimization) and marked by given insn
|
||
enters. */
|
||
int state_alts;
|
||
/* The following member value is the list to automata which can be
|
||
changed by the insn issue. */
|
||
automata_list_el_t important_automata_list;
|
||
/* The following member is used to process insn once for output. */
|
||
int processed_p;
|
||
};
|
||
|
||
/* This contains a declaration mentioned above. */
|
||
struct decl
|
||
{
|
||
/* What node in the union? */
|
||
enum decl_mode mode;
|
||
pos_t pos;
|
||
union
|
||
{
|
||
struct unit_decl unit;
|
||
struct bypass_decl bypass;
|
||
struct automaton_decl automaton;
|
||
struct unit_rel_decl excl;
|
||
struct unit_rel_decl presence;
|
||
struct unit_rel_decl absence;
|
||
struct reserv_decl reserv;
|
||
struct insn_reserv_decl insn_reserv;
|
||
} decl;
|
||
};
|
||
|
||
/* The following structures represent parsed reservation strings. */
|
||
enum regexp_mode
|
||
{
|
||
rm_unit,
|
||
rm_reserv,
|
||
rm_nothing,
|
||
rm_sequence,
|
||
rm_repeat,
|
||
rm_allof,
|
||
rm_oneof
|
||
};
|
||
|
||
/* Cpu unit in reservation. */
|
||
struct unit_regexp
|
||
{
|
||
char *name;
|
||
unit_decl_t unit_decl;
|
||
};
|
||
|
||
/* Define_reservation in a reservation. */
|
||
struct reserv_regexp
|
||
{
|
||
char *name;
|
||
struct reserv_decl *reserv_decl;
|
||
};
|
||
|
||
/* Absence of reservation (represented by string `nothing'). */
|
||
struct nothing_regexp
|
||
{
|
||
/* This used to be empty but ISO C doesn't allow that. */
|
||
char unused;
|
||
};
|
||
|
||
/* Representation of reservations separated by ',' (see file
|
||
rtl.def). */
|
||
struct sequence_regexp
|
||
{
|
||
int regexps_num;
|
||
regexp_t regexps [1];
|
||
};
|
||
|
||
/* Representation of construction `repeat' (see file rtl.def). */
|
||
struct repeat_regexp
|
||
{
|
||
int repeat_num;
|
||
regexp_t regexp;
|
||
};
|
||
|
||
/* Representation of reservations separated by '+' (see file
|
||
rtl.def). */
|
||
struct allof_regexp
|
||
{
|
||
int regexps_num;
|
||
regexp_t regexps [1];
|
||
};
|
||
|
||
/* Representation of reservations separated by '|' (see file
|
||
rtl.def). */
|
||
struct oneof_regexp
|
||
{
|
||
int regexps_num;
|
||
regexp_t regexps [1];
|
||
};
|
||
|
||
/* Representation of a reservation string. */
|
||
struct regexp
|
||
{
|
||
/* What node in the union? */
|
||
enum regexp_mode mode;
|
||
pos_t pos;
|
||
union
|
||
{
|
||
struct unit_regexp unit;
|
||
struct reserv_regexp reserv;
|
||
struct nothing_regexp nothing;
|
||
struct sequence_regexp sequence;
|
||
struct repeat_regexp repeat;
|
||
struct allof_regexp allof;
|
||
struct oneof_regexp oneof;
|
||
} regexp;
|
||
};
|
||
|
||
/* Reperesents description of pipeline hazard description based on
|
||
NDFA. */
|
||
struct description
|
||
{
|
||
int decls_num;
|
||
|
||
/* The following fields are defined by checker. */
|
||
|
||
/* The following fields values are correspondingly number of all
|
||
units, query units, and insns in the description. */
|
||
int units_num;
|
||
int query_units_num;
|
||
int insns_num;
|
||
/* The following field value is max length (in cycles) of
|
||
reservations of insns. The field value is defined only for
|
||
correct programs. */
|
||
int max_insn_reserv_cycles;
|
||
|
||
/* The following fields are defined by automaton generator. */
|
||
|
||
/* The following field value is the first automaton. */
|
||
automaton_t first_automaton;
|
||
|
||
/* The following field is created by pipeline hazard parser and
|
||
contains all declarations. We allocate additional entry for
|
||
special insn "cycle advancing" which is added by the automaton
|
||
generator. */
|
||
decl_t decls [1];
|
||
};
|
||
|
||
|
||
|
||
/* The following nodes are created in automaton checker. */
|
||
|
||
/* The following nodes represent exclusion, presence, absence set for
|
||
cpu units. Each element are accessed through only one excl_list,
|
||
presence_list, absence_list. */
|
||
struct unit_set_el
|
||
{
|
||
unit_decl_t unit_decl;
|
||
unit_set_el_t next_unit_set_el;
|
||
};
|
||
|
||
|
||
|
||
/* The following nodes are created in automaton generator. */
|
||
|
||
/* The following node type describes state automaton. The state may
|
||
be deterministic or non-deterministic. Non-deterministic state has
|
||
several component states which represent alternative cpu units
|
||
reservations. The state also is used for describing a
|
||
deterministic reservation of automaton insn. */
|
||
struct state
|
||
{
|
||
/* The following member value is nonzero if there is a transition by
|
||
cycle advancing. */
|
||
int new_cycle_p;
|
||
/* The following field is list of processor unit reservations on
|
||
each cycle. */
|
||
reserv_sets_t reservs;
|
||
/* The following field is unique number of given state between other
|
||
states. */
|
||
int unique_num;
|
||
/* The following field value is automaton to which given state
|
||
belongs. */
|
||
automaton_t automaton;
|
||
/* The following field value is the first arc output from given
|
||
state. */
|
||
arc_t first_out_arc;
|
||
/* The following field is used to form NDFA. */
|
||
char it_was_placed_in_stack_for_NDFA_forming;
|
||
/* The following field is used to form DFA. */
|
||
char it_was_placed_in_stack_for_DFA_forming;
|
||
/* The following field is used to transform NDFA to DFA. The field
|
||
value is not NULL if the state is a compound state. In this case
|
||
the value of field `unit_sets_list' is NULL. All states in the
|
||
list are in the hash table. The list is formed through field
|
||
`next_sorted_alt_state'. */
|
||
alt_state_t component_states;
|
||
/* The following field is used for passing graph of states. */
|
||
int pass_num;
|
||
/* The list of states belonging to one equivalence class is formed
|
||
with the aid of the following field. */
|
||
state_t next_equiv_class_state;
|
||
/* The two following fields are used during minimization of a finite
|
||
state automaton. */
|
||
int equiv_class_num_1, equiv_class_num_2;
|
||
/* The following field is used during minimization of a finite state
|
||
automaton. The field value is state corresponding to equivalence
|
||
class to which given state belongs. */
|
||
state_t equiv_class_state;
|
||
/* The following field value is the order number of given state.
|
||
The states in final DFA is enumerated with the aid of the
|
||
following field. */
|
||
int order_state_num;
|
||
/* This member is used for passing states for searching minimal
|
||
delay time. */
|
||
int state_pass_num;
|
||
/* The following member is used to evaluate min issue delay of insn
|
||
for a state. */
|
||
int min_insn_issue_delay;
|
||
/* The following member is used to evaluate max issue rate of the
|
||
processor. The value of the member is maximal length of the path
|
||
from given state no containing arcs marked by special insn `cycle
|
||
advancing'. */
|
||
int longest_path_length;
|
||
};
|
||
|
||
/* The following macro is an initial value of member
|
||
`longest_path_length' of a state. */
|
||
#define UNDEFINED_LONGEST_PATH_LENGTH -1
|
||
|
||
/* Automaton arc. */
|
||
struct arc
|
||
{
|
||
/* The following field refers for the state into which given arc
|
||
enters. */
|
||
state_t to_state;
|
||
/* The following field describes that the insn issue (with cycle
|
||
advancing for special insn `cycle advancing' and without cycle
|
||
advancing for others) makes transition from given state to
|
||
another given state. */
|
||
ainsn_t insn;
|
||
/* The following field value is the next arc output from the same
|
||
state. */
|
||
arc_t next_out_arc;
|
||
/* List of arcs marked given insn is formed with the following
|
||
field. The field is used in transfromation NDFA -> DFA. */
|
||
arc_t next_arc_marked_by_insn;
|
||
/* The following field is defined if NDFA_FLAG is zero. The member
|
||
value is number of alternative reservations which can be used for
|
||
transition for given state by given insn. */
|
||
int state_alts;
|
||
};
|
||
|
||
/* The following node type describes a deterministic alternative in
|
||
non-deterministic state which characterizes cpu unit reservations
|
||
of automaton insn or which is part of NDFA. */
|
||
struct alt_state
|
||
{
|
||
/* The following field is a determinist state which characterizes
|
||
unit reservations of the instruction. */
|
||
state_t state;
|
||
/* The following field refers to the next state which characterizes
|
||
unit reservations of the instruction. */
|
||
alt_state_t next_alt_state;
|
||
/* The following field refers to the next state in sorted list. */
|
||
alt_state_t next_sorted_alt_state;
|
||
};
|
||
|
||
/* The following node type describes insn of automaton. They are
|
||
labels of FA arcs. */
|
||
struct ainsn
|
||
{
|
||
/* The following field value is the corresponding insn declaration
|
||
of description. */
|
||
struct insn_reserv_decl *insn_reserv_decl;
|
||
/* The following field value is the next insn declaration for an
|
||
automaton. */
|
||
ainsn_t next_ainsn;
|
||
/* The following field is states which characterize automaton unit
|
||
reservations of the instruction. The value can be NULL only if it
|
||
is special insn `cycle advancing'. */
|
||
alt_state_t alt_states;
|
||
/* The following field is sorted list of states which characterize
|
||
automaton unit reservations of the instruction. The value can be
|
||
NULL only if it is special insn `cycle advancing'. */
|
||
alt_state_t sorted_alt_states;
|
||
/* The following field refers the next automaton insn with
|
||
the same reservations. */
|
||
ainsn_t next_same_reservs_insn;
|
||
/* The following field is flag of the first automaton insn with the
|
||
same reservations in the declaration list. Only arcs marked such
|
||
insn is present in the automaton. This significantly decreases
|
||
memory requirements especially when several automata are
|
||
formed. */
|
||
char first_insn_with_same_reservs;
|
||
/* The following member has nonzero value if there is arc from state of
|
||
the automaton marked by the ainsn. */
|
||
char arc_exists_p;
|
||
/* Cyclic list of insns of an equivalence class is formed with the
|
||
aid of the following field. */
|
||
ainsn_t next_equiv_class_insn;
|
||
/* The following field value is nonzero if the insn declaration is
|
||
the first insn declaration with given equivalence number. */
|
||
char first_ainsn_with_given_equialence_num;
|
||
/* The following field is number of class of equivalence of insns.
|
||
It is necessary because many insns may be equivalent with the
|
||
point of view of pipeline hazards. */
|
||
int insn_equiv_class_num;
|
||
/* The following member value is TRUE if there is an arc in the
|
||
automaton marked by the insn into another state. In other
|
||
words, the insn can change the state of the automaton. */
|
||
int important_p;
|
||
};
|
||
|
||
/* The folowing describes an automaton for PHR. */
|
||
struct automaton
|
||
{
|
||
/* The following field value is the list of insn declarations for
|
||
given automaton. */
|
||
ainsn_t ainsn_list;
|
||
/* The following field value is the corresponding automaton
|
||
declaration. This field is not NULL only if the automatic
|
||
partition on automata is not used. */
|
||
struct automaton_decl *corresponding_automaton_decl;
|
||
/* The following field value is the next automaton. */
|
||
automaton_t next_automaton;
|
||
/* The following field is start state of FA. There are not unit
|
||
reservations in the state. */
|
||
state_t start_state;
|
||
/* The following field value is number of equivalence classes of
|
||
insns (see field `insn_equiv_class_num' in
|
||
`insn_reserv_decl'). */
|
||
int insn_equiv_classes_num;
|
||
/* The following field value is number of states of final DFA. */
|
||
int achieved_states_num;
|
||
/* The following field value is the order number (0, 1, ...) of
|
||
given automaton. */
|
||
int automaton_order_num;
|
||
/* The following fields contain statistics information about
|
||
building automaton. */
|
||
int NDFA_states_num, DFA_states_num;
|
||
/* The following field value is defined only if minimization of DFA
|
||
is used. */
|
||
int minimal_DFA_states_num;
|
||
int NDFA_arcs_num, DFA_arcs_num;
|
||
/* The following field value is defined only if minimization of DFA
|
||
is used. */
|
||
int minimal_DFA_arcs_num;
|
||
/* The following two members refer for two table state x ainsn ->
|
||
int. */
|
||
state_ainsn_table_t trans_table;
|
||
state_ainsn_table_t state_alts_table;
|
||
/* The following member value is maximal value of min issue delay
|
||
for insns of the automaton. */
|
||
int max_min_delay;
|
||
/* Usually min issue delay is small and we can place several (2, 4,
|
||
8) elements in one vector element. So the compression factor can
|
||
be 1 (no compression), 2, 4, 8. */
|
||
int min_issue_delay_table_compression_factor;
|
||
};
|
||
|
||
/* The following is the element of the list of automata. */
|
||
struct automata_list_el
|
||
{
|
||
/* The automaton itself. */
|
||
automaton_t automaton;
|
||
/* The next automata set element. */
|
||
automata_list_el_t next_automata_list_el;
|
||
};
|
||
|
||
/* The following structure describes a table state X ainsn -> int(>= 0). */
|
||
struct state_ainsn_table
|
||
{
|
||
/* Automaton to which given table belongs. */
|
||
automaton_t automaton;
|
||
/* The following tree vectors for comb vector implementation of the
|
||
table. */
|
||
vla_hwint_t comb_vect;
|
||
vla_hwint_t check_vect;
|
||
vla_hwint_t base_vect;
|
||
/* This is simple implementation of the table. */
|
||
vla_hwint_t full_vect;
|
||
/* Minimal and maximal values of the previous vectors. */
|
||
int min_comb_vect_el_value, max_comb_vect_el_value;
|
||
int min_base_vect_el_value, max_base_vect_el_value;
|
||
};
|
||
|
||
/* Macros to access members of unions. Use only them for access to
|
||
union members of declarations and regexps. */
|
||
|
||
#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
|
||
|
||
#define DECL_UNIT(d) __extension__ \
|
||
(({ struct decl *const _decl = (d); \
|
||
if (_decl->mode != dm_unit) \
|
||
decl_mode_check_failed (_decl->mode, "dm_unit", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.unit; }))
|
||
|
||
#define DECL_BYPASS(d) __extension__ \
|
||
(({ struct decl *const _decl = (d); \
|
||
if (_decl->mode != dm_bypass) \
|
||
decl_mode_check_failed (_decl->mode, "dm_bypass", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.bypass; }))
|
||
|
||
#define DECL_AUTOMATON(d) __extension__ \
|
||
(({ 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); \
|
||
if (_decl->mode != dm_excl) \
|
||
decl_mode_check_failed (_decl->mode, "dm_excl", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.excl; }))
|
||
|
||
#define DECL_PRESENCE(d) __extension__ \
|
||
(({ struct decl *const _decl = (d); \
|
||
if (_decl->mode != dm_presence) \
|
||
decl_mode_check_failed (_decl->mode, "dm_presence", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.presence; }))
|
||
|
||
#define DECL_ABSENCE(d) __extension__ \
|
||
(({ struct decl *const _decl = (d); \
|
||
if (_decl->mode != dm_absence) \
|
||
decl_mode_check_failed (_decl->mode, "dm_absence", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.absence; }))
|
||
|
||
#define DECL_RESERV(d) __extension__ \
|
||
(({ struct decl *const _decl = (d); \
|
||
if (_decl->mode != dm_reserv) \
|
||
decl_mode_check_failed (_decl->mode, "dm_reserv", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_decl)->decl.reserv; }))
|
||
|
||
#define DECL_INSN_RESERV(d) __extension__ \
|
||
(({ 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 *));
|
||
|
||
/* Return string representation of declaration mode MODE. */
|
||
static const char *
|
||
decl_name (mode)
|
||
enum decl_mode mode;
|
||
{
|
||
static char str [100];
|
||
|
||
if (mode == dm_unit)
|
||
return "dm_unit";
|
||
else if (mode == dm_bypass)
|
||
return "dm_bypass";
|
||
else if (mode == dm_automaton)
|
||
return "dm_automaton";
|
||
else if (mode == dm_excl)
|
||
return "dm_excl";
|
||
else if (mode == dm_presence)
|
||
return "dm_presence";
|
||
else if (mode == dm_absence)
|
||
return "dm_absence";
|
||
else if (mode == dm_reserv)
|
||
return "dm_reserv";
|
||
else if (mode == dm_insn_reserv)
|
||
return "dm_insn_reserv";
|
||
else
|
||
sprintf (str, "unknown (%d)", (int) mode);
|
||
return str;
|
||
}
|
||
|
||
/* The function prints message about unexpected declaration and finish
|
||
the program. */
|
||
static void
|
||
decl_mode_check_failed (mode, expected_mode_str, file, line, func)
|
||
enum decl_mode mode;
|
||
const char *expected_mode_str;
|
||
const char *file;
|
||
int line;
|
||
const char *func;
|
||
{
|
||
fprintf
|
||
(stderr,
|
||
"\n%s: %d: error in %s: DECL check: expected decl %s, have %s\n",
|
||
file, line, func, expected_mode_str, decl_name (mode));
|
||
exit (1);
|
||
}
|
||
|
||
|
||
#define REGEXP_UNIT(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_unit) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_unit", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.unit; }))
|
||
|
||
#define REGEXP_RESERV(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_reserv) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_reserv", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.reserv; }))
|
||
|
||
#define REGEXP_SEQUENCE(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_sequence) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_sequence", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.sequence; }))
|
||
|
||
#define REGEXP_REPEAT(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_repeat) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_repeat", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.repeat; }))
|
||
|
||
#define REGEXP_ALLOF(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_allof) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_allof", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.allof; }))
|
||
|
||
#define REGEXP_ONEOF(r) __extension__ \
|
||
(({ struct regexp *const _regexp = (r); \
|
||
if (_regexp->mode != rm_oneof) \
|
||
regexp_mode_check_failed (_regexp->mode, "rm_oneof", \
|
||
__FILE__, __LINE__, __FUNCTION__); \
|
||
&(_regexp)->regexp.oneof; }))
|
||
|
||
static const char *regexp_name PARAMS ((enum regexp_mode));
|
||
static void regexp_mode_check_failed PARAMS ((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;
|
||
{
|
||
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;
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
fprintf
|
||
(stderr,
|
||
"\n%s: %d: error in %s: REGEXP check: expected decl %s, have %s\n",
|
||
file, line, func, expected_mode_str, regexp_name (mode));
|
||
exit (1);
|
||
}
|
||
|
||
#else /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
|
||
|
||
#define DECL_UNIT(d) (&(d)->decl.unit)
|
||
#define DECL_BYPASS(d) (&(d)->decl.bypass)
|
||
#define DECL_AUTOMATON(d) (&(d)->decl.automaton)
|
||
#define DECL_EXCL(d) (&(d)->decl.excl)
|
||
#define DECL_PRESENCE(d) (&(d)->decl.presence)
|
||
#define DECL_ABSENCE(d) (&(d)->decl.absence)
|
||
#define DECL_RESERV(d) (&(d)->decl.reserv)
|
||
#define DECL_INSN_RESERV(d) (&(d)->decl.insn_reserv)
|
||
|
||
#define REGEXP_UNIT(r) (&(r)->regexp.unit)
|
||
#define REGEXP_RESERV(r) (&(r)->regexp.reserv)
|
||
#define REGEXP_SEQUENCE(r) (&(r)->regexp.sequence)
|
||
#define REGEXP_REPEAT(r) (&(r)->regexp.repeat)
|
||
#define REGEXP_ALLOF(r) (&(r)->regexp.allof)
|
||
#define REGEXP_ONEOF(r) (&(r)->regexp.oneof)
|
||
|
||
#endif /* #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007) */
|
||
|
||
/* Create IR structure (node). */
|
||
static void *
|
||
create_node (size)
|
||
size_t size;
|
||
{
|
||
void *result;
|
||
|
||
obstack_blank (&irp, size);
|
||
result = obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
/* Default values of members are NULL and zero. */
|
||
memset (result, 0, size);
|
||
return result;
|
||
}
|
||
|
||
/* Copy IR structure (node). */
|
||
static void *
|
||
copy_node (from, size)
|
||
const void *from;
|
||
size_t size;
|
||
{
|
||
void *const result = create_node (size);
|
||
memcpy (result, from, size);
|
||
return result;
|
||
}
|
||
|
||
/* The function checks that NAME does not contain quotes (`"'). */
|
||
static char *
|
||
check_name (name, pos)
|
||
char * name;
|
||
pos_t pos ATTRIBUTE_UNUSED;
|
||
{
|
||
const char *str;
|
||
|
||
for (str = name; *str != '\0'; str++)
|
||
if (*str == '\"')
|
||
error ("Name `%s' contains quotes", name);
|
||
return name;
|
||
}
|
||
|
||
/* Pointers top all declartions during IR generation are stored in the
|
||
following. */
|
||
static vla_ptr_t decls;
|
||
|
||
/* Given a pointer to a (char *) and a separator, return an alloc'ed
|
||
string containing the next separated element, taking parentheses
|
||
into account if PAR_FLAG has nonzero value. Advance the pointer to
|
||
after the string scanned, or the end-of-string. Return NULL if at
|
||
end of string. */
|
||
static char *
|
||
next_sep_el (pstr, sep, par_flag)
|
||
char **pstr;
|
||
int sep;
|
||
int par_flag;
|
||
{
|
||
char *out_str;
|
||
char *p;
|
||
int pars_num;
|
||
int n_spaces;
|
||
|
||
/* Remove leading whitespaces. */
|
||
while (ISSPACE ((int) **pstr))
|
||
(*pstr)++;
|
||
|
||
if (**pstr == '\0')
|
||
return NULL;
|
||
|
||
n_spaces = 0;
|
||
for (pars_num = 0, p = *pstr; *p != '\0'; p++)
|
||
{
|
||
if (par_flag && *p == '(')
|
||
pars_num++;
|
||
else if (par_flag && *p == ')')
|
||
pars_num--;
|
||
else if (pars_num == 0 && *p == sep)
|
||
break;
|
||
if (pars_num == 0 && ISSPACE ((int) *p))
|
||
n_spaces++;
|
||
else
|
||
{
|
||
for (; n_spaces != 0; n_spaces--)
|
||
obstack_1grow (&irp, p [-n_spaces]);
|
||
obstack_1grow (&irp, *p);
|
||
}
|
||
}
|
||
obstack_1grow (&irp, '\0');
|
||
out_str = obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
|
||
*pstr = p;
|
||
if (**pstr == sep)
|
||
(*pstr)++;
|
||
|
||
return out_str;
|
||
}
|
||
|
||
/* Given a string and a separator, return the number of separated
|
||
elements in it, taking parentheses into account if PAR_FLAG has
|
||
nonzero value. Return 0 for the null string, -1 if parantheses is
|
||
not balanced. */
|
||
static int
|
||
n_sep_els (s, sep, par_flag)
|
||
char *s;
|
||
int sep;
|
||
int par_flag;
|
||
{
|
||
int n;
|
||
int pars_num;
|
||
|
||
if (*s == '\0')
|
||
return 0;
|
||
|
||
for (pars_num = 0, n = 1; *s; s++)
|
||
if (par_flag && *s == '(')
|
||
pars_num++;
|
||
else if (par_flag && *s == ')')
|
||
pars_num--;
|
||
else if (pars_num == 0 && *s == sep)
|
||
n++;
|
||
|
||
return (pars_num != 0 ? -1 : n);
|
||
}
|
||
|
||
/* Given a string and a separator, return vector of strings which are
|
||
elements in the string and number of elements through els_num.
|
||
Take parentheses into account if PAR_FLAG has nonzero value.
|
||
Return 0 for the null string, -1 if parantheses are not balanced. */
|
||
static char **
|
||
get_str_vect (str, els_num, sep, par_flag)
|
||
char *str;
|
||
int *els_num;
|
||
int sep;
|
||
int par_flag;
|
||
{
|
||
int i;
|
||
char **vect;
|
||
char **pstr;
|
||
|
||
*els_num = n_sep_els (str, sep, par_flag);
|
||
if (*els_num <= 0)
|
||
return NULL;
|
||
obstack_blank (&irp, sizeof (char *) * (*els_num));
|
||
vect = (char **) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
pstr = &str;
|
||
for (i = 0; i < *els_num; i++)
|
||
vect [i] = next_sep_el (pstr, sep, par_flag);
|
||
if (next_sep_el (pstr, sep, par_flag) != NULL)
|
||
abort ();
|
||
return vect;
|
||
}
|
||
|
||
/* Process a DEFINE_CPU_UNIT.
|
||
|
||
This gives information about a unit contained in CPU. We fill a
|
||
struct unit_decl with information used later by `expand_automata'. */
|
||
void
|
||
gen_cpu_unit (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
char **str_cpu_units;
|
||
int vect_length;
|
||
int i;
|
||
|
||
str_cpu_units = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',', 0);
|
||
if (str_cpu_units == NULL)
|
||
fatal ("invalid string `%s' in define_cpu_unit", XSTR (def, 0));
|
||
for (i = 0; i < vect_length; i++)
|
||
{
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_unit;
|
||
decl->pos = 0;
|
||
DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
|
||
DECL_UNIT (decl)->automaton_name = (char *) XSTR (def, 1);
|
||
DECL_UNIT (decl)->query_p = 0;
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
decl_t decl;
|
||
char **str_cpu_units;
|
||
int vect_length;
|
||
int i;
|
||
|
||
str_cpu_units = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',', 0);
|
||
if (str_cpu_units == NULL)
|
||
fatal ("invalid string `%s' in define_query_cpu_unit", XSTR (def, 0));
|
||
for (i = 0; i < vect_length; i++)
|
||
{
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_unit;
|
||
decl->pos = 0;
|
||
DECL_UNIT (decl)->name = check_name (str_cpu_units [i], decl->pos);
|
||
DECL_UNIT (decl)->automaton_name = (char *) XSTR (def, 1);
|
||
DECL_UNIT (decl)->query_p = 1;
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
decl_t decl;
|
||
char **out_insns;
|
||
int out_length;
|
||
char **in_insns;
|
||
int in_length;
|
||
int i, j;
|
||
|
||
out_insns = get_str_vect ((char *) XSTR (def, 1), &out_length, ',', 0);
|
||
if (out_insns == NULL)
|
||
fatal ("invalid string `%s' in define_bypass", XSTR (def, 1));
|
||
in_insns = get_str_vect ((char *) XSTR (def, 2), &in_length, ',', 0);
|
||
if (in_insns == NULL)
|
||
fatal ("invalid string `%s' in define_bypass", XSTR (def, 2));
|
||
for (i = 0; i < out_length; i++)
|
||
for (j = 0; j < in_length; j++)
|
||
{
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_bypass;
|
||
decl->pos = 0;
|
||
DECL_BYPASS (decl)->latency = XINT (def, 0);
|
||
DECL_BYPASS (decl)->out_insn_name = out_insns [i];
|
||
DECL_BYPASS (decl)->in_insn_name = in_insns [j];
|
||
DECL_BYPASS (decl)->bypass_guard_name = (char *) XSTR (def, 3);
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
}
|
||
|
||
/* Process an EXCLUSION_SET.
|
||
|
||
This gives information about a cpu unit conflicts. We fill a
|
||
struct unit_rel_decl (excl) with information used later by
|
||
`expand_automata'. */
|
||
void
|
||
gen_excl_set (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
char **first_str_cpu_units;
|
||
char **second_str_cpu_units;
|
||
int first_vect_length;
|
||
int length;
|
||
int i;
|
||
|
||
first_str_cpu_units
|
||
= get_str_vect ((char *) XSTR (def, 0), &first_vect_length, ',', 0);
|
||
if (first_str_cpu_units == NULL)
|
||
fatal ("invalid first string `%s' in exclusion_set", XSTR (def, 0));
|
||
second_str_cpu_units = get_str_vect ((char *) XSTR (def, 1), &length, ',',
|
||
0);
|
||
if (second_str_cpu_units == NULL)
|
||
fatal ("invalid second string `%s' in exclusion_set", XSTR (def, 1));
|
||
length += first_vect_length;
|
||
decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
|
||
decl->mode = dm_excl;
|
||
decl->pos = 0;
|
||
DECL_EXCL (decl)->names_num = length;
|
||
DECL_EXCL (decl)->first_list_length = first_vect_length;
|
||
for (i = 0; i < length; i++)
|
||
if (i < first_vect_length)
|
||
DECL_EXCL (decl)->names [i] = first_str_cpu_units [i];
|
||
else
|
||
DECL_EXCL (decl)->names [i]
|
||
= second_str_cpu_units [i - first_vect_length];
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
/* Process a PRESENCE_SET.
|
||
|
||
This gives information about a cpu unit reservation requirements.
|
||
We fill a struct unit_rel_decl (presence) with information used
|
||
later by `expand_automata'. */
|
||
void
|
||
gen_presence_set (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
char **first_str_cpu_units;
|
||
char **second_str_cpu_units;
|
||
int first_vect_length;
|
||
int length;
|
||
int i;
|
||
|
||
first_str_cpu_units
|
||
= get_str_vect ((char *) XSTR (def, 0), &first_vect_length, ',', 0);
|
||
if (first_str_cpu_units == NULL)
|
||
fatal ("invalid first string `%s' in presence_set", XSTR (def, 0));
|
||
second_str_cpu_units = get_str_vect ((char *) XSTR (def, 1), &length, ',',
|
||
0);
|
||
if (second_str_cpu_units == NULL)
|
||
fatal ("invalid second string `%s' in presence_set", XSTR (def, 1));
|
||
length += first_vect_length;
|
||
decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
|
||
decl->mode = dm_presence;
|
||
decl->pos = 0;
|
||
DECL_PRESENCE (decl)->names_num = length;
|
||
DECL_PRESENCE (decl)->first_list_length = first_vect_length;
|
||
for (i = 0; i < length; i++)
|
||
if (i < first_vect_length)
|
||
DECL_PRESENCE (decl)->names [i] = first_str_cpu_units [i];
|
||
else
|
||
DECL_PRESENCE (decl)->names [i]
|
||
= second_str_cpu_units [i - first_vect_length];
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
/* Process an ABSENCE_SET.
|
||
|
||
This gives information about a cpu unit reservation requirements.
|
||
We fill a struct unit_rel_decl (absence) with information used
|
||
later by `expand_automata'. */
|
||
void
|
||
gen_absence_set (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
char **first_str_cpu_units;
|
||
char **second_str_cpu_units;
|
||
int first_vect_length;
|
||
int length;
|
||
int i;
|
||
|
||
first_str_cpu_units
|
||
= get_str_vect ((char *) XSTR (def, 0), &first_vect_length, ',', 0);
|
||
if (first_str_cpu_units == NULL)
|
||
fatal ("invalid first string `%s' in absence_set", XSTR (def, 0));
|
||
second_str_cpu_units = get_str_vect ((char *) XSTR (def, 1), &length, ',',
|
||
0);
|
||
if (second_str_cpu_units == NULL)
|
||
fatal ("invalid second string `%s' in absence_set", XSTR (def, 1));
|
||
length += first_vect_length;
|
||
decl = create_node (sizeof (struct decl) + (length - 1) * sizeof (char *));
|
||
decl->mode = dm_absence;
|
||
decl->pos = 0;
|
||
DECL_ABSENCE (decl)->names_num = length;
|
||
DECL_ABSENCE (decl)->first_list_length = first_vect_length;
|
||
for (i = 0; i < length; i++)
|
||
if (i < first_vect_length)
|
||
DECL_ABSENCE (decl)->names [i] = first_str_cpu_units [i];
|
||
else
|
||
DECL_ABSENCE (decl)->names [i]
|
||
= second_str_cpu_units [i - first_vect_length];
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
decl_t decl;
|
||
char **str_automata;
|
||
int vect_length;
|
||
int i;
|
||
|
||
str_automata = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',', 0);
|
||
if (str_automata == NULL)
|
||
fatal ("invalid string `%s' in define_automaton", XSTR (def, 0));
|
||
for (i = 0; i < vect_length; i++)
|
||
{
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_automaton;
|
||
decl->pos = 0;
|
||
DECL_AUTOMATON (decl)->name = check_name (str_automata [i], decl->pos);
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
if (strcmp ((char *) XSTR (def, 0), NO_MINIMIZATION_OPTION + 1) == 0)
|
||
no_minimization_flag = 1;
|
||
else if (strcmp ((char *) XSTR (def, 0), TIME_OPTION + 1) == 0)
|
||
time_flag = 1;
|
||
else if (strcmp ((char *) XSTR (def, 0), V_OPTION + 1) == 0)
|
||
v_flag = 1;
|
||
else if (strcmp ((char *) XSTR (def, 0), W_OPTION + 1) == 0)
|
||
w_flag = 1;
|
||
else if (strcmp ((char *) XSTR (def, 0), NDFA_OPTION + 1) == 0)
|
||
ndfa_flag = 1;
|
||
else
|
||
fatal ("invalid option `%s' in automata_option", XSTR (def, 0));
|
||
}
|
||
|
||
/* Name in reservation to denote absence reservation. */
|
||
#define NOTHING_NAME "nothing"
|
||
|
||
/* The following string contains original reservation string being
|
||
parsed. */
|
||
static char *reserv_str;
|
||
|
||
/* Parse an element in STR. */
|
||
static regexp_t
|
||
gen_regexp_el (str)
|
||
char *str;
|
||
{
|
||
regexp_t regexp;
|
||
int len;
|
||
|
||
if (*str == '(')
|
||
{
|
||
len = strlen (str);
|
||
if (str [len - 1] != ')')
|
||
fatal ("garbage after ) in reservation `%s'", reserv_str);
|
||
str [len - 1] = '\0';
|
||
regexp = gen_regexp_sequence (str + 1);
|
||
}
|
||
else if (strcmp (str, NOTHING_NAME) == 0)
|
||
{
|
||
regexp = create_node (sizeof (struct decl));
|
||
regexp->mode = rm_nothing;
|
||
}
|
||
else
|
||
{
|
||
regexp = create_node (sizeof (struct decl));
|
||
regexp->mode = rm_unit;
|
||
REGEXP_UNIT (regexp)->name = str;
|
||
}
|
||
return regexp;
|
||
}
|
||
|
||
/* Parse construction `repeat' in STR. */
|
||
static regexp_t
|
||
gen_regexp_repeat (str)
|
||
char *str;
|
||
{
|
||
regexp_t regexp;
|
||
regexp_t repeat;
|
||
char **repeat_vect;
|
||
int els_num;
|
||
int i;
|
||
|
||
repeat_vect = get_str_vect (str, &els_num, '*', 1);
|
||
if (repeat_vect == NULL)
|
||
fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
|
||
if (els_num > 1)
|
||
{
|
||
regexp = gen_regexp_el (repeat_vect [0]);
|
||
for (i = 1; i < els_num; i++)
|
||
{
|
||
repeat = create_node (sizeof (struct regexp));
|
||
repeat->mode = rm_repeat;
|
||
REGEXP_REPEAT (repeat)->regexp = regexp;
|
||
REGEXP_REPEAT (repeat)->repeat_num = atoi (repeat_vect [i]);
|
||
if (REGEXP_REPEAT (repeat)->repeat_num <= 1)
|
||
fatal ("repetition `%s' <= 1 in reservation `%s'",
|
||
str, reserv_str);
|
||
regexp = repeat;
|
||
}
|
||
return regexp;
|
||
}
|
||
else
|
||
return gen_regexp_el (str);
|
||
}
|
||
|
||
/* Parse reservation STR which possibly contains separator '+'. */
|
||
static regexp_t
|
||
gen_regexp_allof (str)
|
||
char *str;
|
||
{
|
||
regexp_t allof;
|
||
char **allof_vect;
|
||
int els_num;
|
||
int i;
|
||
|
||
allof_vect = get_str_vect (str, &els_num, '+', 1);
|
||
if (allof_vect == NULL)
|
||
fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
|
||
if (els_num > 1)
|
||
{
|
||
allof = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t) * (els_num - 1));
|
||
allof->mode = rm_allof;
|
||
REGEXP_ALLOF (allof)->regexps_num = els_num;
|
||
for (i = 0; i < els_num; i++)
|
||
REGEXP_ALLOF (allof)->regexps [i] = gen_regexp_repeat (allof_vect [i]);
|
||
return allof;
|
||
}
|
||
else
|
||
return gen_regexp_repeat (str);
|
||
}
|
||
|
||
/* Parse reservation STR which possibly contains separator '|'. */
|
||
static regexp_t
|
||
gen_regexp_oneof (str)
|
||
char *str;
|
||
{
|
||
regexp_t oneof;
|
||
char **oneof_vect;
|
||
int els_num;
|
||
int i;
|
||
|
||
oneof_vect = get_str_vect (str, &els_num, '|', 1);
|
||
if (oneof_vect == NULL)
|
||
fatal ("invalid `%s' in reservation `%s'", str, reserv_str);
|
||
if (els_num > 1)
|
||
{
|
||
oneof = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t) * (els_num - 1));
|
||
oneof->mode = rm_oneof;
|
||
REGEXP_ONEOF (oneof)->regexps_num = els_num;
|
||
for (i = 0; i < els_num; i++)
|
||
REGEXP_ONEOF (oneof)->regexps [i] = gen_regexp_allof (oneof_vect [i]);
|
||
return oneof;
|
||
}
|
||
else
|
||
return gen_regexp_allof (str);
|
||
}
|
||
|
||
/* Parse reservation STR which possibly contains separator ','. */
|
||
static regexp_t
|
||
gen_regexp_sequence (str)
|
||
char *str;
|
||
{
|
||
regexp_t sequence;
|
||
char **sequence_vect;
|
||
int els_num;
|
||
int i;
|
||
|
||
sequence_vect = get_str_vect (str, &els_num, ',', 1);
|
||
if (els_num > 1)
|
||
{
|
||
sequence = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t) * (els_num - 1));
|
||
sequence->mode = rm_sequence;
|
||
REGEXP_SEQUENCE (sequence)->regexps_num = els_num;
|
||
for (i = 0; i < els_num; i++)
|
||
REGEXP_SEQUENCE (sequence)->regexps [i]
|
||
= gen_regexp_oneof (sequence_vect [i]);
|
||
return sequence;
|
||
}
|
||
else
|
||
return gen_regexp_oneof (str);
|
||
}
|
||
|
||
/* Parse construction reservation STR. */
|
||
static regexp_t
|
||
gen_regexp (str)
|
||
char *str;
|
||
{
|
||
reserv_str = str;
|
||
return gen_regexp_sequence (str);;
|
||
}
|
||
|
||
/* Process a DEFINE_RESERVATION.
|
||
|
||
This gives information about a reservation of cpu units. We fill
|
||
in a struct reserv_decl with information used later by
|
||
`expand_automata'. */
|
||
void
|
||
gen_reserv (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_reserv;
|
||
decl->pos = 0;
|
||
DECL_RESERV (decl)->name = check_name ((char *) XSTR (def, 0), decl->pos);
|
||
DECL_RESERV (decl)->regexp = gen_regexp ((char *) XSTR (def, 1));
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
/* Process a DEFINE_INSN_RESERVATION.
|
||
|
||
This gives information about the reservation of cpu units by an
|
||
insn. We fill a struct insn_reserv_decl with information used
|
||
later by `expand_automata'. */
|
||
void
|
||
gen_insn_reserv (def)
|
||
rtx def;
|
||
{
|
||
decl_t decl;
|
||
|
||
decl = create_node (sizeof (struct decl));
|
||
decl->mode = dm_insn_reserv;
|
||
decl->pos = 0;
|
||
DECL_INSN_RESERV (decl)->name
|
||
= check_name ((char *) XSTR (def, 0), decl->pos);
|
||
DECL_INSN_RESERV (decl)->default_latency = XINT (def, 1);
|
||
DECL_INSN_RESERV (decl)->condexp = XEXP (def, 2);
|
||
DECL_INSN_RESERV (decl)->regexp = gen_regexp ((char *) XSTR (def, 3));
|
||
VLA_PTR_ADD (decls, decl);
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
|
||
|
||
/* The function evaluates hash value (0..UINT_MAX) of string. */
|
||
static unsigned
|
||
string_hash (string)
|
||
const char *string;
|
||
{
|
||
unsigned result, i;
|
||
|
||
for (result = i = 0;*string++ != '\0'; i++)
|
||
result += ((unsigned char) *string << (i % CHAR_BIT));
|
||
return result;
|
||
}
|
||
|
||
|
||
|
||
/* This page contains abstract data `table of automaton declarations'.
|
||
Elements of the table is nodes representing automaton declarations.
|
||
Key of the table elements is name of given automaton. Rememeber
|
||
that automaton names have own space. */
|
||
|
||
/* The function evaluates hash value of an automaton declaration. The
|
||
function is used by abstract data `hashtab'. The function returns
|
||
hash value (0..UINT_MAX) of given automaton declaration. */
|
||
static hashval_t
|
||
automaton_decl_hash (automaton_decl)
|
||
const void *automaton_decl;
|
||
{
|
||
const decl_t decl = (decl_t) automaton_decl;
|
||
|
||
if (decl->mode == dm_automaton && DECL_AUTOMATON (decl)->name == NULL)
|
||
abort ();
|
||
return string_hash (DECL_AUTOMATON (decl)->name);
|
||
}
|
||
|
||
/* The function tests automaton declarations on equality of their
|
||
keys. The function is used by abstract data `hashtab'. The
|
||
function returns 1 if the declarations have the same key, 0
|
||
otherwise. */
|
||
static int
|
||
automaton_decl_eq_p (automaton_decl_1, automaton_decl_2)
|
||
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 ();
|
||
return strcmp (DECL_AUTOMATON (decl1)->name,
|
||
DECL_AUTOMATON (decl2)->name) == 0;
|
||
}
|
||
|
||
/* The automaton declaration table itself is represented by the
|
||
following variable. */
|
||
static htab_t automaton_decl_table;
|
||
|
||
/* The function inserts automaton declaration into the table. The
|
||
function does nothing if an automaton declaration with the same key
|
||
exists already in the table. The function returns automaton
|
||
declaration node in the table with the same key as given automaton
|
||
declaration node. */
|
||
static decl_t
|
||
insert_automaton_decl (automaton_decl)
|
||
decl_t automaton_decl;
|
||
{
|
||
void **entry_ptr;
|
||
|
||
entry_ptr = htab_find_slot (automaton_decl_table, automaton_decl, 1);
|
||
if (*entry_ptr == NULL)
|
||
*entry_ptr = (void *) automaton_decl;
|
||
return (decl_t) *entry_ptr;
|
||
}
|
||
|
||
/* The following variable value is node representing automaton
|
||
declaration. The node used for searching automaton declaration
|
||
with given name. */
|
||
static struct decl work_automaton_decl;
|
||
|
||
/* The function searches for automaton declaration in the table with
|
||
the same key as node representing name of the automaton
|
||
declaration. The function returns node found in the table, NULL if
|
||
such node does not exist in the table. */
|
||
static decl_t
|
||
find_automaton_decl (name)
|
||
char *name;
|
||
{
|
||
void *entry;
|
||
|
||
work_automaton_decl.mode = dm_automaton;
|
||
DECL_AUTOMATON (&work_automaton_decl)->name = name;
|
||
entry = htab_find (automaton_decl_table, &work_automaton_decl);
|
||
return (decl_t) entry;
|
||
}
|
||
|
||
/* The function creates empty automaton declaration table and node
|
||
representing automaton declaration and used for searching automaton
|
||
declaration with given name. The function must be called only once
|
||
before any work with the automaton declaration table. */
|
||
static void
|
||
initiate_automaton_decl_table ()
|
||
{
|
||
work_automaton_decl.mode = dm_automaton;
|
||
automaton_decl_table = htab_create (10, automaton_decl_hash,
|
||
automaton_decl_eq_p, (htab_del) 0);
|
||
}
|
||
|
||
/* The function deletes the automaton declaration table. Only call of
|
||
function `initiate_automaton_decl_table' is possible immediately
|
||
after this function call. */
|
||
static void
|
||
finish_automaton_decl_table ()
|
||
{
|
||
htab_delete (automaton_decl_table);
|
||
}
|
||
|
||
|
||
|
||
/* This page contains abstract data `table of insn declarations'.
|
||
Elements of the table is nodes representing insn declarations. Key
|
||
of the table elements is name of given insn (in corresponding
|
||
define_insn_reservation). Rememeber that insn names have own
|
||
space. */
|
||
|
||
/* The function evaluates hash value of an insn declaration. The
|
||
function is used by abstract data `hashtab'. The function returns
|
||
hash value (0..UINT_MAX) of given insn declaration. */
|
||
static hashval_t
|
||
insn_decl_hash (insn_decl)
|
||
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 ();
|
||
return string_hash (DECL_INSN_RESERV (decl)->name);
|
||
}
|
||
|
||
/* The function tests insn declarations on equality of their keys.
|
||
The function is used by abstract data `hashtab'. The function
|
||
returns 1 if declarations have the same key, 0 otherwise. */
|
||
static int
|
||
insn_decl_eq_p (insn_decl_1, insn_decl_2)
|
||
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 ();
|
||
return strcmp (DECL_INSN_RESERV (decl1)->name,
|
||
DECL_INSN_RESERV (decl2)->name) == 0;
|
||
}
|
||
|
||
/* The insn declaration table itself is represented by the following
|
||
variable. The table does not contain insn reservation
|
||
declarations. */
|
||
static htab_t insn_decl_table;
|
||
|
||
/* The function inserts insn declaration into the table. The function
|
||
does nothing if an insn declaration with the same key exists
|
||
already in the table. The function returns insn declaration node
|
||
in the table with the same key as given insn declaration node. */
|
||
static decl_t
|
||
insert_insn_decl (insn_decl)
|
||
decl_t insn_decl;
|
||
{
|
||
void **entry_ptr;
|
||
|
||
entry_ptr = htab_find_slot (insn_decl_table, insn_decl, 1);
|
||
if (*entry_ptr == NULL)
|
||
*entry_ptr = (void *) insn_decl;
|
||
return (decl_t) *entry_ptr;
|
||
}
|
||
|
||
/* The following variable value is node representing insn reservation
|
||
declaration. The node used for searching insn reservation
|
||
declaration with given name. */
|
||
static struct decl work_insn_decl;
|
||
|
||
/* The function searches for insn reservation declaration in the table
|
||
with the same key as node representing name of the insn reservation
|
||
declaration. The function returns node found in the table, NULL if
|
||
such node does not exist in the table. */
|
||
static decl_t
|
||
find_insn_decl (name)
|
||
char *name;
|
||
{
|
||
void *entry;
|
||
|
||
work_insn_decl.mode = dm_insn_reserv;
|
||
DECL_INSN_RESERV (&work_insn_decl)->name = name;
|
||
entry = htab_find (insn_decl_table, &work_insn_decl);
|
||
return (decl_t) entry;
|
||
}
|
||
|
||
/* The function creates empty insn declaration table and node
|
||
representing insn declaration and used for searching insn
|
||
declaration with given name. The function must be called only once
|
||
before any work with the insn declaration table. */
|
||
static void
|
||
initiate_insn_decl_table ()
|
||
{
|
||
work_insn_decl.mode = dm_insn_reserv;
|
||
insn_decl_table = htab_create (10, insn_decl_hash, insn_decl_eq_p,
|
||
(htab_del) 0);
|
||
}
|
||
|
||
/* The function deletes the insn declaration table. Only call of
|
||
function `initiate_insn_decl_table' is possible immediately after
|
||
this function call. */
|
||
static void
|
||
finish_insn_decl_table ()
|
||
{
|
||
htab_delete (insn_decl_table);
|
||
}
|
||
|
||
|
||
|
||
/* This page contains abstract data `table of declarations'. Elements
|
||
of the table is nodes representing declarations (of units and
|
||
reservations). Key of the table elements is names of given
|
||
declarations. */
|
||
|
||
/* The function evaluates hash value of a declaration. The function
|
||
is used by abstract data `hashtab'. The function returns hash
|
||
value (0..UINT_MAX) of given declaration. */
|
||
static hashval_t
|
||
decl_hash (decl)
|
||
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 ();
|
||
return string_hash (d->mode == dm_unit
|
||
? DECL_UNIT (d)->name : DECL_RESERV (d)->name);
|
||
}
|
||
|
||
/* The function tests declarations on equality of their keys. The
|
||
function is used by abstract data `hashtab'. The function
|
||
returns 1 if the declarations have the same key, 0 otherwise. */
|
||
static int
|
||
decl_eq_p (decl_1, decl_2)
|
||
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 ();
|
||
return strcmp ((d1->mode == dm_unit
|
||
? DECL_UNIT (d1)->name : DECL_RESERV (d1)->name),
|
||
(d2->mode == dm_unit
|
||
? DECL_UNIT (d2)->name : DECL_RESERV (d2)->name)) == 0;
|
||
}
|
||
|
||
/* The declaration table itself is represented by the following
|
||
variable. */
|
||
static htab_t decl_table;
|
||
|
||
/* The function inserts declaration into the table. The function does
|
||
nothing if a declaration with the same key exists already in the
|
||
table. The function returns declaration node in the table with the
|
||
same key as given declaration node. */
|
||
|
||
static decl_t
|
||
insert_decl (decl)
|
||
decl_t decl;
|
||
{
|
||
void **entry_ptr;
|
||
|
||
entry_ptr = htab_find_slot (decl_table, decl, 1);
|
||
if (*entry_ptr == NULL)
|
||
*entry_ptr = (void *) decl;
|
||
return (decl_t) *entry_ptr;
|
||
}
|
||
|
||
/* The following variable value is node representing declaration. The
|
||
node used for searching declaration with given name. */
|
||
static struct decl work_decl;
|
||
|
||
/* The function searches for declaration in the table with the same
|
||
key as node representing name of the declaration. The function
|
||
returns node found in the table, NULL if such node does not exist
|
||
in the table. */
|
||
static decl_t
|
||
find_decl (name)
|
||
char *name;
|
||
{
|
||
void *entry;
|
||
|
||
work_decl.mode = dm_unit;
|
||
DECL_UNIT (&work_decl)->name = name;
|
||
entry = htab_find (decl_table, &work_decl);
|
||
return (decl_t) entry;
|
||
}
|
||
|
||
/* The function creates empty declaration table and node representing
|
||
declaration and used for searching declaration with given name.
|
||
The function must be called only once before any work with the
|
||
declaration table. */
|
||
static void
|
||
initiate_decl_table ()
|
||
{
|
||
work_decl.mode = dm_unit;
|
||
decl_table = htab_create (10, decl_hash, decl_eq_p, (htab_del) 0);
|
||
}
|
||
|
||
/* The function deletes the declaration table. Only call of function
|
||
`initiate_declaration_table' is possible immediately after this
|
||
function call. */
|
||
static void
|
||
finish_decl_table ()
|
||
{
|
||
htab_delete (decl_table);
|
||
}
|
||
|
||
|
||
|
||
/* This page contains checker of pipeline hazard description. */
|
||
|
||
/* Checking NAMES in an exclusion clause vector and returning formed
|
||
unit_set_el_list. */
|
||
static unit_set_el_t
|
||
process_excls (names, num, excl_pos)
|
||
char **names;
|
||
int num;
|
||
pos_t excl_pos ATTRIBUTE_UNUSED;
|
||
{
|
||
unit_set_el_t el_list;
|
||
unit_set_el_t last_el;
|
||
unit_set_el_t new_el;
|
||
decl_t decl_in_table;
|
||
int i;
|
||
|
||
el_list = NULL;
|
||
last_el = NULL;
|
||
for (i = 0; i < num; i++)
|
||
{
|
||
decl_in_table = find_decl (names [i]);
|
||
if (decl_in_table == NULL)
|
||
error ("unit `%s' in exclusion is not declared", names [i]);
|
||
else if (decl_in_table->mode != dm_unit)
|
||
error ("`%s' in exclusion is not unit", names [i]);
|
||
else
|
||
{
|
||
new_el = create_node (sizeof (struct unit_set_el));
|
||
new_el->unit_decl = DECL_UNIT (decl_in_table);
|
||
new_el->next_unit_set_el = NULL;
|
||
if (last_el == NULL)
|
||
el_list = last_el = new_el;
|
||
else
|
||
{
|
||
last_el->next_unit_set_el = new_el;
|
||
last_el = last_el->next_unit_set_el;
|
||
}
|
||
}
|
||
}
|
||
return el_list;
|
||
}
|
||
|
||
/* The function adds each element from SOURCE_LIST to the exclusion
|
||
list of the each element from DEST_LIST. Checking situation "unit
|
||
excludes itself". */
|
||
static void
|
||
add_excls (dest_list, source_list, excl_pos)
|
||
unit_set_el_t dest_list;
|
||
unit_set_el_t source_list;
|
||
pos_t excl_pos ATTRIBUTE_UNUSED;
|
||
{
|
||
unit_set_el_t dst;
|
||
unit_set_el_t src;
|
||
unit_set_el_t curr_el;
|
||
unit_set_el_t prev_el;
|
||
unit_set_el_t copy;
|
||
|
||
for (dst = dest_list; dst != NULL; dst = dst->next_unit_set_el)
|
||
for (src = source_list; src != NULL; src = src->next_unit_set_el)
|
||
{
|
||
if (dst->unit_decl == src->unit_decl)
|
||
{
|
||
error ("unit `%s' excludes itself", src->unit_decl->name);
|
||
continue;
|
||
}
|
||
if (dst->unit_decl->automaton_name != NULL
|
||
&& src->unit_decl->automaton_name != NULL
|
||
&& strcmp (dst->unit_decl->automaton_name,
|
||
src->unit_decl->automaton_name) != 0)
|
||
{
|
||
error ("units `%s' and `%s' in exclusion set belong to different automata",
|
||
src->unit_decl->name, dst->unit_decl->name);
|
||
continue;
|
||
}
|
||
for (curr_el = dst->unit_decl->excl_list, prev_el = NULL;
|
||
curr_el != NULL;
|
||
prev_el = curr_el, curr_el = curr_el->next_unit_set_el)
|
||
if (curr_el->unit_decl == src->unit_decl)
|
||
break;
|
||
if (curr_el == NULL)
|
||
{
|
||
/* Element not found - insert. */
|
||
copy = copy_node (src, sizeof (*src));
|
||
copy->next_unit_set_el = NULL;
|
||
if (prev_el == NULL)
|
||
dst->unit_decl->excl_list = copy;
|
||
else
|
||
prev_el->next_unit_set_el = copy;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Checking NAMES in a presence clause vector and returning formed
|
||
unit_set_el_list. The function is called only after processing all
|
||
exclusion sets. */
|
||
static unit_set_el_t
|
||
process_presence_absence (names, num, req_pos, presence_p)
|
||
char **names;
|
||
int num;
|
||
pos_t req_pos ATTRIBUTE_UNUSED;
|
||
int presence_p;
|
||
{
|
||
unit_set_el_t el_list;
|
||
unit_set_el_t last_el;
|
||
unit_set_el_t new_el;
|
||
decl_t decl_in_table;
|
||
int i;
|
||
|
||
el_list = NULL;
|
||
last_el = NULL;
|
||
for (i = 0; i < num; i++)
|
||
{
|
||
decl_in_table = find_decl (names [i]);
|
||
if (decl_in_table == NULL)
|
||
error ((presence_p
|
||
? "unit `%s' in presence set is not declared"
|
||
: "unit `%s' in absence set is not declared"), names [i]);
|
||
else if (decl_in_table->mode != dm_unit)
|
||
error ((presence_p
|
||
? "`%s' in presence set is not unit"
|
||
: "`%s' in absence set is not unit"), names [i]);
|
||
else
|
||
{
|
||
new_el = create_node (sizeof (struct unit_set_el));
|
||
new_el->unit_decl = DECL_UNIT (decl_in_table);
|
||
new_el->next_unit_set_el = NULL;
|
||
if (last_el == NULL)
|
||
el_list = last_el = new_el;
|
||
else
|
||
{
|
||
last_el->next_unit_set_el = new_el;
|
||
last_el = last_el->next_unit_set_el;
|
||
}
|
||
}
|
||
}
|
||
return el_list;
|
||
}
|
||
|
||
/* The function adds each element from SOURCE_LIST to presence (if
|
||
PRESENCE_P) or absence list of the each element from DEST_LIST.
|
||
Checking situations "unit requires own presence", "unit requires
|
||
own absence", and "unit excludes and requires presence of ...".
|
||
Remember that we process absence sets only after all presence
|
||
sets. */
|
||
static void
|
||
add_presence_absence (dest_list, source_list, req_pos, presence_p)
|
||
unit_set_el_t dest_list;
|
||
unit_set_el_t source_list;
|
||
pos_t req_pos ATTRIBUTE_UNUSED;
|
||
int presence_p;
|
||
{
|
||
unit_set_el_t dst;
|
||
unit_set_el_t src;
|
||
unit_set_el_t curr_el;
|
||
unit_set_el_t prev_el;
|
||
unit_set_el_t copy;
|
||
|
||
for (dst = dest_list; dst != NULL; dst = dst->next_unit_set_el)
|
||
for (src = source_list; src != NULL; src = src->next_unit_set_el)
|
||
{
|
||
if (dst->unit_decl == src->unit_decl)
|
||
{
|
||
error ((presence_p
|
||
? "unit `%s' requires own presence"
|
||
: "unit `%s' requires own absence"), src->unit_decl->name);
|
||
continue;
|
||
}
|
||
if (dst->unit_decl->automaton_name != NULL
|
||
&& src->unit_decl->automaton_name != NULL
|
||
&& strcmp (dst->unit_decl->automaton_name,
|
||
src->unit_decl->automaton_name) != 0)
|
||
{
|
||
error ((presence_p
|
||
? "units `%s' and `%s' in presence set belong to different automata"
|
||
: "units `%s' and `%s' in absence set belong to different automata"),
|
||
src->unit_decl->name, dst->unit_decl->name);
|
||
continue;
|
||
}
|
||
for (curr_el = (presence_p
|
||
? dst->unit_decl->presence_list
|
||
: dst->unit_decl->absence_list), prev_el = NULL;
|
||
curr_el != NULL;
|
||
prev_el = curr_el, curr_el = curr_el->next_unit_set_el)
|
||
if (curr_el->unit_decl == src->unit_decl)
|
||
break;
|
||
if (curr_el == NULL)
|
||
{
|
||
/* Element not found - insert if there is no error. */
|
||
int no_error_flag = 1;
|
||
|
||
if (presence_p)
|
||
for (curr_el = dst->unit_decl->excl_list;
|
||
curr_el != NULL;
|
||
curr_el = curr_el->next_unit_set_el)
|
||
{
|
||
if (src->unit_decl == curr_el->unit_decl)
|
||
{
|
||
if (!w_flag)
|
||
{
|
||
error
|
||
("unit `%s' excludes and requires presence of `%s'",
|
||
dst->unit_decl->name, src->unit_decl->name);
|
||
no_error_flag = 0;
|
||
}
|
||
else
|
||
warning
|
||
("unit `%s' excludes and requires presence of `%s'",
|
||
dst->unit_decl->name, src->unit_decl->name);
|
||
}
|
||
}
|
||
else
|
||
for (curr_el = dst->unit_decl->presence_list;
|
||
curr_el != NULL;
|
||
curr_el = curr_el->next_unit_set_el)
|
||
{
|
||
if (src->unit_decl == curr_el->unit_decl)
|
||
{
|
||
if (!w_flag)
|
||
{
|
||
error
|
||
("unit `%s' requires absence and presence of `%s'",
|
||
dst->unit_decl->name, src->unit_decl->name);
|
||
no_error_flag = 0;
|
||
}
|
||
else
|
||
warning
|
||
("unit `%s' requires absence and presence of `%s'",
|
||
dst->unit_decl->name, src->unit_decl->name);
|
||
}
|
||
}
|
||
if (no_error_flag)
|
||
{
|
||
copy = copy_node (src, sizeof (*src));
|
||
copy->next_unit_set_el = NULL;
|
||
if (prev_el == NULL)
|
||
{
|
||
if (presence_p)
|
||
dst->unit_decl->presence_list = copy;
|
||
else
|
||
dst->unit_decl->absence_list = copy;
|
||
}
|
||
else
|
||
prev_el->next_unit_set_el = copy;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
struct bypass_decl *bypass;
|
||
|
||
for (bypass = bypass_list; bypass != NULL; bypass = bypass->next)
|
||
if (bypass->in_insn_reserv == in_insn_reserv)
|
||
break;
|
||
return bypass;
|
||
}
|
||
|
||
/* The function processes pipeline description declarations, checks
|
||
their correctness, and forms exclusion/presence/absence sets. */
|
||
static void
|
||
process_decls ()
|
||
{
|
||
decl_t decl;
|
||
decl_t automaton_decl;
|
||
decl_t decl_in_table;
|
||
decl_t out_insn_reserv;
|
||
decl_t in_insn_reserv;
|
||
struct bypass_decl *bypass;
|
||
int automaton_presence;
|
||
int i;
|
||
|
||
/* Checking repeated automata declarations. */
|
||
automaton_presence = 0;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_automaton)
|
||
{
|
||
automaton_presence = 1;
|
||
decl_in_table = insert_automaton_decl (decl);
|
||
if (decl_in_table != decl)
|
||
{
|
||
if (!w_flag)
|
||
error ("repeated declaration of automaton `%s'",
|
||
DECL_AUTOMATON (decl)->name);
|
||
else
|
||
warning ("repeated declaration of automaton `%s'",
|
||
DECL_AUTOMATON (decl)->name);
|
||
}
|
||
}
|
||
}
|
||
/* Checking undeclared automata, repeated declarations (except for
|
||
automata) and correctness of their attributes (insn latency times
|
||
etc.). */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
{
|
||
DECL_INSN_RESERV (decl)->condexp
|
||
= check_attr_test (DECL_INSN_RESERV (decl)->condexp, 0, 0);
|
||
if (DECL_INSN_RESERV (decl)->default_latency < 0)
|
||
error ("define_insn_reservation `%s' has negative latency time",
|
||
DECL_INSN_RESERV (decl)->name);
|
||
DECL_INSN_RESERV (decl)->insn_num = description->insns_num;
|
||
description->insns_num++;
|
||
decl_in_table = insert_insn_decl (decl);
|
||
if (decl_in_table != decl)
|
||
error ("`%s' is already used as insn reservation name",
|
||
DECL_INSN_RESERV (decl)->name);
|
||
}
|
||
else if (decl->mode == dm_bypass)
|
||
{
|
||
if (DECL_BYPASS (decl)->latency < 0)
|
||
error ("define_bypass `%s - %s' has negative latency time",
|
||
DECL_BYPASS (decl)->out_insn_name,
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
}
|
||
else if (decl->mode == dm_unit || decl->mode == dm_reserv)
|
||
{
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
DECL_UNIT (decl)->automaton_decl = NULL;
|
||
if (DECL_UNIT (decl)->automaton_name != NULL)
|
||
{
|
||
automaton_decl
|
||
= find_automaton_decl (DECL_UNIT (decl)->automaton_name);
|
||
if (automaton_decl == NULL)
|
||
error ("automaton `%s' is not declared",
|
||
DECL_UNIT (decl)->automaton_name);
|
||
else
|
||
{
|
||
DECL_AUTOMATON (automaton_decl)->automaton_is_used = 1;
|
||
DECL_UNIT (decl)->automaton_decl
|
||
= DECL_AUTOMATON (automaton_decl);
|
||
}
|
||
}
|
||
else if (automaton_presence)
|
||
error ("define_unit `%s' without automaton when one defined",
|
||
DECL_UNIT (decl)->name);
|
||
DECL_UNIT (decl)->unit_num = description->units_num;
|
||
description->units_num++;
|
||
if (strcmp (DECL_UNIT (decl)->name, NOTHING_NAME) == 0)
|
||
{
|
||
error ("`%s' is declared as cpu unit", NOTHING_NAME);
|
||
continue;
|
||
}
|
||
decl_in_table = find_decl (DECL_UNIT (decl)->name);
|
||
}
|
||
else
|
||
{
|
||
if (strcmp (DECL_RESERV (decl)->name, NOTHING_NAME) == 0)
|
||
{
|
||
error ("`%s' is declared as cpu reservation", NOTHING_NAME);
|
||
continue;
|
||
}
|
||
decl_in_table = find_decl (DECL_RESERV (decl)->name);
|
||
}
|
||
if (decl_in_table == NULL)
|
||
decl_in_table = insert_decl (decl);
|
||
else
|
||
{
|
||
if (decl->mode == dm_unit)
|
||
error ("repeated declaration of unit `%s'",
|
||
DECL_UNIT (decl)->name);
|
||
else
|
||
error ("repeated declaration of reservation `%s'",
|
||
DECL_RESERV (decl)->name);
|
||
}
|
||
}
|
||
}
|
||
/* Check bypasses and form list of bypasses for each (output)
|
||
insn. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_bypass)
|
||
{
|
||
out_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->out_insn_name);
|
||
in_insn_reserv = find_insn_decl (DECL_BYPASS (decl)->in_insn_name);
|
||
if (out_insn_reserv == NULL)
|
||
error ("there is no insn reservation `%s'",
|
||
DECL_BYPASS (decl)->out_insn_name);
|
||
else if (in_insn_reserv == NULL)
|
||
error ("there is no insn reservation `%s'",
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
else
|
||
{
|
||
DECL_BYPASS (decl)->out_insn_reserv
|
||
= DECL_INSN_RESERV (out_insn_reserv);
|
||
DECL_BYPASS (decl)->in_insn_reserv
|
||
= DECL_INSN_RESERV (in_insn_reserv);
|
||
bypass
|
||
= find_bypass (DECL_INSN_RESERV (out_insn_reserv)->bypass_list,
|
||
DECL_BYPASS (decl)->in_insn_reserv);
|
||
if (bypass != NULL)
|
||
{
|
||
if (DECL_BYPASS (decl)->latency == bypass->latency)
|
||
{
|
||
if (!w_flag)
|
||
error
|
||
("the same bypass `%s - %s' is already defined",
|
||
DECL_BYPASS (decl)->out_insn_name,
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
else
|
||
warning
|
||
("the same bypass `%s - %s' is already defined",
|
||
DECL_BYPASS (decl)->out_insn_name,
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
}
|
||
else
|
||
error ("bypass `%s - %s' is already defined",
|
||
DECL_BYPASS (decl)->out_insn_name,
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
}
|
||
else
|
||
{
|
||
DECL_BYPASS (decl)->next
|
||
= DECL_INSN_RESERV (out_insn_reserv)->bypass_list;
|
||
DECL_INSN_RESERV (out_insn_reserv)->bypass_list
|
||
= DECL_BYPASS (decl);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Check exclusion set declarations and form exclussion sets. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_excl)
|
||
{
|
||
unit_set_el_t unit_set_el_list;
|
||
unit_set_el_t unit_set_el_list_2;
|
||
|
||
unit_set_el_list
|
||
= process_excls (DECL_EXCL (decl)->names,
|
||
DECL_EXCL (decl)->first_list_length, decl->pos);
|
||
unit_set_el_list_2
|
||
= process_excls (&DECL_EXCL (decl)->names
|
||
[DECL_EXCL (decl)->first_list_length],
|
||
DECL_EXCL (decl)->names_num
|
||
- DECL_EXCL (decl)->first_list_length,
|
||
decl->pos);
|
||
add_excls (unit_set_el_list, unit_set_el_list_2, decl->pos);
|
||
add_excls (unit_set_el_list_2, unit_set_el_list, decl->pos);
|
||
}
|
||
}
|
||
|
||
/* Check presence set declarations and form presence sets. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_presence)
|
||
{
|
||
unit_set_el_t unit_set_el_list;
|
||
unit_set_el_t unit_set_el_list_2;
|
||
|
||
unit_set_el_list
|
||
= process_presence_absence
|
||
(DECL_PRESENCE (decl)->names,
|
||
DECL_PRESENCE (decl)->first_list_length, decl->pos, 1);
|
||
unit_set_el_list_2
|
||
= process_presence_absence
|
||
(&DECL_PRESENCE (decl)->names
|
||
[DECL_PRESENCE (decl)->first_list_length],
|
||
DECL_PRESENCE (decl)->names_num
|
||
- DECL_PRESENCE (decl)->first_list_length,
|
||
decl->pos, 1);
|
||
add_presence_absence (unit_set_el_list, unit_set_el_list_2,
|
||
decl->pos, 1);
|
||
}
|
||
}
|
||
|
||
/* Check absence set declarations and form absence sets. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_absence)
|
||
{
|
||
unit_set_el_t unit_set_el_list;
|
||
unit_set_el_t unit_set_el_list_2;
|
||
|
||
unit_set_el_list
|
||
= process_presence_absence
|
||
(DECL_ABSENCE (decl)->names,
|
||
DECL_ABSENCE (decl)->first_list_length, decl->pos, 0);
|
||
unit_set_el_list_2
|
||
= process_presence_absence
|
||
(&DECL_ABSENCE (decl)->names
|
||
[DECL_ABSENCE (decl)->first_list_length],
|
||
DECL_ABSENCE (decl)->names_num
|
||
- DECL_ABSENCE (decl)->first_list_length,
|
||
decl->pos, 0);
|
||
add_presence_absence (unit_set_el_list, unit_set_el_list_2,
|
||
decl->pos, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The following function checks that declared automaton is used. If
|
||
the automaton is not used, the function fixes error/warning. The
|
||
following function must be called only after `process_decls'. */
|
||
static void
|
||
check_automaton_usage ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_automaton
|
||
&& !DECL_AUTOMATON (decl)->automaton_is_used)
|
||
{
|
||
if (!w_flag)
|
||
error ("automaton `%s' is not used", DECL_AUTOMATON (decl)->name);
|
||
else
|
||
warning ("automaton `%s' is not used",
|
||
DECL_AUTOMATON (decl)->name);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The following recursive function processes all regexp in order to
|
||
fix usage of units or reservations and to fix errors of undeclared
|
||
name. The function may change unit_regexp onto reserv_regexp.
|
||
Remember that reserv_regexp does not exist before the function
|
||
call. */
|
||
static regexp_t
|
||
process_regexp (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
decl_t decl_in_table;
|
||
regexp_t new_regexp;
|
||
int i;
|
||
|
||
if (regexp->mode == 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 ();
|
||
}
|
||
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;
|
||
}
|
||
|
||
/* The following function processes regexp of define_reservation and
|
||
define_insn_reservation with the aid of function
|
||
`process_regexp'. */
|
||
static void
|
||
process_regexp_decls ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_reserv)
|
||
DECL_RESERV (decl)->regexp
|
||
= process_regexp (DECL_RESERV (decl)->regexp);
|
||
else if (decl->mode == dm_insn_reserv)
|
||
DECL_INSN_RESERV (decl)->regexp
|
||
= process_regexp (DECL_INSN_RESERV (decl)->regexp);
|
||
}
|
||
}
|
||
|
||
/* The following function checks that declared unit is used. If the
|
||
unit is not used, the function fixes errors/warnings. The
|
||
following function must be called only after `process_decls',
|
||
`process_regexp_decls'. */
|
||
static void
|
||
check_usage ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit && !DECL_UNIT (decl)->unit_is_used)
|
||
{
|
||
if (!w_flag)
|
||
error ("unit `%s' is not used", DECL_UNIT (decl)->name);
|
||
else
|
||
warning ("unit `%s' is not used", DECL_UNIT (decl)->name);
|
||
}
|
||
else if (decl->mode == dm_reserv && !DECL_RESERV (decl)->reserv_is_used)
|
||
{
|
||
if (!w_flag)
|
||
error ("reservation `%s' is not used", DECL_RESERV (decl)->name);
|
||
else
|
||
warning ("reservation `%s' is not used", DECL_RESERV (decl)->name);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The following variable value is number of reservation being
|
||
processed on loop recognition. */
|
||
static int curr_loop_pass_num;
|
||
|
||
/* The following recursive function returns nonzero value if REGEXP
|
||
contains given decl or reservations in given regexp refers for
|
||
given decl. */
|
||
static int
|
||
loop_in_regexp (regexp, start_decl)
|
||
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)
|
||
{
|
||
if (start_decl->mode == dm_reserv
|
||
&& REGEXP_RESERV (regexp)->reserv_decl == DECL_RESERV (start_decl))
|
||
return 1;
|
||
else if (REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
|
||
== curr_loop_pass_num)
|
||
/* declaration has been processed. */
|
||
return 0;
|
||
else
|
||
{
|
||
REGEXP_RESERV (regexp)->reserv_decl->loop_pass_num
|
||
= curr_loop_pass_num;
|
||
return loop_in_regexp (REGEXP_RESERV (regexp)->reserv_decl->regexp,
|
||
start_decl);
|
||
}
|
||
}
|
||
else if (regexp->mode == 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)
|
||
{
|
||
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)
|
||
{
|
||
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 ();
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* The following function fixes errors "cycle in definition ...". The
|
||
function uses function `loop_in_regexp' for that. */
|
||
static void
|
||
check_loops_in_regexps ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_reserv)
|
||
DECL_RESERV (decl)->loop_pass_num = 0;
|
||
}
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
curr_loop_pass_num = i;
|
||
|
||
if (decl->mode == dm_reserv)
|
||
{
|
||
DECL_RESERV (decl)->loop_pass_num = curr_loop_pass_num;
|
||
if (loop_in_regexp (DECL_RESERV (decl)->regexp, decl))
|
||
{
|
||
if (DECL_RESERV (decl)->regexp == NULL)
|
||
abort ();
|
||
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 and for result in the
|
||
reservation. */
|
||
static int
|
||
process_regexp_cycles (regexp, start_cycle)
|
||
regexp_t regexp;
|
||
int start_cycle;
|
||
{
|
||
int i;
|
||
|
||
if (regexp->mode == rm_unit)
|
||
{
|
||
if (REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num < start_cycle)
|
||
REGEXP_UNIT (regexp)->unit_decl->max_occ_cycle_num = start_cycle;
|
||
return start_cycle;
|
||
}
|
||
else if (regexp->mode == rm_reserv)
|
||
return process_regexp_cycles (REGEXP_RESERV (regexp)->reserv_decl->regexp,
|
||
start_cycle);
|
||
else if (regexp->mode == rm_repeat)
|
||
{
|
||
for (i = 0; i < REGEXP_REPEAT (regexp)->repeat_num; i++)
|
||
start_cycle = process_regexp_cycles (REGEXP_REPEAT (regexp)->regexp,
|
||
start_cycle) + 1;
|
||
return start_cycle;
|
||
}
|
||
else if (regexp->mode == rm_sequence)
|
||
{
|
||
for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
|
||
start_cycle
|
||
= process_regexp_cycles (REGEXP_SEQUENCE (regexp)->regexps [i],
|
||
start_cycle) + 1;
|
||
return start_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_regexp_cycles (REGEXP_ALLOF (regexp)->regexps [i],
|
||
start_cycle);
|
||
if (finish_cycle < cycle)
|
||
finish_cycle = cycle;
|
||
}
|
||
return finish_cycle;
|
||
}
|
||
else if (regexp->mode == rm_oneof)
|
||
{
|
||
int finish_cycle = 0;
|
||
int cycle;
|
||
|
||
for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
|
||
{
|
||
cycle = process_regexp_cycles (REGEXP_ONEOF (regexp)->regexps [i],
|
||
start_cycle);
|
||
if (finish_cycle < cycle)
|
||
finish_cycle = cycle;
|
||
}
|
||
return finish_cycle;
|
||
}
|
||
else
|
||
{
|
||
if (regexp->mode != rm_nothing)
|
||
abort ();
|
||
return start_cycle;
|
||
}
|
||
}
|
||
|
||
/* The following function is called only for correct program. The
|
||
function defines max reservation of insns in cycles. */
|
||
static void
|
||
evaluate_max_reserv_cycles ()
|
||
{
|
||
int max_insn_cycles_num;
|
||
decl_t decl;
|
||
int i;
|
||
|
||
description->max_insn_reserv_cycles = 0;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
{
|
||
max_insn_cycles_num
|
||
= process_regexp_cycles (DECL_INSN_RESERV (decl)->regexp, 0);
|
||
if (description->max_insn_reserv_cycles < max_insn_cycles_num)
|
||
description->max_insn_reserv_cycles = max_insn_cycles_num;
|
||
}
|
||
}
|
||
description->max_insn_reserv_cycles++;
|
||
}
|
||
|
||
/* The following function calls functions for checking all
|
||
description. */
|
||
static void
|
||
check_all_description ()
|
||
{
|
||
process_decls ();
|
||
check_automaton_usage ();
|
||
process_regexp_decls ();
|
||
check_usage ();
|
||
check_loops_in_regexps ();
|
||
if (!have_error)
|
||
evaluate_max_reserv_cycles ();
|
||
}
|
||
|
||
|
||
|
||
/* The page contains abstract data `ticker'. This data is used to
|
||
report time of different phases of building automata. It is
|
||
possibly to write a description for which automata will be built
|
||
during several minutes even on fast machine. */
|
||
|
||
/* The following function creates ticker and makes it active. */
|
||
static ticker_t
|
||
create_ticker ()
|
||
{
|
||
ticker_t ticker;
|
||
|
||
ticker.modified_creation_time = get_run_time ();
|
||
ticker.incremented_off_time = 0;
|
||
return ticker;
|
||
}
|
||
|
||
/* The following function switches off given ticker. */
|
||
static void
|
||
ticker_off (ticker)
|
||
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;
|
||
{
|
||
if (ticker->incremented_off_time != 0)
|
||
{
|
||
ticker->modified_creation_time
|
||
+= get_run_time () - ticker->incremented_off_time + 1;
|
||
ticker->incremented_off_time = 0;
|
||
}
|
||
}
|
||
|
||
/* The following function returns current time in milliseconds since
|
||
the moment when given ticker was created. */
|
||
static int
|
||
active_time (ticker)
|
||
ticker_t ticker;
|
||
{
|
||
if (ticker.incremented_off_time != 0)
|
||
return ticker.incremented_off_time - 1 - ticker.modified_creation_time;
|
||
else
|
||
return get_run_time () - ticker.modified_creation_time;
|
||
}
|
||
|
||
/* The following function returns string representation of active time
|
||
of given ticker. The result is string representation of seconds
|
||
with accuracy of 1/100 second. Only result of the last call of the
|
||
function exists. Therefore the following code is not correct
|
||
|
||
printf ("parser time: %s\ngeneration time: %s\n",
|
||
active_time_string (parser_ticker),
|
||
active_time_string (generation_ticker));
|
||
|
||
Correct code has to be the following
|
||
|
||
printf ("parser time: %s\n", active_time_string (parser_ticker));
|
||
printf ("generation time: %s\n",
|
||
active_time_string (generation_ticker));
|
||
|
||
*/
|
||
static void
|
||
print_active_time (f, ticker)
|
||
FILE *f;
|
||
ticker_t ticker;
|
||
{
|
||
int msecs;
|
||
|
||
msecs = active_time (ticker);
|
||
fprintf (f, "%d.%06d", msecs / 1000000, msecs % 1000000);
|
||
}
|
||
|
||
|
||
|
||
/* The following variable value is number of automaton which are
|
||
really being created. This value is defined on the base of
|
||
argument of option `-split'. If the variable has zero value the
|
||
number of automata is defined by the constructions `%automaton'.
|
||
This case occures when option `-split' is absent or has zero
|
||
argument. If constructions `define_automaton' is absent only one
|
||
automaton is created. */
|
||
static int automata_num;
|
||
|
||
/* The following variable values are times of
|
||
o transformation of regular expressions
|
||
o building NDFA (DFA if !ndfa_flag)
|
||
o NDFA -> DFA (simply the same automaton if !ndfa_flag)
|
||
o DFA minimization
|
||
o building insn equivalence classes
|
||
o all previous ones
|
||
o code output */
|
||
static ticker_t transform_time;
|
||
static ticker_t NDFA_time;
|
||
static ticker_t NDFA_to_DFA_time;
|
||
static ticker_t minimize_time;
|
||
static ticker_t equiv_time;
|
||
static ticker_t automaton_generation_time;
|
||
static ticker_t output_time;
|
||
|
||
/* The following variable values are times of
|
||
all checking
|
||
all generation
|
||
all pipeline hazard translator work */
|
||
static ticker_t check_time;
|
||
static ticker_t generation_time;
|
||
static ticker_t all_time;
|
||
|
||
|
||
|
||
/* Pseudo insn decl which denotes advancing cycle. */
|
||
static decl_t advance_cycle_insn_decl;
|
||
static void
|
||
add_advance_cycle_insn_decl ()
|
||
{
|
||
advance_cycle_insn_decl = create_node (sizeof (struct decl));
|
||
advance_cycle_insn_decl->mode = dm_insn_reserv;
|
||
advance_cycle_insn_decl->pos = no_pos;
|
||
DECL_INSN_RESERV (advance_cycle_insn_decl)->regexp = NULL;
|
||
DECL_INSN_RESERV (advance_cycle_insn_decl)->name = (char *) "$advance_cycle";
|
||
DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num
|
||
= description->insns_num;
|
||
description->decls [description->decls_num] = advance_cycle_insn_decl;
|
||
description->decls_num++;
|
||
description->insns_num++;
|
||
num_dfa_decls++;
|
||
}
|
||
|
||
|
||
/* Abstract data `alternative states' which reperesents
|
||
nondeterministic nature of the description (see comments for
|
||
structures alt_state and state). */
|
||
|
||
/* List of free states. */
|
||
static alt_state_t first_free_alt_state;
|
||
|
||
#ifndef NDEBUG
|
||
/* The following variables is maximal number of allocated nodes
|
||
alt_state. */
|
||
static int allocated_alt_states_num = 0;
|
||
#endif
|
||
|
||
/* The following function returns free node alt_state. It may be new
|
||
allocated node or node freed eralier. */
|
||
static alt_state_t
|
||
get_free_alt_state ()
|
||
{
|
||
alt_state_t result;
|
||
|
||
if (first_free_alt_state != NULL)
|
||
{
|
||
result = first_free_alt_state;
|
||
first_free_alt_state = first_free_alt_state->next_alt_state;
|
||
}
|
||
else
|
||
{
|
||
#ifndef NDEBUG
|
||
allocated_alt_states_num++;
|
||
#endif
|
||
result = create_node (sizeof (struct alt_state));
|
||
}
|
||
result->state = NULL;
|
||
result->next_alt_state = NULL;
|
||
result->next_sorted_alt_state = NULL;
|
||
return result;
|
||
}
|
||
|
||
/* The function frees node ALT_STATE. */
|
||
static void
|
||
free_alt_state (alt_state)
|
||
alt_state_t alt_state;
|
||
{
|
||
if (alt_state == NULL)
|
||
return;
|
||
alt_state->next_alt_state = first_free_alt_state;
|
||
first_free_alt_state = alt_state;
|
||
}
|
||
|
||
/* The function frees list started with node ALT_STATE_LIST. */
|
||
static void
|
||
free_alt_states (alt_states_list)
|
||
alt_state_t alt_states_list;
|
||
{
|
||
alt_state_t curr_alt_state;
|
||
alt_state_t next_alt_state;
|
||
|
||
for (curr_alt_state = alt_states_list;
|
||
curr_alt_state != NULL;
|
||
curr_alt_state = next_alt_state)
|
||
{
|
||
next_alt_state = curr_alt_state->next_alt_state;
|
||
free_alt_state (curr_alt_state);
|
||
}
|
||
}
|
||
|
||
/* The function compares unique numbers of alt states. */
|
||
static int
|
||
alt_state_cmp (alt_state_ptr_1, alt_state_ptr_2)
|
||
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)
|
||
return 0;
|
||
else if ((*(alt_state_t *) alt_state_ptr_1)->state->unique_num
|
||
< (*(alt_state_t *) alt_state_ptr_2)->state->unique_num)
|
||
return -1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
/* The function sorts ALT_STATES_LIST and removes duplicated alt
|
||
states from the list. The comparison key is alt state unique
|
||
number. */
|
||
static alt_state_t
|
||
uniq_sort_alt_states (alt_states_list)
|
||
alt_state_t alt_states_list;
|
||
{
|
||
alt_state_t curr_alt_state;
|
||
vla_ptr_t alt_states;
|
||
size_t i;
|
||
size_t prev_unique_state_ind;
|
||
alt_state_t result;
|
||
alt_state_t *result_ptr;
|
||
|
||
VLA_PTR_CREATE (alt_states, 150, "alt_states");
|
||
for (curr_alt_state = alt_states_list;
|
||
curr_alt_state != NULL;
|
||
curr_alt_state = curr_alt_state->next_alt_state)
|
||
VLA_PTR_ADD (alt_states, curr_alt_state);
|
||
qsort (VLA_PTR_BEGIN (alt_states), VLA_PTR_LENGTH (alt_states),
|
||
sizeof (alt_state_t), alt_state_cmp);
|
||
if (VLA_PTR_LENGTH (alt_states) == 0)
|
||
result = NULL;
|
||
else
|
||
{
|
||
result_ptr = VLA_PTR_BEGIN (alt_states);
|
||
prev_unique_state_ind = 0;
|
||
for (i = 1; i < VLA_PTR_LENGTH (alt_states); i++)
|
||
if (result_ptr [prev_unique_state_ind]->state != result_ptr [i]->state)
|
||
{
|
||
prev_unique_state_ind++;
|
||
result_ptr [prev_unique_state_ind] = result_ptr [i];
|
||
}
|
||
#if 0
|
||
for (i = prev_unique_state_ind + 1; i < VLA_PTR_LENGTH (alt_states); i++)
|
||
free_alt_state (result_ptr [i]);
|
||
#endif
|
||
VLA_PTR_SHORTEN (alt_states, i - prev_unique_state_ind - 1);
|
||
result_ptr = VLA_PTR_BEGIN (alt_states);
|
||
for (i = 1; i < VLA_PTR_LENGTH (alt_states); i++)
|
||
result_ptr [i - 1]->next_sorted_alt_state = result_ptr [i];
|
||
result_ptr [i - 1]->next_sorted_alt_state = NULL;
|
||
result = *result_ptr;
|
||
}
|
||
VLA_PTR_DELETE (alt_states);
|
||
return result;
|
||
}
|
||
|
||
/* The function checks equality of alt state lists. Remember that the
|
||
lists must be already sorted by the previous function. */
|
||
static int
|
||
alt_states_eq (alt_states_1, alt_states_2)
|
||
alt_state_t alt_states_1;
|
||
alt_state_t alt_states_2;
|
||
{
|
||
while (alt_states_1 != NULL && alt_states_2 != NULL
|
||
&& alt_state_cmp (&alt_states_1, &alt_states_2) == 0)
|
||
{
|
||
alt_states_1 = alt_states_1->next_sorted_alt_state;
|
||
alt_states_2 = alt_states_2->next_sorted_alt_state;
|
||
}
|
||
return alt_states_1 == alt_states_2;
|
||
}
|
||
|
||
/* Initialization of the abstract data. */
|
||
static void
|
||
initiate_alt_states ()
|
||
{
|
||
first_free_alt_state = NULL;
|
||
}
|
||
|
||
/* Finishing work with the abstract data. */
|
||
static void
|
||
finish_alt_states ()
|
||
{
|
||
}
|
||
|
||
|
||
|
||
/* The page contains macros for work with bits strings. We could use
|
||
standard gcc bitmap or sbitmap but it would result in difficulties
|
||
of building canadian cross. */
|
||
|
||
/* Set bit number bitno in the bit string. The macro is not side
|
||
effect proof. */
|
||
#define SET_BIT(bitstring, bitno) \
|
||
(((char *) (bitstring)) [(bitno) / CHAR_BIT] |= 1 << (bitno) % CHAR_BIT)
|
||
|
||
/* Test if bit number bitno in the bitstring is set. The macro is not
|
||
side effect proof. */
|
||
#define TEST_BIT(bitstring, bitno) \
|
||
(((char *) (bitstring)) [(bitno) / CHAR_BIT] >> (bitno) % CHAR_BIT & 1)
|
||
|
||
|
||
|
||
/* This page contains abstract data `state'. */
|
||
|
||
/* Maximal length of reservations in cycles (>= 1). */
|
||
static int max_cycles_num;
|
||
|
||
/* Number of set elements (see type set_el_t) needed for
|
||
representation of one cycle reservation. It is depended on units
|
||
number. */
|
||
static int els_in_cycle_reserv;
|
||
|
||
/* Number of set elements (see type set_el_t) needed for
|
||
representation of maximal length reservation. Deterministic
|
||
reservation is stored as set (bit string) of length equal to the
|
||
variable value * number of bits in set_el_t. */
|
||
static int els_in_reservs;
|
||
|
||
/* VLA for representation of array of pointers to unit
|
||
declarations. */
|
||
static vla_ptr_t units_container;
|
||
|
||
/* The start address of the array. */
|
||
static unit_decl_t *units_array;
|
||
|
||
/* Empty reservation of maximal length. */
|
||
static reserv_sets_t empty_reserv;
|
||
|
||
/* The state table itself is represented by the following variable. */
|
||
static htab_t state_table;
|
||
|
||
/* VLA for representation of array of pointers to free nodes
|
||
`state'. */
|
||
static vla_ptr_t free_states;
|
||
|
||
static int curr_unique_state_num;
|
||
|
||
#ifndef NDEBUG
|
||
/* The following variables is maximal number of allocated nodes
|
||
`state'. */
|
||
static int allocated_states_num = 0;
|
||
#endif
|
||
|
||
/* Allocate new reservation set. */
|
||
static reserv_sets_t
|
||
alloc_empty_reserv_sets ()
|
||
{
|
||
reserv_sets_t result;
|
||
|
||
obstack_blank (&irp, els_in_reservs * sizeof (set_el_t));
|
||
result = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
memset (result, 0, els_in_reservs * sizeof (set_el_t));
|
||
return result;
|
||
}
|
||
|
||
/* Hash value of reservation set. */
|
||
static unsigned
|
||
reserv_sets_hash_value (reservs)
|
||
reserv_sets_t reservs;
|
||
{
|
||
set_el_t hash_value;
|
||
unsigned result;
|
||
int reservs_num, i;
|
||
set_el_t *reserv_ptr;
|
||
|
||
hash_value = 0;
|
||
reservs_num = els_in_reservs;
|
||
reserv_ptr = reservs;
|
||
i = 0;
|
||
while (reservs_num != 0)
|
||
{
|
||
reservs_num--;
|
||
hash_value += ((*reserv_ptr >> i)
|
||
| (*reserv_ptr << (sizeof (set_el_t) * CHAR_BIT - i)));
|
||
i++;
|
||
if (i == sizeof (set_el_t) * CHAR_BIT)
|
||
i = 0;
|
||
reserv_ptr++;
|
||
}
|
||
if (sizeof (set_el_t) <= sizeof (unsigned))
|
||
return hash_value;
|
||
result = 0;
|
||
for (i = sizeof (set_el_t); i > 0; i -= sizeof (unsigned) - 1)
|
||
{
|
||
result += (unsigned) hash_value;
|
||
hash_value >>= (sizeof (unsigned) - 1) * CHAR_BIT;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* Comparison of given reservation sets. */
|
||
static int
|
||
reserv_sets_cmp (reservs_1, reservs_2)
|
||
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 ();
|
||
reservs_num = els_in_reservs;
|
||
reserv_ptr_1 = reservs_1;
|
||
reserv_ptr_2 = reservs_2;
|
||
while (reservs_num != 0 && *reserv_ptr_1 == *reserv_ptr_2)
|
||
{
|
||
reservs_num--;
|
||
reserv_ptr_1++;
|
||
reserv_ptr_2++;
|
||
}
|
||
if (reservs_num == 0)
|
||
return 0;
|
||
else if (*reserv_ptr_1 < *reserv_ptr_2)
|
||
return -1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
/* The function checks equality of the reservation sets. */
|
||
static int
|
||
reserv_sets_eq (reservs_1, reservs_2)
|
||
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;
|
||
{
|
||
if (cycle_num >= max_cycles_num)
|
||
abort ();
|
||
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;
|
||
{
|
||
if (cycle_num >= max_cycles_num)
|
||
abort ();
|
||
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;
|
||
{
|
||
set_el_t *reserv_ptr;
|
||
int reservs_num;
|
||
|
||
if (operand == NULL)
|
||
abort ();
|
||
for (reservs_num = els_in_reservs, reserv_ptr = operand;
|
||
reservs_num != 0;
|
||
reserv_ptr++, reservs_num--)
|
||
if (*reserv_ptr != 0)
|
||
return 0;
|
||
return 1;
|
||
}
|
||
|
||
/* The function checks that the reservation sets are intersected,
|
||
i.e. there is a unit reservation on a cycle in both reservation
|
||
sets. */
|
||
static int
|
||
reserv_sets_are_intersected (operand_1, operand_2)
|
||
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;
|
||
int nonzero_p;
|
||
|
||
if (operand_1 == NULL || operand_2 == NULL)
|
||
abort ();
|
||
for (el_ptr_1 = operand_1, el_ptr_2 = operand_2;
|
||
el_ptr_1 < operand_1 + els_in_reservs;
|
||
el_ptr_1++, el_ptr_2++)
|
||
if (*el_ptr_1 & *el_ptr_2)
|
||
return 1;
|
||
for (cycle_ptr_1 = operand_1, cycle_ptr_2 = operand_2;
|
||
cycle_ptr_1 < operand_1 + els_in_reservs;
|
||
cycle_ptr_1 += els_in_cycle_reserv, cycle_ptr_2 += els_in_cycle_reserv)
|
||
{
|
||
for (el_ptr_1 = cycle_ptr_1, el_ptr_2 = get_excl_set (cycle_ptr_2);
|
||
el_ptr_1 < cycle_ptr_1 + els_in_cycle_reserv;
|
||
el_ptr_1++, el_ptr_2++)
|
||
if (*el_ptr_1 & *el_ptr_2)
|
||
return 1;
|
||
nonzero_p = 0;
|
||
for (el_ptr_1 = cycle_ptr_1,
|
||
el_ptr_2 = get_presence_absence_set (cycle_ptr_2, 1);
|
||
el_ptr_1 < cycle_ptr_1 + els_in_cycle_reserv;
|
||
el_ptr_1++, el_ptr_2++)
|
||
if (*el_ptr_1 & *el_ptr_2)
|
||
break;
|
||
else if (*el_ptr_2 != 0)
|
||
nonzero_p = 1;
|
||
if (nonzero_p && el_ptr_1 >= cycle_ptr_1 + els_in_cycle_reserv)
|
||
return 1;
|
||
for (el_ptr_1 = cycle_ptr_1,
|
||
el_ptr_2 = get_presence_absence_set (cycle_ptr_2, 0);
|
||
el_ptr_1 < cycle_ptr_1 + els_in_cycle_reserv;
|
||
el_ptr_1++, el_ptr_2++)
|
||
/* It looks like code for exclusion but exclusion set is
|
||
made as symmetric relation preliminary. */
|
||
if (*el_ptr_1 & *el_ptr_2)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* The function sets up RESULT bits by bits of OPERAND shifted on one
|
||
cpu cycle. The remaining bits of OPERAND (representing the last
|
||
cycle unit reservations) are not chenged. */
|
||
static void
|
||
reserv_sets_shift (result, operand)
|
||
reserv_sets_t result;
|
||
reserv_sets_t operand;
|
||
{
|
||
int i;
|
||
|
||
if (result == NULL || operand == NULL || result == operand)
|
||
abort ();
|
||
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;
|
||
{
|
||
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 ();
|
||
for (el_ptr_1 = operand_1, el_ptr_2 = operand_2, result_set_el_ptr = result;
|
||
el_ptr_1 < operand_1 + els_in_reservs;
|
||
el_ptr_1++, el_ptr_2++, result_set_el_ptr++)
|
||
*result_set_el_ptr = *el_ptr_1 | *el_ptr_2;
|
||
}
|
||
|
||
/* AND of the reservation sets. */
|
||
static void
|
||
reserv_sets_and (result, operand_1, operand_2)
|
||
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 ();
|
||
for (el_ptr_1 = operand_1, el_ptr_2 = operand_2, result_set_el_ptr = result;
|
||
el_ptr_1 < operand_1 + els_in_reservs;
|
||
el_ptr_1++, el_ptr_2++, result_set_el_ptr++)
|
||
*result_set_el_ptr = *el_ptr_1 & *el_ptr_2;
|
||
}
|
||
|
||
/* The function outputs string representation of units reservation on
|
||
cycle START_CYCLE in the reservation set. The function uses repeat
|
||
construction if REPETITION_NUM > 1. */
|
||
static void
|
||
output_cycle_reservs (f, reservs, start_cycle, repetition_num)
|
||
FILE *f;
|
||
reserv_sets_t reservs;
|
||
int start_cycle;
|
||
int repetition_num;
|
||
{
|
||
int unit_num;
|
||
int reserved_units_num;
|
||
|
||
reserved_units_num = 0;
|
||
for (unit_num = 0; unit_num < description->units_num; unit_num++)
|
||
if (TEST_BIT (reservs, start_cycle * els_in_cycle_reserv
|
||
* sizeof (set_el_t) * CHAR_BIT + unit_num))
|
||
reserved_units_num++;
|
||
if (repetition_num <= 0)
|
||
abort ();
|
||
if (repetition_num != 1 && reserved_units_num > 1)
|
||
fprintf (f, "(");
|
||
reserved_units_num = 0;
|
||
for (unit_num = 0;
|
||
unit_num < description->units_num;
|
||
unit_num++)
|
||
if (TEST_BIT (reservs, start_cycle * els_in_cycle_reserv
|
||
* sizeof (set_el_t) * CHAR_BIT + unit_num))
|
||
{
|
||
if (reserved_units_num != 0)
|
||
fprintf (f, "+");
|
||
reserved_units_num++;
|
||
fprintf (f, "%s", units_array [unit_num]->name);
|
||
}
|
||
if (reserved_units_num == 0)
|
||
fprintf (f, NOTHING_NAME);
|
||
if (repetition_num <= 0)
|
||
abort ();
|
||
if (reserved_units_num > 1)
|
||
fprintf (f, ")");
|
||
if (repetition_num != 1)
|
||
fprintf (f, "*%d", repetition_num);
|
||
}
|
||
|
||
/* The function outputs string representation of units reservation in
|
||
the reservation set. */
|
||
static void
|
||
output_reserv_sets (f, reservs)
|
||
FILE *f;
|
||
reserv_sets_t reservs;
|
||
{
|
||
int start_cycle = 0;
|
||
int cycle;
|
||
int repetition_num;
|
||
|
||
repetition_num = 0;
|
||
for (cycle = 0; cycle < max_cycles_num; cycle++)
|
||
if (repetition_num == 0)
|
||
{
|
||
repetition_num++;
|
||
start_cycle = cycle;
|
||
}
|
||
else if (memcmp
|
||
((char *) reservs + start_cycle * els_in_cycle_reserv
|
||
* sizeof (set_el_t),
|
||
(char *) reservs + cycle * els_in_cycle_reserv
|
||
* sizeof (set_el_t),
|
||
els_in_cycle_reserv * sizeof (set_el_t)) == 0)
|
||
repetition_num++;
|
||
else
|
||
{
|
||
if (start_cycle != 0)
|
||
fprintf (f, ", ");
|
||
output_cycle_reservs (f, reservs, start_cycle, repetition_num);
|
||
repetition_num = 1;
|
||
start_cycle = cycle;
|
||
}
|
||
if (start_cycle < max_cycles_num)
|
||
{
|
||
if (start_cycle != 0)
|
||
fprintf (f, ", ");
|
||
output_cycle_reservs (f, reservs, start_cycle, repetition_num);
|
||
}
|
||
}
|
||
|
||
/* The following function returns free node state for AUTOMATON. It
|
||
may be new allocated node or node freed eralier. 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;
|
||
{
|
||
state_t result;
|
||
|
||
if (max_cycles_num <= 0 || automaton == NULL)
|
||
abort ();
|
||
if (VLA_PTR_LENGTH (free_states) != 0)
|
||
{
|
||
result = VLA_PTR (free_states, VLA_PTR_LENGTH (free_states) - 1);
|
||
VLA_PTR_SHORTEN (free_states, 1);
|
||
result->automaton = automaton;
|
||
result->first_out_arc = NULL;
|
||
result->it_was_placed_in_stack_for_NDFA_forming = 0;
|
||
result->it_was_placed_in_stack_for_DFA_forming = 0;
|
||
result->component_states = NULL;
|
||
result->longest_path_length = UNDEFINED_LONGEST_PATH_LENGTH;
|
||
}
|
||
else
|
||
{
|
||
#ifndef NDEBUG
|
||
allocated_states_num++;
|
||
#endif
|
||
result = create_node (sizeof (struct state));
|
||
result->automaton = automaton;
|
||
result->first_out_arc = NULL;
|
||
result->unique_num = curr_unique_state_num;
|
||
result->longest_path_length = UNDEFINED_LONGEST_PATH_LENGTH;
|
||
curr_unique_state_num++;
|
||
}
|
||
if (with_reservs)
|
||
{
|
||
if (result->reservs == NULL)
|
||
result->reservs = alloc_empty_reserv_sets ();
|
||
else
|
||
memset (result->reservs, 0, els_in_reservs * sizeof (set_el_t));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* The function frees node STATE. */
|
||
static void
|
||
free_state (state)
|
||
state_t state;
|
||
{
|
||
free_alt_states (state->component_states);
|
||
VLA_PTR_ADD (free_states, state);
|
||
}
|
||
|
||
/* Hash value of STATE. If STATE represents deterministic state it is
|
||
simply hash value of the corresponding reservation set. Otherwise
|
||
it is formed from hash values of the component deterministic
|
||
states. One more key is order number of state automaton. */
|
||
static hashval_t
|
||
state_hash (state)
|
||
const void *state;
|
||
{
|
||
unsigned int hash_value;
|
||
alt_state_t alt_state;
|
||
|
||
if (((state_t) state)->component_states == NULL)
|
||
hash_value = reserv_sets_hash_value (((state_t) state)->reservs);
|
||
else
|
||
{
|
||
hash_value = 0;
|
||
for (alt_state = ((state_t) state)->component_states;
|
||
alt_state != NULL;
|
||
alt_state = alt_state->next_sorted_alt_state)
|
||
hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
|
||
| (hash_value << CHAR_BIT))
|
||
+ alt_state->state->unique_num);
|
||
}
|
||
hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
|
||
| (hash_value << CHAR_BIT))
|
||
+ ((state_t) state)->automaton->automaton_order_num);
|
||
return hash_value;
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
alt_state_t alt_state_1;
|
||
alt_state_t alt_state_2;
|
||
|
||
if (((state_t) state_1)->automaton != ((state_t) state_2)->automaton)
|
||
return 0;
|
||
else if (((state_t) state_1)->component_states == NULL
|
||
&& ((state_t) state_2)->component_states == NULL)
|
||
return reserv_sets_eq (((state_t) state_1)->reservs,
|
||
((state_t) state_2)->reservs);
|
||
else if (((state_t) state_1)->component_states != NULL
|
||
&& ((state_t) state_2)->component_states != NULL)
|
||
{
|
||
for (alt_state_1 = ((state_t) state_1)->component_states,
|
||
alt_state_2 = ((state_t) state_2)->component_states;
|
||
alt_state_1 != NULL && alt_state_2 != NULL;
|
||
alt_state_1 = alt_state_1->next_sorted_alt_state,
|
||
alt_state_2 = alt_state_2->next_sorted_alt_state)
|
||
/* All state in the list must be already in the hash table.
|
||
Also the lists must be sorted. */
|
||
if (alt_state_1->state != alt_state_2->state)
|
||
return 0;
|
||
return alt_state_1 == alt_state_2;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
/* Insert STATE into the state table. */
|
||
static state_t
|
||
insert_state (state)
|
||
state_t state;
|
||
{
|
||
void **entry_ptr;
|
||
|
||
entry_ptr = htab_find_slot (state_table, (void *) state, 1);
|
||
if (*entry_ptr == NULL)
|
||
*entry_ptr = (void *) state;
|
||
return (state_t) *entry_ptr;
|
||
}
|
||
|
||
/* Add reservation of unit with UNIT_NUM on cycle CYCLE_NUM to
|
||
deterministic STATE. */
|
||
static void
|
||
set_state_reserv (state, cycle_num, unit_num)
|
||
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;
|
||
{
|
||
if (state1->automaton != state2->automaton)
|
||
abort ();
|
||
return reserv_sets_are_intersected (state1->reservs, state2->reservs);
|
||
}
|
||
|
||
/* Return deterministic state (inserted into the table) which
|
||
representing the automaton state whic is union of reservations of
|
||
deterministic states. */
|
||
static state_t
|
||
states_union (state1, state2)
|
||
state_t state1;
|
||
state_t state2;
|
||
{
|
||
state_t result;
|
||
state_t state_in_table;
|
||
|
||
if (state1->automaton != state2->automaton)
|
||
abort ();
|
||
result = get_free_state (1, state1->automaton);
|
||
reserv_sets_or (result->reservs, state1->reservs, state2->reservs);
|
||
state_in_table = insert_state (result);
|
||
if (result != state_in_table)
|
||
{
|
||
free_state (result);
|
||
result = state_in_table;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* Return deterministic state (inserted into the table) which
|
||
represent the automaton state is obtained from deterministic STATE
|
||
by advancing cpu cycle. */
|
||
static state_t
|
||
state_shift (state)
|
||
state_t state;
|
||
{
|
||
state_t result;
|
||
state_t state_in_table;
|
||
|
||
result = get_free_state (1, state->automaton);
|
||
reserv_sets_shift (result->reservs, state->reservs);
|
||
state_in_table = insert_state (result);
|
||
if (result != state_in_table)
|
||
{
|
||
free_state (result);
|
||
result = state_in_table;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* Initialization of the abstract data. */
|
||
static void
|
||
initiate_states ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
VLA_PTR_CREATE (units_container, description->units_num, "units_container");
|
||
units_array
|
||
= (description->decls_num && description->units_num
|
||
? VLA_PTR_BEGIN (units_container) : NULL);
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
units_array [DECL_UNIT (decl)->unit_num] = DECL_UNIT (decl);
|
||
}
|
||
max_cycles_num = description->max_insn_reserv_cycles;
|
||
els_in_cycle_reserv
|
||
= ((description->units_num + sizeof (set_el_t) * CHAR_BIT - 1)
|
||
/ (sizeof (set_el_t) * CHAR_BIT));
|
||
els_in_reservs = els_in_cycle_reserv * max_cycles_num;
|
||
curr_unique_state_num = 0;
|
||
initiate_alt_states ();
|
||
VLA_PTR_CREATE (free_states, 1500, "free states");
|
||
state_table = htab_create (1500, state_hash, state_eq_p, (htab_del) 0);
|
||
empty_reserv = alloc_empty_reserv_sets ();
|
||
}
|
||
|
||
/* Finisging work with the abstract data. */
|
||
static void
|
||
finish_states ()
|
||
{
|
||
VLA_PTR_DELETE (units_container);
|
||
htab_delete (state_table);
|
||
VLA_PTR_DELETE (free_states);
|
||
finish_alt_states ();
|
||
}
|
||
|
||
|
||
|
||
/* Abstract data `arcs'. */
|
||
|
||
/* List of free arcs. */
|
||
static arc_t first_free_arc;
|
||
|
||
#ifndef NDEBUG
|
||
/* The following variables is maximal number of allocated nodes
|
||
`arc'. */
|
||
static int allocated_arcs_num = 0;
|
||
#endif
|
||
|
||
/* The function frees node ARC. */
|
||
static void
|
||
free_arc (arc)
|
||
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;
|
||
{
|
||
arc_t prev_arc;
|
||
arc_t curr_arc;
|
||
|
||
if (arc == NULL)
|
||
abort ();
|
||
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 ();
|
||
if (prev_arc == NULL)
|
||
from_state->first_out_arc = arc->next_out_arc;
|
||
else
|
||
prev_arc->next_out_arc = arc->next_out_arc;
|
||
free_arc (arc);
|
||
}
|
||
|
||
/* The functions returns arc with given characteristics (or NULL if
|
||
the arc does not exist). */
|
||
static arc_t
|
||
find_arc (from_state, to_state, insn)
|
||
state_t from_state;
|
||
state_t to_state;
|
||
ainsn_t insn;
|
||
{
|
||
arc_t arc;
|
||
|
||
for (arc = first_out_arc (from_state); arc != NULL; arc = next_out_arc (arc))
|
||
if (arc->to_state == to_state && arc->insn == insn)
|
||
return arc;
|
||
return NULL;
|
||
}
|
||
|
||
/* The function adds arc from FROM_STATE to TO_STATE marked by AINSN
|
||
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;
|
||
{
|
||
arc_t new_arc;
|
||
|
||
new_arc = find_arc (from_state, to_state, ainsn);
|
||
if (new_arc != NULL)
|
||
return new_arc;
|
||
if (first_free_arc == NULL)
|
||
{
|
||
#ifndef NDEBUG
|
||
allocated_arcs_num++;
|
||
#endif
|
||
new_arc = create_node (sizeof (struct arc));
|
||
new_arc->to_state = NULL;
|
||
new_arc->insn = NULL;
|
||
new_arc->next_out_arc = NULL;
|
||
}
|
||
else
|
||
{
|
||
new_arc = first_free_arc;
|
||
first_free_arc = first_free_arc->next_out_arc;
|
||
}
|
||
new_arc->to_state = to_state;
|
||
new_arc->insn = ainsn;
|
||
ainsn->arc_exists_p = 1;
|
||
new_arc->next_out_arc = from_state->first_out_arc;
|
||
from_state->first_out_arc = new_arc;
|
||
new_arc->next_arc_marked_by_insn = NULL;
|
||
new_arc->state_alts = state_alts;
|
||
return new_arc;
|
||
}
|
||
|
||
/* The function returns the first arc starting from STATE. */
|
||
static arc_t
|
||
first_out_arc (state)
|
||
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;
|
||
{
|
||
return arc->next_out_arc;
|
||
}
|
||
|
||
/* Initialization of the abstract data. */
|
||
static void
|
||
initiate_arcs ()
|
||
{
|
||
first_free_arc = NULL;
|
||
}
|
||
|
||
/* Finishing work with the abstract data. */
|
||
static void
|
||
finish_arcs ()
|
||
{
|
||
}
|
||
|
||
|
||
|
||
/* Abstract data `automata lists'. */
|
||
|
||
/* List of free states. */
|
||
static automata_list_el_t first_free_automata_list_el;
|
||
|
||
/* The list being formed. */
|
||
static automata_list_el_t current_automata_list;
|
||
|
||
/* Hash table of automata lists. */
|
||
static htab_t automata_list_table;
|
||
|
||
/* The following function returns free automata list el. It may be
|
||
new allocated node or node freed earlier. */
|
||
static automata_list_el_t
|
||
get_free_automata_list_el ()
|
||
{
|
||
automata_list_el_t result;
|
||
|
||
if (first_free_automata_list_el != NULL)
|
||
{
|
||
result = first_free_automata_list_el;
|
||
first_free_automata_list_el
|
||
= first_free_automata_list_el->next_automata_list_el;
|
||
}
|
||
else
|
||
result = create_node (sizeof (struct automata_list_el));
|
||
result->automaton = NULL;
|
||
result->next_automata_list_el = NULL;
|
||
return result;
|
||
}
|
||
|
||
/* The function frees node AUTOMATA_LIST_EL. */
|
||
static void
|
||
free_automata_list_el (automata_list_el)
|
||
automata_list_el_t automata_list_el;
|
||
{
|
||
if (automata_list_el == NULL)
|
||
return;
|
||
automata_list_el->next_automata_list_el = first_free_automata_list_el;
|
||
first_free_automata_list_el = automata_list_el;
|
||
}
|
||
|
||
/* The function frees list AUTOMATA_LIST. */
|
||
static void
|
||
free_automata_list (automata_list)
|
||
automata_list_el_t automata_list;
|
||
{
|
||
automata_list_el_t curr_automata_list_el;
|
||
automata_list_el_t next_automata_list_el;
|
||
|
||
for (curr_automata_list_el = automata_list;
|
||
curr_automata_list_el != NULL;
|
||
curr_automata_list_el = next_automata_list_el)
|
||
{
|
||
next_automata_list_el = curr_automata_list_el->next_automata_list_el;
|
||
free_automata_list_el (curr_automata_list_el);
|
||
}
|
||
}
|
||
|
||
/* Hash value of AUTOMATA_LIST. */
|
||
static hashval_t
|
||
automata_list_hash (automata_list)
|
||
const void *automata_list;
|
||
{
|
||
unsigned int hash_value;
|
||
automata_list_el_t curr_automata_list_el;
|
||
|
||
hash_value = 0;
|
||
for (curr_automata_list_el = (automata_list_el_t) automata_list;
|
||
curr_automata_list_el != NULL;
|
||
curr_automata_list_el = curr_automata_list_el->next_automata_list_el)
|
||
hash_value = (((hash_value >> (sizeof (unsigned) - 1) * CHAR_BIT)
|
||
| (hash_value << CHAR_BIT))
|
||
+ curr_automata_list_el->automaton->automaton_order_num);
|
||
return hash_value;
|
||
}
|
||
|
||
/* Return nonzero value if the automata_lists are the same. */
|
||
static int
|
||
automata_list_eq_p (automata_list_1, automata_list_2)
|
||
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;
|
||
|
||
for (automata_list_el_1 = (automata_list_el_t) automata_list_1,
|
||
automata_list_el_2 = (automata_list_el_t) automata_list_2;
|
||
automata_list_el_1 != NULL && automata_list_el_2 != NULL;
|
||
automata_list_el_1 = automata_list_el_1->next_automata_list_el,
|
||
automata_list_el_2 = automata_list_el_2->next_automata_list_el)
|
||
if (automata_list_el_1->automaton != automata_list_el_2->automaton)
|
||
return 0;
|
||
return automata_list_el_1 == automata_list_el_2;
|
||
}
|
||
|
||
/* Initialization of the abstract data. */
|
||
static void
|
||
initiate_automata_lists ()
|
||
{
|
||
first_free_automata_list_el = NULL;
|
||
automata_list_table = htab_create (1500, automata_list_hash,
|
||
automata_list_eq_p, (htab_del) 0);
|
||
}
|
||
|
||
/* The following function starts new automata list and makes it the
|
||
current one. */
|
||
static void
|
||
automata_list_start ()
|
||
{
|
||
current_automata_list = NULL;
|
||
}
|
||
|
||
/* The following function adds AUTOMATON to the current list. */
|
||
static void
|
||
automata_list_add (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
automata_list_el_t el;
|
||
|
||
el = get_free_automata_list_el ();
|
||
el->automaton = automaton;
|
||
el->next_automata_list_el = current_automata_list;
|
||
current_automata_list = el;
|
||
}
|
||
|
||
/* The following function finishes forming the current list, inserts
|
||
it into the table and returns it. */
|
||
static automata_list_el_t
|
||
automata_list_finish ()
|
||
{
|
||
void **entry_ptr;
|
||
|
||
if (current_automata_list == NULL)
|
||
return NULL;
|
||
entry_ptr = htab_find_slot (automata_list_table,
|
||
(void *) current_automata_list, 1);
|
||
if (*entry_ptr == NULL)
|
||
*entry_ptr = (void *) current_automata_list;
|
||
else
|
||
free_automata_list (current_automata_list);
|
||
current_automata_list = NULL;
|
||
return (automata_list_el_t) *entry_ptr;
|
||
}
|
||
|
||
/* Finishing work with the abstract data. */
|
||
static void
|
||
finish_automata_lists ()
|
||
{
|
||
htab_delete (automata_list_table);
|
||
}
|
||
|
||
|
||
|
||
/* The page contains abstract data for work with exclusion sets (see
|
||
exclusion_set in file rtl.def). */
|
||
|
||
/* The following variable refers to an exclusion set returned by
|
||
get_excl_set. This is bit string of length equal to cpu units
|
||
number. If exclusion set for given unit contains 1 for a unit,
|
||
then simultaneous reservation of the units is prohibited. */
|
||
static reserv_sets_t excl_set;
|
||
|
||
/* The array contains exclusion sets for each unit. */
|
||
static reserv_sets_t *unit_excl_set_table;
|
||
|
||
/* The following function forms the array containing exclusion sets
|
||
for each unit. */
|
||
static void
|
||
initiate_excl_sets ()
|
||
{
|
||
decl_t decl;
|
||
reserv_sets_t unit_excl_set;
|
||
unit_set_el_t el;
|
||
int i;
|
||
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
excl_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
obstack_blank (&irp, description->units_num * sizeof (reserv_sets_t));
|
||
unit_excl_set_table = (reserv_sets_t *) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
/* Evaluate unit exclusion sets. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
unit_excl_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
memset (unit_excl_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
|
||
for (el = DECL_UNIT (decl)->excl_list;
|
||
el != NULL;
|
||
el = el->next_unit_set_el)
|
||
SET_BIT (unit_excl_set, el->unit_decl->unit_num);
|
||
unit_excl_set_table [DECL_UNIT (decl)->unit_num] = unit_excl_set;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The function sets up and return EXCL_SET which is union of
|
||
exclusion sets for each unit in IN_SET. */
|
||
static reserv_sets_t
|
||
get_excl_set (in_set)
|
||
reserv_sets_t in_set;
|
||
{
|
||
int excl_char_num;
|
||
int chars_num;
|
||
int i;
|
||
int start_unit_num;
|
||
int unit_num;
|
||
|
||
chars_num = els_in_cycle_reserv * sizeof (set_el_t);
|
||
memset (excl_set, 0, chars_num);
|
||
for (excl_char_num = 0; excl_char_num < chars_num; excl_char_num++)
|
||
if (((unsigned char *) in_set) [excl_char_num])
|
||
for (i = CHAR_BIT - 1; i >= 0; i--)
|
||
if ((((unsigned char *) in_set) [excl_char_num] >> i) & 1)
|
||
{
|
||
start_unit_num = excl_char_num * CHAR_BIT + i;
|
||
if (start_unit_num >= description->units_num)
|
||
return excl_set;
|
||
for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++)
|
||
{
|
||
excl_set [unit_num]
|
||
|= unit_excl_set_table [start_unit_num] [unit_num];
|
||
}
|
||
}
|
||
return excl_set;
|
||
}
|
||
|
||
|
||
|
||
/* The page contains abstract data for work with presence/absence sets
|
||
(see presence_set/absence_set in file rtl.def). */
|
||
|
||
/* The following variables refer to correspondingly a presence and an
|
||
absence set returned by get_presence_absence_set. This is bit
|
||
string of length equal to cpu units number. */
|
||
static reserv_sets_t presence_set, absence_set;
|
||
|
||
/* The following arrays contain correspondingly presence and absence
|
||
sets for each unit. */
|
||
static reserv_sets_t *unit_presence_set_table, *unit_absence_set_table;
|
||
|
||
/* The following function forms the array containing presence and
|
||
absence sets for each unit */
|
||
static void
|
||
initiate_presence_absence_sets ()
|
||
{
|
||
decl_t decl;
|
||
reserv_sets_t unit_set;
|
||
unit_set_el_t el;
|
||
int i;
|
||
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
presence_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
obstack_blank (&irp, description->units_num * sizeof (reserv_sets_t));
|
||
unit_presence_set_table = (reserv_sets_t *) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
absence_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
obstack_blank (&irp, description->units_num * sizeof (reserv_sets_t));
|
||
unit_absence_set_table = (reserv_sets_t *) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
/* Evaluate unit presence/absence sets. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
unit_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
memset (unit_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
|
||
for (el = DECL_UNIT (decl)->presence_list;
|
||
el != NULL;
|
||
el = el->next_unit_set_el)
|
||
SET_BIT (unit_set, el->unit_decl->unit_num);
|
||
unit_presence_set_table [DECL_UNIT (decl)->unit_num] = unit_set;
|
||
|
||
obstack_blank (&irp, els_in_cycle_reserv * sizeof (set_el_t));
|
||
unit_set = (reserv_sets_t) obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
memset (unit_set, 0, els_in_cycle_reserv * sizeof (set_el_t));
|
||
for (el = DECL_UNIT (decl)->absence_list;
|
||
el != NULL;
|
||
el = el->next_unit_set_el)
|
||
SET_BIT (unit_set, el->unit_decl->unit_num);
|
||
unit_absence_set_table [DECL_UNIT (decl)->unit_num] = unit_set;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The function sets up and return PRESENCE_SET (if PRESENCE_P) or
|
||
ABSENCE_SET which is union of corresponding sets for each unit in
|
||
IN_SET. */
|
||
static reserv_sets_t
|
||
get_presence_absence_set (in_set, presence_p)
|
||
reserv_sets_t in_set;
|
||
int presence_p;
|
||
{
|
||
int char_num;
|
||
int chars_num;
|
||
int i;
|
||
int start_unit_num;
|
||
int unit_num;
|
||
|
||
chars_num = els_in_cycle_reserv * sizeof (set_el_t);
|
||
if (presence_p)
|
||
memset (presence_set, 0, chars_num);
|
||
else
|
||
memset (absence_set, 0, chars_num);
|
||
for (char_num = 0; char_num < chars_num; char_num++)
|
||
if (((unsigned char *) in_set) [char_num])
|
||
for (i = CHAR_BIT - 1; i >= 0; i--)
|
||
if ((((unsigned char *) in_set) [char_num] >> i) & 1)
|
||
{
|
||
start_unit_num = char_num * CHAR_BIT + i;
|
||
if (start_unit_num >= description->units_num)
|
||
return (presence_p ? presence_set : absence_set);
|
||
for (unit_num = 0; unit_num < els_in_cycle_reserv; unit_num++)
|
||
if (presence_p)
|
||
presence_set [unit_num]
|
||
|= unit_presence_set_table [start_unit_num] [unit_num];
|
||
else
|
||
absence_set [unit_num]
|
||
|= unit_absence_set_table [start_unit_num] [unit_num];
|
||
}
|
||
return (presence_p ? presence_set : absence_set);
|
||
}
|
||
|
||
|
||
|
||
/* This page contains code for transformation of original reservations
|
||
described in .md file. The main goal of transformations is
|
||
simplifying reservation and lifting up all `|' on the top of IR
|
||
reservation representation. */
|
||
|
||
|
||
/* The following function makes copy of IR representation of
|
||
reservation. The function also substitutes all reservations
|
||
defined by define_reservation by corresponding value during making
|
||
the copy. */
|
||
static regexp_t
|
||
copy_insn_regexp (regexp)
|
||
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)
|
||
{
|
||
result = copy_node (regexp, sizeof (struct regexp));
|
||
REGEXP_REPEAT (result)->regexp
|
||
= copy_insn_regexp (REGEXP_REPEAT (regexp)->regexp);
|
||
}
|
||
else if (regexp->mode == 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)
|
||
{
|
||
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)
|
||
{
|
||
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 ();
|
||
result = copy_node (regexp, sizeof (struct regexp));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* The following variable is set up 1 if a transformation has been
|
||
applied. */
|
||
static int regexp_transformed_p;
|
||
|
||
/* The function makes transformation
|
||
A*N -> A, A, ... */
|
||
static regexp_t
|
||
transform_1 (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
int i;
|
||
int repeat_num;
|
||
regexp_t operand;
|
||
pos_t pos;
|
||
|
||
if (regexp->mode == rm_repeat)
|
||
{
|
||
repeat_num = REGEXP_REPEAT (regexp)->repeat_num;
|
||
if (repeat_num <= 1)
|
||
abort ();
|
||
operand = REGEXP_REPEAT (regexp)->regexp;
|
||
pos = regexp->mode;
|
||
regexp = create_node (sizeof (struct regexp) + sizeof (regexp_t)
|
||
* (repeat_num - 1));
|
||
regexp->mode = rm_sequence;
|
||
regexp->pos = pos;
|
||
REGEXP_SEQUENCE (regexp)->regexps_num = repeat_num;
|
||
for (i = 0; i < repeat_num; i++)
|
||
REGEXP_SEQUENCE (regexp)->regexps [i] = copy_insn_regexp (operand);
|
||
regexp_transformed_p = 1;
|
||
}
|
||
return regexp;
|
||
}
|
||
|
||
/* The function makes transformations
|
||
...,(A,B,...),C,... -> ...,A,B,...,C,...
|
||
...+(A+B+...)+C+... -> ...+A+B+...+C+...
|
||
...|(A|B|...)|C|... -> ...|A|B|...|C|... */
|
||
static regexp_t
|
||
transform_2 (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
if (regexp->mode == rm_sequence)
|
||
{
|
||
regexp_t sequence = NULL;
|
||
regexp_t result;
|
||
int sequence_index = 0;
|
||
int i, j;
|
||
|
||
for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
|
||
if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_sequence)
|
||
{
|
||
sequence_index = i;
|
||
sequence = REGEXP_SEQUENCE (regexp)->regexps [i];
|
||
break;
|
||
}
|
||
if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
|
||
{
|
||
if ( REGEXP_SEQUENCE (sequence)->regexps_num <= 1
|
||
|| REGEXP_SEQUENCE (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_SEQUENCE (regexp)->regexps_num
|
||
+ REGEXP_SEQUENCE (sequence)->regexps_num
|
||
- 2));
|
||
result->mode = rm_sequence;
|
||
result->pos = regexp->pos;
|
||
REGEXP_SEQUENCE (result)->regexps_num
|
||
= (REGEXP_SEQUENCE (regexp)->regexps_num
|
||
+ REGEXP_SEQUENCE (sequence)->regexps_num - 1);
|
||
for (i = 0; i < REGEXP_SEQUENCE (regexp)->regexps_num; i++)
|
||
if (i < sequence_index)
|
||
REGEXP_SEQUENCE (result)->regexps [i]
|
||
= copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
|
||
else if (i > sequence_index)
|
||
REGEXP_SEQUENCE (result)->regexps
|
||
[i + REGEXP_SEQUENCE (sequence)->regexps_num - 1]
|
||
= copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
|
||
else
|
||
for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
|
||
REGEXP_SEQUENCE (result)->regexps [i + j]
|
||
= copy_insn_regexp (REGEXP_SEQUENCE (sequence)->regexps [j]);
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
}
|
||
else if (regexp->mode == rm_allof)
|
||
{
|
||
regexp_t allof = NULL;
|
||
regexp_t result;
|
||
int allof_index = 0;
|
||
int i, j;
|
||
|
||
for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
|
||
if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_allof)
|
||
{
|
||
allof_index = i;
|
||
allof = REGEXP_ALLOF (regexp)->regexps [i];
|
||
break;
|
||
}
|
||
if (i < REGEXP_ALLOF (regexp)->regexps_num)
|
||
{
|
||
if (REGEXP_ALLOF (allof)->regexps_num <= 1
|
||
|| REGEXP_ALLOF (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_ALLOF (regexp)->regexps_num
|
||
+ REGEXP_ALLOF (allof)->regexps_num - 2));
|
||
result->mode = rm_allof;
|
||
result->pos = regexp->pos;
|
||
REGEXP_ALLOF (result)->regexps_num
|
||
= (REGEXP_ALLOF (regexp)->regexps_num
|
||
+ REGEXP_ALLOF (allof)->regexps_num - 1);
|
||
for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
|
||
if (i < allof_index)
|
||
REGEXP_ALLOF (result)->regexps [i]
|
||
= copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
|
||
else if (i > allof_index)
|
||
REGEXP_ALLOF (result)->regexps
|
||
[i + REGEXP_ALLOF (allof)->regexps_num - 1]
|
||
= copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
|
||
else
|
||
for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
|
||
REGEXP_ALLOF (result)->regexps [i + j]
|
||
= copy_insn_regexp (REGEXP_ALLOF (allof)->regexps [j]);
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
}
|
||
else if (regexp->mode == rm_oneof)
|
||
{
|
||
regexp_t oneof = NULL;
|
||
regexp_t result;
|
||
int oneof_index = 0;
|
||
int i, j;
|
||
|
||
for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
|
||
if (REGEXP_ONEOF (regexp)->regexps [i]->mode == rm_oneof)
|
||
{
|
||
oneof_index = i;
|
||
oneof = REGEXP_ONEOF (regexp)->regexps [i];
|
||
break;
|
||
}
|
||
if (i < REGEXP_ONEOF (regexp)->regexps_num)
|
||
{
|
||
if (REGEXP_ONEOF (oneof)->regexps_num <= 1
|
||
|| REGEXP_ONEOF (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_ONEOF (regexp)->regexps_num
|
||
+ REGEXP_ONEOF (oneof)->regexps_num - 2));
|
||
result->mode = rm_oneof;
|
||
result->pos = regexp->pos;
|
||
REGEXP_ONEOF (result)->regexps_num
|
||
= (REGEXP_ONEOF (regexp)->regexps_num
|
||
+ REGEXP_ONEOF (oneof)->regexps_num - 1);
|
||
for (i = 0; i < REGEXP_ONEOF (regexp)->regexps_num; i++)
|
||
if (i < oneof_index)
|
||
REGEXP_ONEOF (result)->regexps [i]
|
||
= copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
|
||
else if (i > oneof_index)
|
||
REGEXP_ONEOF (result)->regexps
|
||
[i + REGEXP_ONEOF (oneof)->regexps_num - 1]
|
||
= copy_insn_regexp (REGEXP_ONEOF (regexp)->regexps [i]);
|
||
else
|
||
for (j = 0; j < REGEXP_ONEOF (oneof)->regexps_num; j++)
|
||
REGEXP_ONEOF (result)->regexps [i + j]
|
||
= copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [j]);
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
}
|
||
return regexp;
|
||
}
|
||
|
||
/* The function makes transformations
|
||
...,A|B|...,C,... -> (...,A,C,...)|(...,B,C,...)|...
|
||
...+(A|B|...)+C+... -> (...+A+C+...)|(...+B+C+...)|...
|
||
...+(A,B,...)+C+... -> (...+A+C+...),B,...
|
||
...+(A,B,...)+(C,D,...) -> (A+C),(B+D),... */
|
||
static regexp_t
|
||
transform_3 (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
if (regexp->mode == rm_sequence)
|
||
{
|
||
regexp_t oneof = NULL;
|
||
int oneof_index = 0;
|
||
regexp_t result;
|
||
regexp_t sequence;
|
||
int i, j;
|
||
|
||
for (i = 0; i <REGEXP_SEQUENCE (regexp)->regexps_num; i++)
|
||
if (REGEXP_SEQUENCE (regexp)->regexps [i]->mode == rm_oneof)
|
||
{
|
||
oneof_index = i;
|
||
oneof = REGEXP_SEQUENCE (regexp)->regexps [i];
|
||
break;
|
||
}
|
||
if (i < REGEXP_SEQUENCE (regexp)->regexps_num)
|
||
{
|
||
if (REGEXP_ONEOF (oneof)->regexps_num <= 1
|
||
|| REGEXP_SEQUENCE (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_ONEOF (oneof)->regexps_num - 1));
|
||
result->mode = rm_oneof;
|
||
result->pos = regexp->pos;
|
||
REGEXP_ONEOF (result)->regexps_num
|
||
= REGEXP_ONEOF (oneof)->regexps_num;
|
||
for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
|
||
{
|
||
sequence
|
||
= create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_SEQUENCE (regexp)->regexps_num - 1));
|
||
sequence->mode = rm_sequence;
|
||
sequence->pos = regexp->pos;
|
||
REGEXP_SEQUENCE (sequence)->regexps_num
|
||
= REGEXP_SEQUENCE (regexp)->regexps_num;
|
||
REGEXP_ONEOF (result)->regexps [i] = sequence;
|
||
for (j = 0; j < REGEXP_SEQUENCE (sequence)->regexps_num; j++)
|
||
if (j != oneof_index)
|
||
REGEXP_SEQUENCE (sequence)->regexps [j]
|
||
= copy_insn_regexp (REGEXP_SEQUENCE (regexp)->regexps [j]);
|
||
else
|
||
REGEXP_SEQUENCE (sequence)->regexps [j]
|
||
= copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
|
||
}
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
}
|
||
else if (regexp->mode == rm_allof)
|
||
{
|
||
regexp_t oneof = NULL, seq;
|
||
int oneof_index = 0, max_seq_length, allof_length;
|
||
regexp_t result;
|
||
regexp_t allof = NULL, allof_op = NULL;
|
||
int i, j;
|
||
|
||
for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
|
||
if (REGEXP_ALLOF (regexp)->regexps [i]->mode == rm_oneof)
|
||
{
|
||
oneof_index = i;
|
||
oneof = REGEXP_ALLOF (regexp)->regexps [i];
|
||
break;
|
||
}
|
||
if (i < REGEXP_ALLOF (regexp)->regexps_num)
|
||
{
|
||
if (REGEXP_ONEOF (oneof)->regexps_num <= 1
|
||
|| REGEXP_ALLOF (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_ONEOF (oneof)->regexps_num - 1));
|
||
result->mode = rm_oneof;
|
||
result->pos = regexp->pos;
|
||
REGEXP_ONEOF (result)->regexps_num
|
||
= REGEXP_ONEOF (oneof)->regexps_num;
|
||
for (i = 0; i < REGEXP_ONEOF (result)->regexps_num; i++)
|
||
{
|
||
allof
|
||
= create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (REGEXP_ALLOF (regexp)->regexps_num - 1));
|
||
allof->mode = rm_allof;
|
||
allof->pos = regexp->pos;
|
||
REGEXP_ALLOF (allof)->regexps_num
|
||
= REGEXP_ALLOF (regexp)->regexps_num;
|
||
REGEXP_ONEOF (result)->regexps [i] = allof;
|
||
for (j = 0; j < REGEXP_ALLOF (allof)->regexps_num; j++)
|
||
if (j != oneof_index)
|
||
REGEXP_ALLOF (allof)->regexps [j]
|
||
= copy_insn_regexp (REGEXP_ALLOF (regexp)->regexps [j]);
|
||
else
|
||
REGEXP_ALLOF (allof)->regexps [j]
|
||
= copy_insn_regexp (REGEXP_ONEOF (oneof)->regexps [i]);
|
||
}
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
max_seq_length = 0;
|
||
if (regexp->mode == rm_allof)
|
||
for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
|
||
{
|
||
if (REGEXP_ALLOF (regexp)->regexps [i]->mode == 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)
|
||
{
|
||
max_seq_length = 0;
|
||
break;
|
||
}
|
||
}
|
||
if (max_seq_length != 0)
|
||
{
|
||
if (max_seq_length == 1 || REGEXP_ALLOF (regexp)->regexps_num <= 1)
|
||
abort ();
|
||
result = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t) * (max_seq_length - 1));
|
||
result->mode = rm_sequence;
|
||
result->pos = regexp->pos;
|
||
REGEXP_SEQUENCE (result)->regexps_num = max_seq_length;
|
||
for (i = 0; i < max_seq_length; i++)
|
||
{
|
||
allof_length = 0;
|
||
for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
|
||
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))
|
||
{
|
||
allof_op = REGEXP_ALLOF (regexp)->regexps [j];
|
||
allof_length++;
|
||
}
|
||
if (allof_length == 1)
|
||
REGEXP_SEQUENCE (result)->regexps [i] = allof_op;
|
||
else
|
||
{
|
||
allof = create_node (sizeof (struct regexp)
|
||
+ sizeof (regexp_t)
|
||
* (allof_length - 1));
|
||
allof->mode = rm_allof;
|
||
allof->pos = regexp->pos;
|
||
REGEXP_ALLOF (allof)->regexps_num = allof_length;
|
||
REGEXP_SEQUENCE (result)->regexps [i] = allof;
|
||
allof_length = 0;
|
||
for (j = 0; j < REGEXP_ALLOF (regexp)->regexps_num; j++)
|
||
if (REGEXP_ALLOF (regexp)->regexps [j]->mode == rm_sequence
|
||
&& (i <
|
||
(REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
|
||
->regexps [j])->regexps_num)))
|
||
{
|
||
allof_op = (REGEXP_SEQUENCE (REGEXP_ALLOF (regexp)
|
||
->regexps [j])
|
||
->regexps [i]);
|
||
REGEXP_ALLOF (allof)->regexps [allof_length]
|
||
= allof_op;
|
||
allof_length++;
|
||
}
|
||
else if (i == 0
|
||
&& (REGEXP_ALLOF (regexp)->regexps [j]->mode
|
||
== rm_unit))
|
||
{
|
||
allof_op = REGEXP_ALLOF (regexp)->regexps [j];
|
||
REGEXP_ALLOF (allof)->regexps [allof_length]
|
||
= allof_op;
|
||
allof_length++;
|
||
}
|
||
}
|
||
}
|
||
regexp_transformed_p = 1;
|
||
regexp = result;
|
||
}
|
||
}
|
||
return regexp;
|
||
}
|
||
|
||
/* The function traverses IR of reservation and applies transformations
|
||
implemented by FUNC. */
|
||
static regexp_t
|
||
regexp_transform_func (regexp, func)
|
||
regexp_t regexp;
|
||
regexp_t (*func) PARAMS ((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 ();
|
||
return (*func) (regexp);
|
||
}
|
||
|
||
/* The function applies all transformations for IR representation of
|
||
reservation REGEXP. */
|
||
static regexp_t
|
||
transform_regexp (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
regexp = regexp_transform_func (regexp, transform_1);
|
||
do
|
||
{
|
||
regexp_transformed_p = 0;
|
||
regexp = regexp_transform_func (regexp, transform_2);
|
||
regexp = regexp_transform_func (regexp, transform_3);
|
||
}
|
||
while (regexp_transformed_p);
|
||
return regexp;
|
||
}
|
||
|
||
/* The function applys all transformations for reservations of all
|
||
insn declarations. */
|
||
static void
|
||
transform_insn_regexps ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
transform_time = create_ticker ();
|
||
add_advance_cycle_insn_decl ();
|
||
fprintf (stderr, "Reservation transformation...");
|
||
fflush (stderr);
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
DECL_INSN_RESERV (decl)->transformed_regexp
|
||
= transform_regexp (copy_insn_regexp
|
||
(DECL_INSN_RESERV (decl)->regexp));
|
||
}
|
||
fprintf (stderr, "done\n");
|
||
ticker_off (&transform_time);
|
||
fflush (stderr);
|
||
}
|
||
|
||
|
||
|
||
/* The following variable is an array indexed by cycle. Each element
|
||
contains cyclic list of units which should be in the same cycle. */
|
||
static unit_decl_t *the_same_automaton_lists;
|
||
|
||
/* The function processes all alternative reservations on CYCLE in
|
||
given REGEXP to check the UNIT is not reserved on the all
|
||
alternatives. If it is true, the unit should be in the same
|
||
automaton with other analogous units reserved on CYCLE in given
|
||
REGEXP. */
|
||
static void
|
||
process_unit_to_form_the_same_automaton_unit_lists (unit, regexp, cycle)
|
||
regexp_t unit;
|
||
regexp_t regexp;
|
||
int cycle;
|
||
{
|
||
int i, k;
|
||
regexp_t seq, allof;
|
||
unit_decl_t unit_decl, last;
|
||
|
||
if (regexp == NULL || regexp->mode != rm_oneof)
|
||
abort ();
|
||
unit_decl = REGEXP_UNIT (unit)->unit_decl;
|
||
for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
|
||
{
|
||
seq = REGEXP_ONEOF (regexp)->regexps [i];
|
||
if (seq->mode == rm_sequence)
|
||
{
|
||
if (cycle >= REGEXP_SEQUENCE (seq)->regexps_num)
|
||
break;
|
||
allof = REGEXP_SEQUENCE (seq)->regexps [cycle];
|
||
if (allof->mode == rm_allof)
|
||
{
|
||
for (k = 0; k < REGEXP_ALLOF (allof)->regexps_num; k++)
|
||
if (REGEXP_ALLOF (allof)->regexps [k]->mode == rm_unit
|
||
&& (REGEXP_UNIT (REGEXP_ALLOF (allof)->regexps [k])
|
||
->unit_decl == unit_decl))
|
||
break;
|
||
if (k >= REGEXP_ALLOF (allof)->regexps_num)
|
||
break;
|
||
}
|
||
else if (allof->mode == rm_unit
|
||
&& REGEXP_UNIT (allof)->unit_decl != unit_decl)
|
||
break;
|
||
}
|
||
else if (cycle != 0)
|
||
break;
|
||
else if (seq->mode == rm_allof)
|
||
{
|
||
for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
|
||
if (REGEXP_ALLOF (seq)->regexps [k]->mode == rm_unit
|
||
&& (REGEXP_UNIT (REGEXP_ALLOF (seq)->regexps [k])->unit_decl
|
||
== unit_decl))
|
||
break;
|
||
if (k >= REGEXP_ALLOF (seq)->regexps_num)
|
||
break;
|
||
}
|
||
else if (seq->mode == rm_unit
|
||
&& REGEXP_UNIT (seq)->unit_decl != unit_decl)
|
||
break;
|
||
}
|
||
if (i >= 0)
|
||
{
|
||
if (the_same_automaton_lists [cycle] == NULL)
|
||
the_same_automaton_lists [cycle] = unit_decl;
|
||
else
|
||
{
|
||
for (last = the_same_automaton_lists [cycle];;)
|
||
{
|
||
if (last == unit_decl)
|
||
return;
|
||
if (last->the_same_automaton_unit
|
||
== the_same_automaton_lists [cycle])
|
||
break;
|
||
last = last->the_same_automaton_unit;
|
||
}
|
||
last->the_same_automaton_unit = unit_decl->the_same_automaton_unit;
|
||
unit_decl->the_same_automaton_unit
|
||
= the_same_automaton_lists [cycle];
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The function processes given REGEXP to find units which should be
|
||
in the same automaton. */
|
||
static void
|
||
form_the_same_automaton_unit_lists_from_regexp (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
int i, j, k;
|
||
regexp_t seq, allof, unit;
|
||
|
||
if (regexp == NULL || regexp->mode != rm_oneof)
|
||
return;
|
||
for (i = 0; i < description->max_insn_reserv_cycles; i++)
|
||
the_same_automaton_lists [i] = NULL;
|
||
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++)
|
||
{
|
||
unit = REGEXP_ALLOF (allof)->regexps [k];
|
||
if (unit->mode == rm_unit)
|
||
process_unit_to_form_the_same_automaton_unit_lists
|
||
(unit, regexp, j);
|
||
else if (unit->mode != rm_nothing)
|
||
abort ();
|
||
}
|
||
else if (allof->mode == rm_unit)
|
||
process_unit_to_form_the_same_automaton_unit_lists
|
||
(allof, regexp, j);
|
||
else if (allof->mode != rm_nothing)
|
||
abort ();
|
||
}
|
||
else if (seq->mode == rm_allof)
|
||
for (k = 0; k < REGEXP_ALLOF (seq)->regexps_num; k++)
|
||
{
|
||
unit = REGEXP_ALLOF (seq)->regexps [k];
|
||
if (unit->mode == rm_unit)
|
||
process_unit_to_form_the_same_automaton_unit_lists
|
||
(unit, regexp, 0);
|
||
else if (unit->mode != rm_nothing)
|
||
abort ();
|
||
}
|
||
else if (seq->mode == rm_unit)
|
||
process_unit_to_form_the_same_automaton_unit_lists (seq, regexp, 0);
|
||
else if (seq->mode != rm_nothing)
|
||
abort ();
|
||
}
|
||
}
|
||
|
||
/* The function initializes data to search for units which should be
|
||
in the same automaton and call function
|
||
`form_the_same_automaton_unit_lists_from_regexp' for each insn
|
||
reservation regexp. */
|
||
static void
|
||
form_the_same_automaton_unit_lists ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
the_same_automaton_lists
|
||
= (unit_decl_t *) xmalloc (description->max_insn_reserv_cycles
|
||
* sizeof (unit_decl_t));
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
DECL_UNIT (decl)->the_same_automaton_message_reported_p = FALSE;
|
||
DECL_UNIT (decl)->the_same_automaton_unit = DECL_UNIT (decl);
|
||
}
|
||
}
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
form_the_same_automaton_unit_lists_from_regexp
|
||
(DECL_INSN_RESERV (decl)->transformed_regexp);
|
||
}
|
||
free (the_same_automaton_lists);
|
||
}
|
||
|
||
/* The function finds units which should be in the same automaton and,
|
||
if they are not, reports about it. */
|
||
static void
|
||
check_unit_distributions_to_automata ()
|
||
{
|
||
decl_t decl;
|
||
unit_decl_t start_unit_decl, unit_decl;
|
||
int i;
|
||
|
||
form_the_same_automaton_unit_lists ();
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
start_unit_decl = DECL_UNIT (decl);
|
||
if (!start_unit_decl->the_same_automaton_message_reported_p)
|
||
for (unit_decl = start_unit_decl->the_same_automaton_unit;
|
||
unit_decl != start_unit_decl;
|
||
unit_decl = unit_decl->the_same_automaton_unit)
|
||
if (start_unit_decl->automaton_decl != unit_decl->automaton_decl)
|
||
{
|
||
error ("Units `%s' and `%s' should be in the same automaton",
|
||
start_unit_decl->name, unit_decl->name);
|
||
unit_decl->the_same_automaton_message_reported_p = TRUE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* The page contains code for building alt_states (see comments for
|
||
IR) describing all possible insns reservations of an automaton. */
|
||
|
||
/* Current state being formed for which the current alt_state
|
||
refers. */
|
||
static state_t state_being_formed;
|
||
|
||
/* Current alt_state being formed. */
|
||
static alt_state_t alt_state_being_formed;
|
||
|
||
/* This recursive function processes `,' and units in reservation
|
||
REGEXP for forming alt_states of AUTOMATON. It is believed that
|
||
CURR_CYCLE is start cycle of all reservation REGEXP. */
|
||
static int
|
||
process_seq_for_forming_states (regexp, automaton, curr_cycle)
|
||
regexp_t regexp;
|
||
automaton_t automaton;
|
||
int curr_cycle;
|
||
{
|
||
int i;
|
||
|
||
if (regexp == NULL)
|
||
return curr_cycle;
|
||
else if (regexp->mode == 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)
|
||
{
|
||
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 ();
|
||
return curr_cycle;
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
state_t state_in_table;
|
||
state_t corresponding_state;
|
||
|
||
corresponding_state = alt_state->state;
|
||
state_in_table = insert_state (corresponding_state);
|
||
if (state_in_table != corresponding_state)
|
||
{
|
||
free_state (corresponding_state);
|
||
alt_state->state = state_in_table;
|
||
}
|
||
}
|
||
|
||
/* The following variable value is current automaton insn for whose
|
||
reservation the alt states are created. */
|
||
static ainsn_t curr_ainsn;
|
||
|
||
/* This recursive function processes `|' in reservation REGEXP for
|
||
forming alt_states of AUTOMATON. List of the alt states should
|
||
have the same order as in the description. */
|
||
static void
|
||
process_alts_for_forming_states (regexp, automaton, inside_oneof_p)
|
||
regexp_t regexp;
|
||
automaton_t automaton;
|
||
int inside_oneof_p;
|
||
{
|
||
int i;
|
||
|
||
if (regexp->mode != rm_oneof)
|
||
{
|
||
alt_state_being_formed = get_free_alt_state ();
|
||
state_being_formed = get_free_state (1, automaton);
|
||
alt_state_being_formed->state = state_being_formed;
|
||
/* We inserts in reverse order but we process alternatives also
|
||
in reverse order. So we have the same order of alternative
|
||
as in the description. */
|
||
alt_state_being_formed->next_alt_state = curr_ainsn->alt_states;
|
||
curr_ainsn->alt_states = alt_state_being_formed;
|
||
(void) process_seq_for_forming_states (regexp, automaton, 0);
|
||
finish_forming_alt_state (alt_state_being_formed, automaton);
|
||
}
|
||
else
|
||
{
|
||
if (inside_oneof_p)
|
||
abort ();
|
||
/* We processes it in reverse order to get list with the same
|
||
order as in the description. See also the previous
|
||
commentary. */
|
||
for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
|
||
process_alts_for_forming_states (REGEXP_ONEOF (regexp)->regexps [i],
|
||
automaton, 1);
|
||
}
|
||
}
|
||
|
||
/* Create nodes alt_state for all AUTOMATON insns. */
|
||
static void
|
||
create_alt_states (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
struct insn_reserv_decl *reserv_decl;
|
||
|
||
for (curr_ainsn = automaton->ainsn_list;
|
||
curr_ainsn != NULL;
|
||
curr_ainsn = curr_ainsn->next_ainsn)
|
||
{
|
||
reserv_decl = curr_ainsn->insn_reserv_decl;
|
||
if (reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
|
||
{
|
||
curr_ainsn->alt_states = NULL;
|
||
process_alts_for_forming_states (reserv_decl->transformed_regexp,
|
||
automaton, 0);
|
||
curr_ainsn->sorted_alt_states
|
||
= uniq_sort_alt_states (curr_ainsn->alt_states);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* The page contains major code for building DFA(s) for fast pipeline
|
||
hazards recognition. */
|
||
|
||
/* The function forms list of ainsns of AUTOMATON with the same
|
||
reservation. */
|
||
static void
|
||
form_ainsn_with_same_reservs (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
ainsn_t curr_ainsn;
|
||
size_t i;
|
||
vla_ptr_t first_insns;
|
||
vla_ptr_t last_insns;
|
||
|
||
VLA_PTR_CREATE (first_insns, 150, "first insns with the same reservs");
|
||
VLA_PTR_CREATE (last_insns, 150, "last insns with the same reservs");
|
||
for (curr_ainsn = automaton->ainsn_list;
|
||
curr_ainsn != NULL;
|
||
curr_ainsn = curr_ainsn->next_ainsn)
|
||
if (curr_ainsn->insn_reserv_decl
|
||
== DECL_INSN_RESERV (advance_cycle_insn_decl))
|
||
{
|
||
curr_ainsn->next_same_reservs_insn = NULL;
|
||
curr_ainsn->first_insn_with_same_reservs = 1;
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < VLA_PTR_LENGTH (first_insns); i++)
|
||
if (alt_states_eq
|
||
(curr_ainsn->sorted_alt_states,
|
||
((ainsn_t) VLA_PTR (first_insns, i))->sorted_alt_states))
|
||
break;
|
||
curr_ainsn->next_same_reservs_insn = NULL;
|
||
if (i < VLA_PTR_LENGTH (first_insns))
|
||
{
|
||
curr_ainsn->first_insn_with_same_reservs = 0;
|
||
((ainsn_t) VLA_PTR (last_insns, i))->next_same_reservs_insn
|
||
= curr_ainsn;
|
||
VLA_PTR (last_insns, i) = curr_ainsn;
|
||
}
|
||
else
|
||
{
|
||
VLA_PTR_ADD (first_insns, curr_ainsn);
|
||
VLA_PTR_ADD (last_insns, curr_ainsn);
|
||
curr_ainsn->first_insn_with_same_reservs = 1;
|
||
}
|
||
}
|
||
VLA_PTR_DELETE (first_insns);
|
||
VLA_PTR_DELETE (last_insns);
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
ainsn_t ainsn;
|
||
struct insn_reserv_decl *insn_reserv_decl;
|
||
alt_state_t alt_state;
|
||
state_t state;
|
||
state_t start_state;
|
||
state_t state2;
|
||
ainsn_t advance_cycle_ainsn;
|
||
arc_t added_arc;
|
||
vla_ptr_t state_stack;
|
||
|
||
VLA_PTR_CREATE (state_stack, 150, "state stack");
|
||
/* Create the start state (empty state). */
|
||
start_state = insert_state (get_free_state (1, automaton));
|
||
automaton->start_state = start_state;
|
||
start_state->it_was_placed_in_stack_for_NDFA_forming = 1;
|
||
VLA_PTR_ADD (state_stack, start_state);
|
||
while (VLA_PTR_LENGTH (state_stack) != 0)
|
||
{
|
||
state = VLA_PTR (state_stack, VLA_PTR_LENGTH (state_stack) - 1);
|
||
VLA_PTR_SHORTEN (state_stack, 1);
|
||
advance_cycle_ainsn = NULL;
|
||
for (ainsn = automaton->ainsn_list;
|
||
ainsn != NULL;
|
||
ainsn = ainsn->next_ainsn)
|
||
if (ainsn->first_insn_with_same_reservs)
|
||
{
|
||
insn_reserv_decl = ainsn->insn_reserv_decl;
|
||
if (insn_reserv_decl != DECL_INSN_RESERV (advance_cycle_insn_decl))
|
||
{
|
||
/* We process alt_states in the same order as they are
|
||
present in the description. */
|
||
added_arc = NULL;
|
||
for (alt_state = ainsn->alt_states;
|
||
alt_state != NULL;
|
||
alt_state = alt_state->next_alt_state)
|
||
{
|
||
state2 = alt_state->state;
|
||
if (!intersected_state_reservs_p (state, state2))
|
||
{
|
||
state2 = states_union (state, state2);
|
||
if (!state2->it_was_placed_in_stack_for_NDFA_forming)
|
||
{
|
||
state2->it_was_placed_in_stack_for_NDFA_forming
|
||
= 1;
|
||
VLA_PTR_ADD (state_stack, state2);
|
||
}
|
||
added_arc = add_arc (state, state2, ainsn, 1);
|
||
if (!ndfa_flag)
|
||
break;
|
||
}
|
||
}
|
||
if (!ndfa_flag && added_arc != NULL)
|
||
{
|
||
added_arc->state_alts = 0;
|
||
for (alt_state = ainsn->alt_states;
|
||
alt_state != NULL;
|
||
alt_state = alt_state->next_alt_state)
|
||
{
|
||
state2 = alt_state->state;
|
||
if (!intersected_state_reservs_p (state, state2))
|
||
added_arc->state_alts++;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
advance_cycle_ainsn = ainsn;
|
||
}
|
||
/* Add transition to advance cycle. */
|
||
state2 = state_shift (state);
|
||
if (!state2->it_was_placed_in_stack_for_NDFA_forming)
|
||
{
|
||
state2->it_was_placed_in_stack_for_NDFA_forming = 1;
|
||
VLA_PTR_ADD (state_stack, state2);
|
||
}
|
||
if (advance_cycle_ainsn == NULL)
|
||
abort ();
|
||
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;
|
||
{
|
||
decl_t decl;
|
||
arc_t arc;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
DECL_INSN_RESERV (decl)->arcs_marked_by_insn = NULL;
|
||
}
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
{
|
||
if (arc->insn == NULL)
|
||
abort ();
|
||
arc->next_arc_marked_by_insn
|
||
= arc->insn->insn_reserv_decl->arcs_marked_by_insn;
|
||
arc->insn->insn_reserv_decl->arcs_marked_by_insn = arc;
|
||
}
|
||
}
|
||
|
||
/* The function creates composed state (see comments for IR) from
|
||
ORIGINAL_STATE and list of arcs ARCS_MARKED_BY_INSN marked by the
|
||
same insn. If the composed state is not in STATE_STACK yet, it is
|
||
popped to STATE_STACK. */
|
||
static void
|
||
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;
|
||
{
|
||
state_t state;
|
||
alt_state_t curr_alt_state;
|
||
alt_state_t new_alt_state;
|
||
arc_t curr_arc;
|
||
arc_t next_arc;
|
||
state_t state_in_table;
|
||
state_t temp_state;
|
||
alt_state_t canonical_alt_states_list;
|
||
int alts_number;
|
||
|
||
if (arcs_marked_by_insn == NULL)
|
||
return;
|
||
if (arcs_marked_by_insn->next_arc_marked_by_insn == NULL)
|
||
state = arcs_marked_by_insn->to_state;
|
||
else
|
||
{
|
||
if (!ndfa_flag)
|
||
abort ();
|
||
/* Create composed state. */
|
||
state = get_free_state (0, arcs_marked_by_insn->to_state->automaton);
|
||
curr_alt_state = NULL;
|
||
for (curr_arc = arcs_marked_by_insn;
|
||
curr_arc != NULL;
|
||
curr_arc = curr_arc->next_arc_marked_by_insn)
|
||
{
|
||
new_alt_state = get_free_alt_state ();
|
||
new_alt_state->next_alt_state = curr_alt_state;
|
||
new_alt_state->state = curr_arc->to_state;
|
||
if (curr_arc->to_state->component_states != NULL)
|
||
abort ();
|
||
curr_alt_state = new_alt_state;
|
||
}
|
||
/* There are not identical sets in the alt state list. */
|
||
canonical_alt_states_list = uniq_sort_alt_states (curr_alt_state);
|
||
if (canonical_alt_states_list->next_sorted_alt_state == NULL)
|
||
{
|
||
temp_state = state;
|
||
state = canonical_alt_states_list->state;
|
||
free_state (temp_state);
|
||
}
|
||
else
|
||
{
|
||
state->component_states = canonical_alt_states_list;
|
||
state_in_table = insert_state (state);
|
||
if (state_in_table != state)
|
||
{
|
||
if (!state_in_table->it_was_placed_in_stack_for_DFA_forming)
|
||
abort ();
|
||
free_state (state);
|
||
state = state_in_table;
|
||
}
|
||
else
|
||
{
|
||
if (state->it_was_placed_in_stack_for_DFA_forming)
|
||
abort ();
|
||
for (curr_alt_state = state->component_states;
|
||
curr_alt_state != NULL;
|
||
curr_alt_state = curr_alt_state->next_sorted_alt_state)
|
||
for (curr_arc = first_out_arc (curr_alt_state->state);
|
||
curr_arc != NULL;
|
||
curr_arc = next_out_arc (curr_arc))
|
||
add_arc (state, curr_arc->to_state, curr_arc->insn, 1);
|
||
}
|
||
arcs_marked_by_insn->to_state = state;
|
||
for (alts_number = 0,
|
||
curr_arc = arcs_marked_by_insn->next_arc_marked_by_insn;
|
||
curr_arc != NULL;
|
||
curr_arc = next_arc)
|
||
{
|
||
next_arc = curr_arc->next_arc_marked_by_insn;
|
||
remove_arc (original_state, curr_arc);
|
||
alts_number++;
|
||
}
|
||
arcs_marked_by_insn->state_alts = alts_number;
|
||
}
|
||
}
|
||
if (!state->it_was_placed_in_stack_for_DFA_forming)
|
||
{
|
||
state->it_was_placed_in_stack_for_DFA_forming = 1;
|
||
VLA_PTR_ADD (*state_stack, state);
|
||
}
|
||
}
|
||
|
||
/* The function transformes nondeterminstic AUTOMATON into
|
||
deterministic. */
|
||
static void
|
||
NDFA_to_DFA (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
state_t start_state;
|
||
state_t state;
|
||
decl_t decl;
|
||
vla_ptr_t state_stack;
|
||
int i;
|
||
|
||
VLA_PTR_CREATE (state_stack, 150, "state stack");
|
||
/* Create the start state (empty state). */
|
||
start_state = automaton->start_state;
|
||
start_state->it_was_placed_in_stack_for_DFA_forming = 1;
|
||
VLA_PTR_ADD (state_stack, start_state);
|
||
while (VLA_PTR_LENGTH (state_stack) != 0)
|
||
{
|
||
state = VLA_PTR (state_stack, VLA_PTR_LENGTH (state_stack) - 1);
|
||
VLA_PTR_SHORTEN (state_stack, 1);
|
||
form_arcs_marked_by_insn (state);
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
create_composed_state
|
||
(state, DECL_INSN_RESERV (decl)->arcs_marked_by_insn,
|
||
&state_stack);
|
||
}
|
||
}
|
||
VLA_PTR_DELETE (state_stack);
|
||
}
|
||
|
||
/* The following variable value is current number (1, 2, ...) of passing
|
||
graph of states. */
|
||
static int curr_state_graph_pass_num;
|
||
|
||
/* This recursive function passes all states achieved from START_STATE
|
||
and applies APPLIED_FUNC to them. */
|
||
static void
|
||
pass_state_graph (start_state, applied_func)
|
||
state_t start_state;
|
||
void (*applied_func) PARAMS ((state_t state));
|
||
{
|
||
arc_t arc;
|
||
|
||
if (start_state->pass_num == curr_state_graph_pass_num)
|
||
return;
|
||
start_state->pass_num = curr_state_graph_pass_num;
|
||
(*applied_func) (start_state);
|
||
for (arc = first_out_arc (start_state);
|
||
arc != NULL;
|
||
arc = next_out_arc (arc))
|
||
pass_state_graph (arc->to_state, applied_func);
|
||
}
|
||
|
||
/* This recursive function passes all states of AUTOMATON and applies
|
||
APPLIED_FUNC to them. */
|
||
static void
|
||
pass_states (automaton, applied_func)
|
||
automaton_t automaton;
|
||
void (*applied_func) PARAMS ((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 ()
|
||
{
|
||
curr_state_graph_pass_num = 0;
|
||
}
|
||
|
||
/* The following vla is used for storing pointers to all achieved
|
||
states. */
|
||
static vla_ptr_t all_achieved_states;
|
||
|
||
/* This function is called by function pass_states to add an achieved
|
||
STATE. */
|
||
static void
|
||
add_achieved_state (state)
|
||
state_t state;
|
||
{
|
||
VLA_PTR_ADD (all_achieved_states, state);
|
||
}
|
||
|
||
/* The function sets up equivalence numbers of insns which mark all
|
||
out arcs of STATE by equiv_class_num_1 (if ODD_ITERATION_FLAG has
|
||
nonzero value) or by equiv_class_num_2 of the destination state.
|
||
The function returns number of out arcs of STATE. */
|
||
static int
|
||
set_out_arc_insns_equiv_num (state, odd_iteration_flag)
|
||
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 ();
|
||
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 ();
|
||
}
|
||
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;
|
||
{
|
||
arc_t arc;
|
||
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
{
|
||
arc->insn->insn_reserv_decl->equiv_class_num = 0;
|
||
arc->insn->insn_reserv_decl->state_alts = 0;
|
||
}
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
state_t *class_ptr;
|
||
|
||
VLA_PTR_NULLIFY (*to);
|
||
for (class_ptr = VLA_PTR_BEGIN (*from);
|
||
class_ptr <= (state_t *) VLA_PTR_LAST (*from);
|
||
class_ptr++)
|
||
VLA_PTR_ADD (*to, *class_ptr);
|
||
}
|
||
|
||
/* The function returns nonzero value if STATE is not equivalent to
|
||
another state from the same current partition on equivalence
|
||
classes Another state has ORIGINAL_STATE_OUT_ARCS_NUM number of
|
||
output arcs. Iteration of making equivalence partition is defined
|
||
by ODD_ITERATION_FLAG. */
|
||
static int
|
||
state_is_differed (state, original_state_out_arcs_num, odd_iteration_flag)
|
||
state_t state;
|
||
int original_state_out_arcs_num;
|
||
int odd_iteration_flag;
|
||
{
|
||
arc_t arc;
|
||
int state_out_arcs_num;
|
||
|
||
state_out_arcs_num = 0;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
{
|
||
state_out_arcs_num++;
|
||
if ((odd_iteration_flag
|
||
? arc->to_state->equiv_class_num_1
|
||
: arc->to_state->equiv_class_num_2)
|
||
!= arc->insn->insn_reserv_decl->equiv_class_num
|
||
|| (arc->insn->insn_reserv_decl->state_alts != arc->state_alts))
|
||
return 1;
|
||
}
|
||
return state_out_arcs_num != original_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;
|
||
{
|
||
state_t *state_ptr;
|
||
state_t result_equiv_class;
|
||
|
||
result_equiv_class = NULL;
|
||
for (state_ptr = states; state_ptr < states + states_num; state_ptr++)
|
||
{
|
||
(*state_ptr)->equiv_class_num_1 = 1;
|
||
(*state_ptr)->next_equiv_class_state = result_equiv_class;
|
||
result_equiv_class = *state_ptr;
|
||
}
|
||
return result_equiv_class;
|
||
}
|
||
|
||
/* The function processes equivalence class given by its pointer
|
||
EQUIV_CLASS_PTR on odd iteration if ODD_ITERATION_FLAG. If there
|
||
are not equvalent states, the function partitions the class
|
||
removing nonequivalent states and placing them in
|
||
*NEXT_ITERATION_CLASSES, increments *NEW_EQUIV_CLASS_NUM_PTR ans
|
||
assigns it to the state equivalence number. If the class has been
|
||
partitioned, the function returns nonzero value. */
|
||
static int
|
||
partition_equiv_class (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;
|
||
{
|
||
state_t new_equiv_class;
|
||
int partition_p;
|
||
state_t first_state;
|
||
state_t curr_state;
|
||
state_t prev_state;
|
||
state_t next_state;
|
||
int out_arcs_num;
|
||
|
||
partition_p = 0;
|
||
if (*equiv_class_ptr == NULL)
|
||
abort ();
|
||
for (first_state = *equiv_class_ptr;
|
||
first_state != NULL;
|
||
first_state = new_equiv_class)
|
||
{
|
||
new_equiv_class = NULL;
|
||
if (first_state->next_equiv_class_state != NULL)
|
||
{
|
||
/* There are more one states in the class equivalence. */
|
||
out_arcs_num = set_out_arc_insns_equiv_num (first_state,
|
||
odd_iteration_flag);
|
||
for (prev_state = first_state,
|
||
curr_state = first_state->next_equiv_class_state;
|
||
curr_state != NULL;
|
||
curr_state = next_state)
|
||
{
|
||
next_state = curr_state->next_equiv_class_state;
|
||
if (state_is_differed (curr_state, out_arcs_num,
|
||
odd_iteration_flag))
|
||
{
|
||
/* Remove curr state from the class equivalence. */
|
||
prev_state->next_equiv_class_state = next_state;
|
||
/* Add curr state to the new class equivalence. */
|
||
curr_state->next_equiv_class_state = new_equiv_class;
|
||
if (new_equiv_class == NULL)
|
||
(*new_equiv_class_num_ptr)++;
|
||
if (odd_iteration_flag)
|
||
curr_state->equiv_class_num_2 = *new_equiv_class_num_ptr;
|
||
else
|
||
curr_state->equiv_class_num_1 = *new_equiv_class_num_ptr;
|
||
new_equiv_class = curr_state;
|
||
partition_p = 1;
|
||
}
|
||
else
|
||
prev_state = curr_state;
|
||
}
|
||
clear_arc_insns_equiv_num (first_state);
|
||
}
|
||
if (new_equiv_class != NULL)
|
||
VLA_PTR_ADD (*next_iteration_classes, new_equiv_class);
|
||
}
|
||
return partition_p;
|
||
}
|
||
|
||
/* The function finds equivalent states of AUTOMATON. */
|
||
static void
|
||
evaluate_equiv_classes (automaton, equiv_classes)
|
||
automaton_t automaton;
|
||
vla_ptr_t *equiv_classes;
|
||
{
|
||
state_t new_equiv_class;
|
||
int new_equiv_class_num;
|
||
int odd_iteration_flag;
|
||
int finish_flag;
|
||
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),
|
||
VLA_PTR_LENGTH (all_achieved_states));
|
||
odd_iteration_flag = 0;
|
||
new_equiv_class_num = 1;
|
||
VLA_PTR_CREATE (next_iteration_classes, 150, "next iteration classes");
|
||
VLA_PTR_ADD (next_iteration_classes, new_equiv_class);
|
||
do
|
||
{
|
||
odd_iteration_flag = !odd_iteration_flag;
|
||
finish_flag = 1;
|
||
copy_equiv_class (equiv_classes, &next_iteration_classes);
|
||
/* Transfer equiv numbers for the next iteration. */
|
||
for (state_ptr = VLA_PTR_BEGIN (all_achieved_states);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (all_achieved_states);
|
||
state_ptr++)
|
||
if (odd_iteration_flag)
|
||
(*state_ptr)->equiv_class_num_2 = (*state_ptr)->equiv_class_num_1;
|
||
else
|
||
(*state_ptr)->equiv_class_num_1 = (*state_ptr)->equiv_class_num_2;
|
||
for (equiv_class_ptr = VLA_PTR_BEGIN (*equiv_classes);
|
||
equiv_class_ptr <= (state_t *) VLA_PTR_LAST (*equiv_classes);
|
||
equiv_class_ptr++)
|
||
if (partition_equiv_class (equiv_class_ptr, odd_iteration_flag,
|
||
&next_iteration_classes,
|
||
&new_equiv_class_num))
|
||
finish_flag = 0;
|
||
}
|
||
while (!finish_flag);
|
||
VLA_PTR_DELETE (next_iteration_classes);
|
||
VLA_PTR_DELETE (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;
|
||
{
|
||
state_t *equiv_class_ptr;
|
||
state_t curr_state;
|
||
state_t new_state;
|
||
state_t first_class_state;
|
||
alt_state_t alt_states;
|
||
alt_state_t new_alt_state;
|
||
arc_t curr_arc;
|
||
arc_t next_arc;
|
||
|
||
/* Create states corresponding to equivalence classes containing two
|
||
or more states. */
|
||
for (equiv_class_ptr = VLA_PTR_BEGIN (*equiv_classes);
|
||
equiv_class_ptr <= (state_t *) VLA_PTR_LAST (*equiv_classes);
|
||
equiv_class_ptr++)
|
||
if ((*equiv_class_ptr)->next_equiv_class_state != NULL)
|
||
{
|
||
/* There are more one states in the class equivalence. */
|
||
/* Create new compound state. */
|
||
new_state = get_free_state (0, automaton);
|
||
alt_states = NULL;
|
||
first_class_state = *equiv_class_ptr;
|
||
for (curr_state = first_class_state;
|
||
curr_state != NULL;
|
||
curr_state = curr_state->next_equiv_class_state)
|
||
{
|
||
curr_state->equiv_class_state = new_state;
|
||
new_alt_state = get_free_alt_state ();
|
||
new_alt_state->state = curr_state;
|
||
new_alt_state->next_sorted_alt_state = alt_states;
|
||
alt_states = new_alt_state;
|
||
}
|
||
new_state->component_states = alt_states;
|
||
}
|
||
else
|
||
(*equiv_class_ptr)->equiv_class_state = *equiv_class_ptr;
|
||
for (equiv_class_ptr = VLA_PTR_BEGIN (*equiv_classes);
|
||
equiv_class_ptr <= (state_t *) VLA_PTR_LAST (*equiv_classes);
|
||
equiv_class_ptr++)
|
||
if ((*equiv_class_ptr)->next_equiv_class_state != NULL)
|
||
{
|
||
first_class_state = *equiv_class_ptr;
|
||
/* Create new arcs output from the state corresponding to
|
||
equiv class. */
|
||
for (curr_arc = first_out_arc (first_class_state);
|
||
curr_arc != NULL;
|
||
curr_arc = next_out_arc (curr_arc))
|
||
add_arc (first_class_state->equiv_class_state,
|
||
curr_arc->to_state->equiv_class_state,
|
||
curr_arc->insn, curr_arc->state_alts);
|
||
/* Delete output arcs from states of given class equivalence. */
|
||
for (curr_state = first_class_state;
|
||
curr_state != NULL;
|
||
curr_state = curr_state->next_equiv_class_state)
|
||
{
|
||
if (automaton->start_state == curr_state)
|
||
automaton->start_state = curr_state->equiv_class_state;
|
||
/* Delete the state and its output arcs. */
|
||
for (curr_arc = first_out_arc (curr_state);
|
||
curr_arc != NULL;
|
||
curr_arc = next_arc)
|
||
{
|
||
next_arc = next_out_arc (curr_arc);
|
||
free_arc (curr_arc);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Change `to_state' of arcs output from the state of given
|
||
equivalence class. */
|
||
for (curr_arc = first_out_arc (*equiv_class_ptr);
|
||
curr_arc != NULL;
|
||
curr_arc = next_out_arc (curr_arc))
|
||
curr_arc->to_state = curr_arc->to_state->equiv_class_state;
|
||
}
|
||
}
|
||
|
||
/* The function sets up new_cycle_p for states if there is arc to the
|
||
state marked by advance_cycle_insn_decl. */
|
||
static void
|
||
set_new_cycle_flags (state)
|
||
state_t state;
|
||
{
|
||
arc_t arc;
|
||
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
if (arc->insn->insn_reserv_decl
|
||
== DECL_INSN_RESERV (advance_cycle_insn_decl))
|
||
arc->to_state->new_cycle_p = 1;
|
||
}
|
||
|
||
/* The top level function for minimization of deterministic
|
||
AUTOMATON. */
|
||
static void
|
||
minimize_DFA (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
vla_ptr_t equiv_classes;
|
||
|
||
VLA_PTR_CREATE (equiv_classes, 1500, "equivalence classes");
|
||
evaluate_equiv_classes (automaton, &equiv_classes);
|
||
merge_states (automaton, &equiv_classes);
|
||
pass_states (automaton, set_new_cycle_flags);
|
||
VLA_PTR_DELETE (equiv_classes);
|
||
}
|
||
|
||
/* Values of two variables are counted number of states and arcs in an
|
||
automaton. */
|
||
static int curr_counted_states_num;
|
||
static int curr_counted_arcs_num;
|
||
|
||
/* The function is called by function `pass_states' to count states
|
||
and arcs of an automaton. */
|
||
static void
|
||
incr_states_and_arcs_nums (state)
|
||
state_t state;
|
||
{
|
||
arc_t arc;
|
||
|
||
curr_counted_states_num++;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
curr_counted_arcs_num++;
|
||
}
|
||
|
||
/* The function counts states and arcs of AUTOMATON. */
|
||
static void
|
||
count_states_and_arcs (automaton, states_num, arcs_num)
|
||
automaton_t automaton;
|
||
int *states_num;
|
||
int *arcs_num;
|
||
{
|
||
curr_counted_states_num = 0;
|
||
curr_counted_arcs_num = 0;
|
||
pass_states (automaton, incr_states_and_arcs_nums);
|
||
*states_num = curr_counted_states_num;
|
||
*arcs_num = curr_counted_arcs_num;
|
||
}
|
||
|
||
/* The function builds one DFA AUTOMATON for fast pipeline hazards
|
||
recognition after checking and simplifying IR of the
|
||
description. */
|
||
static void
|
||
build_automaton (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
int states_num;
|
||
int arcs_num;
|
||
|
||
ticker_on (&NDFA_time);
|
||
make_automaton (automaton);
|
||
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);
|
||
NDFA_to_DFA (automaton);
|
||
ticker_off (&NDFA_to_DFA_time);
|
||
count_states_and_arcs (automaton, &states_num, &arcs_num);
|
||
automaton->DFA_states_num = states_num;
|
||
automaton->DFA_arcs_num = arcs_num;
|
||
if (!no_minimization_flag)
|
||
{
|
||
ticker_on (&minimize_time);
|
||
minimize_DFA (automaton);
|
||
ticker_off (&minimize_time);
|
||
count_states_and_arcs (automaton, &states_num, &arcs_num);
|
||
automaton->minimal_DFA_states_num = states_num;
|
||
automaton->minimal_DFA_arcs_num = arcs_num;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* The page contains code for enumeration of all states of an automaton. */
|
||
|
||
/* Variable used for enumeration of all states of an automaton. Its
|
||
value is current number of automaton states. */
|
||
static int curr_state_order_num;
|
||
|
||
/* The function is called by function `pass_states' for enumerating
|
||
states. */
|
||
static void
|
||
set_order_state_num (state)
|
||
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;
|
||
{
|
||
curr_state_order_num = 0;
|
||
pass_states (automaton, set_order_state_num);
|
||
automaton->achieved_states_num = curr_state_order_num;
|
||
}
|
||
|
||
|
||
|
||
/* The page contains code for finding equivalent automaton insns
|
||
(ainsns). */
|
||
|
||
/* The function inserts AINSN into cyclic list
|
||
CYCLIC_EQUIV_CLASS_INSN_LIST of ainsns. */
|
||
static ainsn_t
|
||
insert_ainsn_into_equiv_class (ainsn, cyclic_equiv_class_insn_list)
|
||
ainsn_t ainsn;
|
||
ainsn_t cyclic_equiv_class_insn_list;
|
||
{
|
||
if (cyclic_equiv_class_insn_list == NULL)
|
||
ainsn->next_equiv_class_insn = ainsn;
|
||
else
|
||
{
|
||
ainsn->next_equiv_class_insn
|
||
= cyclic_equiv_class_insn_list->next_equiv_class_insn;
|
||
cyclic_equiv_class_insn_list->next_equiv_class_insn = ainsn;
|
||
}
|
||
return ainsn;
|
||
}
|
||
|
||
/* The function deletes equiv_class_insn into cyclic list of
|
||
equivalent ainsns. */
|
||
static void
|
||
delete_ainsn_from_equiv_class (equiv_class_insn)
|
||
ainsn_t equiv_class_insn;
|
||
{
|
||
ainsn_t curr_equiv_class_insn;
|
||
ainsn_t prev_equiv_class_insn;
|
||
|
||
prev_equiv_class_insn = equiv_class_insn;
|
||
for (curr_equiv_class_insn = equiv_class_insn->next_equiv_class_insn;
|
||
curr_equiv_class_insn != equiv_class_insn;
|
||
curr_equiv_class_insn = curr_equiv_class_insn->next_equiv_class_insn)
|
||
prev_equiv_class_insn = curr_equiv_class_insn;
|
||
if (prev_equiv_class_insn != equiv_class_insn)
|
||
prev_equiv_class_insn->next_equiv_class_insn
|
||
= equiv_class_insn->next_equiv_class_insn;
|
||
}
|
||
|
||
/* The function processes AINSN of a state in order to find equivalent
|
||
ainsns. INSN_ARCS_ARRAY is table: code of insn -> out arc of the
|
||
state. */
|
||
static void
|
||
process_insn_equiv_class (ainsn, insn_arcs_array)
|
||
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 ();
|
||
curr_insn = ainsn;
|
||
/* New class of ainsns which are not equivalent to given ainsn. */
|
||
cyclic_insn_list = NULL;
|
||
do
|
||
{
|
||
next_insn = curr_insn->next_equiv_class_insn;
|
||
arc = insn_arcs_array [curr_insn->insn_reserv_decl->insn_num];
|
||
if (arc == NULL
|
||
|| (insn_arcs_array [ainsn->insn_reserv_decl->insn_num]->to_state
|
||
!= arc->to_state))
|
||
{
|
||
delete_ainsn_from_equiv_class (curr_insn);
|
||
cyclic_insn_list = insert_ainsn_into_equiv_class (curr_insn,
|
||
cyclic_insn_list);
|
||
}
|
||
curr_insn = next_insn;
|
||
}
|
||
while (curr_insn != ainsn);
|
||
}
|
||
|
||
/* The function processes STATE in order to find equivalent ainsns. */
|
||
static void
|
||
process_state_for_insn_equiv_partition (state)
|
||
state_t state;
|
||
{
|
||
arc_t arc;
|
||
arc_t *insn_arcs_array;
|
||
int i;
|
||
vla_ptr_t insn_arcs_vect;
|
||
|
||
VLA_PTR_CREATE (insn_arcs_vect, 500, "insn arcs vector");
|
||
VLA_PTR_EXPAND (insn_arcs_vect, description->insns_num);
|
||
insn_arcs_array = VLA_PTR_BEGIN (insn_arcs_vect);
|
||
/* Process insns of the arcs. */
|
||
for (i = 0; i < description->insns_num; i++)
|
||
insn_arcs_array [i] = NULL;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
insn_arcs_array [arc->insn->insn_reserv_decl->insn_num] = arc;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
process_insn_equiv_class (arc->insn, insn_arcs_array);
|
||
VLA_PTR_DELETE (insn_arcs_vect);
|
||
}
|
||
|
||
/* The function searches for equivalent ainsns of AUTOMATON. */
|
||
static void
|
||
set_insn_equiv_classes (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
ainsn_t ainsn;
|
||
ainsn_t first_insn;
|
||
ainsn_t curr_insn;
|
||
ainsn_t cyclic_insn_list;
|
||
ainsn_t insn_with_same_reservs;
|
||
int equiv_classes_num;
|
||
|
||
/* All insns are included in one equivalence class. */
|
||
cyclic_insn_list = NULL;
|
||
for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
|
||
if (ainsn->first_insn_with_same_reservs)
|
||
cyclic_insn_list = insert_ainsn_into_equiv_class (ainsn,
|
||
cyclic_insn_list);
|
||
/* Process insns in order to make equivalence partition. */
|
||
pass_states (automaton, process_state_for_insn_equiv_partition);
|
||
/* Enumerate equiv classes. */
|
||
for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
|
||
/* Set undefined value. */
|
||
ainsn->insn_equiv_class_num = -1;
|
||
equiv_classes_num = 0;
|
||
for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
|
||
if (ainsn->insn_equiv_class_num < 0)
|
||
{
|
||
first_insn = ainsn;
|
||
if (!first_insn->first_insn_with_same_reservs)
|
||
abort ();
|
||
first_insn->first_ainsn_with_given_equialence_num = 1;
|
||
curr_insn = first_insn;
|
||
do
|
||
{
|
||
for (insn_with_same_reservs = curr_insn;
|
||
insn_with_same_reservs != NULL;
|
||
insn_with_same_reservs
|
||
= insn_with_same_reservs->next_same_reservs_insn)
|
||
insn_with_same_reservs->insn_equiv_class_num = equiv_classes_num;
|
||
curr_insn = curr_insn->next_equiv_class_insn;
|
||
}
|
||
while (curr_insn != first_insn);
|
||
equiv_classes_num++;
|
||
}
|
||
automaton->insn_equiv_classes_num = equiv_classes_num;
|
||
}
|
||
|
||
|
||
|
||
/* This page contains code for creating DFA(s) and calls functions
|
||
building them. */
|
||
|
||
|
||
/* The following value is used to prevent floating point overflow for
|
||
estimating an automaton bound. The value should be less DBL_MAX on
|
||
the host machine. We use here approximate minimum of maximal
|
||
double floating point value required by ANSI C standard. It
|
||
will work for non ANSI sun compiler too. */
|
||
|
||
#define MAX_FLOATING_POINT_VALUE_FOR_AUTOMATON_BOUND 1.0E37
|
||
|
||
/* The function estimate size of the single DFA used by PHR (pipeline
|
||
hazards recognizer). */
|
||
static double
|
||
estimate_one_automaton_bound ()
|
||
{
|
||
decl_t decl;
|
||
double one_automaton_estimation_bound;
|
||
double root_value;
|
||
int i;
|
||
|
||
one_automaton_estimation_bound = 1.0;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
root_value = exp (log (DECL_UNIT (decl)->max_occ_cycle_num + 1.0)
|
||
/ automata_num);
|
||
if (MAX_FLOATING_POINT_VALUE_FOR_AUTOMATON_BOUND / root_value
|
||
> one_automaton_estimation_bound)
|
||
one_automaton_estimation_bound *= root_value;
|
||
}
|
||
}
|
||
return one_automaton_estimation_bound;
|
||
}
|
||
|
||
/* The function compares unit declarations acoording 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;
|
||
{
|
||
if ((DECL_UNIT (*(decl_t *) unit_decl_1)->max_occ_cycle_num)
|
||
< (DECL_UNIT (*(decl_t *) unit_decl_2)->max_occ_cycle_num))
|
||
return 1;
|
||
else if ((DECL_UNIT (*(decl_t *) unit_decl_1)->max_occ_cycle_num)
|
||
== (DECL_UNIT (*(decl_t *) unit_decl_2)->max_occ_cycle_num))
|
||
return 0;
|
||
else
|
||
return -1;
|
||
}
|
||
|
||
/* The function makes heuristic assigning automata to units. Actually
|
||
efficacy of the algorithm has been checked yet??? */
|
||
static void
|
||
units_to_automata_heuristic_distr ()
|
||
{
|
||
double estimation_bound;
|
||
decl_t decl;
|
||
decl_t *unit_decl_ptr;
|
||
int automaton_num;
|
||
int rest_units_num;
|
||
double bound_value;
|
||
vla_ptr_t unit_decls;
|
||
int i;
|
||
|
||
if (description->units_num == 0)
|
||
return;
|
||
estimation_bound = estimate_one_automaton_bound ();
|
||
VLA_PTR_CREATE (unit_decls, 150, "unit decls");
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
VLA_PTR_ADD (unit_decls, decl);
|
||
}
|
||
qsort (VLA_PTR_BEGIN (unit_decls), VLA_PTR_LENGTH (unit_decls),
|
||
sizeof (decl_t), compare_max_occ_cycle_nums);
|
||
automaton_num = 0;
|
||
unit_decl_ptr = VLA_PTR_BEGIN (unit_decls);
|
||
bound_value = DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
|
||
DECL_UNIT (*unit_decl_ptr)->corresponding_automaton_num = automaton_num;
|
||
for (unit_decl_ptr++;
|
||
unit_decl_ptr <= (decl_t *) VLA_PTR_LAST (unit_decls);
|
||
unit_decl_ptr++)
|
||
{
|
||
rest_units_num
|
||
= ((decl_t *) VLA_PTR_LAST (unit_decls) - unit_decl_ptr + 1);
|
||
if (automata_num - automaton_num - 1 > rest_units_num)
|
||
abort ();
|
||
if (automaton_num < automata_num - 1
|
||
&& ((automata_num - automaton_num - 1 == rest_units_num)
|
||
|| (bound_value
|
||
> (estimation_bound
|
||
/ (DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num)))))
|
||
{
|
||
bound_value = DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
|
||
automaton_num++;
|
||
}
|
||
else
|
||
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 ();
|
||
VLA_PTR_DELETE (unit_decls);
|
||
}
|
||
|
||
/* The functions creates automaton insns for each automata. Automaton
|
||
insn is simply insn for given automaton which makes reservation
|
||
only of units of the automaton. */
|
||
static ainsn_t
|
||
create_ainsns ()
|
||
{
|
||
decl_t decl;
|
||
ainsn_t first_ainsn;
|
||
ainsn_t curr_ainsn;
|
||
ainsn_t prev_ainsn;
|
||
int i;
|
||
|
||
first_ainsn = NULL;
|
||
prev_ainsn = NULL;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
{
|
||
curr_ainsn = create_node (sizeof (struct ainsn));
|
||
curr_ainsn->insn_reserv_decl = DECL_INSN_RESERV (decl);
|
||
curr_ainsn->important_p = FALSE;
|
||
curr_ainsn->next_ainsn = NULL;
|
||
if (prev_ainsn == NULL)
|
||
first_ainsn = curr_ainsn;
|
||
else
|
||
prev_ainsn->next_ainsn = curr_ainsn;
|
||
prev_ainsn = curr_ainsn;
|
||
}
|
||
}
|
||
return first_ainsn;
|
||
}
|
||
|
||
/* The function assigns automata to units according to constructions
|
||
`define_automaton' in the description. */
|
||
static void
|
||
units_to_automata_distr ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
if (DECL_UNIT (decl)->automaton_decl == NULL
|
||
|| (DECL_UNIT (decl)->automaton_decl->corresponding_automaton
|
||
== NULL))
|
||
/* Distribute to the first automaton. */
|
||
DECL_UNIT (decl)->corresponding_automaton_num = 0;
|
||
else
|
||
DECL_UNIT (decl)->corresponding_automaton_num
|
||
= (DECL_UNIT (decl)->automaton_decl
|
||
->corresponding_automaton->automaton_order_num);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The function creates DFA(s) for fast pipeline hazards recognition
|
||
after checking and simplifying IR of the description. */
|
||
static void
|
||
create_automata ()
|
||
{
|
||
automaton_t curr_automaton;
|
||
automaton_t prev_automaton;
|
||
decl_t decl;
|
||
int curr_automaton_num;
|
||
int i;
|
||
|
||
if (automata_num != 0)
|
||
{
|
||
units_to_automata_heuristic_distr ();
|
||
for (prev_automaton = NULL, curr_automaton_num = 0;
|
||
curr_automaton_num < automata_num;
|
||
curr_automaton_num++, prev_automaton = curr_automaton)
|
||
{
|
||
curr_automaton = create_node (sizeof (struct automaton));
|
||
curr_automaton->ainsn_list = create_ainsns ();
|
||
curr_automaton->corresponding_automaton_decl = NULL;
|
||
curr_automaton->next_automaton = NULL;
|
||
curr_automaton->automaton_order_num = curr_automaton_num;
|
||
if (prev_automaton == NULL)
|
||
description->first_automaton = curr_automaton;
|
||
else
|
||
prev_automaton->next_automaton = curr_automaton;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
curr_automaton_num = 0;
|
||
prev_automaton = NULL;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_automaton
|
||
&& DECL_AUTOMATON (decl)->automaton_is_used)
|
||
{
|
||
curr_automaton = create_node (sizeof (struct automaton));
|
||
curr_automaton->ainsn_list = create_ainsns ();
|
||
curr_automaton->corresponding_automaton_decl
|
||
= DECL_AUTOMATON (decl);
|
||
curr_automaton->next_automaton = NULL;
|
||
DECL_AUTOMATON (decl)->corresponding_automaton = curr_automaton;
|
||
curr_automaton->automaton_order_num = curr_automaton_num;
|
||
if (prev_automaton == NULL)
|
||
description->first_automaton = curr_automaton;
|
||
else
|
||
prev_automaton->next_automaton = curr_automaton;
|
||
curr_automaton_num++;
|
||
prev_automaton = curr_automaton;
|
||
}
|
||
}
|
||
if (curr_automaton_num == 0)
|
||
{
|
||
curr_automaton = create_node (sizeof (struct automaton));
|
||
curr_automaton->ainsn_list = create_ainsns ();
|
||
curr_automaton->corresponding_automaton_decl = NULL;
|
||
curr_automaton->next_automaton = NULL;
|
||
description->first_automaton = curr_automaton;
|
||
}
|
||
units_to_automata_distr ();
|
||
}
|
||
NDFA_time = create_ticker ();
|
||
ticker_off (&NDFA_time);
|
||
NDFA_to_DFA_time = create_ticker ();
|
||
ticker_off (&NDFA_to_DFA_time);
|
||
minimize_time = create_ticker ();
|
||
ticker_off (&minimize_time);
|
||
equiv_time = create_ticker ();
|
||
ticker_off (&equiv_time);
|
||
for (curr_automaton = description->first_automaton;
|
||
curr_automaton != NULL;
|
||
curr_automaton = curr_automaton->next_automaton)
|
||
{
|
||
if (curr_automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (stderr, "Create anonymous automaton ...");
|
||
else
|
||
fprintf (stderr, "Create automaton `%s'...",
|
||
curr_automaton->corresponding_automaton_decl->name);
|
||
create_alt_states (curr_automaton);
|
||
form_ainsn_with_same_reservs (curr_automaton);
|
||
build_automaton (curr_automaton);
|
||
enumerate_states (curr_automaton);
|
||
ticker_on (&equiv_time);
|
||
set_insn_equiv_classes (curr_automaton);
|
||
ticker_off (&equiv_time);
|
||
fprintf (stderr, "done\n");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* This page contains code for forming string representation of
|
||
regexp. The representation is formed on IR obstack. So you should
|
||
not work with IR obstack between regexp_representation and
|
||
finish_regexp_representation calls. */
|
||
|
||
/* This recursive function forms string representation of regexp
|
||
(without tailing '\0'). */
|
||
static void
|
||
form_regexp (regexp)
|
||
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++)
|
||
{
|
||
if (i != 0)
|
||
obstack_1grow (&irp, ',');
|
||
form_regexp (REGEXP_SEQUENCE (regexp)->regexps [i]);
|
||
}
|
||
else if (regexp->mode == rm_allof)
|
||
{
|
||
obstack_1grow (&irp, '(');
|
||
for (i = 0; i < REGEXP_ALLOF (regexp)->regexps_num; i++)
|
||
{
|
||
if (i != 0)
|
||
obstack_1grow (&irp, '+');
|
||
if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
|
||
|| REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
|
||
obstack_1grow (&irp, '(');
|
||
form_regexp (REGEXP_ALLOF (regexp)->regexps [i]);
|
||
if (REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_sequence
|
||
|| REGEXP_ALLOF (regexp)->regexps[i]->mode == rm_oneof)
|
||
obstack_1grow (&irp, ')');
|
||
}
|
||
obstack_1grow (&irp, ')');
|
||
}
|
||
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)
|
||
obstack_1grow (&irp, ')');
|
||
}
|
||
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 ();
|
||
}
|
||
|
||
/* The function returns string representation of REGEXP on IR
|
||
obstack. */
|
||
static const char *
|
||
regexp_representation (regexp)
|
||
regexp_t regexp;
|
||
{
|
||
form_regexp (regexp);
|
||
obstack_1grow (&irp, '\0');
|
||
return obstack_base (&irp);
|
||
}
|
||
|
||
/* The function frees memory allocated for last formed string
|
||
representation of regexp. */
|
||
static void
|
||
finish_regexp_representation ()
|
||
{
|
||
int length = obstack_object_size (&irp);
|
||
|
||
obstack_blank_fast (&irp, -length);
|
||
}
|
||
|
||
|
||
|
||
/* This page contains code for output PHR (pipeline hazards recognizer). */
|
||
|
||
/* The function outputs minimal C type which is sufficient for
|
||
representation numbers in range min_range_value and
|
||
max_range_value. Because host machine and build machine may be
|
||
different, we use here minimal values required by ANSI C standard
|
||
instead of UCHAR_MAX, SHRT_MAX, SHRT_MIN, etc. This is a good
|
||
approximation. */
|
||
|
||
static void
|
||
output_range_type (f, min_range_value, max_range_value)
|
||
FILE *f;
|
||
long int min_range_value;
|
||
long int max_range_value;
|
||
{
|
||
if (min_range_value >= 0 && max_range_value <= 255)
|
||
fprintf (f, "unsigned char");
|
||
else if (min_range_value >= -127 && max_range_value <= 127)
|
||
fprintf (f, "signed char");
|
||
else if (min_range_value >= 0 && max_range_value <= 65535)
|
||
fprintf (f, "unsigned short");
|
||
else if (min_range_value >= -32767 && max_range_value <= 32767)
|
||
fprintf (f, "short");
|
||
else
|
||
fprintf (f, "int");
|
||
}
|
||
|
||
/* The following macro value is used as value of member
|
||
`longest_path_length' of state when we are processing path and the
|
||
state on the path. */
|
||
|
||
#define ON_THE_PATH -2
|
||
|
||
/* The following recursive function searches for the length of the
|
||
longest path starting from STATE which does not contain cycles and
|
||
`cycle advance' arcs. */
|
||
|
||
static int
|
||
longest_path_length (state)
|
||
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 alreday visited the state. */
|
||
return state->longest_path_length;
|
||
|
||
result = 0;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
/* Ignore cycles containing one state and `cycle advance' arcs. */
|
||
if (arc->to_state != state
|
||
&& (arc->insn->insn_reserv_decl
|
||
!= DECL_INSN_RESERV (advance_cycle_insn_decl)))
|
||
{
|
||
length = longest_path_length (arc->to_state);
|
||
if (length > result)
|
||
result = length;
|
||
}
|
||
state->longest_path_length = result + 1;
|
||
return result;
|
||
}
|
||
|
||
/* The following variable value is value of the corresponding global
|
||
variable in the automaton based pipeline interface. */
|
||
|
||
static int max_dfa_issue_rate;
|
||
|
||
/* The following function processes the longest path length staring
|
||
from STATE to find MAX_DFA_ISSUE_RATE. */
|
||
|
||
static void
|
||
process_state_longest_path_length (state)
|
||
state_t state;
|
||
{
|
||
int value;
|
||
|
||
value = longest_path_length (state);
|
||
if (value > max_dfa_issue_rate)
|
||
max_dfa_issue_rate = value;
|
||
}
|
||
|
||
/* The following macro value is name of the corresponding global
|
||
variable in the automaton based pipeline interface. */
|
||
|
||
#define MAX_DFA_ISSUE_RATE_VAR_NAME "max_dfa_issue_rate"
|
||
|
||
/* The following function calculates value of the corresponding
|
||
global variable and outputs its declaration. */
|
||
|
||
static void
|
||
output_dfa_max_issue_rate ()
|
||
{
|
||
automaton_t automaton;
|
||
|
||
if (UNDEFINED_LONGEST_PATH_LENGTH == ON_THE_PATH || ON_THE_PATH >= 0)
|
||
abort ();
|
||
max_dfa_issue_rate = 0;
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
pass_states (automaton, process_state_longest_path_length);
|
||
fprintf (output_file, "\nint %s = %d;\n",
|
||
MAX_DFA_ISSUE_RATE_VAR_NAME, max_dfa_issue_rate);
|
||
}
|
||
|
||
/* The function outputs all initialization values of VECT with length
|
||
vect_length. */
|
||
static void
|
||
output_vect (vect, vect_length)
|
||
vect_el_t *vect;
|
||
int vect_length;
|
||
{
|
||
int els_on_line;
|
||
|
||
els_on_line = 1;
|
||
if (vect_length == 0)
|
||
fprintf (output_file,
|
||
"0 /* This is dummy el because the vect is empty */");
|
||
else
|
||
{
|
||
do
|
||
{
|
||
fprintf (output_file, "%5ld", (long) *vect);
|
||
vect_length--;
|
||
if (els_on_line == 10)
|
||
{
|
||
els_on_line = 0;
|
||
fprintf (output_file, ",\n");
|
||
}
|
||
else if (vect_length != 0)
|
||
fprintf (output_file, ", ");
|
||
els_on_line++;
|
||
vect++;
|
||
}
|
||
while (vect_length != 0);
|
||
}
|
||
}
|
||
|
||
/* The following is name of the structure which represents DFA(s) for
|
||
PHR. */
|
||
#define CHIP_NAME "DFA_chip"
|
||
|
||
/* The following is name of member which represents state of a DFA for
|
||
PHR. */
|
||
static void
|
||
output_chip_member_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "automaton_state_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_automaton_state",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* The following is name of temporary variable which stores state of a
|
||
DFA for PHR. */
|
||
static void
|
||
output_temp_chip_member_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
fprintf (f, "_");
|
||
output_chip_member_name (f, automaton);
|
||
}
|
||
|
||
/* This is name of macro value which is code of pseudo_insn
|
||
representing advancing cpu cycle. Its value is used as internal
|
||
code unknown insn. */
|
||
#define ADVANCE_CYCLE_VALUE_NAME "DFA__ADVANCE_CYCLE"
|
||
|
||
/* Output name of translate vector for given automaton. */
|
||
static void
|
||
output_translate_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "translate_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_translate", automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name for simple transition table representation. */
|
||
static void
|
||
output_trans_full_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "transitions_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_transitions",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of comb vector of the transition table for given
|
||
automaton. */
|
||
static void
|
||
output_trans_comb_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "transitions_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_transitions",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of check vector of the transition table for given
|
||
automaton. */
|
||
static void
|
||
output_trans_check_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "check_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_check", automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of base vector of the transition table for given
|
||
automaton. */
|
||
static void
|
||
output_trans_base_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "base_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_base", automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name for simple alternatives number representation. */
|
||
static void
|
||
output_state_alts_full_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "state_alts_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_state_alts",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "state_alts_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_state_alts",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "check_state_alts_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_check_state_alts",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "base_state_alts_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_base_state_alts",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of simple min issue delay table representation. */
|
||
static void
|
||
output_min_issue_delay_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "min_issue_delay_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_min_issue_delay",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of deadlock vector for given automaton. */
|
||
static void
|
||
output_dead_lock_vect_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "dead_lock_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_dead_lock", automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Output name of reserved units table for AUTOMATON into file F. */
|
||
static void
|
||
output_reserved_units_table_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "reserved_units_%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "%s_reserved_units",
|
||
automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Name of the PHR interface macro. */
|
||
#define AUTOMATON_STATE_ALTS_MACRO_NAME "AUTOMATON_STATE_ALTS"
|
||
|
||
/* Name of the PHR interface macro. */
|
||
#define CPU_UNITS_QUERY_MACRO_NAME "CPU_UNITS_QUERY"
|
||
|
||
/* Names of an internal functions: */
|
||
#define INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME "internal_min_issue_delay"
|
||
|
||
/* This is external type of DFA(s) state. */
|
||
#define STATE_TYPE_NAME "state_t"
|
||
|
||
#define INTERNAL_TRANSITION_FUNC_NAME "internal_state_transition"
|
||
|
||
#define INTERNAL_STATE_ALTS_FUNC_NAME "internal_state_alts"
|
||
|
||
#define INTERNAL_RESET_FUNC_NAME "internal_reset"
|
||
|
||
#define INTERNAL_DEAD_LOCK_FUNC_NAME "internal_state_dead_lock_p"
|
||
|
||
#define INTERNAL_INSN_LATENCY_FUNC_NAME "internal_insn_latency"
|
||
|
||
/* Name of cache of insn dfa codes. */
|
||
#define DFA_INSN_CODES_VARIABLE_NAME "dfa_insn_codes"
|
||
|
||
/* Name of length of cache of insn dfa codes. */
|
||
#define DFA_INSN_CODES_LENGTH_VARIABLE_NAME "dfa_insn_codes_length"
|
||
|
||
/* Names of the PHR interface functions: */
|
||
#define SIZE_FUNC_NAME "state_size"
|
||
|
||
#define TRANSITION_FUNC_NAME "state_transition"
|
||
|
||
#define STATE_ALTS_FUNC_NAME "state_alts"
|
||
|
||
#define MIN_ISSUE_DELAY_FUNC_NAME "min_issue_delay"
|
||
|
||
#define MIN_INSN_CONFLICT_DELAY_FUNC_NAME "min_insn_conflict_delay"
|
||
|
||
#define DEAD_LOCK_FUNC_NAME "state_dead_lock_p"
|
||
|
||
#define RESET_FUNC_NAME "state_reset"
|
||
|
||
#define INSN_LATENCY_FUNC_NAME "insn_latency"
|
||
|
||
#define PRINT_RESERVATION_FUNC_NAME "print_reservation"
|
||
|
||
#define GET_CPU_UNIT_CODE_FUNC_NAME "get_cpu_unit_code"
|
||
|
||
#define CPU_UNIT_RESERVATION_P_FUNC_NAME "cpu_unit_reservation_p"
|
||
|
||
#define DFA_START_FUNC_NAME "dfa_start"
|
||
|
||
#define DFA_FINISH_FUNC_NAME "dfa_finish"
|
||
|
||
/* Names of parameters of the PHR interface functions. */
|
||
#define STATE_NAME "state"
|
||
|
||
#define INSN_PARAMETER_NAME "insn"
|
||
|
||
#define INSN2_PARAMETER_NAME "insn2"
|
||
|
||
#define CHIP_PARAMETER_NAME "chip"
|
||
|
||
#define FILE_PARAMETER_NAME "f"
|
||
|
||
#define CPU_UNIT_NAME_PARAMETER_NAME "cpu_unit_name"
|
||
|
||
#define CPU_CODE_PARAMETER_NAME "cpu_unit_code"
|
||
|
||
/* Names of the variables whose values are internal insn code of rtx
|
||
insn. */
|
||
#define INTERNAL_INSN_CODE_NAME "insn_code"
|
||
|
||
#define INTERNAL_INSN2_CODE_NAME "insn2_code"
|
||
|
||
/* Names of temporary variables in some functions. */
|
||
#define TEMPORARY_VARIABLE_NAME "temp"
|
||
|
||
#define I_VARIABLE_NAME "i"
|
||
|
||
/* Name of result variable in some functions. */
|
||
#define RESULT_VARIABLE_NAME "res"
|
||
|
||
/* Name of function (attribute) to translate insn into number of insn
|
||
alternatives reservation. */
|
||
#define INSN_ALTS_FUNC_NAME "insn_alts"
|
||
|
||
/* Name of function (attribute) to translate insn into internal insn
|
||
code. */
|
||
#define INTERNAL_DFA_INSN_CODE_FUNC_NAME "internal_dfa_insn_code"
|
||
|
||
/* Name of function (attribute) to translate insn into internal insn
|
||
code with caching. */
|
||
#define DFA_INSN_CODE_FUNC_NAME "dfa_insn_code"
|
||
|
||
/* Name of function (attribute) to translate insn into internal insn
|
||
code. */
|
||
#define INSN_DEFAULT_LATENCY_FUNC_NAME "insn_default_latency"
|
||
|
||
/* Name of function (attribute) to translate insn into internal insn
|
||
code. */
|
||
#define BYPASS_P_FUNC_NAME "bypass_p"
|
||
|
||
/* 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_range_type (f, 0, automaton->achieved_states_num);
|
||
}
|
||
|
||
/* Output definition of the structure representing current DFA(s)
|
||
state(s). */
|
||
static void
|
||
output_chip_definitions ()
|
||
{
|
||
automaton_t automaton;
|
||
|
||
fprintf (output_file, "struct %s\n{\n", CHIP_NAME);
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
fprintf (output_file, " ");
|
||
output_state_member_type (output_file, automaton);
|
||
fprintf (output_file, " ");
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, ";\n");
|
||
}
|
||
fprintf (output_file, "};\n\n");
|
||
#if 0
|
||
fprintf (output_file, "static struct %s %s;\n\n", CHIP_NAME, CHIP_NAME);
|
||
#endif
|
||
}
|
||
|
||
|
||
/* The function outputs translate vector of internal insn code into
|
||
insn equivalence class number. The equivalence class number is
|
||
used to access to table and vectors reprewsenting DFA(s). */
|
||
static void
|
||
output_translate_vect (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
ainsn_t ainsn;
|
||
int insn_value;
|
||
vla_hwint_t translate_vect;
|
||
|
||
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++)
|
||
/* Undefined value */
|
||
VLA_HWINT (translate_vect, insn_value) = automaton->insn_equiv_classes_num;
|
||
for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
|
||
VLA_HWINT (translate_vect, ainsn->insn_reserv_decl->insn_num)
|
||
= ainsn->insn_equiv_class_num;
|
||
fprintf (output_file,
|
||
"/* Vector translating external insn codes to internal ones.*/\n");
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, 0, automaton->insn_equiv_classes_num);
|
||
fprintf (output_file, " ");
|
||
output_translate_vect_name (output_file, automaton);
|
||
fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (translate_vect),
|
||
VLA_HWINT_LENGTH (translate_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
VLA_HWINT_DELETE (translate_vect);
|
||
}
|
||
|
||
/* The value in a table state x ainsn -> something which represents
|
||
undefined value. */
|
||
static int undefined_vect_el_value;
|
||
|
||
/* The following function returns nonzero value if the best
|
||
representation of the table is comb vector. */
|
||
static int
|
||
comb_vect_p (tab)
|
||
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;
|
||
{
|
||
state_ainsn_table_t tab;
|
||
int full_vect_length;
|
||
int i;
|
||
|
||
tab = create_node (sizeof (struct state_ainsn_table));
|
||
tab->automaton = automaton;
|
||
VLA_HWINT_CREATE (tab->comb_vect, 10000, "comb vector");
|
||
VLA_HWINT_CREATE (tab->check_vect, 10000, "check vector");
|
||
VLA_HWINT_CREATE (tab->base_vect, 1000, "base vector");
|
||
VLA_HWINT_EXPAND (tab->base_vect, automaton->achieved_states_num);
|
||
VLA_HWINT_CREATE (tab->full_vect, 10000, "full vector");
|
||
full_vect_length = (automaton->insn_equiv_classes_num
|
||
* automaton->achieved_states_num);
|
||
VLA_HWINT_EXPAND (tab->full_vect, full_vect_length);
|
||
for (i = 0; i < full_vect_length; i++)
|
||
VLA_HWINT (tab->full_vect, i) = undefined_vect_el_value;
|
||
tab->min_base_vect_el_value = 0;
|
||
tab->max_base_vect_el_value = 0;
|
||
tab->min_comb_vect_el_value = 0;
|
||
tab->max_comb_vect_el_value = 0;
|
||
return tab;
|
||
}
|
||
|
||
/* The following function outputs the best C representation of the
|
||
table TAB of given TABLE_NAME. */
|
||
static void
|
||
output_state_ainsn_table (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));
|
||
{
|
||
if (!comb_vect_p (tab))
|
||
{
|
||
fprintf (output_file, "/* Vector for %s. */\n", table_name);
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, tab->min_comb_vect_el_value,
|
||
tab->max_comb_vect_el_value);
|
||
fprintf (output_file, " ");
|
||
(*output_full_vect_name_func) (output_file, tab->automaton);
|
||
fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (tab->full_vect),
|
||
VLA_HWINT_LENGTH (tab->full_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
}
|
||
else
|
||
{
|
||
fprintf (output_file, "/* Comb vector for %s. */\n", table_name);
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, tab->min_comb_vect_el_value,
|
||
tab->max_comb_vect_el_value);
|
||
fprintf (output_file, " ");
|
||
(*output_comb_vect_name_func) (output_file, tab->automaton);
|
||
fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (tab->comb_vect),
|
||
VLA_HWINT_LENGTH (tab->comb_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
fprintf (output_file, "/* Check vector for %s. */\n", table_name);
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, 0, tab->automaton->achieved_states_num);
|
||
fprintf (output_file, " ");
|
||
(*output_check_vect_name_func) (output_file, tab->automaton);
|
||
fprintf (output_file, "[] = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (tab->check_vect),
|
||
VLA_HWINT_LENGTH (tab->check_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
fprintf (output_file, "/* Base vector for %s. */\n", table_name);
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, tab->min_base_vect_el_value,
|
||
tab->max_base_vect_el_value);
|
||
fprintf (output_file, " ");
|
||
(*output_base_vect_name_func) (output_file, tab->automaton);
|
||
fprintf (output_file, "[] = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (tab->base_vect),
|
||
VLA_HWINT_LENGTH (tab->base_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
}
|
||
}
|
||
|
||
/* The following function adds vector with length VECT_LENGTH and
|
||
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;
|
||
{
|
||
int real_vect_length;
|
||
vect_el_t *comb_vect_start;
|
||
vect_el_t *check_vect_start;
|
||
int comb_vect_index;
|
||
int comb_vect_els_num;
|
||
int vect_index;
|
||
int first_unempty_vect_index;
|
||
int additional_els_num;
|
||
int no_state_value;
|
||
vect_el_t vect_el;
|
||
int i;
|
||
|
||
if (vect_length == 0)
|
||
abort ();
|
||
real_vect_length = tab->automaton->insn_equiv_classes_num;
|
||
if (vect [vect_length - 1] == undefined_vect_el_value)
|
||
abort ();
|
||
/* 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 ();
|
||
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 < vect_length;
|
||
first_unempty_vect_index++)
|
||
if (vect [first_unempty_vect_index] != undefined_vect_el_value)
|
||
break;
|
||
/* Search for the place in comb vect for the inserted vect. */
|
||
for (comb_vect_index = 0;
|
||
comb_vect_index < comb_vect_els_num;
|
||
comb_vect_index++)
|
||
{
|
||
for (vect_index = first_unempty_vect_index;
|
||
vect_index < vect_length
|
||
&& vect_index + comb_vect_index < comb_vect_els_num;
|
||
vect_index++)
|
||
if (vect [vect_index] != undefined_vect_el_value
|
||
&& (comb_vect_start [vect_index + comb_vect_index]
|
||
!= undefined_vect_el_value))
|
||
break;
|
||
if (vect_index >= vect_length
|
||
|| vect_index + comb_vect_index >= comb_vect_els_num)
|
||
break;
|
||
}
|
||
/* Slot was found. */
|
||
additional_els_num = comb_vect_index + real_vect_length - comb_vect_els_num;
|
||
if (additional_els_num < 0)
|
||
additional_els_num = 0;
|
||
/* Expand comb and check vectors. */
|
||
vect_el = undefined_vect_el_value;
|
||
no_state_value = tab->automaton->achieved_states_num;
|
||
while (additional_els_num > 0)
|
||
{
|
||
VLA_HWINT_ADD (tab->comb_vect, vect_el);
|
||
VLA_HWINT_ADD (tab->check_vect, no_state_value);
|
||
additional_els_num--;
|
||
}
|
||
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 ();
|
||
/* 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 ();
|
||
comb_vect_start [comb_vect_index + vect_index] = vect [vect_index];
|
||
if (vect [vect_index] < 0)
|
||
abort ();
|
||
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_base_vect_el_value < comb_vect_index)
|
||
tab->max_base_vect_el_value = comb_vect_index;
|
||
if (tab->min_base_vect_el_value > comb_vect_index)
|
||
tab->min_base_vect_el_value = comb_vect_index;
|
||
VLA_HWINT (tab->base_vect, vect_num) = comb_vect_index;
|
||
}
|
||
|
||
/* Return number of out arcs of STATE. */
|
||
static int
|
||
out_state_arcs_num (state)
|
||
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)
|
||
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;
|
||
{
|
||
int transition_els_num_1;
|
||
int transition_els_num_2;
|
||
|
||
transition_els_num_1 = out_state_arcs_num (*(state_t *) state_ptr_1);
|
||
transition_els_num_2 = out_state_arcs_num (*(state_t *) state_ptr_2);
|
||
if (transition_els_num_1 < transition_els_num_2)
|
||
return 1;
|
||
else if (transition_els_num_1 == transition_els_num_2)
|
||
return 0;
|
||
else
|
||
return -1;
|
||
}
|
||
|
||
/* The function adds element EL_VALUE to vector VECT for a table state
|
||
x AINSN. */
|
||
static void
|
||
add_vect_el (vect, ainsn, el_value)
|
||
vla_hwint_t *vect;
|
||
ainsn_t ainsn;
|
||
int el_value;
|
||
{
|
||
int equiv_class_num;
|
||
int vect_index;
|
||
|
||
if (ainsn == NULL)
|
||
abort ();
|
||
equiv_class_num = ainsn->insn_equiv_class_num;
|
||
for (vect_index = VLA_HWINT_LENGTH (*vect);
|
||
vect_index <= equiv_class_num;
|
||
vect_index++)
|
||
VLA_HWINT_ADD (*vect, undefined_vect_el_value);
|
||
VLA_HWINT (*vect, equiv_class_num) = el_value;
|
||
}
|
||
|
||
/* This is for forming vector of states of an automaton. */
|
||
static vla_ptr_t output_states_vect;
|
||
|
||
/* The function is called by function pass_states. The function adds
|
||
STATE to `output_states_vect'. */
|
||
static void
|
||
add_states_vect_el (state)
|
||
state_t state;
|
||
{
|
||
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;
|
||
{
|
||
state_t *state_ptr;
|
||
arc_t arc;
|
||
vla_hwint_t transition_vect;
|
||
|
||
undefined_vect_el_value = automaton->achieved_states_num;
|
||
automaton->trans_table = create_state_ainsn_table (automaton);
|
||
/* Create vect of pointers to states ordered by num of transitions
|
||
from the state (state with the maximum num is the first). */
|
||
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
|
||
pass_states (automaton, add_states_vect_el);
|
||
qsort (VLA_PTR_BEGIN (output_states_vect),
|
||
VLA_PTR_LENGTH (output_states_vect),
|
||
sizeof (state_t), compare_transition_els_num);
|
||
VLA_HWINT_CREATE (transition_vect, 500, "transition vector");
|
||
for (state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
state_ptr++)
|
||
{
|
||
VLA_HWINT_NULLIFY (transition_vect);
|
||
for (arc = first_out_arc (*state_ptr);
|
||
arc != NULL;
|
||
arc = next_out_arc (arc))
|
||
{
|
||
if (arc->insn == NULL)
|
||
abort ();
|
||
if (arc->insn->first_ainsn_with_given_equialence_num)
|
||
add_vect_el (&transition_vect, arc->insn,
|
||
arc->to_state->order_state_num);
|
||
}
|
||
add_vect (automaton->trans_table, (*state_ptr)->order_state_num,
|
||
VLA_HWINT_BEGIN (transition_vect),
|
||
VLA_HWINT_LENGTH (transition_vect));
|
||
}
|
||
output_state_ainsn_table
|
||
(automaton->trans_table, (char *) "state transitions",
|
||
output_trans_full_vect_name, output_trans_comb_vect_name,
|
||
output_trans_check_vect_name, output_trans_base_vect_name);
|
||
VLA_PTR_DELETE (output_states_vect);
|
||
VLA_HWINT_DELETE (transition_vect);
|
||
}
|
||
|
||
/* Form and output vectors (comb, check, base or simple vect)
|
||
representing alts number table of AUTOMATON. The table is state x
|
||
ainsn -> number of possible alternative reservations by the
|
||
ainsn. */
|
||
static void
|
||
output_state_alts_table (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
state_t *state_ptr;
|
||
arc_t arc;
|
||
vla_hwint_t state_alts_vect;
|
||
|
||
undefined_vect_el_value = 0; /* no alts when transition is not possible */
|
||
automaton->state_alts_table = create_state_ainsn_table (automaton);
|
||
/* Create vect of pointers to states ordered by num of transitions
|
||
from the state (state with the maximum num is the first). */
|
||
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
|
||
pass_states (automaton, add_states_vect_el);
|
||
qsort (VLA_PTR_BEGIN (output_states_vect),
|
||
VLA_PTR_LENGTH (output_states_vect),
|
||
sizeof (state_t), compare_transition_els_num);
|
||
/* Create base, comb, and check vectors. */
|
||
VLA_HWINT_CREATE (state_alts_vect, 500, "state alts vector");
|
||
for (state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
state_ptr++)
|
||
{
|
||
VLA_HWINT_NULLIFY (state_alts_vect);
|
||
for (arc = first_out_arc (*state_ptr);
|
||
arc != NULL;
|
||
arc = next_out_arc (arc))
|
||
{
|
||
if (arc->insn == NULL)
|
||
abort ();
|
||
if (arc->insn->first_ainsn_with_given_equialence_num)
|
||
add_vect_el (&state_alts_vect, arc->insn, arc->state_alts);
|
||
}
|
||
add_vect (automaton->state_alts_table, (*state_ptr)->order_state_num,
|
||
VLA_HWINT_BEGIN (state_alts_vect),
|
||
VLA_HWINT_LENGTH (state_alts_vect));
|
||
}
|
||
output_state_ainsn_table
|
||
(automaton->state_alts_table, (char *) "state insn alternatives",
|
||
output_state_alts_full_vect_name, output_state_alts_comb_vect_name,
|
||
output_state_alts_check_vect_name, output_state_alts_base_vect_name);
|
||
VLA_PTR_DELETE (output_states_vect);
|
||
VLA_HWINT_DELETE (state_alts_vect);
|
||
}
|
||
|
||
/* The current number of passing states to find minimal issue delay
|
||
value for an ainsn and state. */
|
||
static int curr_state_pass_num;
|
||
|
||
|
||
/* This recursive function passes states to find minimal issue delay
|
||
value for AINSN. The state being visited is STATE. The function
|
||
returns minimal issue delay value for AINSN in STATE or -1 if we
|
||
enter into a loop. */
|
||
static int
|
||
min_issue_delay_pass_states (state, ainsn)
|
||
state_t state;
|
||
ainsn_t ainsn;
|
||
{
|
||
arc_t arc;
|
||
int min_insn_issue_delay, insn_issue_delay;
|
||
|
||
if (state->state_pass_num == curr_state_pass_num
|
||
|| state->min_insn_issue_delay != -1)
|
||
/* We've entered into a loop or already have the correct value for
|
||
given state and ainsn. */
|
||
return state->min_insn_issue_delay;
|
||
state->state_pass_num = curr_state_pass_num;
|
||
min_insn_issue_delay = -1;
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
if (arc->insn == ainsn)
|
||
{
|
||
min_insn_issue_delay = 0;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
insn_issue_delay = min_issue_delay_pass_states (arc->to_state, ainsn);
|
||
if (insn_issue_delay != -1)
|
||
{
|
||
if (arc->insn->insn_reserv_decl
|
||
== DECL_INSN_RESERV (advance_cycle_insn_decl))
|
||
insn_issue_delay++;
|
||
if (min_insn_issue_delay == -1
|
||
|| min_insn_issue_delay > insn_issue_delay)
|
||
{
|
||
min_insn_issue_delay = insn_issue_delay;
|
||
if (insn_issue_delay == 0)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return min_insn_issue_delay;
|
||
}
|
||
|
||
/* The function searches minimal issue delay value for AINSN in STATE.
|
||
The function can return negative value if we can not issue AINSN. We
|
||
will report about it later. */
|
||
static int
|
||
min_issue_delay (state, ainsn)
|
||
state_t state;
|
||
ainsn_t ainsn;
|
||
{
|
||
curr_state_pass_num++;
|
||
state->min_insn_issue_delay = min_issue_delay_pass_states (state, ainsn);
|
||
return state->min_insn_issue_delay;
|
||
}
|
||
|
||
/* The function initiates code for finding minimal issue delay values.
|
||
It should be called only once. */
|
||
static void
|
||
initiate_min_issue_delay_pass_states ()
|
||
{
|
||
curr_state_pass_num = 0;
|
||
}
|
||
|
||
/* Form and output vectors representing minimal issue delay table of
|
||
AUTOMATON. The table is state x ainsn -> minimal issue delay of
|
||
the ainsn. */
|
||
static void
|
||
output_min_issue_delay_table (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
vla_hwint_t min_issue_delay_vect;
|
||
vla_hwint_t compressed_min_issue_delay_vect;
|
||
vect_el_t min_delay;
|
||
ainsn_t ainsn;
|
||
state_t *state_ptr;
|
||
int i;
|
||
|
||
/* Create vect of pointers to states ordered by num of transitions
|
||
from the state (state with the maximum num is the first). */
|
||
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
|
||
pass_states (automaton, add_states_vect_el);
|
||
VLA_HWINT_CREATE (min_issue_delay_vect, 1500, "min issue delay vector");
|
||
VLA_HWINT_EXPAND (min_issue_delay_vect,
|
||
VLA_HWINT_LENGTH (output_states_vect)
|
||
* automaton->insn_equiv_classes_num);
|
||
for (i = 0;
|
||
i < ((int) VLA_HWINT_LENGTH (output_states_vect)
|
||
* automaton->insn_equiv_classes_num);
|
||
i++)
|
||
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)
|
||
{
|
||
for (state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
state_ptr++)
|
||
(*state_ptr)->min_insn_issue_delay = -1;
|
||
for (state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
state_ptr++)
|
||
{
|
||
min_delay = min_issue_delay (*state_ptr, ainsn);
|
||
if (automaton->max_min_delay < min_delay)
|
||
automaton->max_min_delay = min_delay;
|
||
VLA_HWINT (min_issue_delay_vect,
|
||
(*state_ptr)->order_state_num
|
||
* automaton->insn_equiv_classes_num
|
||
+ ainsn->insn_equiv_class_num) = min_delay;
|
||
}
|
||
}
|
||
fprintf (output_file, "/* Vector of min issue delay of insns.*/\n");
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, 0, automaton->max_min_delay);
|
||
fprintf (output_file, " ");
|
||
output_min_issue_delay_vect_name (output_file, automaton);
|
||
fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
|
||
/* Compress the vector */
|
||
if (automaton->max_min_delay < 2)
|
||
automaton->min_issue_delay_table_compression_factor = 8;
|
||
else if (automaton->max_min_delay < 4)
|
||
automaton->min_issue_delay_table_compression_factor = 4;
|
||
else if (automaton->max_min_delay < 16)
|
||
automaton->min_issue_delay_table_compression_factor = 2;
|
||
else
|
||
automaton->min_issue_delay_table_compression_factor = 1;
|
||
VLA_HWINT_CREATE (compressed_min_issue_delay_vect, 1500,
|
||
"compressed min issue delay vector");
|
||
VLA_HWINT_EXPAND (compressed_min_issue_delay_vect,
|
||
(VLA_HWINT_LENGTH (min_issue_delay_vect)
|
||
+ automaton->min_issue_delay_table_compression_factor
|
||
- 1)
|
||
/ automaton->min_issue_delay_table_compression_factor);
|
||
for (i = 0;
|
||
i < (int) VLA_HWINT_LENGTH (compressed_min_issue_delay_vect);
|
||
i++)
|
||
VLA_HWINT (compressed_min_issue_delay_vect, i) = 0;
|
||
for (i = 0; i < (int) VLA_HWINT_LENGTH (min_issue_delay_vect); i++)
|
||
VLA_HWINT (compressed_min_issue_delay_vect,
|
||
i / automaton->min_issue_delay_table_compression_factor)
|
||
|= (VLA_HWINT (min_issue_delay_vect, i)
|
||
<< (8 - (i % automaton->min_issue_delay_table_compression_factor
|
||
+ 1)
|
||
* (8 / automaton->min_issue_delay_table_compression_factor)));
|
||
output_vect (VLA_HWINT_BEGIN (compressed_min_issue_delay_vect),
|
||
VLA_HWINT_LENGTH (compressed_min_issue_delay_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
VLA_PTR_DELETE (output_states_vect);
|
||
VLA_HWINT_DELETE (min_issue_delay_vect);
|
||
VLA_HWINT_DELETE (compressed_min_issue_delay_vect);
|
||
}
|
||
|
||
#ifndef NDEBUG
|
||
/* Number of states which contains transition only by advancing cpu
|
||
cycle. */
|
||
static int locked_states_num;
|
||
#endif
|
||
|
||
/* Form and output vector representing the locked states of
|
||
AUTOMATON. */
|
||
static void
|
||
output_dead_lock_vect (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
state_t *state_ptr;
|
||
arc_t arc;
|
||
vla_hwint_t dead_lock_vect;
|
||
|
||
/* Create vect of pointers to states ordered by num of
|
||
transitions from the state (state with the maximum num is the
|
||
first). */
|
||
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
|
||
pass_states (automaton, add_states_vect_el);
|
||
VLA_HWINT_CREATE (dead_lock_vect, 1500, "is dead locked vector");
|
||
VLA_HWINT_EXPAND (dead_lock_vect, VLA_HWINT_LENGTH (output_states_vect));
|
||
for (state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
state_ptr++)
|
||
{
|
||
arc = first_out_arc (*state_ptr);
|
||
if (arc == NULL)
|
||
abort ();
|
||
VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num)
|
||
= (next_out_arc (arc) == NULL
|
||
&& (arc->insn->insn_reserv_decl
|
||
== DECL_INSN_RESERV (advance_cycle_insn_decl)) ? 1 : 0);
|
||
#ifndef NDEBUG
|
||
if (VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num))
|
||
locked_states_num++;
|
||
#endif
|
||
}
|
||
fprintf (output_file, "/* Vector for locked state flags. */\n");
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, 0, 1);
|
||
fprintf (output_file, " ");
|
||
output_dead_lock_vect_name (output_file, automaton);
|
||
fprintf (output_file, "[] = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (dead_lock_vect),
|
||
VLA_HWINT_LENGTH (dead_lock_vect));
|
||
fprintf (output_file, "};\n\n");
|
||
VLA_HWINT_DELETE (dead_lock_vect);
|
||
VLA_PTR_DELETE (output_states_vect);
|
||
}
|
||
|
||
/* Form and output vector representing reserved units of the states of
|
||
AUTOMATON. */
|
||
static void
|
||
output_reserved_units_table (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
state_t *curr_state_ptr;
|
||
vla_hwint_t reserved_units_table;
|
||
size_t state_byte_size;
|
||
int i;
|
||
|
||
/* Create vect of pointers to states. */
|
||
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
|
||
pass_states (automaton, add_states_vect_el);
|
||
/* Create vector. */
|
||
VLA_HWINT_CREATE (reserved_units_table, 1500, "reserved units vector");
|
||
state_byte_size = (description->query_units_num + 7) / 8;
|
||
VLA_HWINT_EXPAND (reserved_units_table,
|
||
VLA_HWINT_LENGTH (output_states_vect) * state_byte_size);
|
||
for (i = 0;
|
||
i < (int) (VLA_HWINT_LENGTH (output_states_vect) * state_byte_size);
|
||
i++)
|
||
VLA_HWINT (reserved_units_table, i) = 0;
|
||
for (curr_state_ptr = VLA_PTR_BEGIN (output_states_vect);
|
||
curr_state_ptr <= (state_t *) VLA_PTR_LAST (output_states_vect);
|
||
curr_state_ptr++)
|
||
{
|
||
for (i = 0; i < description->units_num; i++)
|
||
if (units_array [i]->query_p)
|
||
{
|
||
if (test_unit_reserv ((*curr_state_ptr)->reservs, 0, i))
|
||
VLA_HWINT (reserved_units_table,
|
||
(*curr_state_ptr)->order_state_num * state_byte_size
|
||
+ units_array [i]->query_num / 8)
|
||
+= (1 << (units_array [i]->query_num % 8));
|
||
}
|
||
}
|
||
fprintf (output_file, "/* Vector for reserved units of states. */\n");
|
||
fprintf (output_file, "static const ");
|
||
output_range_type (output_file, 0, 255);
|
||
fprintf (output_file, " ");
|
||
output_reserved_units_table_name (output_file, automaton);
|
||
fprintf (output_file, "[] = {\n");
|
||
output_vect (VLA_HWINT_BEGIN (reserved_units_table),
|
||
VLA_HWINT_LENGTH (reserved_units_table));
|
||
fprintf (output_file, "};\n\n");
|
||
VLA_HWINT_DELETE (reserved_units_table);
|
||
VLA_PTR_DELETE (output_states_vect);
|
||
}
|
||
|
||
/* The function outputs all tables representing DFA(s) used for fast
|
||
pipeline hazards recognition. */
|
||
static void
|
||
output_tables ()
|
||
{
|
||
automaton_t automaton;
|
||
|
||
#ifndef NDEBUG
|
||
locked_states_num = 0;
|
||
#endif
|
||
initiate_min_issue_delay_pass_states ();
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
output_translate_vect (automaton);
|
||
output_trans_table (automaton);
|
||
fprintf (output_file, "\n#if %s\n", AUTOMATON_STATE_ALTS_MACRO_NAME);
|
||
output_state_alts_table (automaton);
|
||
fprintf (output_file, "\n#endif /* #if %s */\n\n",
|
||
AUTOMATON_STATE_ALTS_MACRO_NAME);
|
||
output_min_issue_delay_table (automaton);
|
||
output_dead_lock_vect (automaton);
|
||
if (no_minimization_flag)
|
||
{
|
||
fprintf (output_file, "\n#if %s\n\n", CPU_UNITS_QUERY_MACRO_NAME);
|
||
output_reserved_units_table (automaton);
|
||
fprintf (output_file, "\n#endif /* #if %s */\n\n",
|
||
CPU_UNITS_QUERY_MACRO_NAME);
|
||
}
|
||
}
|
||
fprintf (output_file, "\n#define %s %d\n\n", ADVANCE_CYCLE_VALUE_NAME,
|
||
DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num);
|
||
}
|
||
|
||
/* The function outputs definition and value of PHR interface variable
|
||
`max_insn_queue_index'. Its value is not less than maximal queue
|
||
length needed for the insn scheduler. */
|
||
static void
|
||
output_max_insn_queue_index_def ()
|
||
{
|
||
int i, max, latency;
|
||
decl_t decl;
|
||
|
||
max = description->max_insn_reserv_cycles;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
latency = DECL_INSN_RESERV (decl)->default_latency;
|
||
if (latency > max)
|
||
max = latency;
|
||
}
|
||
else if (decl->mode == dm_bypass)
|
||
{
|
||
latency = DECL_BYPASS (decl)->latency;
|
||
if (latency > max)
|
||
max = latency;
|
||
}
|
||
}
|
||
for (i = 0; (1 << i) <= max; i++)
|
||
;
|
||
if (i < 0)
|
||
abort ();
|
||
fprintf (output_file, "\nint max_insn_queue_index = %d;\n\n", (1 << i) - 1);
|
||
}
|
||
|
||
|
||
/* The function outputs switch cases for insn reseravtions 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));
|
||
{
|
||
decl_t decl, decl2;
|
||
int i, j;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
DECL_INSN_RESERV (decl)->processed_p = FALSE;
|
||
}
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv
|
||
&& !DECL_INSN_RESERV (decl)->processed_p)
|
||
{
|
||
for (j = i; j < description->decls_num; j++)
|
||
{
|
||
decl2 = description->decls [j];
|
||
if (decl2->mode == dm_insn_reserv
|
||
&& (DECL_INSN_RESERV (decl2)->important_automata_list
|
||
== DECL_INSN_RESERV (decl)->important_automata_list))
|
||
{
|
||
DECL_INSN_RESERV (decl2)->processed_p = TRUE;
|
||
fprintf (output_file, " case %d: /* %s */\n",
|
||
DECL_INSN_RESERV (decl2)->insn_num,
|
||
DECL_INSN_RESERV (decl2)->name);
|
||
}
|
||
}
|
||
(*output_automata_list_code)
|
||
(DECL_INSN_RESERV (decl)->important_automata_list);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* The function outputs a code for evaluation of a minimal delay of
|
||
issue of insns which have reservations in given AUTOMATA_LIST. */
|
||
static void
|
||
output_automata_list_min_issue_delay_code (automata_list)
|
||
automata_list_el_t automata_list;
|
||
{
|
||
automata_list_el_t el;
|
||
automaton_t automaton;
|
||
|
||
for (el = automata_list; el != NULL; el = el->next_automata_list_el)
|
||
{
|
||
automaton = el->automaton;
|
||
fprintf (output_file, "\n %s = ", TEMPORARY_VARIABLE_NAME);
|
||
output_min_issue_delay_vect_name (output_file, automaton);
|
||
fprintf (output_file,
|
||
(automaton->min_issue_delay_table_compression_factor != 1
|
||
? " [(" : " ["));
|
||
output_translate_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, " * %d", automaton->insn_equiv_classes_num);
|
||
if (automaton->min_issue_delay_table_compression_factor == 1)
|
||
fprintf (output_file, "];\n");
|
||
else
|
||
{
|
||
fprintf (output_file, ") / %d];\n",
|
||
automaton->min_issue_delay_table_compression_factor);
|
||
fprintf (output_file, " %s = (%s >> (8 - (",
|
||
TEMPORARY_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
|
||
output_translate_vect_name (output_file, automaton);
|
||
fprintf
|
||
(output_file, " [%s] %% %d + 1) * %d)) & %d;\n",
|
||
INTERNAL_INSN_CODE_NAME,
|
||
automaton->min_issue_delay_table_compression_factor,
|
||
8 / automaton->min_issue_delay_table_compression_factor,
|
||
(1 << (8 / automaton->min_issue_delay_table_compression_factor))
|
||
- 1);
|
||
}
|
||
if (el == automata_list)
|
||
fprintf (output_file, " %s = %s;\n",
|
||
RESULT_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
|
||
else
|
||
{
|
||
fprintf (output_file, " if (%s > %s)\n",
|
||
TEMPORARY_VARIABLE_NAME, RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = %s;\n",
|
||
RESULT_VARIABLE_NAME, TEMPORARY_VARIABLE_NAME);
|
||
}
|
||
}
|
||
fprintf (output_file, " break;\n\n");
|
||
}
|
||
|
||
/* Output function `internal_min_issue_delay'. */
|
||
static void
|
||
output_internal_min_issue_delay_func ()
|
||
{
|
||
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",
|
||
INTERNAL_MIN_ISSUE_DELAY_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 int %s = -1;\n",
|
||
TEMPORARY_VARIABLE_NAME, RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, "\n switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME);
|
||
output_insn_code_cases (output_automata_list_min_issue_delay_code);
|
||
fprintf (output_file,
|
||
"\n default:\n %s = -1;\n break;\n }\n",
|
||
RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, " return %s;\n", RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, "}\n\n");
|
||
}
|
||
|
||
/* The function outputs a code changing state after issue of insns
|
||
which have reservations in given AUTOMATA_LIST. */
|
||
static void
|
||
output_automata_list_transition_code (automata_list)
|
||
automata_list_el_t automata_list;
|
||
{
|
||
automata_list_el_t el, next_el;
|
||
|
||
fprintf (output_file, " {\n");
|
||
if (automata_list != NULL && automata_list->next_automata_list_el != NULL)
|
||
for (el = automata_list;; el = next_el)
|
||
{
|
||
next_el = el->next_automata_list_el;
|
||
if (next_el == NULL)
|
||
break;
|
||
fprintf (output_file, " ");
|
||
output_state_member_type (output_file, el->automaton);
|
||
fprintf (output_file, " ");
|
||
output_temp_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, ";\n");
|
||
}
|
||
for (el = automata_list; el != NULL; el = el->next_automata_list_el)
|
||
if (comb_vect_p (el->automaton->trans_table))
|
||
{
|
||
fprintf (output_file, "\n %s = ", TEMPORARY_VARIABLE_NAME);
|
||
output_trans_base_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, "] + ");
|
||
output_translate_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [%s];\n", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, " if (");
|
||
output_trans_check_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [%s] != %s->",
|
||
TEMPORARY_VARIABLE_NAME, CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, ")\n");
|
||
fprintf (output_file, " return %s (%s, %s);\n",
|
||
INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
|
||
CHIP_PARAMETER_NAME);
|
||
fprintf (output_file, " else\n");
|
||
fprintf (output_file, " ");
|
||
if (el->next_automata_list_el != NULL)
|
||
output_temp_chip_member_name (output_file, el->automaton);
|
||
else
|
||
{
|
||
fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
}
|
||
fprintf (output_file, " = ");
|
||
output_trans_comb_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [%s];\n", TEMPORARY_VARIABLE_NAME);
|
||
}
|
||
else
|
||
{
|
||
fprintf (output_file, "\n %s = ", TEMPORARY_VARIABLE_NAME);
|
||
output_trans_full_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [");
|
||
output_translate_vect_name (output_file, el->automaton);
|
||
fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, " * %d];\n",
|
||
el->automaton->insn_equiv_classes_num);
|
||
fprintf (output_file, " if (%s >= %d)\n",
|
||
TEMPORARY_VARIABLE_NAME, el->automaton->achieved_states_num);
|
||
fprintf (output_file, " return %s (%s, %s);\n",
|
||
INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
|
||
CHIP_PARAMETER_NAME);
|
||
fprintf (output_file, " else\n ");
|
||
if (el->next_automata_list_el != NULL)
|
||
output_temp_chip_member_name (output_file, el->automaton);
|
||
else
|
||
{
|
||
fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
}
|
||
fprintf (output_file, " = %s;\n", TEMPORARY_VARIABLE_NAME);
|
||
}
|
||
if (automata_list != NULL && automata_list->next_automata_list_el != NULL)
|
||
for (el = automata_list;; el = next_el)
|
||
{
|
||
next_el = el->next_automata_list_el;
|
||
if (next_el == NULL)
|
||
break;
|
||
fprintf (output_file, " %s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, " = ");
|
||
output_temp_chip_member_name (output_file, el->automaton);
|
||
fprintf (output_file, ";\n");
|
||
}
|
||
fprintf (output_file, " return -1;\n");
|
||
fprintf (output_file, " }\n");
|
||
}
|
||
|
||
/* Output function `internal_state_transition'. */
|
||
static void
|
||
output_internal_trans_func ()
|
||
{
|
||
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",
|
||
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);
|
||
output_insn_code_cases (output_automata_list_transition_code);
|
||
fprintf (output_file, "\n default:\n return -1;\n }\n");
|
||
fprintf (output_file, "}\n\n");
|
||
}
|
||
|
||
/* Output code
|
||
|
||
if (insn != 0)
|
||
{
|
||
insn_code = dfa_insn_code (insn);
|
||
if (insn_code > DFA__ADVANCE_CYCLE)
|
||
return code;
|
||
}
|
||
else
|
||
insn_code = DFA__ADVANCE_CYCLE;
|
||
|
||
where insn denotes INSN_NAME, insn_code denotes INSN_CODE_NAME, and
|
||
code denotes CODE. */
|
||
static void
|
||
output_internal_insn_code_evaluation (insn_name, insn_code_name, code)
|
||
const char *insn_name;
|
||
const char *insn_code_name;
|
||
int code;
|
||
{
|
||
fprintf (output_file, "\n if (%s != 0)\n {\n", insn_name);
|
||
fprintf (output_file, " %s = %s (%s);\n", insn_code_name,
|
||
DFA_INSN_CODE_FUNC_NAME, insn_name);
|
||
fprintf (output_file, " if (%s > %s)\n return %d;\n",
|
||
insn_code_name, ADVANCE_CYCLE_VALUE_NAME, code);
|
||
fprintf (output_file, " }\n else\n %s = %s;\n\n",
|
||
insn_code_name, ADVANCE_CYCLE_VALUE_NAME);
|
||
}
|
||
|
||
|
||
/* The function outputs function `dfa_insn_code'. */
|
||
static void
|
||
output_dfa_insn_code_func ()
|
||
{
|
||
fprintf (output_file, "#ifdef __GNUC__\n__inline__\n#endif\n");
|
||
fprintf (output_file, "static int %s PARAMS ((rtx));\n",
|
||
DFA_INSN_CODE_FUNC_NAME);
|
||
fprintf (output_file, "static int\n%s (%s)\n\trtx %s;\n",
|
||
DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME, INSN_PARAMETER_NAME);
|
||
fprintf (output_file, "{\n int %s;\n int %s;\n\n",
|
||
INTERNAL_INSN_CODE_NAME, TEMPORARY_VARIABLE_NAME);
|
||
fprintf (output_file, " if (INSN_UID (%s) >= %s)\n {\n",
|
||
INSN_PARAMETER_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = %s;\n %s = 2 * INSN_UID (%s);\n",
|
||
TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
|
||
DFA_INSN_CODES_LENGTH_VARIABLE_NAME, INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " %s = xrealloc (%s, %s * sizeof (int));\n",
|
||
DFA_INSN_CODES_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
|
||
DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
|
||
fprintf (output_file,
|
||
" for (; %s < %s; %s++)\n %s [%s] = -1;\n }\n",
|
||
TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME,
|
||
TEMPORARY_VARIABLE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
|
||
TEMPORARY_VARIABLE_NAME);
|
||
fprintf (output_file, " if ((%s = %s [INSN_UID (%s)]) < 0)\n {\n",
|
||
INTERNAL_INSN_CODE_NAME, DFA_INSN_CODES_VARIABLE_NAME,
|
||
INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " %s = %s (%s);\n", INTERNAL_INSN_CODE_NAME,
|
||
INTERNAL_DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " %s [INSN_UID (%s)] = %s;\n",
|
||
DFA_INSN_CODES_VARIABLE_NAME, INSN_PARAMETER_NAME,
|
||
INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, " }\n return %s;\n}\n\n",
|
||
INTERNAL_INSN_CODE_NAME);
|
||
}
|
||
|
||
/* The function outputs PHR interface function `state_transition'. */
|
||
static void
|
||
output_trans_func ()
|
||
{
|
||
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, "{\n int %s;\n", INTERNAL_INSN_CODE_NAME);
|
||
output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
|
||
INTERNAL_INSN_CODE_NAME, -1);
|
||
fprintf (output_file, " return %s (%s, %s);\n}\n\n",
|
||
INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME, STATE_NAME);
|
||
}
|
||
|
||
/* 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;
|
||
{
|
||
automata_list_el_t el;
|
||
automaton_t automaton;
|
||
|
||
fprintf (output_file, " {\n");
|
||
for (el = automata_list; el != NULL; el = el->next_automata_list_el)
|
||
if (comb_vect_p (el->automaton->state_alts_table))
|
||
{
|
||
fprintf (output_file, " int %s;\n", TEMPORARY_VARIABLE_NAME);
|
||
break;
|
||
}
|
||
for (el = automata_list; el != NULL; el = el->next_automata_list_el)
|
||
{
|
||
automaton = el->automaton;
|
||
if (comb_vect_p (automaton->state_alts_table))
|
||
{
|
||
fprintf (output_file, "\n %s = ", TEMPORARY_VARIABLE_NAME);
|
||
output_state_alts_base_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, "] + ");
|
||
output_translate_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s];\n", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, " if (");
|
||
output_state_alts_check_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s] != %s->",
|
||
TEMPORARY_VARIABLE_NAME, CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, ")\n");
|
||
fprintf (output_file, " return 0;\n");
|
||
fprintf (output_file, " else\n");
|
||
fprintf (output_file,
|
||
(el == automata_list
|
||
? " %s = " : " %s += "),
|
||
RESULT_VARIABLE_NAME);
|
||
output_state_alts_comb_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s];\n", TEMPORARY_VARIABLE_NAME);
|
||
}
|
||
else
|
||
{
|
||
fprintf (output_file,
|
||
(el == automata_list
|
||
? "\n %s = " : " %s += "),
|
||
RESULT_VARIABLE_NAME);
|
||
output_state_alts_full_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [");
|
||
output_translate_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s] + ", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, "%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, " * %d];\n",
|
||
automaton->insn_equiv_classes_num);
|
||
}
|
||
}
|
||
fprintf (output_file, " break;\n }\n\n");
|
||
}
|
||
|
||
/* Output function `internal_state_alts'. */
|
||
static void
|
||
output_internal_state_alts_func ()
|
||
{
|
||
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",
|
||
INTERNAL_STATE_ALTS_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
|
||
CHIP_PARAMETER_NAME, INTERNAL_INSN_CODE_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);
|
||
fprintf (output_file,
|
||
"\n default:\n %s = 0;\n break;\n }\n",
|
||
RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, " return %s;\n", RESULT_VARIABLE_NAME);
|
||
fprintf (output_file, "}\n\n");
|
||
}
|
||
|
||
/* The function outputs PHR interface function `state_alts'. */
|
||
static void
|
||
output_state_alts_func ()
|
||
{
|
||
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,
|
||
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, 0);
|
||
fprintf (output_file, " return %s (%s, %s);\n}\n\n",
|
||
INTERNAL_STATE_ALTS_FUNC_NAME, INTERNAL_INSN_CODE_NAME, STATE_NAME);
|
||
}
|
||
|
||
/* Output function `min_issue_delay'. */
|
||
static void
|
||
output_min_issue_delay_func ()
|
||
{
|
||
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, "{\n int %s;\n", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, "\n if (%s != 0)\n {\n", INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " %s = %s (%s);\n", INTERNAL_INSN_CODE_NAME,
|
||
DFA_INSN_CODE_FUNC_NAME, INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " if (%s > %s)\n return 0;\n",
|
||
INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
|
||
fprintf (output_file, " }\n else\n %s = %s;\n",
|
||
INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
|
||
fprintf (output_file, "\n return %s (%s, %s);\n",
|
||
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 ()
|
||
{
|
||
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, "{\n");
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
fprintf (output_file, " if (");
|
||
output_dead_lock_vect_name (output_file, automaton);
|
||
fprintf (output_file, " [%s->", CHIP_PARAMETER_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, "])\n return 1/* TRUE */;\n");
|
||
}
|
||
fprintf (output_file, " return 0/* FALSE */;\n}\n\n");
|
||
}
|
||
|
||
/* The function outputs PHR interface function `state_dead_lock_p'. */
|
||
static void
|
||
output_dead_lock_func ()
|
||
{
|
||
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, "{\n return %s (%s);\n}\n\n",
|
||
INTERNAL_DEAD_LOCK_FUNC_NAME, STATE_NAME);
|
||
}
|
||
|
||
/* Output function `internal_reset'. */
|
||
static void
|
||
output_internal_reset_func ()
|
||
{
|
||
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, "{\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 ()
|
||
{
|
||
fprintf (output_file, "int\n%s ()\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 ()
|
||
{
|
||
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, "{\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 ()
|
||
{
|
||
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",
|
||
CHIP_NAME, CHIP_NAME, INTERNAL_INSN_CODE_NAME,
|
||
INTERNAL_INSN2_CODE_NAME);
|
||
output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
|
||
INTERNAL_INSN_CODE_NAME, 0);
|
||
output_internal_insn_code_evaluation (INSN2_PARAMETER_NAME,
|
||
INTERNAL_INSN2_CODE_NAME, 0);
|
||
fprintf (output_file, " memcpy (&%s, %s, sizeof (%s));\n",
|
||
CHIP_NAME, STATE_NAME, CHIP_NAME);
|
||
fprintf (output_file, " %s (&%s);\n", INTERNAL_RESET_FUNC_NAME, CHIP_NAME);
|
||
fprintf (output_file, " if (%s (%s, &%s) > 0)\n abort ();\n",
|
||
INTERNAL_TRANSITION_FUNC_NAME, INTERNAL_INSN_CODE_NAME, CHIP_NAME);
|
||
fprintf (output_file, " return %s (%s, &%s);\n",
|
||
INTERNAL_MIN_ISSUE_DELAY_FUNC_NAME, INTERNAL_INSN2_CODE_NAME,
|
||
CHIP_NAME);
|
||
fprintf (output_file, "}\n\n");
|
||
}
|
||
|
||
/* Output function `internal_insn_latency'. */
|
||
static void
|
||
output_internal_insn_latency_func ()
|
||
{
|
||
decl_t decl;
|
||
struct bypass_decl *bypass;
|
||
int i;
|
||
|
||
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)",
|
||
INTERNAL_INSN_LATENCY_FUNC_NAME, INTERNAL_INSN_CODE_NAME,
|
||
INTERNAL_INSN2_CODE_NAME, INSN_PARAMETER_NAME,
|
||
INSN2_PARAMETER_NAME);
|
||
fprintf (output_file, "\n\tint %s;\n\tint %s;\n",
|
||
INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME);
|
||
fprintf (output_file,
|
||
"\trtx %s ATTRIBUTE_UNUSED;\n\trtx %s ATTRIBUTE_UNUSED;\n",
|
||
INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
|
||
fprintf (output_file, "{\n switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME);
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
{
|
||
fprintf (output_file, " case %d:\n",
|
||
DECL_INSN_RESERV (decl)->insn_num);
|
||
if (DECL_INSN_RESERV (decl)->bypass_list == NULL)
|
||
fprintf (output_file, " return (%s != %s ? %d : 0);\n",
|
||
INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
|
||
DECL_INSN_RESERV (decl)->default_latency);
|
||
else
|
||
{
|
||
fprintf (output_file, " switch (%s)\n {\n",
|
||
INTERNAL_INSN2_CODE_NAME);
|
||
for (bypass = DECL_INSN_RESERV (decl)->bypass_list;
|
||
bypass != NULL;
|
||
bypass = bypass->next)
|
||
{
|
||
fprintf (output_file, " case %d:\n",
|
||
bypass->in_insn_reserv->insn_num);
|
||
if (bypass->bypass_guard_name == NULL)
|
||
fprintf (output_file, " return %d;\n",
|
||
bypass->latency);
|
||
else
|
||
fprintf (output_file,
|
||
" return (%s (%s, %s) ? %d : %d);\n",
|
||
bypass->bypass_guard_name, INSN_PARAMETER_NAME,
|
||
INSN2_PARAMETER_NAME, bypass->latency,
|
||
DECL_INSN_RESERV (decl)->default_latency);
|
||
}
|
||
fprintf (output_file, " default:\n");
|
||
fprintf (output_file,
|
||
" return (%s != %s ? %d : 0);\n }\n",
|
||
INTERNAL_INSN2_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME,
|
||
DECL_INSN_RESERV (decl)->default_latency);
|
||
|
||
}
|
||
}
|
||
}
|
||
fprintf (output_file, " default:\n return 0;\n }\n}\n\n");
|
||
}
|
||
|
||
/* The function outputs PHR interface function `insn_latency'. */
|
||
static void
|
||
output_insn_latency_func ()
|
||
{
|
||
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, "{\n int %s, %s;\n",
|
||
INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME);
|
||
output_internal_insn_code_evaluation (INSN_PARAMETER_NAME,
|
||
INTERNAL_INSN_CODE_NAME, 0);
|
||
output_internal_insn_code_evaluation (INSN2_PARAMETER_NAME,
|
||
INTERNAL_INSN2_CODE_NAME, 0);
|
||
fprintf (output_file, " return %s (%s, %s, %s, %s);\n}\n\n",
|
||
INTERNAL_INSN_LATENCY_FUNC_NAME,
|
||
INTERNAL_INSN_CODE_NAME, INTERNAL_INSN2_CODE_NAME,
|
||
INSN_PARAMETER_NAME, INSN2_PARAMETER_NAME);
|
||
}
|
||
|
||
/* The function outputs PHR interface function `print_reservation'. */
|
||
static void
|
||
output_print_reservation_func ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
fprintf (output_file, "void\n%s (%s, %s)\n\tFILE *%s;\n\trtx %s;\n",
|
||
PRINT_RESERVATION_FUNC_NAME, FILE_PARAMETER_NAME,
|
||
INSN_PARAMETER_NAME, FILE_PARAMETER_NAME,
|
||
INSN_PARAMETER_NAME);
|
||
fprintf (output_file, "{\n int %s;\n", INTERNAL_INSN_CODE_NAME);
|
||
fprintf (output_file, "\n if (%s != 0)\n {\n", INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " %s = %s (%s);\n",
|
||
INTERNAL_INSN_CODE_NAME, DFA_INSN_CODE_FUNC_NAME,
|
||
INSN_PARAMETER_NAME);
|
||
fprintf (output_file, " if (%s > %s)\n",
|
||
INTERNAL_INSN_CODE_NAME, ADVANCE_CYCLE_VALUE_NAME);
|
||
fprintf (output_file, " {\n fprintf (%s, \"%s\");\n",
|
||
FILE_PARAMETER_NAME, NOTHING_NAME);
|
||
fprintf (output_file, " return;\n }\n");
|
||
fprintf (output_file, " }\n else\n");
|
||
fprintf (output_file,
|
||
" {\n fprintf (%s, \"%s\");\n return;\n }\n",
|
||
FILE_PARAMETER_NAME, NOTHING_NAME);
|
||
fprintf (output_file, " switch (%s)\n {\n", INTERNAL_INSN_CODE_NAME);
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
fprintf (output_file,
|
||
" case %d:\n", DECL_INSN_RESERV (decl)->insn_num);
|
||
fprintf (output_file,
|
||
" fprintf (%s, \"%s\");\n break;\n",
|
||
FILE_PARAMETER_NAME,
|
||
regexp_representation (DECL_INSN_RESERV (decl)->regexp));
|
||
finish_regexp_representation ();
|
||
}
|
||
}
|
||
fprintf (output_file, " default:\n fprintf (%s, \"%s\");\n }\n",
|
||
FILE_PARAMETER_NAME, NOTHING_NAME);
|
||
fprintf (output_file, "}\n\n");
|
||
}
|
||
|
||
/* The following function is used to sort unit declaration by their
|
||
names. */
|
||
static int
|
||
units_cmp (unit1, unit2)
|
||
const void *unit1, *unit2;
|
||
{
|
||
const unit_decl_t u1 = *(unit_decl_t *) unit1;
|
||
const unit_decl_t u2 = *(unit_decl_t *) unit2;
|
||
|
||
return strcmp (u1->name, u2->name);
|
||
}
|
||
|
||
/* The following macro value is name of struct containing unit name
|
||
and unit code. */
|
||
#define NAME_CODE_STRUCT_NAME "name_code"
|
||
|
||
/* The following macro value is name of table of struct name_code. */
|
||
#define NAME_CODE_TABLE_NAME "name_code_table"
|
||
|
||
/* The following macro values are member names for struct name_code. */
|
||
#define NAME_MEMBER_NAME "name"
|
||
#define CODE_MEMBER_NAME "code"
|
||
|
||
/* The following macro values are local variable names for function
|
||
`get_cpu_unit_code'. */
|
||
#define CMP_VARIABLE_NAME "cmp"
|
||
#define LOW_VARIABLE_NAME "l"
|
||
#define MIDDLE_VARIABLE_NAME "m"
|
||
#define HIGH_VARIABLE_NAME "h"
|
||
|
||
/* The following function outputs function to obtain internal cpu unit
|
||
code by the cpu unit name. */
|
||
static void
|
||
output_get_cpu_unit_code_func ()
|
||
{
|
||
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, "{\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);
|
||
memcpy (units, units_array, sizeof (unit_decl_t) * description->units_num);
|
||
qsort (units, description->units_num, sizeof (unit_decl_t), units_cmp);
|
||
for (i = 0; i < description->units_num; i++)
|
||
if (units [i]->query_p)
|
||
fprintf (output_file, " {\"%s\", %d},\n",
|
||
units[i]->name, units[i]->query_num);
|
||
fprintf (output_file, " };\n\n");
|
||
fprintf (output_file, " /* The following is binary search: */\n");
|
||
fprintf (output_file, " %s = 0;\n", LOW_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = sizeof (%s) / sizeof (struct %s) - 1;\n",
|
||
HIGH_VARIABLE_NAME, NAME_CODE_TABLE_NAME, NAME_CODE_STRUCT_NAME);
|
||
fprintf (output_file, " while (%s <= %s)\n {\n",
|
||
LOW_VARIABLE_NAME, HIGH_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = (%s + %s) / 2;\n",
|
||
MIDDLE_VARIABLE_NAME, LOW_VARIABLE_NAME, HIGH_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = strcmp (%s, %s [%s].%s);\n",
|
||
CMP_VARIABLE_NAME, CPU_UNIT_NAME_PARAMETER_NAME,
|
||
NAME_CODE_TABLE_NAME, MIDDLE_VARIABLE_NAME, NAME_MEMBER_NAME);
|
||
fprintf (output_file, " if (%s < 0)\n", CMP_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = %s - 1;\n",
|
||
HIGH_VARIABLE_NAME, MIDDLE_VARIABLE_NAME);
|
||
fprintf (output_file, " else if (%s > 0)\n", CMP_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = %s + 1;\n",
|
||
LOW_VARIABLE_NAME, MIDDLE_VARIABLE_NAME);
|
||
fprintf (output_file, " else\n");
|
||
fprintf (output_file, " return %s [%s].%s;\n }\n",
|
||
NAME_CODE_TABLE_NAME, MIDDLE_VARIABLE_NAME, CODE_MEMBER_NAME);
|
||
fprintf (output_file, " return -1;\n}\n\n");
|
||
free (units);
|
||
}
|
||
|
||
/* The following function outputs function to check reservation of cpu
|
||
unit (its internal code will be passed as the function argument) in
|
||
given cpu state. */
|
||
static void
|
||
output_cpu_unit_reservation_p ()
|
||
{
|
||
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,
|
||
CPU_CODE_PARAMETER_NAME);
|
||
fprintf (output_file, "{\n if (%s < 0 || %s >= %d)\n abort ();\n",
|
||
CPU_CODE_PARAMETER_NAME, CPU_CODE_PARAMETER_NAME,
|
||
description->query_units_num);
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
fprintf (output_file, " if ((");
|
||
output_reserved_units_table_name (output_file, automaton);
|
||
fprintf (output_file, " [((struct %s *) %s)->", CHIP_NAME, STATE_NAME);
|
||
output_chip_member_name (output_file, automaton);
|
||
fprintf (output_file, " * %d + %s / 8] >> (%s %% 8)) & 1)\n",
|
||
(description->query_units_num + 7) / 8,
|
||
CPU_CODE_PARAMETER_NAME, CPU_CODE_PARAMETER_NAME);
|
||
fprintf (output_file, " return 1;\n");
|
||
}
|
||
fprintf (output_file, " return 0;\n}\n\n");
|
||
}
|
||
|
||
/* The function outputs PHR interface function `dfa_start'. */
|
||
static void
|
||
output_dfa_start_func ()
|
||
{
|
||
fprintf (output_file,
|
||
"void\n%s ()\n{\n int %s;\n\n %s = get_max_uid ();\n",
|
||
DFA_START_FUNC_NAME, I_VARIABLE_NAME,
|
||
DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
|
||
fprintf (output_file, " %s = (int *) xmalloc (%s * sizeof (int));\n",
|
||
DFA_INSN_CODES_VARIABLE_NAME, DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
|
||
fprintf (output_file,
|
||
" for (%s = 0; %s < %s; %s++)\n %s [%s] = -1;\n}\n\n",
|
||
I_VARIABLE_NAME, I_VARIABLE_NAME,
|
||
DFA_INSN_CODES_LENGTH_VARIABLE_NAME, I_VARIABLE_NAME,
|
||
DFA_INSN_CODES_VARIABLE_NAME, I_VARIABLE_NAME);
|
||
}
|
||
|
||
/* The function outputs PHR interface function `dfa_finish'. */
|
||
static void
|
||
output_dfa_finish_func ()
|
||
{
|
||
fprintf (output_file, "void\n%s ()\n{\n free (%s);\n}\n\n",
|
||
DFA_FINISH_FUNC_NAME, DFA_INSN_CODES_VARIABLE_NAME);
|
||
}
|
||
|
||
|
||
|
||
/* The page contains code for output description file (readable
|
||
representation of original description and generated DFA(s). */
|
||
|
||
/* The function outputs string representation of IR reservation. */
|
||
static void
|
||
output_regexp (regexp)
|
||
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;
|
||
{
|
||
unit_set_el_t el;
|
||
|
||
for (el = list; el != NULL; el = el->next_unit_set_el)
|
||
{
|
||
if (el != list)
|
||
fprintf (output_description_file, ",");
|
||
fprintf (output_description_file, "%s", el->unit_decl->name);
|
||
}
|
||
}
|
||
|
||
/* The function outputs string representation of IR define_reservation
|
||
and define_insn_reservation. */
|
||
static void
|
||
output_description ()
|
||
{
|
||
decl_t decl;
|
||
int i;
|
||
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit)
|
||
{
|
||
if (DECL_UNIT (decl)->excl_list != NULL)
|
||
{
|
||
fprintf (output_description_file, "unit %s exlusion_set: ",
|
||
DECL_UNIT (decl)->name);
|
||
output_unit_set_el_list (DECL_UNIT (decl)->excl_list);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
if (DECL_UNIT (decl)->presence_list != NULL)
|
||
{
|
||
fprintf (output_description_file, "unit %s presence_set: ",
|
||
DECL_UNIT (decl)->name);
|
||
output_unit_set_el_list (DECL_UNIT (decl)->presence_list);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
if (DECL_UNIT (decl)->absence_list != NULL)
|
||
{
|
||
fprintf (output_description_file, "unit %s absence_set: ",
|
||
DECL_UNIT (decl)->name);
|
||
output_unit_set_el_list (DECL_UNIT (decl)->absence_list);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
}
|
||
}
|
||
fprintf (output_description_file, "\n");
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_reserv)
|
||
{
|
||
fprintf (output_description_file, "reservation ");
|
||
fprintf (output_description_file, DECL_RESERV (decl)->name);
|
||
fprintf (output_description_file, ": ");
|
||
output_regexp (DECL_RESERV (decl)->regexp);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
else if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
fprintf (output_description_file, "insn reservation %s ",
|
||
DECL_INSN_RESERV (decl)->name);
|
||
print_rtl (output_description_file,
|
||
DECL_INSN_RESERV (decl)->condexp);
|
||
fprintf (output_description_file, ": ");
|
||
output_regexp (DECL_INSN_RESERV (decl)->regexp);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
else if (decl->mode == dm_bypass)
|
||
fprintf (output_description_file, "bypass %d %s %s\n",
|
||
DECL_BYPASS (decl)->latency,
|
||
DECL_BYPASS (decl)->out_insn_name,
|
||
DECL_BYPASS (decl)->in_insn_name);
|
||
}
|
||
fprintf (output_description_file, "\n\f\n");
|
||
}
|
||
|
||
/* The function outputs name of AUTOMATON. */
|
||
static void
|
||
output_automaton_name (f, automaton)
|
||
FILE *f;
|
||
automaton_t automaton;
|
||
{
|
||
if (automaton->corresponding_automaton_decl == NULL)
|
||
fprintf (f, "#%d", automaton->automaton_order_num);
|
||
else
|
||
fprintf (f, "`%s'", automaton->corresponding_automaton_decl->name);
|
||
}
|
||
|
||
/* Maximal length of line for pretty printing into description
|
||
file. */
|
||
#define MAX_LINE_LENGTH 70
|
||
|
||
/* The function outputs units name belonging to AUTOMATON. */
|
||
static void
|
||
output_automaton_units (automaton)
|
||
automaton_t automaton;
|
||
{
|
||
decl_t decl;
|
||
char *name;
|
||
int curr_line_length;
|
||
int there_is_an_automaton_unit;
|
||
int i;
|
||
|
||
fprintf (output_description_file, "\n Coresponding units:\n");
|
||
fprintf (output_description_file, " ");
|
||
curr_line_length = 4;
|
||
there_is_an_automaton_unit = 0;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_unit
|
||
&& (DECL_UNIT (decl)->corresponding_automaton_num
|
||
== automaton->automaton_order_num))
|
||
{
|
||
there_is_an_automaton_unit = 1;
|
||
name = DECL_UNIT (decl)->name;
|
||
if (curr_line_length + strlen (name) + 1 > MAX_LINE_LENGTH )
|
||
{
|
||
curr_line_length = strlen (name) + 4;
|
||
fprintf (output_description_file, "\n ");
|
||
}
|
||
else
|
||
{
|
||
curr_line_length += strlen (name) + 1;
|
||
fprintf (output_description_file, " ");
|
||
}
|
||
fprintf (output_description_file, name);
|
||
}
|
||
}
|
||
if (!there_is_an_automaton_unit)
|
||
fprintf (output_description_file, "<None>");
|
||
fprintf (output_description_file, "\n\n");
|
||
}
|
||
|
||
/* The following variable is used for forming array of all possible cpu unit
|
||
reservations described by the current DFA state. */
|
||
static vla_ptr_t state_reservs;
|
||
|
||
/* The function forms `state_reservs' for STATE. */
|
||
static void
|
||
add_state_reservs (state)
|
||
state_t state;
|
||
{
|
||
alt_state_t curr_alt_state;
|
||
reserv_sets_t reservs;
|
||
|
||
if (state->component_states != NULL)
|
||
for (curr_alt_state = state->component_states;
|
||
curr_alt_state != NULL;
|
||
curr_alt_state = curr_alt_state->next_sorted_alt_state)
|
||
add_state_reservs (curr_alt_state->state);
|
||
else
|
||
{
|
||
reservs = state->reservs;
|
||
VLA_PTR_ADD (state_reservs, reservs);
|
||
}
|
||
}
|
||
|
||
/* The function outputs readable represenatation of all out arcs of
|
||
STATE. */
|
||
static void
|
||
output_state_arcs (state)
|
||
state_t state;
|
||
{
|
||
arc_t arc;
|
||
ainsn_t ainsn;
|
||
char *insn_name;
|
||
int curr_line_length;
|
||
|
||
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
|
||
{
|
||
ainsn = arc->insn;
|
||
if (!ainsn->first_insn_with_same_reservs)
|
||
abort ();
|
||
fprintf (output_description_file, " ");
|
||
curr_line_length = 7;
|
||
fprintf (output_description_file, "%2d: ", ainsn->insn_equiv_class_num);
|
||
do
|
||
{
|
||
insn_name = ainsn->insn_reserv_decl->name;
|
||
if (curr_line_length + strlen (insn_name) > MAX_LINE_LENGTH)
|
||
{
|
||
if (ainsn != arc->insn)
|
||
{
|
||
fprintf (output_description_file, ",\n ");
|
||
curr_line_length = strlen (insn_name) + 6;
|
||
}
|
||
else
|
||
curr_line_length += strlen (insn_name);
|
||
}
|
||
else
|
||
{
|
||
curr_line_length += strlen (insn_name);
|
||
if (ainsn != arc->insn)
|
||
{
|
||
curr_line_length += 2;
|
||
fprintf (output_description_file, ", ");
|
||
}
|
||
}
|
||
fprintf (output_description_file, insn_name);
|
||
ainsn = ainsn->next_same_reservs_insn;
|
||
}
|
||
while (ainsn != NULL);
|
||
fprintf (output_description_file, " %d (%d)\n",
|
||
arc->to_state->order_state_num, arc->state_alts);
|
||
}
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
|
||
/* The following function is used for sorting possible cpu unit
|
||
reservation of a DFA state. */
|
||
static int
|
||
state_reservs_cmp (reservs_ptr_1, reservs_ptr_2)
|
||
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 ()
|
||
{
|
||
reserv_sets_t *reservs_ptr;
|
||
reserv_sets_t *last_formed_reservs_ptr;
|
||
|
||
last_formed_reservs_ptr = NULL;
|
||
for (reservs_ptr = VLA_PTR_BEGIN (state_reservs);
|
||
reservs_ptr <= (reserv_sets_t *) VLA_PTR_LAST (state_reservs);
|
||
reservs_ptr++)
|
||
if (last_formed_reservs_ptr == NULL)
|
||
last_formed_reservs_ptr = reservs_ptr;
|
||
else if (reserv_sets_cmp (*last_formed_reservs_ptr, *reservs_ptr) != 0)
|
||
{
|
||
++last_formed_reservs_ptr;
|
||
*last_formed_reservs_ptr = *reservs_ptr;
|
||
}
|
||
VLA_PTR_SHORTEN (state_reservs, reservs_ptr - last_formed_reservs_ptr - 1);
|
||
}
|
||
|
||
/* The following function output readable representation of DFA(s)
|
||
state used for fast recognition of pipeline hazards. State is
|
||
described by possible (current and scehduled) cpu unit
|
||
reservations. */
|
||
static void
|
||
output_state (state)
|
||
state_t state;
|
||
{
|
||
reserv_sets_t *reservs_ptr;
|
||
|
||
VLA_PTR_CREATE (state_reservs, 150, "state reservations");
|
||
fprintf (output_description_file, " State #%d", state->order_state_num);
|
||
fprintf (output_description_file,
|
||
state->new_cycle_p ? " (new cycle)\n" : "\n");
|
||
add_state_reservs (state);
|
||
qsort (VLA_PTR_BEGIN (state_reservs), VLA_PTR_LENGTH (state_reservs),
|
||
sizeof (reserv_sets_t), state_reservs_cmp);
|
||
remove_state_duplicate_reservs ();
|
||
for (reservs_ptr = VLA_PTR_BEGIN (state_reservs);
|
||
reservs_ptr <= (reserv_sets_t *) VLA_PTR_LAST (state_reservs);
|
||
reservs_ptr++)
|
||
{
|
||
fprintf (output_description_file, " ");
|
||
output_reserv_sets (output_description_file, *reservs_ptr);
|
||
fprintf (output_description_file, "\n");
|
||
}
|
||
fprintf (output_description_file, "\n");
|
||
output_state_arcs (state);
|
||
VLA_PTR_DELETE (state_reservs);
|
||
}
|
||
|
||
/* The following function output readable representation of
|
||
DFAs used for fast recognition of pipeline hazards. */
|
||
static void
|
||
output_automaton_descriptions ()
|
||
{
|
||
automaton_t automaton;
|
||
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
fprintf (output_description_file, "\nAutomaton ");
|
||
output_automaton_name (output_description_file, automaton);
|
||
fprintf (output_description_file, "\n");
|
||
output_automaton_units (automaton);
|
||
pass_states (automaton, output_state);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* The page contains top level function for generation DFA(s) used for
|
||
PHR. */
|
||
|
||
/* The function outputs statistics about work of different phases of
|
||
DFA generator. */
|
||
static void
|
||
output_statistics (f)
|
||
FILE *f;
|
||
{
|
||
automaton_t automaton;
|
||
#ifndef NDEBUG
|
||
int transition_comb_vect_els = 0;
|
||
int transition_full_vect_els = 0;
|
||
int state_alts_comb_vect_els = 0;
|
||
int state_alts_full_vect_els = 0;
|
||
int min_issue_delay_vect_els = 0;
|
||
#endif
|
||
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
fprintf (f, "\nAutomaton ");
|
||
output_automaton_name (f, automaton);
|
||
fprintf (f, "\n %5d NDFA states, %5d NDFA arcs\n",
|
||
automaton->NDFA_states_num, automaton->NDFA_arcs_num);
|
||
fprintf (f, " %5d DFA states, %5d DFA arcs\n",
|
||
automaton->DFA_states_num, automaton->DFA_arcs_num);
|
||
if (!no_minimization_flag)
|
||
fprintf (f, " %5d minimal DFA states, %5d minimal DFA arcs\n",
|
||
automaton->minimal_DFA_states_num,
|
||
automaton->minimal_DFA_arcs_num);
|
||
fprintf (f, " %5d all insns %5d insn equivalence classes\n",
|
||
description->insns_num, automaton->insn_equiv_classes_num);
|
||
#ifndef NDEBUG
|
||
fprintf
|
||
(f, "%5ld transition comb vector els, %5ld trans table els: %s\n",
|
||
(long) VLA_HWINT_LENGTH (automaton->trans_table->comb_vect),
|
||
(long) VLA_HWINT_LENGTH (automaton->trans_table->full_vect),
|
||
(comb_vect_p (automaton->trans_table)
|
||
? "use comb vect" : "use simple vect"));
|
||
fprintf
|
||
(f, "%5ld state alts comb vector els, %5ld state alts table els: %s\n",
|
||
(long) VLA_HWINT_LENGTH (automaton->state_alts_table->comb_vect),
|
||
(long) VLA_HWINT_LENGTH (automaton->state_alts_table->full_vect),
|
||
(comb_vect_p (automaton->state_alts_table)
|
||
? "use comb vect" : "use simple vect"));
|
||
fprintf
|
||
(f, "%5ld min delay table els, compression factor %d\n",
|
||
(long) automaton->DFA_states_num * automaton->insn_equiv_classes_num,
|
||
automaton->min_issue_delay_table_compression_factor);
|
||
transition_comb_vect_els
|
||
+= VLA_HWINT_LENGTH (automaton->trans_table->comb_vect);
|
||
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);
|
||
state_alts_full_vect_els
|
||
+= VLA_HWINT_LENGTH (automaton->state_alts_table->full_vect);
|
||
min_issue_delay_vect_els
|
||
+= automaton->DFA_states_num * automaton->insn_equiv_classes_num;
|
||
#endif
|
||
}
|
||
#ifndef NDEBUG
|
||
fprintf (f, "\n%5d all allocated states, %5d all allocated arcs\n",
|
||
allocated_states_num, allocated_arcs_num);
|
||
fprintf (f, "%5d all allocated alternative states\n",
|
||
allocated_alt_states_num);
|
||
fprintf (f, "%5d all transition comb vector els, %5d all trans table els\n",
|
||
transition_comb_vect_els, transition_full_vect_els);
|
||
fprintf
|
||
(f, "%5d all state alts comb vector els, %5d all state alts table els\n",
|
||
state_alts_comb_vect_els, state_alts_full_vect_els);
|
||
fprintf (f, "%5d all min delay table els\n", min_issue_delay_vect_els);
|
||
fprintf (f, "%5d locked states num\n", locked_states_num);
|
||
#endif
|
||
}
|
||
|
||
/* The function output times of work of different phases of DFA
|
||
generator. */
|
||
static void
|
||
output_time_statistics (f)
|
||
FILE *f;
|
||
{
|
||
fprintf (f, "\n transformation: ");
|
||
print_active_time (f, transform_time);
|
||
fprintf (f, (!ndfa_flag ? ", building DFA: " : ", building NDFA: "));
|
||
print_active_time (f, NDFA_time);
|
||
if (ndfa_flag)
|
||
{
|
||
fprintf (f, ", NDFA -> DFA: ");
|
||
print_active_time (f, NDFA_to_DFA_time);
|
||
}
|
||
fprintf (f, "\n DFA minimization: ");
|
||
print_active_time (f, minimize_time);
|
||
fprintf (f, ", making insn equivalence: ");
|
||
print_active_time (f, equiv_time);
|
||
fprintf (f, "\n all automaton generation: ");
|
||
print_active_time (f, automaton_generation_time);
|
||
fprintf (f, ", output: ");
|
||
print_active_time (f, output_time);
|
||
fprintf (f, "\n");
|
||
}
|
||
|
||
/* The function generates DFA (deterministic finate state automaton)
|
||
for fast recognition of pipeline hazards. No errors during
|
||
checking must be fixed before this function call. */
|
||
static void
|
||
generate ()
|
||
{
|
||
automata_num = split_argument;
|
||
if (description->units_num < automata_num)
|
||
automata_num = description->units_num;
|
||
initiate_states ();
|
||
initiate_arcs ();
|
||
initiate_automata_lists ();
|
||
initiate_pass_states ();
|
||
initiate_excl_sets ();
|
||
initiate_presence_absence_sets ();
|
||
automaton_generation_time = create_ticker ();
|
||
create_automata ();
|
||
ticker_off (&automaton_generation_time);
|
||
}
|
||
|
||
|
||
|
||
/* The following function creates insn attribute whose values are
|
||
number alternatives in insn reservations. */
|
||
static void
|
||
make_insn_alts_attr ()
|
||
{
|
||
int i, insn_num;
|
||
decl_t decl;
|
||
rtx condexp;
|
||
|
||
condexp = rtx_alloc (COND);
|
||
XVEC (condexp, 0) = rtvec_alloc ((description->insns_num - 1) * 2);
|
||
XEXP (condexp, 1) = make_numeric_value (0);
|
||
for (i = insn_num = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
XVECEXP (condexp, 0, 2 * insn_num)
|
||
= DECL_INSN_RESERV (decl)->condexp;
|
||
XVECEXP (condexp, 0, 2 * insn_num + 1)
|
||
= make_numeric_value
|
||
(DECL_INSN_RESERV (decl)->transformed_regexp->mode != rm_oneof
|
||
? 1 : REGEXP_ONEOF (DECL_INSN_RESERV (decl)
|
||
->transformed_regexp)->regexps_num);
|
||
insn_num++;
|
||
}
|
||
}
|
||
if (description->insns_num != insn_num + 1)
|
||
abort ();
|
||
make_internal_attr (attr_printf (sizeof ("*")
|
||
+ strlen (INSN_ALTS_FUNC_NAME) + 1,
|
||
"*%s", INSN_ALTS_FUNC_NAME),
|
||
condexp, 0);
|
||
}
|
||
|
||
|
||
|
||
/* The following function creates attribute which is order number of
|
||
insn in pipeline hazard description translator. */
|
||
static void
|
||
make_internal_dfa_insn_code_attr ()
|
||
{
|
||
int i, insn_num;
|
||
decl_t decl;
|
||
rtx condexp;
|
||
|
||
condexp = rtx_alloc (COND);
|
||
XVEC (condexp, 0) = rtvec_alloc ((description->insns_num - 1) * 2);
|
||
XEXP (condexp, 1)
|
||
= make_numeric_value (DECL_INSN_RESERV (advance_cycle_insn_decl)
|
||
->insn_num + 1);
|
||
for (i = insn_num = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
XVECEXP (condexp, 0, 2 * insn_num)
|
||
= DECL_INSN_RESERV (decl)->condexp;
|
||
XVECEXP (condexp, 0, 2 * insn_num + 1)
|
||
= make_numeric_value (DECL_INSN_RESERV (decl)->insn_num);
|
||
insn_num++;
|
||
}
|
||
}
|
||
if (description->insns_num != insn_num + 1)
|
||
abort ();
|
||
make_internal_attr
|
||
(attr_printf (sizeof ("*")
|
||
+ strlen (INTERNAL_DFA_INSN_CODE_FUNC_NAME) + 1,
|
||
"*%s", INTERNAL_DFA_INSN_CODE_FUNC_NAME),
|
||
condexp, 0);
|
||
}
|
||
|
||
|
||
|
||
/* The following function creates attribute which order number of insn
|
||
in pipeline hazard description translator. */
|
||
static void
|
||
make_default_insn_latency_attr ()
|
||
{
|
||
int i, insn_num;
|
||
decl_t decl;
|
||
rtx condexp;
|
||
|
||
condexp = rtx_alloc (COND);
|
||
XVEC (condexp, 0) = rtvec_alloc ((description->insns_num - 1) * 2);
|
||
XEXP (condexp, 1) = make_numeric_value (0);
|
||
for (i = insn_num = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv && decl != advance_cycle_insn_decl)
|
||
{
|
||
XVECEXP (condexp, 0, 2 * insn_num)
|
||
= DECL_INSN_RESERV (decl)->condexp;
|
||
XVECEXP (condexp, 0, 2 * insn_num + 1)
|
||
= make_numeric_value (DECL_INSN_RESERV (decl)->default_latency);
|
||
insn_num++;
|
||
}
|
||
}
|
||
if (description->insns_num != insn_num + 1)
|
||
abort ();
|
||
make_internal_attr (attr_printf (sizeof ("*")
|
||
+ strlen (INSN_DEFAULT_LATENCY_FUNC_NAME)
|
||
+ 1, "*%s", INSN_DEFAULT_LATENCY_FUNC_NAME),
|
||
condexp, 0);
|
||
}
|
||
|
||
|
||
|
||
/* The following function creates attribute which returns 1 if given
|
||
output insn has bypassing and 0 otherwise. */
|
||
static void
|
||
make_bypass_attr ()
|
||
{
|
||
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];
|
||
if (decl->mode == dm_insn_reserv
|
||
&& DECL_INSN_RESERV (decl)->condexp != NULL
|
||
&& DECL_INSN_RESERV (decl)->bypass_list != NULL)
|
||
bypass_insns_num++;
|
||
}
|
||
if (bypass_insns_num == 0)
|
||
result_rtx = make_numeric_value (0);
|
||
else
|
||
{
|
||
result_rtx = rtx_alloc (COND);
|
||
XVEC (result_rtx, 0) = rtvec_alloc (bypass_insns_num * 2);
|
||
XEXP (result_rtx, 1) = make_numeric_value (0);
|
||
|
||
for (i = bypass_insn = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv
|
||
&& DECL_INSN_RESERV (decl)->condexp != NULL
|
||
&& DECL_INSN_RESERV (decl)->bypass_list != NULL)
|
||
{
|
||
XVECEXP (result_rtx, 0, 2 * bypass_insn)
|
||
= DECL_INSN_RESERV (decl)->condexp;
|
||
XVECEXP (result_rtx, 0, 2 * bypass_insn + 1)
|
||
= make_numeric_value (1);
|
||
bypass_insn++;
|
||
}
|
||
}
|
||
}
|
||
make_internal_attr (attr_printf (sizeof ("*")
|
||
+ strlen (BYPASS_P_FUNC_NAME) + 1,
|
||
"*%s", BYPASS_P_FUNC_NAME),
|
||
result_rtx, 0);
|
||
}
|
||
|
||
|
||
|
||
/* This page mainly contains top level functions of pipeline hazards
|
||
description translator. */
|
||
|
||
/* The following macro value is suffix of name of description file of
|
||
pipeline hazards description translator. */
|
||
#define STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX ".dfa"
|
||
|
||
/* The function returns suffix of given file name. The returned
|
||
string can not be changed. */
|
||
static const char *
|
||
file_name_suffix (file_name)
|
||
const char *file_name;
|
||
{
|
||
const char *last_period;
|
||
|
||
for (last_period = NULL; *file_name != '\0'; file_name++)
|
||
if (*file_name == '.')
|
||
last_period = file_name;
|
||
return (last_period == NULL ? file_name : last_period);
|
||
}
|
||
|
||
/* The function returns base name of given file name, i.e. pointer to
|
||
first char after last `/' (or `\' for WIN32) in given file name,
|
||
given file name itself if the directory name is absent. The
|
||
returned string can not be changed. */
|
||
static const char *
|
||
base_file_name (file_name)
|
||
const char *file_name;
|
||
{
|
||
int directory_name_length;
|
||
|
||
directory_name_length = strlen (file_name);
|
||
#ifdef WIN32
|
||
while (directory_name_length >= 0 && file_name[directory_name_length] != '/'
|
||
&& file_name[directory_name_length] != '\\')
|
||
#else
|
||
while (directory_name_length >= 0 && file_name[directory_name_length] != '/')
|
||
#endif
|
||
directory_name_length--;
|
||
return file_name + directory_name_length + 1;
|
||
}
|
||
|
||
/* The following is top level function to initialize the work of
|
||
pipeline hazards description translator. */
|
||
void
|
||
initiate_automaton_gen (argc, argv)
|
||
int argc;
|
||
char **argv;
|
||
{
|
||
const char *base_name;
|
||
int i;
|
||
|
||
ndfa_flag = 0;
|
||
split_argument = 0; /* default value */
|
||
no_minimization_flag = 0;
|
||
time_flag = 0;
|
||
v_flag = 0;
|
||
w_flag = 0;
|
||
for (i = 2; i < argc; i++)
|
||
if (strcmp (argv [i], NO_MINIMIZATION_OPTION) == 0)
|
||
no_minimization_flag = 1;
|
||
else if (strcmp (argv [i], TIME_OPTION) == 0)
|
||
time_flag = 1;
|
||
else if (strcmp (argv [i], V_OPTION) == 0)
|
||
v_flag = 1;
|
||
else if (strcmp (argv [i], W_OPTION) == 0)
|
||
w_flag = 1;
|
||
else if (strcmp (argv [i], NDFA_OPTION) == 0)
|
||
ndfa_flag = 1;
|
||
else if (strcmp (argv [i], "-split") == 0)
|
||
{
|
||
if (i + 1 >= argc)
|
||
fatal ("-split has no argument.");
|
||
fatal ("option `-split' has not been implemented yet\n");
|
||
/* split_argument = atoi (argument_vect [i + 1]); */
|
||
}
|
||
VLA_PTR_CREATE (decls, 150, "decls");
|
||
/* Initialize IR storage. */
|
||
obstack_init (&irp);
|
||
initiate_automaton_decl_table ();
|
||
initiate_insn_decl_table ();
|
||
initiate_decl_table ();
|
||
output_file = stdout;
|
||
output_description_file = NULL;
|
||
base_name = base_file_name (argv[1]);
|
||
obstack_grow (&irp, base_name,
|
||
strlen (base_name) - strlen (file_name_suffix (base_name)));
|
||
obstack_grow (&irp, STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX,
|
||
strlen (STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX) + 1);
|
||
obstack_1grow (&irp, '\0');
|
||
output_description_file_name = obstack_base (&irp);
|
||
obstack_finish (&irp);
|
||
}
|
||
|
||
/* The following function checks existence at least one arc marked by
|
||
each insn. */
|
||
static void
|
||
check_automata_insn_issues ()
|
||
{
|
||
automaton_t automaton;
|
||
ainsn_t ainsn, reserv_ainsn;
|
||
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
for (ainsn = automaton->ainsn_list;
|
||
ainsn != NULL;
|
||
ainsn = ainsn->next_ainsn)
|
||
if (ainsn->first_insn_with_same_reservs && !ainsn->arc_exists_p)
|
||
{
|
||
for (reserv_ainsn = ainsn;
|
||
reserv_ainsn != NULL;
|
||
reserv_ainsn = reserv_ainsn->next_same_reservs_insn)
|
||
if (automaton->corresponding_automaton_decl != NULL)
|
||
{
|
||
if (!w_flag)
|
||
error ("Automaton `%s': Insn `%s' will never be issued",
|
||
automaton->corresponding_automaton_decl->name,
|
||
reserv_ainsn->insn_reserv_decl->name);
|
||
else
|
||
warning
|
||
("Automaton `%s': Insn `%s' will never be issued",
|
||
automaton->corresponding_automaton_decl->name,
|
||
reserv_ainsn->insn_reserv_decl->name);
|
||
}
|
||
else
|
||
{
|
||
if (!w_flag)
|
||
error ("Insn `%s' will never be issued",
|
||
reserv_ainsn->insn_reserv_decl->name);
|
||
else
|
||
warning ("Insn `%s' will never be issued",
|
||
reserv_ainsn->insn_reserv_decl->name);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* The following vla is used for storing pointers to all achieved
|
||
states. */
|
||
static vla_ptr_t automaton_states;
|
||
|
||
/* This function is called by function pass_states to add an achieved
|
||
STATE. */
|
||
static void
|
||
add_automaton_state (state)
|
||
state_t state;
|
||
{
|
||
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 ()
|
||
{
|
||
automaton_t automaton;
|
||
state_t *state_ptr;
|
||
decl_t decl;
|
||
ainsn_t ainsn;
|
||
arc_t arc;
|
||
int i;
|
||
|
||
VLA_PTR_CREATE (automaton_states, 1500,
|
||
"automaton states for forming important insn automata sets");
|
||
/* Mark important ainsns. */
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
{
|
||
VLA_PTR_NULLIFY (automaton_states);
|
||
pass_states (automaton, add_automaton_state);
|
||
for (state_ptr = VLA_PTR_BEGIN (automaton_states);
|
||
state_ptr <= (state_t *) VLA_PTR_LAST (automaton_states);
|
||
state_ptr++)
|
||
{
|
||
for (arc = first_out_arc (*state_ptr);
|
||
arc != NULL;
|
||
arc = next_out_arc (arc))
|
||
if (arc->to_state != *state_ptr)
|
||
{
|
||
if (!arc->insn->first_insn_with_same_reservs)
|
||
abort ();
|
||
for (ainsn = arc->insn;
|
||
ainsn != NULL;
|
||
ainsn = ainsn->next_same_reservs_insn)
|
||
ainsn->important_p = TRUE;
|
||
}
|
||
}
|
||
}
|
||
VLA_PTR_DELETE (automaton_states);
|
||
/* Create automata sets for the insns. */
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
decl = description->decls [i];
|
||
if (decl->mode == dm_insn_reserv)
|
||
{
|
||
automata_list_start ();
|
||
for (automaton = description->first_automaton;
|
||
automaton != NULL;
|
||
automaton = automaton->next_automaton)
|
||
for (ainsn = automaton->ainsn_list;
|
||
ainsn != NULL;
|
||
ainsn = ainsn->next_ainsn)
|
||
if (ainsn->important_p
|
||
&& ainsn->insn_reserv_decl == DECL_INSN_RESERV (decl))
|
||
{
|
||
automata_list_add (automaton);
|
||
break;
|
||
}
|
||
DECL_INSN_RESERV (decl)->important_automata_list
|
||
= automata_list_finish ();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* The following is top level function to generate automat(a,on) for
|
||
fast recognition of pipeline hazards. */
|
||
void
|
||
expand_automata ()
|
||
{
|
||
int i;
|
||
|
||
description = create_node (sizeof (struct description)
|
||
/* One entry for cycle advancing insn. */
|
||
+ sizeof (decl_t) * VLA_PTR_LENGTH (decls));
|
||
description->decls_num = VLA_PTR_LENGTH (decls);
|
||
description->query_units_num = 0;
|
||
for (i = 0; i < description->decls_num; i++)
|
||
{
|
||
description->decls [i] = VLA_PTR (decls, i);
|
||
if (description->decls [i]->mode == dm_unit
|
||
&& DECL_UNIT (description->decls [i])->query_p)
|
||
DECL_UNIT (description->decls [i])->query_num
|
||
= description->query_units_num++;
|
||
}
|
||
all_time = create_ticker ();
|
||
check_time = create_ticker ();
|
||
fprintf (stderr, "Check description...");
|
||
fflush (stderr);
|
||
check_all_description ();
|
||
fprintf (stderr, "done\n");
|
||
ticker_off (&check_time);
|
||
generation_time = create_ticker ();
|
||
if (!have_error)
|
||
{
|
||
transform_insn_regexps ();
|
||
check_unit_distributions_to_automata ();
|
||
}
|
||
if (!have_error)
|
||
{
|
||
generate ();
|
||
check_automata_insn_issues ();
|
||
}
|
||
if (!have_error)
|
||
{
|
||
form_important_insn_automata_lists ();
|
||
fprintf (stderr, "Generation of attributes...");
|
||
fflush (stderr);
|
||
make_internal_dfa_insn_code_attr ();
|
||
make_insn_alts_attr ();
|
||
make_default_insn_latency_attr ();
|
||
make_bypass_attr ();
|
||
fprintf (stderr, "done\n");
|
||
}
|
||
ticker_off (&generation_time);
|
||
ticker_off (&all_time);
|
||
fprintf (stderr, "All other genattrtab stuff...");
|
||
fflush (stderr);
|
||
}
|
||
|
||
/* The following is top level function to output PHR and to finish
|
||
work with pipeline description translator. */
|
||
void
|
||
write_automata ()
|
||
{
|
||
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);
|
||
output_dfa_max_issue_rate ();
|
||
output_tables ();
|
||
fprintf (stderr, "done\n");
|
||
fprintf (stderr, "Output functions to work with automata...");
|
||
fflush (stderr);
|
||
output_chip_definitions ();
|
||
output_max_insn_queue_index_def ();
|
||
output_internal_min_issue_delay_func ();
|
||
output_internal_trans_func ();
|
||
/* Cache of insn dfa codes: */
|
||
fprintf (output_file, "\nstatic int *%s;\n", DFA_INSN_CODES_VARIABLE_NAME);
|
||
fprintf (output_file, "\nstatic int %s;\n\n",
|
||
DFA_INSN_CODES_LENGTH_VARIABLE_NAME);
|
||
output_dfa_insn_code_func ();
|
||
output_trans_func ();
|
||
fprintf (output_file, "\n#if %s\n\n", AUTOMATON_STATE_ALTS_MACRO_NAME);
|
||
output_internal_state_alts_func ();
|
||
output_state_alts_func ();
|
||
fprintf (output_file, "\n#endif /* #if %s */\n\n",
|
||
AUTOMATON_STATE_ALTS_MACRO_NAME);
|
||
output_min_issue_delay_func ();
|
||
output_internal_dead_lock_func ();
|
||
output_dead_lock_func ();
|
||
output_size_func ();
|
||
output_internal_reset_func ();
|
||
output_reset_func ();
|
||
output_min_insn_conflict_delay_func ();
|
||
output_internal_insn_latency_func ();
|
||
output_insn_latency_func ();
|
||
output_print_reservation_func ();
|
||
if (no_minimization_flag)
|
||
{
|
||
fprintf (output_file, "\n#if %s\n\n", CPU_UNITS_QUERY_MACRO_NAME);
|
||
output_get_cpu_unit_code_func ();
|
||
output_cpu_unit_reservation_p ();
|
||
fprintf (output_file, "\n#endif /* #if %s */\n\n",
|
||
CPU_UNITS_QUERY_MACRO_NAME);
|
||
}
|
||
output_dfa_start_func ();
|
||
output_dfa_finish_func ();
|
||
fprintf (stderr, "done\n");
|
||
if (v_flag)
|
||
{
|
||
output_description_file = fopen (output_description_file_name, "w");
|
||
if (output_description_file == NULL)
|
||
{
|
||
perror (output_description_file_name);
|
||
exit (FATAL_EXIT_CODE);
|
||
}
|
||
fprintf (stderr, "Output automata description...");
|
||
fflush (stderr);
|
||
output_description ();
|
||
output_automaton_descriptions ();
|
||
fprintf (stderr, "done\n");
|
||
output_statistics (output_description_file);
|
||
}
|
||
output_statistics (stderr);
|
||
ticker_off (&output_time);
|
||
output_time_statistics (stderr);
|
||
finish_states ();
|
||
finish_arcs ();
|
||
finish_automata_lists ();
|
||
if (time_flag)
|
||
{
|
||
fprintf (stderr, "Summary:\n");
|
||
fprintf (stderr, " check time ");
|
||
print_active_time (stderr, check_time);
|
||
fprintf (stderr, ", generation time ");
|
||
print_active_time (stderr, generation_time);
|
||
fprintf (stderr, ", all time ");
|
||
print_active_time (stderr, all_time);
|
||
fprintf (stderr, "\n");
|
||
}
|
||
/* Finish all work. */
|
||
if (output_description_file != NULL)
|
||
{
|
||
fflush (output_description_file);
|
||
if (ferror (stdout) != 0)
|
||
fatal ("Error in writing DFA description file %s",
|
||
output_description_file_name);
|
||
fclose (output_description_file);
|
||
}
|
||
finish_automaton_decl_table ();
|
||
finish_insn_decl_table ();
|
||
finish_decl_table ();
|
||
obstack_free (&irp, NULL);
|
||
if (have_error && output_description_file != NULL)
|
||
remove (output_description_file_name);
|
||
}
|