Skip to content

R
riscv-gcc-1
Commit 1fb49ce7 by Zack Weinberg Committed by Zack Weinberg
Options

r110125@banpei: zack | 2006-01-22 14:46:46 -0800 

 r110125@banpei:  zack | 2006-01-22 14:46:46 -0800
 	* genautomata.c:  Include vec.h, not varray.h.
 	Delete vla_ptr_t, all of the VLA_PTR_ macros, and all of the
 	VLA_HWINT_ macros.  Change vla_hwint_t to a typedef for
 	VEC(vect_el_t,heap) *.  Convert all uses of VLA_* macros to
 	VEC_* macros operating on appropriately typed vectors, or to
 	malloced arrays when the size is known in advance.  Const-ify
 	many char* variables and function arguments.  No functional changes.
 	* Makefile.in (build/varray.o): Delete rule.
 	(build/genattrtab): Depend on build/vec.o instead of build/varray.o.
 	(build/genautomata.o): Depend on vec.h instead of $(VARRAY_H).

From-SVN: r110121
parent 0458fe77
Showing with 561 additions and 668 deletions
gcc/ChangeLog
2006-01-22 Zack Weinberg <zackw@panix.com>
* genautomata.c: Include vec.h, not varray.h.
Delete vla_ptr_t, all of the VLA_PTR_ macros, and all of the
VLA_HWINT_ macros. Change vla_hwint_t to a typedef for
VEC(vect_el_t,heap) *. Convert all uses of VLA_* macros to
VEC_* macros operating on appropriately typed vectors, or to
malloced arrays when the size is known in advance. Const-ify
many char* variables and function arguments. No functional changes.
* Makefile.in (build/varray.o): Delete rule.
(build/genattrtab): Depend on build/vec.o instead of build/varray.o.
(build/genautomata.o): Depend on vec.h instead of $(VARRAY_H).
2006-01-22 Zack Weinberg <zackw@panix.com>
* gensupport.c: Define get_insn_name and record_insn_name here.
(read_md_rtx): Call record_insn_name as appropriate.
* genattr.c, genattrtab.c, gencodes.c, genconfig.c, genemit.c
......
gcc/Makefile.in
......@@ -2894,8 +2894,6 @@ build/read-rtl.o: read-rtl.c $(BCONFIG_H) $(SYSTEM_H) coretypes.h \
$(GTM_H) $(RTL_BASE_H) $(OBSTACK_H) $(HASHTAB_H) gensupport.h
build/rtl.o: rtl.c $(BCONFIG_H) coretypes.h $(GTM_H) $(SYSTEM_H) \
$(RTL_H) real.h $(GGC_H) errors.h
build/varray.o: varray.c $(BCONFIG_H) coretypes.h $(GTM_H) $(SYSTEM_H) \
$(VARRAY_H) $(RTL_BASE_H) $(GGC_H) $(TREE_H) bitmap.h errors.h
build/vec.o : vec.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) coretypes.h vec.h \
$(GGC_H) toplev.h
build/gencondmd.o : build/gencondmd.c $(CONFIG_H) $(SYSTEM_H) $(GTM_H) \
......@@ -2910,7 +2908,7 @@ build/genattrtab.o : genattrtab.c $(RTL_BASE_H) $(OBSTACK_H) \
$(BCONFIG_H) $(SYSTEM_H) coretypes.h $(GTM_H) errors.h $(GGC_H) \
gensupport.h genattrtab.h
build/genautomata.o : genautomata.c $(RTL_BASE_H) $(OBSTACK_H) \
$(BCONFIG_H) $(SYSTEM_H) coretypes.h $(GTM_H) errors.h $(VARRAY_H) \
$(BCONFIG_H) $(SYSTEM_H) coretypes.h $(GTM_H) errors.h vec.h \
genattrtab.h $(HASHTAB_H)
build/gencheck.o : gencheck.c gencheck.h tree.def $(BCONFIG_H) $(GTM_H) \
$(SYSTEM_H) coretypes.h $(lang_tree_files)
......@@ -2968,7 +2966,7 @@ $(genprogmd:%=build/gen%$(build_exeext)): $(BUILD_RTL) $(BUILD_ERRORS)
# These programs need files over and above what they get from the above list.
build/genextract$(build_exeext) : build/vec.o
build/genattrtab$(build_exeext) : build/genautomata.o build/varray.o
build/genattrtab$(build_exeext) : build/genautomata.o build/vec.o
build/genattrtab$(build_exeext) : BUILD_LIBS += -lm
# These programs are not linked with the MD reader.
......
gcc/genautomata.c
......@@ -113,6 +113,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#include <math.h>
#include "hashtab.h"
#include "varray.h"
#include "vec.h"
#ifndef CHAR_BIT
#define CHAR_BIT 8
......@@ -132,17 +133,6 @@ typedef unsigned HOST_WIDE_INT set_el_t;
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
{
......@@ -218,24 +208,24 @@ typedef struct state_ainsn_table *state_ainsn_table_t;
static void *create_node (size_t);
static void *copy_node (const void *, size_t);
static char *check_name (char *, pos_t);
static char *next_sep_el (char **, int, int);
static int n_sep_els (char *, int, int);
static char **get_str_vect (char *, int *, int, int);
static const char *check_name (const char *, pos_t);
static char *next_sep_el (const char **, int, int);
static int n_sep_els (const char *, int, int);
static char **get_str_vect (const char *, int *, int, int);
static void gen_presence_absence_set (rtx, int, int);
static regexp_t gen_regexp_el (char *);
static regexp_t gen_regexp_repeat (char *);
static regexp_t gen_regexp_allof (char *);
static regexp_t gen_regexp_oneof (char *);
static regexp_t gen_regexp_sequence (char *);
static regexp_t gen_regexp (char *);
static regexp_t gen_regexp_el (const char *);
static regexp_t gen_regexp_repeat (const char *);
static regexp_t gen_regexp_allof (const char *);
static regexp_t gen_regexp_oneof (const char *);
static regexp_t gen_regexp_sequence (const char *);
static regexp_t gen_regexp (const char *);
static unsigned string_hash (const char *);
static unsigned automaton_decl_hash (const void *);
static int automaton_decl_eq_p (const void *,
const void *);
static decl_t insert_automaton_decl (decl_t);
static decl_t find_automaton_decl (char *);
static decl_t find_automaton_decl (const char *);
static void initiate_automaton_decl_table (void);
static void finish_automaton_decl_table (void);
......@@ -243,7 +233,7 @@ static hashval_t insn_decl_hash (const void *);
static int insn_decl_eq_p (const void *,
const void *);
static decl_t insert_insn_decl (decl_t);
static decl_t find_insn_decl (char *);
static decl_t find_insn_decl (const char *);
static void initiate_insn_decl_table (void);
static void finish_insn_decl_table (void);
......@@ -251,7 +241,7 @@ static hashval_t decl_hash (const void *);
static int decl_eq_p (const void *,
const void *);
static decl_t insert_decl (decl_t);
static decl_t find_decl (char *);
static decl_t find_decl (const char *);
static void initiate_decl_table (void);
static void finish_decl_table (void);
......@@ -385,7 +375,6 @@ static void form_ainsn_with_same_reservs (automaton_t);
static reserv_sets_t form_reservs_matter (automaton_t);
static void make_automaton (automaton_t);
static void form_arcs_marked_by_insn (state_t);
static int create_composed_state (state_t, arc_t, vla_ptr_t *);
static void NDFA_to_DFA (automaton_t);
static void pass_state_graph (state_t, void (*) (state_t));
static void pass_states (automaton_t,
......@@ -394,15 +383,8 @@ static void initiate_pass_states (void);
static void add_achieved_state (state_t);
static int set_out_arc_insns_equiv_num (state_t, int);
static void clear_arc_insns_equiv_num (state_t);
static void copy_equiv_class (vla_ptr_t *to,
const vla_ptr_t *from);
static int first_cycle_unit_presence (state_t, int);
static int state_is_differed (state_t, state_t, int, int);
static state_t init_equiv_class (state_t *states, int);
static int partition_equiv_class (state_t *, int,
vla_ptr_t *, int *);
static void evaluate_equiv_classes (automaton_t, vla_ptr_t *);
static void merge_states (automaton_t, vla_ptr_t *);
static void set_new_cycle_flags (state_t);
static void minimize_DFA (automaton_t);
static void incr_states_and_arcs_nums (state_t);
......@@ -434,7 +416,6 @@ static void output_range_type (FILE *, long int, long int);
static int longest_path_length (state_t);
static void process_state_longest_path_length (state_t);
static void output_dfa_max_issue_rate (void);
static void output_vect (vect_el_t *, int);
static void output_chip_member_name (FILE *, automaton_t);
static void output_temp_chip_member_name (FILE *, automaton_t);
static void output_translate_vect_name (FILE *, automaton_t);
......@@ -455,15 +436,11 @@ static void output_translate_vect (automaton_t);
static int comb_vect_p (state_ainsn_table_t);
static state_ainsn_table_t create_state_ainsn_table (automaton_t);
static void output_state_ainsn_table
(state_ainsn_table_t, char *, void (*) (FILE *, automaton_t),
(state_ainsn_table_t, const char *, void (*) (FILE *, automaton_t),
void (*) (FILE *, automaton_t), void (*) (FILE *, automaton_t),
void (*) (FILE *, automaton_t));
static void add_vect (state_ainsn_table_t,
int, vect_el_t *, int);
static int out_state_arcs_num (state_t);
static int compare_transition_els_num (const void *, const void *);
static void add_vect_el (vla_hwint_t *,
ainsn_t, int);
static void add_states_vect_el (state_t);
static void output_trans_table (automaton_t);
static void output_state_alts_table (automaton_t);
......@@ -539,110 +516,22 @@ static pos_t no_pos = 0;
static struct obstack irp;
/* Declare vector types for various data structures: */
/* 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)
DEF_VEC_P(alt_state_t);
DEF_VEC_ALLOC_P(alt_state_t,heap);
DEF_VEC_P(ainsn_t);
DEF_VEC_ALLOC_P(ainsn_t,heap);
DEF_VEC_P(state_t);
DEF_VEC_ALLOC_P(state_t,heap);
DEF_VEC_P(decl_t);
DEF_VEC_ALLOC_P(decl_t,heap);
DEF_VEC_P(reserv_sets_t);
DEF_VEC_ALLOC_P(reserv_sets_t,heap);
DEF_VEC_I(vect_el_t);
DEF_VEC_ALLOC_I(vect_el_t, heap);
typedef VEC(vect_el_t,heap) *vla_hwint_t;
/* Options with the following names can be set up in automata_option
......@@ -727,9 +616,9 @@ enum decl_mode
rtl.def). */
struct unit_decl
{
char *name;
const char *name;
/* NULL if the automaton name is absent. */
char *automaton_name;
const char *automaton_name;
/* If the following value is not zero, the cpu unit reservation is
described in define_query_cpu_unit. */
char query_p;
......@@ -789,9 +678,9 @@ struct unit_decl
struct bypass_decl
{
int latency;
char *out_insn_name;
char *in_insn_name;
char *bypass_guard_name;
const char *out_insn_name;
const char *in_insn_name;
const char *bypass_guard_name;
/* The following fields are defined by checker. */
......@@ -805,7 +694,7 @@ struct bypass_decl
/* This describes define_automaton (see file rtl.def). */
struct automaton_decl
{
char *name;
const char *name;
/* The following fields are defined by automaton generator. */
......@@ -845,7 +734,7 @@ struct unit_pattern_rel_decl
/* This describes define_reservation (see file rtl.def). */
struct reserv_decl
{
char *name;
const char *name;
regexp_t regexp;
/* The following fields are defined by checker. */
......@@ -864,7 +753,7 @@ struct insn_reserv_decl
rtx condexp;
int default_latency;
regexp_t regexp;
char *name;
const char *name;
/* The following fields are defined by checker. */
......@@ -938,14 +827,14 @@ enum regexp_mode
/* Cpu unit in reservation. */
struct unit_regexp
{
char *name;
const char *name;
unit_decl_t unit_decl;
};
/* Define_reservation in a reservation. */
struct reserv_regexp
{
char *name;
const char *name;
struct reserv_decl *reserv_decl;
};
......@@ -1532,8 +1421,8 @@ copy_node (const void *from, size_t size)
}
/* The function checks that NAME does not contain quotes (`"'). */
static char *
check_name (char * name, pos_t pos ATTRIBUTE_UNUSED)
static const char *
check_name (const char * name, pos_t pos ATTRIBUTE_UNUSED)
{
const char *str;
......@@ -1545,7 +1434,7 @@ check_name (char * name, pos_t pos ATTRIBUTE_UNUSED)
/* Pointers to all declarations during IR generation are stored in the
following. */
static vla_ptr_t decls;
static VEC(decl_t,heap) *decls;
/* Given a pointer to a (char *) and a separator, return an alloc'ed
string containing the next separated element, taking parentheses
......@@ -1553,10 +1442,10 @@ static vla_ptr_t decls;
after the string scanned, or the end-of-string. Return NULL if at
end of string. */
static char *
next_sep_el (char **pstr, int sep, int par_flag)
next_sep_el (const char **pstr, int sep, int par_flag)
{
char *out_str;
char *p;
const char *p;
int pars_num;
int n_spaces;
......@@ -1601,7 +1490,7 @@ next_sep_el (char **pstr, int sep, int par_flag)
nonzero value. Return 0 for the null string, -1 if parentheses is
not balanced. */
static int
n_sep_els (char *s, int sep, int par_flag)
n_sep_els (const char *s, int sep, int par_flag)
{
int n;
int pars_num;
......@@ -1626,11 +1515,11 @@ n_sep_els (char *s, int sep, int par_flag)
function also inserts the end marker NULL at the end of vector.
Return 0 for the null string, -1 if parentheses are not balanced. */
static char **
get_str_vect (char *str, int *els_num, int sep, int paren_p)
get_str_vect (const char *str, int *els_num, int sep, int paren_p)
{
int i;
char **vect;
char **pstr;
const char **pstr;
char *trail;
*els_num = n_sep_els (str, sep, paren_p);
......@@ -1660,8 +1549,7 @@ gen_cpu_unit (rtx def)
int vect_length;
int i;
str_cpu_units = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',',
FALSE);
str_cpu_units = get_str_vect (XSTR (def, 0), &vect_length, ',', FALSE);
if (str_cpu_units == NULL)
fatal ("invalid string `%s' in define_cpu_unit", XSTR (def, 0));
for (i = 0; i < vect_length; i++)
......@@ -1670,11 +1558,11 @@ gen_cpu_unit (rtx def)
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)->automaton_name = XSTR (def, 1);
DECL_UNIT (decl)->query_p = 0;
DECL_UNIT (decl)->min_occ_cycle_num = -1;
DECL_UNIT (decl)->in_set_p = 0;
VLA_PTR_ADD (decls, decl);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
}
......@@ -1691,7 +1579,7 @@ gen_query_cpu_unit (rtx def)
int vect_length;
int i;
str_cpu_units = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',',
str_cpu_units = get_str_vect (XSTR (def, 0), &vect_length, ',',
FALSE);
if (str_cpu_units == NULL)
fatal ("invalid string `%s' in define_query_cpu_unit", XSTR (def, 0));
......@@ -1701,9 +1589,9 @@ gen_query_cpu_unit (rtx def)
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)->automaton_name = XSTR (def, 1);
DECL_UNIT (decl)->query_p = 1;
VLA_PTR_ADD (decls, decl);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
}
......@@ -1723,10 +1611,10 @@ gen_bypass (rtx def)
int in_length;
int i, j;
out_insns = get_str_vect ((char *) XSTR (def, 1), &out_length, ',', FALSE);
out_insns = get_str_vect (XSTR (def, 1), &out_length, ',', FALSE);
if (out_insns == NULL)
fatal ("invalid string `%s' in define_bypass", XSTR (def, 1));
in_insns = get_str_vect ((char *) XSTR (def, 2), &in_length, ',', FALSE);
in_insns = get_str_vect (XSTR (def, 2), &in_length, ',', FALSE);
if (in_insns == NULL)
fatal ("invalid string `%s' in define_bypass", XSTR (def, 2));
for (i = 0; i < out_length; i++)
......@@ -1738,8 +1626,8 @@ gen_bypass (rtx def)
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);
DECL_BYPASS (decl)->bypass_guard_name = XSTR (def, 3);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
}
......@@ -1760,10 +1648,10 @@ gen_excl_set (rtx def)
int i;
first_str_cpu_units
= get_str_vect ((char *) XSTR (def, 0), &first_vect_length, ',', FALSE);
= get_str_vect (XSTR (def, 0), &first_vect_length, ',', FALSE);
if (first_str_cpu_units == NULL)
fatal ("invalid first string `%s' in exclusion_set", XSTR (def, 0));
second_str_cpu_units = get_str_vect ((char *) XSTR (def, 1), &length, ',',
second_str_cpu_units = get_str_vect (XSTR (def, 1), &length, ',',
FALSE);
if (second_str_cpu_units == NULL)
fatal ("invalid second string `%s' in exclusion_set", XSTR (def, 1));
......@@ -1779,7 +1667,7 @@ gen_excl_set (rtx def)
else
DECL_EXCL (decl)->names [i]
= second_str_cpu_units [i - first_vect_length];
VLA_PTR_ADD (decls, decl);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
......@@ -1794,13 +1682,14 @@ gen_presence_absence_set (rtx def, int presence_p, int final_p)
{
decl_t decl;
char **str_cpu_units;
char **str_pattern_lists;
char ***str_patterns;
int cpu_units_length;
int length;
int patterns_length;
int i;
str_cpu_units = get_str_vect ((char *) XSTR (def, 0), &cpu_units_length, ',',
str_cpu_units = get_str_vect (XSTR (def, 0), &cpu_units_length, ',',
FALSE);
if (str_cpu_units == NULL)
fatal ((presence_p
......@@ -1811,9 +1700,9 @@ gen_presence_absence_set (rtx def, int presence_p, int final_p)
? "invalid first string `%s' in final_absence_set"
: "invalid first string `%s' in absence_set")),
XSTR (def, 0));
str_patterns = (char ***) get_str_vect ((char *) XSTR (def, 1),
str_pattern_lists = get_str_vect (XSTR (def, 1),
&patterns_length, ',', FALSE);
if (str_patterns == NULL)
if (str_pattern_lists == NULL)
fatal ((presence_p
? (final_p
? "invalid second string `%s' in final_presence_set"
......@@ -1821,10 +1710,11 @@ gen_presence_absence_set (rtx def, int presence_p, int final_p)
: (final_p
? "invalid second string `%s' in final_absence_set"
: "invalid second string `%s' in absence_set")), XSTR (def, 1));
str_patterns = obstack_alloc (&irp, patterns_length * sizeof (char **));
for (i = 0; i < patterns_length; i++)
{
str_patterns [i] = get_str_vect ((char *) str_patterns [i], &length, ' ',
FALSE);
str_patterns [i] = get_str_vect (str_pattern_lists [i],
&length, ' ', FALSE);
gcc_assert (str_patterns [i]);
}
decl = create_node (sizeof (struct decl));
......@@ -1847,7 +1737,7 @@ gen_presence_absence_set (rtx def, int presence_p, int final_p)
DECL_ABSENCE (decl)->patterns_num = patterns_length;
DECL_ABSENCE (decl)->final_p = final_p;
}
VLA_PTR_ADD (decls, decl);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
......@@ -1908,8 +1798,7 @@ gen_automaton (rtx def)
int vect_length;
int i;
str_automata = get_str_vect ((char *) XSTR (def, 0), &vect_length, ',',
FALSE);
str_automata = get_str_vect (XSTR (def, 0), &vect_length, ',', FALSE);
if (str_automata == NULL)
fatal ("invalid string `%s' in define_automaton", XSTR (def, 0));
for (i = 0; i < vect_length; i++)
......@@ -1918,7 +1807,7 @@ gen_automaton (rtx def)
decl->mode = dm_automaton;
decl->pos = 0;
DECL_AUTOMATON (decl)->name = check_name (str_automata [i], decl->pos);
VLA_PTR_ADD (decls, decl);
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
}
......@@ -1951,13 +1840,14 @@ gen_automata_option (rtx def)
/* The following string contains original reservation string being
parsed. */
static char *reserv_str;
static const char *reserv_str;
/* Parse an element in STR. */
static regexp_t
gen_regexp_el (char *str)
gen_regexp_el (const char *str)
{
regexp_t regexp;
char *dstr;
int len;
if (*str == '(')
......@@ -1965,8 +1855,10 @@ gen_regexp_el (char *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);
dstr = alloca (len - 1);
memcpy (dstr, str + 1, len - 2);
dstr [len-2] = '\0';
regexp = gen_regexp_sequence (dstr);
}
else if (strcmp (str, NOTHING_NAME) == 0)
{
......@@ -1984,7 +1876,7 @@ gen_regexp_el (char *str)
/* Parse construction `repeat' in STR. */
static regexp_t
gen_regexp_repeat (char *str)
gen_regexp_repeat (const char *str)
{
regexp_t regexp;
regexp_t repeat;
......@@ -2017,7 +1909,7 @@ gen_regexp_repeat (char *str)
/* Parse reservation STR which possibly contains separator '+'. */
static regexp_t
gen_regexp_allof (char *str)
gen_regexp_allof (const char *str)
{
regexp_t allof;
char **allof_vect;
......@@ -2043,7 +1935,7 @@ gen_regexp_allof (char *str)
/* Parse reservation STR which possibly contains separator '|'. */
static regexp_t
gen_regexp_oneof (char *str)
gen_regexp_oneof (const char *str)
{
regexp_t oneof;
char **oneof_vect;
......@@ -2069,7 +1961,7 @@ gen_regexp_oneof (char *str)
/* Parse reservation STR which possibly contains separator ','. */
static regexp_t
gen_regexp_sequence (char *str)
gen_regexp_sequence (const char *str)
{
regexp_t sequence;
char **sequence_vect;
......@@ -2094,7 +1986,7 @@ gen_regexp_sequence (char *str)
/* Parse construction reservation STR. */
static regexp_t
gen_regexp (char *str)
gen_regexp (const char *str)
{
reserv_str = str;
return gen_regexp_sequence (str);;
......@@ -2113,9 +2005,9 @@ gen_reserv (rtx def)
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);
DECL_RESERV (decl)->name = check_name (XSTR (def, 0), decl->pos);
DECL_RESERV (decl)->regexp = gen_regexp (XSTR (def, 1));
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
......@@ -2133,11 +2025,11 @@ gen_insn_reserv (rtx def)
decl->mode = dm_insn_reserv;
decl->pos = 0;
DECL_INSN_RESERV (decl)->name
= check_name ((char *) XSTR (def, 0), decl->pos);
= check_name (XSTR (def, 0), decl->pos);
DECL_INSN_RESERV (decl)->default_latency = XINT (def, 1);
DECL_INSN_RESERV (decl)->condexp = XEXP (def, 2);
DECL_INSN_RESERV (decl)->regexp = gen_regexp ((char *) XSTR (def, 3));
VLA_PTR_ADD (decls, decl);
DECL_INSN_RESERV (decl)->regexp = gen_regexp (XSTR (def, 3));
VEC_safe_push (decl_t,heap, decls, decl);
num_dfa_decls++;
}
......@@ -2223,7 +2115,7 @@ static struct decl work_automaton_decl;
declaration. The function returns node found in the table, NULL if
such node does not exist in the table. */
static decl_t
find_automaton_decl (char *name)
find_automaton_decl (const char *name)
{
void *entry;
......@@ -2322,7 +2214,7 @@ static struct decl work_insn_decl;
declaration. The function returns node found in the table, NULL if
such node does not exist in the table. */
static decl_t
find_insn_decl (char *name)
find_insn_decl (const char *name)
{
void *entry;
......@@ -2422,7 +2314,7 @@ static struct decl work_decl;
returns node found in the table, NULL if such node does not exist
in the table. */
static decl_t
find_decl (char *name)
find_decl (const char *name)
{
void *entry;
......@@ -3537,7 +3429,7 @@ add_advance_cycle_insn_decl (void)
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)->name = "$advance_cycle";
DECL_INSN_RESERV (advance_cycle_insn_decl)->insn_num
= description->insns_num;
description->decls [description->decls_num] = advance_cycle_insn_decl;
......@@ -3628,47 +3520,50 @@ alt_state_cmp (const void *alt_state_ptr_1, const void *alt_state_ptr_2)
/* The function sorts ALT_STATES_LIST and removes duplicated alt
states from the list. The comparison key is alt state unique
number. */
static alt_state_t
uniq_sort_alt_states (alt_state_t alt_states_list)
{
alt_state_t curr_alt_state;
vla_ptr_t alt_states;
VEC(alt_state_t,heap) *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");
if (alt_states_list == 0)
return 0;
if (alt_states_list->next_alt_state == 0)
return alt_states_list;
alt_states = VEC_alloc (alt_state_t,heap, 150);
for (curr_alt_state = alt_states_list;
curr_alt_state != NULL;
curr_alt_state = curr_alt_state->next_alt_state)
VLA_PTR_ADD (alt_states, curr_alt_state);
qsort (VLA_PTR_BEGIN (alt_states), VLA_PTR_LENGTH (alt_states),
VEC_safe_push (alt_state_t,heap, alt_states, curr_alt_state);
qsort (VEC_address (alt_state_t, alt_states),
VEC_length (alt_state_t, alt_states),
sizeof (alt_state_t), alt_state_cmp);
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)
for (i = 1; i < VEC_length (alt_state_t, alt_states); i++)
if (VEC_index (alt_state_t, alt_states, prev_unique_state_ind)->state
!= VEC_index (alt_state_t, alt_states, i)->state)
{
prev_unique_state_ind++;
result_ptr [prev_unique_state_ind] = result_ptr [i];
VEC_replace (alt_state_t, alt_states, prev_unique_state_ind,
VEC_index (alt_state_t, alt_states, 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);
VEC_truncate (alt_state_t, alt_states, prev_unique_state_ind + 1);
for (i = 1; i < VEC_length (alt_state_t, alt_states); i++)
VEC_index (alt_state_t, alt_states, i-1)->next_sorted_alt_state
= VEC_index (alt_state_t, alt_states, i);
VEC_last (alt_state_t, alt_states)->next_sorted_alt_state = 0;
result = VEC_index (alt_state_t, alt_states, 0);
VEC_free (alt_state_t,heap, alt_states);
return result;
}
......@@ -3736,11 +3631,7 @@ static int els_in_cycle_reserv;
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. */
/* Array of pointers to unit declarations. */
static unit_decl_t *units_array;
/* Temporary reservation of maximal length. */
......@@ -3749,9 +3640,9 @@ static reserv_sets_t temp_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;
/* Linked list of free 'state' structures to be recycled. The
next_equiv_class_state pointer is borrowed for a free list. */
static state_t first_free_state;
static int curr_unique_state_num;
......@@ -4053,10 +3944,12 @@ get_free_state (int with_reservs, automaton_t automaton)
state_t result;
gcc_assert (max_cycles_num > 0 && automaton);
if (VLA_PTR_LENGTH (free_states) != 0)
if (first_free_state)
{
result = VLA_PTR (free_states, VLA_PTR_LENGTH (free_states) - 1);
VLA_PTR_SHORTEN (free_states, 1);
result = first_free_state;
first_free_state = result->next_equiv_class_state;
result->next_equiv_class_state = NULL;
result->automaton = automaton;
result->first_out_arc = NULL;
result->it_was_placed_in_stack_for_NDFA_forming = 0;
......@@ -4091,7 +3984,8 @@ static void
free_state (state_t state)
{
free_alt_states (state->component_states);
VLA_PTR_ADD (free_states, state);
state->next_equiv_class_state = first_free_state;
first_free_state = state;
}
/* Hash value of STATE. If STATE represents deterministic state it is
......@@ -4232,10 +4126,11 @@ initiate_states (void)
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);
if (description->units_num)
units_array = xmalloc (description->units_num * sizeof (unit_decl_t));
else
units_array = 0;
for (i = 0; i < description->decls_num; i++)
{
decl = description->decls [i];
......@@ -4249,7 +4144,6 @@ initiate_states (void)
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);
temp_reserv = alloc_empty_reserv_sets ();
}
......@@ -4258,9 +4152,10 @@ initiate_states (void)
static void
finish_states (void)
{
VLA_PTR_DELETE (units_container);
free (units_array);
units_array = 0;
htab_delete (state_table);
VLA_PTR_DELETE (free_states);
first_free_state = NULL;
finish_alt_states ();
}
......@@ -5337,6 +5232,10 @@ struct unit_usage
same alternative. */
struct unit_usage *next;
};
typedef struct unit_usage *unit_usage_t;
DEF_VEC_P(unit_usage_t);
DEF_VEC_ALLOC_P(unit_usage_t,heap);
/* Obstack for unit_usage structures. */
static struct obstack unit_usages;
......@@ -5347,7 +5246,7 @@ static struct obstack unit_usages;
alternative with given number are referred through element with
index equals to the cycle * number of all alternatives in the regexp
+ the alternative number. */
static vla_ptr_t cycle_alt_unit_usages;
static VEC(unit_usage_t,heap) *cycle_alt_unit_usages;
/* The following function creates the structure unit_usage for UNIT on
CYCLE in REGEXP alternative with ALT_NUM. The structure is made
......@@ -5356,29 +5255,26 @@ static void
store_alt_unit_usage (regexp_t regexp, regexp_t unit, int cycle,
int alt_num)
{
size_t i, length, old_length;
size_t length;
unit_decl_t unit_decl;
struct unit_usage *unit_usage_ptr;
unit_usage_t unit_usage_ptr;
int index;
gcc_assert (regexp && regexp->mode == rm_oneof
&& alt_num < REGEXP_ONEOF (regexp)->regexps_num);
unit_decl = REGEXP_UNIT (unit)->unit_decl;
old_length = VLA_PTR_LENGTH (cycle_alt_unit_usages);
length = (cycle + 1) * REGEXP_ONEOF (regexp)->regexps_num;
if (old_length < length)
{
VLA_PTR_EXPAND (cycle_alt_unit_usages, length - old_length);
for (i = old_length; i < length; i++)
VLA_PTR (cycle_alt_unit_usages, i) = NULL;
}
while (VEC_length (unit_usage_t, cycle_alt_unit_usages) < length)
VEC_safe_push (unit_usage_t,heap, cycle_alt_unit_usages, 0);
obstack_blank (&unit_usages, sizeof (struct unit_usage));
unit_usage_ptr = (struct unit_usage *) obstack_base (&unit_usages);
obstack_finish (&unit_usages);
unit_usage_ptr->unit_decl = unit_decl;
index = cycle * REGEXP_ONEOF (regexp)->regexps_num + alt_num;
unit_usage_ptr->next = VLA_PTR (cycle_alt_unit_usages, index);
VLA_PTR (cycle_alt_unit_usages, index) = unit_usage_ptr;
unit_usage_ptr->next = VEC_index (unit_usage_t, cycle_alt_unit_usages, index);
VEC_replace (unit_usage_t, cycle_alt_unit_usages, index, unit_usage_ptr);
unit_decl->last_distribution_check_cycle = -1; /* undefined */
}
......@@ -5396,7 +5292,8 @@ check_regexp_units_distribution (const char *insn_reserv_name,
return;
/* Store all unit usages in the regexp: */
obstack_init (&unit_usages);
VLA_PTR_CREATE (cycle_alt_unit_usages, 100, "unit usages on cycles");
cycle_alt_unit_usages = 0;
for (i = REGEXP_ONEOF (regexp)->regexps_num - 1; i >= 0; i--)
{
seq = REGEXP_ONEOF (regexp)->regexps [i];
......@@ -5463,31 +5360,33 @@ check_regexp_units_distribution (const char *insn_reserv_name,
}
}
/* Check distribution: */
for (i = 0; i < (int) VLA_PTR_LENGTH (cycle_alt_unit_usages); i++)
for (i = 0; i < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages); i++)
{
cycle = i / REGEXP_ONEOF (regexp)->regexps_num;
for (unit_usage_ptr = VLA_PTR (cycle_alt_unit_usages, i);
for (unit_usage_ptr = VEC_index (unit_usage_t, cycle_alt_unit_usages, i);
unit_usage_ptr != NULL;
unit_usage_ptr = unit_usage_ptr->next)
if (cycle != unit_usage_ptr->unit_decl->last_distribution_check_cycle)
{
unit_usage_ptr->unit_decl->last_distribution_check_cycle = cycle;
for (k = cycle * REGEXP_ONEOF (regexp)->regexps_num;
k < (int) VLA_PTR_LENGTH (cycle_alt_unit_usages)
k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
&& k == cycle * REGEXP_ONEOF (regexp)->regexps_num;
k++)
{
for (other_unit_usage_ptr = VLA_PTR (cycle_alt_unit_usages, k);
for (other_unit_usage_ptr
= VEC_index (unit_usage_t, cycle_alt_unit_usages, k);
other_unit_usage_ptr != NULL;
other_unit_usage_ptr = other_unit_usage_ptr->next)
if (unit_usage_ptr->unit_decl->automaton_decl
== other_unit_usage_ptr->unit_decl->automaton_decl)
break;
if (other_unit_usage_ptr == NULL
&& VLA_PTR (cycle_alt_unit_usages, k) != NULL)
&& (VEC_index (unit_usage_t, cycle_alt_unit_usages, k)
!= NULL))
break;
}
if (k < (int) VLA_PTR_LENGTH (cycle_alt_unit_usages)
if (k < (int) VEC_length (unit_usage_t, cycle_alt_unit_usages)
&& k == cycle * REGEXP_ONEOF (regexp)->regexps_num)
{
if (!annotation_message_reported_p)
......@@ -5503,7 +5402,7 @@ check_regexp_units_distribution (const char *insn_reserv_name,
}
}
}
VLA_PTR_DELETE (cycle_alt_unit_usages);
VEC_free (unit_usage_t,heap, cycle_alt_unit_usages);
obstack_free (&unit_usages, NULL);
}
......@@ -5679,16 +5578,14 @@ create_alt_states (automaton_t automaton)
/* The function forms list of ainsns of AUTOMATON with the same
reservation. */
static void
form_ainsn_with_same_reservs (automaton_t automaton)
{
ainsn_t curr_ainsn;
size_t i;
vla_ptr_t first_insns;
vla_ptr_t last_insns;
VEC(ainsn_t,heap) *last_insns = VEC_alloc (ainsn_t,heap, 150);
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)
......@@ -5700,28 +5597,26 @@ form_ainsn_with_same_reservs (automaton_t automaton)
}
else
{
for (i = 0; i < VLA_PTR_LENGTH (first_insns); i++)
for (i = 0; i < VEC_length (ainsn_t, last_insns); i++)
if (alt_states_eq
(curr_ainsn->sorted_alt_states,
((ainsn_t) VLA_PTR (first_insns, i))->sorted_alt_states))
VEC_index (ainsn_t, last_insns, i)->sorted_alt_states))
break;
curr_ainsn->next_same_reservs_insn = NULL;
if (i < VLA_PTR_LENGTH (first_insns))
if (i < VEC_length (ainsn_t, last_insns))
{
curr_ainsn->first_insn_with_same_reservs = 0;
((ainsn_t) VLA_PTR (last_insns, i))->next_same_reservs_insn
VEC_index (ainsn_t, last_insns, i)->next_same_reservs_insn
= curr_ainsn;
VLA_PTR (last_insns, i) = curr_ainsn;
VEC_replace (ainsn_t, last_insns, i, curr_ainsn);
}
else
{
VLA_PTR_ADD (first_insns, curr_ainsn);
VLA_PTR_ADD (last_insns, curr_ainsn);
VEC_safe_push (ainsn_t, heap, last_insns, curr_ainsn);
curr_ainsn->first_insn_with_same_reservs = 1;
}
}
VLA_PTR_DELETE (first_insns);
VLA_PTR_DELETE (last_insns);
VEC_free (ainsn_t,heap, last_insns);
}
/* Forming unit reservations which can affect creating the automaton
......@@ -5753,8 +5648,7 @@ form_reservs_matter (automaton_t automaton)
return reservs_matter;
}
/* The following function creates all states of nondeterministic (if
NDFA_FLAG has nonzero value) or deterministic AUTOMATON. */
/* The following function creates all states of nondeterministic AUTOMATON. */
static void
make_automaton (automaton_t automaton)
{
......@@ -5766,21 +5660,19 @@ make_automaton (automaton_t automaton)
state_t state2;
ainsn_t advance_cycle_ainsn;
arc_t added_arc;
vla_ptr_t state_stack;
VEC(state_t,heap) *state_stack = VEC_alloc(state_t,heap, 150);
int states_n;
reserv_sets_t reservs_matter = form_reservs_matter (automaton);
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);
VEC_safe_push (state_t,heap, state_stack, start_state);
states_n = 1;
while (VLA_PTR_LENGTH (state_stack) != 0)
while (VEC_length (state_t, state_stack) != 0)
{
state = VLA_PTR (state_stack, VLA_PTR_LENGTH (state_stack) - 1);
VLA_PTR_SHORTEN (state_stack, 1);
state = VEC_pop (state_t, state_stack);
advance_cycle_ainsn = NULL;
for (ainsn = automaton->ainsn_list;
ainsn != NULL;
......@@ -5805,7 +5697,7 @@ make_automaton (automaton_t automaton)
{
state2->it_was_placed_in_stack_for_NDFA_forming
= 1;
VLA_PTR_ADD (state_stack, state2);
VEC_safe_push (state_t,heap, state_stack, state2);
states_n++;
if (progress_flag && states_n % 100 == 0)
fprintf (stderr, ".");
......@@ -5836,7 +5728,7 @@ make_automaton (automaton_t automaton)
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);
VEC_safe_push (state_t,heap, state_stack, state2);
states_n++;
if (progress_flag && states_n % 100 == 0)
fprintf (stderr, ".");
......@@ -5844,7 +5736,7 @@ make_automaton (automaton_t automaton)
gcc_assert (advance_cycle_ainsn);
add_arc (state, state2, advance_cycle_ainsn, 1);
}
VLA_PTR_DELETE (state_stack);
VEC_free (state_t,heap, state_stack);
}
/* Foms lists of all arcs of STATE marked by the same ainsn. */
......@@ -5874,9 +5766,10 @@ form_arcs_marked_by_insn (state_t state)
ORIGINAL_STATE and list of arcs ARCS_MARKED_BY_INSN marked by the
same insn. If the composed state is not in STATE_STACK yet, it is
pushed into STATE_STACK. */
static int
create_composed_state (state_t original_state, arc_t arcs_marked_by_insn,
vla_ptr_t *state_stack)
VEC(state_t,heap) **state_stack)
{
state_t state;
alt_state_t alt_state, curr_alt_state;
......@@ -5967,33 +5860,34 @@ create_composed_state (state_t original_state, arc_t arcs_marked_by_insn,
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);
VEC_safe_push (state_t,heap, *state_stack, state);
}
return new_state_p;
}
/* The function transforms nondeterministic AUTOMATON into
deterministic. */
static void
NDFA_to_DFA (automaton_t automaton)
{
state_t start_state;
state_t state;
decl_t decl;
vla_ptr_t state_stack;
VEC(state_t,heap) *state_stack;
int i;
int states_n;
VLA_PTR_CREATE (state_stack, 150, "state stack");
state_stack = VEC_alloc (state_t,heap, 0);
/* Create the start state (empty state). */
start_state = automaton->start_state;
start_state->it_was_placed_in_stack_for_DFA_forming = 1;
VLA_PTR_ADD (state_stack, start_state);
VEC_safe_push (state_t,heap, state_stack, start_state);
states_n = 1;
while (VLA_PTR_LENGTH (state_stack) != 0)
while (VEC_length (state_t, state_stack) != 0)
{
state = VLA_PTR (state_stack, VLA_PTR_LENGTH (state_stack) - 1);
VLA_PTR_SHORTEN (state_stack, 1);
state = VEC_pop (state_t, state_stack);
form_arcs_marked_by_insn (state);
for (i = 0; i < description->decls_num; i++)
{
......@@ -6009,7 +5903,7 @@ NDFA_to_DFA (automaton_t automaton)
}
}
}
VLA_PTR_DELETE (state_stack);
VEC_free (state_t,heap, state_stack);
}
/* The following variable value is current number (1, 2, ...) of passing
......@@ -6051,14 +5945,14 @@ initiate_pass_states (void)
/* The following vla is used for storing pointers to all achieved
states. */
static vla_ptr_t all_achieved_states;
static VEC(state_t,heap) *all_achieved_states;
/* This function is called by function pass_states to add an achieved
STATE. */
static void
add_achieved_state (state_t state)
{
VLA_PTR_ADD (all_achieved_states, state);
VEC_safe_push (state_t,heap, all_achieved_states, state);
}
/* The function sets up equivalence numbers of insns which mark all
......@@ -6102,19 +5996,6 @@ clear_arc_insns_equiv_num (state_t state)
}
}
/* The function copies pointers to equivalent states from vla FROM
into vla TO. */
static void
copy_equiv_class (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 following function returns TRUE if STATE reserves the unit with
UNIT_NUM on the first cycle. */
......@@ -6178,46 +6059,50 @@ state_is_differed (state_t state, state_t another_state,
/* The function makes initial partition of STATES on equivalent
classes. */
static state_t
init_equiv_class (state_t *states, int states_num)
init_equiv_class (VEC(state_t,heap) *states)
{
state_t *state_ptr;
state_t result_equiv_class;
size_t i;
state_t prev = 0;
result_equiv_class = NULL;
for (state_ptr = states; state_ptr < states + states_num; state_ptr++)
for (i = 0; i < VEC_length (state_t, states); i++)
{
(*state_ptr)->equiv_class_num_1 = 1;
(*state_ptr)->next_equiv_class_state = result_equiv_class;
result_equiv_class = *state_ptr;
VEC_index (state_t, states, i)->equiv_class_num_1 = 1;
VEC_index (state_t, states, i)->next_equiv_class_state = prev;
prev = VEC_index (state_t, states, i);
}
return result_equiv_class;
return prev;
}
/* The function processes equivalence class given by its pointer
EQUIV_CLASS_PTR on odd iteration if ODD_ITERATION_FLAG. If there
/* The function copies pointers to equivalent states from vla FROM
into vla TO. */
static void
copy_equiv_class (VEC(state_t,heap) **to, VEC(state_t,heap) *from)
{
VEC_free (state_t,heap, *to);
*to = VEC_copy (state_t,heap, from);
}
/* The function processes equivalence class given by its first state,
FIRST_STATE, on odd iteration if ODD_ITERATION_FLAG. If there
are not equivalent states, the function partitions the class
removing nonequivalent states and placing them in
*NEXT_ITERATION_CLASSES, increments *NEW_EQUIV_CLASS_NUM_PTR ans
assigns it to the state equivalence number. If the class has been
partitioned, the function returns nonzero value. */
static int
partition_equiv_class (state_t *equiv_class_ptr, int odd_iteration_flag,
vla_ptr_t *next_iteration_classes,
partition_equiv_class (state_t first_state, int odd_iteration_flag,
VEC(state_t,heap) **next_iteration_classes,
int *new_equiv_class_num_ptr)
{
state_t new_equiv_class;
int partition_p;
state_t first_state;
state_t curr_state;
state_t prev_state;
state_t next_state;
int out_arcs_num;
partition_p = 0;
gcc_assert (*equiv_class_ptr);
for (first_state = *equiv_class_ptr;
first_state != NULL;
first_state = new_equiv_class)
while (first_state != NULL)
{
new_equiv_class = NULL;
if (first_state->next_equiv_class_state != NULL)
......@@ -6253,62 +6138,64 @@ partition_equiv_class (state_t *equiv_class_ptr, int odd_iteration_flag,
clear_arc_insns_equiv_num (first_state);
}
if (new_equiv_class != NULL)
VLA_PTR_ADD (*next_iteration_classes, new_equiv_class);
VEC_safe_push (state_t,heap, *next_iteration_classes, new_equiv_class);
first_state = new_equiv_class;
}
return partition_p;
}
/* The function finds equivalent states of AUTOMATON. */
static void
evaluate_equiv_classes (automaton_t automaton, vla_ptr_t *equiv_classes)
evaluate_equiv_classes (automaton_t automaton,
VEC(state_t,heap) **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;
VEC (state_t,heap) *next_iteration_classes;
size_t i;
VLA_PTR_CREATE (all_achieved_states, 1500, "all achieved states");
all_achieved_states = VEC_alloc (state_t,heap, 1500);
pass_states (automaton, add_achieved_state);
new_equiv_class = init_equiv_class (VLA_PTR_BEGIN (all_achieved_states),
VLA_PTR_LENGTH (all_achieved_states));
new_equiv_class = init_equiv_class (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);
next_iteration_classes = VEC_alloc (state_t,heap, 150);
VEC_quick_push (state_t, next_iteration_classes, new_equiv_class);
do
{
odd_iteration_flag = !odd_iteration_flag;
finish_flag = 1;
copy_equiv_class (equiv_classes, &next_iteration_classes);
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++)
for (i = 0; i < VEC_length (state_t, all_achieved_states); i++)
if (odd_iteration_flag)
(*state_ptr)->equiv_class_num_2 = (*state_ptr)->equiv_class_num_1;
VEC_index (state_t, all_achieved_states, i)->equiv_class_num_2
= VEC_index (state_t, all_achieved_states, i)->equiv_class_num_1;
else
(*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,
VEC_index (state_t, all_achieved_states, i)->equiv_class_num_1
= VEC_index (state_t, all_achieved_states, i)->equiv_class_num_2;
for (i = 0; i < VEC_length (state_t, *equiv_classes); i++)
if (partition_equiv_class (VEC_index (state_t, *equiv_classes, i),
odd_iteration_flag,
&next_iteration_classes,
&new_equiv_class_num))
finish_flag = 0;
}
while (!finish_flag);
VLA_PTR_DELETE (next_iteration_classes);
VLA_PTR_DELETE (all_achieved_states);
VEC_free (state_t,heap, next_iteration_classes);
VEC_free (state_t,heap, all_achieved_states);
}
/* The function merges equivalent states of AUTOMATON. */
static void
merge_states (automaton_t automaton, vla_ptr_t *equiv_classes)
merge_states (automaton_t automaton, VEC(state_t,heap) *equiv_classes)
{
state_t *equiv_class_ptr;
state_t curr_state;
state_t new_state;
state_t first_class_state;
......@@ -6316,19 +6203,20 @@ merge_states (automaton_t automaton, vla_ptr_t *equiv_classes)
alt_state_t alt_state, new_alt_state;
arc_t curr_arc;
arc_t next_arc;
size_t i;
/* Create states corresponding to equivalence classes containing two
or more states. */
for (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)
for (i = 0; i < VEC_length (state_t, equiv_classes); i++)
{
curr_state = VEC_index (state_t, equiv_classes, i);
if (curr_state->next_equiv_class_state != NULL)
{
/* There are more one states in the class equivalence. */
/* Create new compound state. */
new_state = get_free_state (0, automaton);
alt_states = NULL;
first_class_state = *equiv_class_ptr;
first_class_state = curr_state;
for (curr_state = first_class_state;
curr_state != NULL;
curr_state = curr_state->next_equiv_class_state)
......@@ -6357,13 +6245,15 @@ merge_states (automaton_t automaton, vla_ptr_t *equiv_classes)
new_state->component_states = uniq_sort_alt_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)
curr_state->equiv_class_state = curr_state;
}
for (i = 0; i < VEC_length (state_t, equiv_classes); i++)
{
first_class_state = *equiv_class_ptr;
curr_state = VEC_index (state_t, equiv_classes, i);
if (curr_state->next_equiv_class_state != NULL)
{
first_class_state = curr_state;
/* Create new arcs output from the state corresponding to
equiv class. */
for (curr_arc = first_out_arc (first_class_state);
......@@ -6393,11 +6283,12 @@ merge_states (automaton_t automaton, vla_ptr_t *equiv_classes)
{
/* Change `to_state' of arcs output from the state of given
equivalence class. */
for (curr_arc = first_out_arc (*equiv_class_ptr);
for (curr_arc = first_out_arc (curr_state);
curr_arc != NULL;
curr_arc = next_out_arc (curr_arc))
curr_arc->to_state = curr_arc->to_state->equiv_class_state;
}
}
}
/* The function sets up new_cycle_p for states if there is arc to the
......@@ -6418,13 +6309,13 @@ set_new_cycle_flags (state_t state)
static void
minimize_DFA (automaton_t automaton)
{
vla_ptr_t equiv_classes;
VEC(state_t,heap) *equiv_classes = 0;
VLA_PTR_CREATE (equiv_classes, 1500, "equivalence classes");
evaluate_equiv_classes (automaton, &equiv_classes);
merge_states (automaton, &equiv_classes);
merge_states (automaton, equiv_classes);
pass_states (automaton, set_new_cycle_flags);
VLA_PTR_DELETE (equiv_classes);
VEC_free (state_t,heap, equiv_classes);
}
/* Values of two variables are counted number of states and arcs in an
......@@ -6623,21 +6514,15 @@ static void
process_state_for_insn_equiv_partition (state_t state)
{
arc_t arc;
arc_t *insn_arcs_array;
int i;
vla_ptr_t insn_arcs_vect;
arc_t *insn_arcs_array = xmalloc (description->insns_num * sizeof(arc_t));
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);
free (insn_arcs_array);
}
/* The function searches for equivalent ainsns of AUTOMATON. */
......@@ -6745,56 +6630,53 @@ compare_max_occ_cycle_nums (const void *unit_decl_1,
/* The function makes heuristic assigning automata to units. Actually
efficacy of the algorithm has been checked yet??? */
static void
units_to_automata_heuristic_distr (void)
{
double estimation_bound;
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;
unit_decl_t *unit_decls;
int i, j;
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);
unit_decls = xmalloc (description->units_num * sizeof (unit_decl_t));
for (i = 0, j = 0; i < description->decls_num; i++)
if (description->decls[i]->mode == dm_unit)
unit_decls[j++] = DECL_UNIT (description->decls[i]);
gcc_assert (j == description->units_num);
qsort (unit_decls, description->units_num,
sizeof (unit_decl_t), compare_max_occ_cycle_nums);
automaton_num = 0;
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);
bound_value = unit_decls[0]->max_occ_cycle_num;
unit_decls[0]->corresponding_automaton_num = automaton_num;
for (i = 1; i < description->units_num; i++)
{
rest_units_num = description->units_num - i + 1;
gcc_assert (automata_num - automaton_num - 1 <= rest_units_num);
if (automaton_num < automata_num - 1
&& ((automata_num - automaton_num - 1 == rest_units_num)
|| (bound_value
> (estimation_bound
/ (DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num)))))
/ unit_decls[i]->max_occ_cycle_num))))
{
bound_value = DECL_UNIT (*unit_decl_ptr)->max_occ_cycle_num;
bound_value = unit_decls[i]->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;
bound_value *= unit_decls[i]->max_occ_cycle_num;
unit_decls[i]->corresponding_automaton_num = automaton_num;
}
gcc_assert (automaton_num == automata_num - 1);
VLA_PTR_DELETE (unit_decls);
free (unit_decls);
}
/* The functions creates automaton insns for each automata. Automaton
......@@ -7174,34 +7056,29 @@ output_dfa_max_issue_rate (void)
MAX_DFA_ISSUE_RATE_VAR_NAME, max_dfa_issue_rate);
}
/* The function outputs all initialization values of VECT with length
vect_length. */
/* The function outputs all initialization values of VECT. */
static void
output_vect (vect_el_t *vect, int vect_length)
output_vect (vla_hwint_t vect)
{
int els_on_line;
size_t vect_length = VEC_length (vect_el_t, vect);
size_t i;
els_on_line = 1;
if (vect_length == 0)
fprintf (output_file,
"0 /* This is dummy el because the vect is empty */");
fputs ("0 /* This is dummy el because the vect is empty */", output_file);
else
for (i = 0; i < vect_length; i++)
{
do
{
fprintf (output_file, "%5ld", (long) *vect);
vect_length--;
fprintf (output_file, "%5ld", (long) VEC_index (vect_el_t, vect, i));
if (els_on_line == 10)
{
els_on_line = 0;
fprintf (output_file, ",\n");
fputs (",\n", output_file);
}
else if (vect_length != 0)
fprintf (output_file, ", ");
else if (i < vect_length-1)
fputs (", ", output_file);
els_on_line++;
vect++;
}
while (vect_length != 0);
}
}
......@@ -7514,14 +7391,18 @@ output_translate_vect (automaton_t automaton)
int insn_value;
vla_hwint_t translate_vect;
VLA_HWINT_CREATE (translate_vect, 250, "translate vector");
VLA_HWINT_EXPAND (translate_vect, description->insns_num);
translate_vect = VEC_alloc (vect_el_t,heap, 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;
VEC_quick_push (vect_el_t, translate_vect,
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;
VEC_replace (vect_el_t, translate_vect,
ainsn->insn_reserv_decl->insn_num,
ainsn->insn_equiv_class_num);
fprintf (output_file,
"/* Vector translating external insn codes to internal ones.*/\n");
fprintf (output_file, "static const ");
......@@ -7529,10 +7410,9 @@ output_translate_vect (automaton_t automaton)
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));
output_vect (translate_vect);
fprintf (output_file, "};\n\n");
VLA_HWINT_DELETE (translate_vect);
VEC_free (vect_el_t,heap, translate_vect);
}
/* The value in a table state x ainsn -> something which represents
......@@ -7544,8 +7424,8 @@ static int undefined_vect_el_value;
static int
comb_vect_p (state_ainsn_table_t tab)
{
return (2 * VLA_HWINT_LENGTH (tab->full_vect)
> 5 * VLA_HWINT_LENGTH (tab->comb_vect));
return (2 * VEC_length (vect_el_t, tab->full_vect)
> 5 * VEC_length (vect_el_t, tab->comb_vect));
}
/* The following function creates new table for AUTOMATON. */
......@@ -7558,16 +7438,20 @@ create_state_ainsn_table (automaton_t automaton)
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");
tab->comb_vect = VEC_alloc (vect_el_t,heap, 10000);
tab->check_vect = VEC_alloc (vect_el_t,heap, 10000);
tab->base_vect = 0;
VEC_safe_grow (vect_el_t,heap, tab->base_vect,
automaton->achieved_states_num);
full_vect_length = (automaton->insn_equiv_classes_num
* automaton->achieved_states_num);
VLA_HWINT_EXPAND (tab->full_vect, full_vect_length);
tab->full_vect = VEC_alloc (vect_el_t,heap, full_vect_length);
for (i = 0; i < full_vect_length; i++)
VLA_HWINT (tab->full_vect, i) = undefined_vect_el_value;
VEC_quick_push (vect_el_t, tab->full_vect, undefined_vect_el_value);
tab->min_base_vect_el_value = 0;
tab->max_base_vect_el_value = 0;
tab->min_comb_vect_el_value = 0;
......@@ -7578,7 +7462,7 @@ create_state_ainsn_table (automaton_t automaton)
/* The following function outputs the best C representation of the
table TAB of given TABLE_NAME. */
static void
output_state_ainsn_table (state_ainsn_table_t tab, char *table_name,
output_state_ainsn_table (state_ainsn_table_t tab, const char *table_name,
void (*output_full_vect_name_func) (FILE *, automaton_t),
void (*output_comb_vect_name_func) (FILE *, automaton_t),
void (*output_check_vect_name_func) (FILE *, automaton_t),
......@@ -7593,8 +7477,7 @@ output_state_ainsn_table (state_ainsn_table_t tab, char *table_name,
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));
output_vect (tab->full_vect);
fprintf (output_file, "};\n\n");
}
else
......@@ -7606,8 +7489,7 @@ output_state_ainsn_table (state_ainsn_table_t tab, char *table_name,
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));
output_vect (tab->comb_vect);
fprintf (output_file, "};\n\n");
fprintf (output_file, "/* Check vector for %s. */\n", table_name);
fprintf (output_file, "static const ");
......@@ -7615,8 +7497,7 @@ output_state_ainsn_table (state_ainsn_table_t tab, char *table_name,
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));
output_vect (tab->check_vect);
fprintf (output_file, "};\n\n");
fprintf (output_file, "/* Base vector for %s. */\n", table_name);
fprintf (output_file, "static const ");
......@@ -7625,22 +7506,18 @@ output_state_ainsn_table (state_ainsn_table_t tab, char *table_name,
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));
output_vect (tab->base_vect);
fprintf (output_file, "};\n\n");
}
}
/* The following function adds vector with length VECT_LENGTH and
elements pointed to by VECT to table TAB as its line with number
VECT_NUM. */
/* The following function adds vector VECT to table TAB as its line
with number VECT_NUM. */
static void
add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
int vect_length)
add_vect (state_ainsn_table_t tab, int vect_num, vla_hwint_t vect)
{
int real_vect_length;
vect_el_t *comb_vect_start;
vect_el_t *check_vect_start;
int vect_length;
size_t real_vect_length;
int comb_vect_index;
int comb_vect_els_num;
int vect_index;
......@@ -7651,23 +7528,30 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
int i;
unsigned long vect_mask, comb_vect_mask;
vect_length = VEC_length (vect_el_t, vect);
gcc_assert (vect_length);
gcc_assert (VEC_last (vect_el_t, vect) != undefined_vect_el_value);
real_vect_length = tab->automaton->insn_equiv_classes_num;
gcc_assert (vect [vect_length - 1] != undefined_vect_el_value);
/* Form full vector in the table: */
{
size_t full_base = tab->automaton->insn_equiv_classes_num * vect_num;
if (VEC_length (vect_el_t, tab->full_vect) < full_base + vect_length)
VEC_safe_grow (vect_el_t,heap, tab->full_vect,
full_base + vect_length);
for (i = 0; i < vect_length; i++)
VLA_HWINT (tab->full_vect,
i + tab->automaton->insn_equiv_classes_num * vect_num)
= vect [i];
VEC_replace (vect_el_t, tab->full_vect, full_base + i,
VEC_index (vect_el_t, vect, i));
}
/* Form comb vector in the table: */
gcc_assert (VLA_HWINT_LENGTH (tab->comb_vect)
== VLA_HWINT_LENGTH (tab->check_vect));
comb_vect_start = VLA_HWINT_BEGIN (tab->comb_vect);
comb_vect_els_num = VLA_HWINT_LENGTH (tab->comb_vect);
gcc_assert (VEC_length (vect_el_t, tab->comb_vect)
== VEC_length (vect_el_t, tab->check_vect));
comb_vect_els_num = VEC_length (vect_el_t, tab->comb_vect);
for (first_unempty_vect_index = 0;
first_unempty_vect_index < vect_length;
first_unempty_vect_index++)
if (vect [first_unempty_vect_index] != undefined_vect_el_value)
if (VEC_index (vect_el_t, vect, first_unempty_vect_index)
!= undefined_vect_el_value)
break;
/* Search for the place in comb vect for the inserted vect. */
......@@ -7683,8 +7567,10 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
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]
if (VEC_index (vect_el_t, vect, vect_index)
!= undefined_vect_el_value
&& (VEC_index (vect_el_t, tab->comb_vect,
vect_index + comb_vect_index)
!= undefined_vect_el_value))
break;
if (vect_index >= vect_length
......@@ -7701,7 +7587,7 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
vect_index++)
{
vect_mask = vect_mask << 1;
if (vect [vect_index] != undefined_vect_el_value)
if (VEC_index (vect_el_t, vect, vect_index) != undefined_vect_el_value)
vect_mask |= 1;
}
......@@ -7717,7 +7603,7 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
{
comb_vect_mask <<= 1;
if (vect_index + comb_vect_index < comb_vect_els_num
&& comb_vect_start [vect_index + comb_vect_index]
&& VEC_index (vect_el_t, tab->comb_vect, vect_index + comb_vect_index)
!= undefined_vect_el_value)
comb_vect_mask |= 1;
}
......@@ -7728,7 +7614,8 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
comb_vect_index++, i++)
{
comb_vect_mask = (comb_vect_mask << 1) | 1;
comb_vect_mask ^= comb_vect_start [i] == undefined_vect_el_value;
comb_vect_mask ^= (VEC_index (vect_el_t, tab->comb_vect, i)
== undefined_vect_el_value);
if ((vect_mask & comb_vect_mask) == 0)
goto found;
}
......@@ -7749,27 +7636,29 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
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);
VEC_safe_push (vect_el_t,heap, tab->comb_vect, vect_el);
VEC_safe_push (vect_el_t,heap, tab->check_vect, no_state_value);
additional_els_num--;
}
comb_vect_start = VLA_HWINT_BEGIN (tab->comb_vect);
check_vect_start = VLA_HWINT_BEGIN (tab->check_vect);
gcc_assert (VLA_HWINT_LENGTH (tab->comb_vect)
>= (size_t) (comb_vect_index + real_vect_length));
gcc_assert (VEC_length (vect_el_t, tab->comb_vect)
>= comb_vect_index + real_vect_length);
/* Fill comb and check vectors. */
for (vect_index = 0; vect_index < vect_length; vect_index++)
if (vect [vect_index] != undefined_vect_el_value)
if (VEC_index (vect_el_t, vect, vect_index) != undefined_vect_el_value)
{
gcc_assert (comb_vect_start [comb_vect_index + vect_index]
vect_el_t x = VEC_index (vect_el_t, vect, vect_index);
gcc_assert (VEC_index (vect_el_t, tab->comb_vect,
comb_vect_index + vect_index)
== undefined_vect_el_value);
comb_vect_start [comb_vect_index + vect_index] = vect [vect_index];
gcc_assert (vect [vect_index] >= 0);
if (tab->max_comb_vect_el_value < vect [vect_index])
tab->max_comb_vect_el_value = vect [vect_index];
if (tab->min_comb_vect_el_value > vect [vect_index])
tab->min_comb_vect_el_value = vect [vect_index];
check_vect_start [comb_vect_index + vect_index] = vect_num;
gcc_assert (x >= 0);
if (tab->max_comb_vect_el_value < x)
tab->max_comb_vect_el_value = x;
if (tab->min_comb_vect_el_value > x)
tab->min_comb_vect_el_value = x;
VEC_replace (vect_el_t, tab->comb_vect,
comb_vect_index + vect_index, x);
VEC_replace (vect_el_t, tab->check_vect,
comb_vect_index + vect_index, vect_num);
}
if (tab->max_comb_vect_el_value < undefined_vect_el_value)
tab->max_comb_vect_el_value = undefined_vect_el_value;
......@@ -7779,7 +7668,8 @@ add_vect (state_ainsn_table_t tab, int vect_num, vect_el_t *vect,
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;
VEC_replace (vect_el_t, tab->base_vect, vect_num, comb_vect_index);
}
/* Return number of out arcs of STATE. */
......@@ -7827,22 +7717,22 @@ add_vect_el (vla_hwint_t *vect, ainsn_t ainsn, int el_value)
gcc_assert (ainsn);
equiv_class_num = ainsn->insn_equiv_class_num;
for (vect_index = VLA_HWINT_LENGTH (*vect);
for (vect_index = VEC_length (vect_el_t, *vect);
vect_index <= equiv_class_num;
vect_index++)
VLA_HWINT_ADD (*vect, undefined_vect_el_value);
VLA_HWINT (*vect, equiv_class_num) = el_value;
VEC_safe_push (vect_el_t,heap, *vect, undefined_vect_el_value);
VEC_replace (vect_el_t, *vect, equiv_class_num, el_value);
}
/* This is for forming vector of states of an automaton. */
static vla_ptr_t output_states_vect;
static VEC(state_t,heap) *output_states_vect;
/* The function is called by function pass_states. The function adds
STATE to `output_states_vect'. */
static void
add_states_vect_el (state_t state)
{
VLA_PTR_ADD (output_states_vect, state);
VEC_safe_push (state_t,heap, output_states_vect, state);
}
/* Form and output vectors (comb, check, base or full vector)
......@@ -7850,26 +7740,24 @@ add_states_vect_el (state_t state)
static void
output_trans_table (automaton_t automaton)
{
state_t *state_ptr;
size_t i;
arc_t arc;
vla_hwint_t transition_vect;
vla_hwint_t transition_vect = 0;
undefined_vect_el_value = automaton->achieved_states_num;
automaton->trans_table = create_state_ainsn_table (automaton);
/* Create vect of pointers to states ordered by num of transitions
from the state (state with the maximum num is the first). */
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
output_states_vect = 0;
pass_states (automaton, add_states_vect_el);
qsort (VLA_PTR_BEGIN (output_states_vect),
VLA_PTR_LENGTH (output_states_vect),
qsort (VEC_address (state_t, output_states_vect),
VEC_length (state_t, 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++)
for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
{
VLA_HWINT_NULLIFY (transition_vect);
for (arc = first_out_arc (*state_ptr);
VEC_truncate (vect_el_t, transition_vect, 0);
for (arc = first_out_arc (VEC_index (state_t, output_states_vect, i));
arc != NULL;
arc = next_out_arc (arc))
{
......@@ -7878,16 +7766,17 @@ output_trans_table (automaton_t automaton)
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));
add_vect (automaton->trans_table,
VEC_index (state_t, output_states_vect, i)->order_state_num,
transition_vect);
}
output_state_ainsn_table
(automaton->trans_table, (char *) "state transitions",
(automaton->trans_table, "state transitions",
output_trans_full_vect_name, output_trans_comb_vect_name,
output_trans_check_vect_name, output_trans_base_vect_name);
VLA_PTR_DELETE (output_states_vect);
VLA_HWINT_DELETE (transition_vect);
VEC_free (state_t,heap, output_states_vect);
VEC_free (vect_el_t,heap, transition_vect);
}
/* Form and output vectors (comb, check, base or simple vect)
......@@ -7897,7 +7786,7 @@ output_trans_table (automaton_t automaton)
static void
output_state_alts_table (automaton_t automaton)
{
state_t *state_ptr;
size_t i;
arc_t arc;
vla_hwint_t state_alts_vect;
......@@ -7905,19 +7794,19 @@ output_state_alts_table (automaton_t automaton)
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");
output_states_vect = 0;
pass_states (automaton, add_states_vect_el);
qsort (VLA_PTR_BEGIN (output_states_vect),
VLA_PTR_LENGTH (output_states_vect),
qsort (VEC_address (state_t, output_states_vect),
VEC_length (state_t, 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++)
state_alts_vect = 0;
for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
{
VLA_HWINT_NULLIFY (state_alts_vect);
for (arc = first_out_arc (*state_ptr);
VEC_truncate (vect_el_t, state_alts_vect, 0);
for (arc = first_out_arc (VEC_index (state_t, output_states_vect, i));
arc != NULL;
arc = next_out_arc (arc))
{
......@@ -7925,16 +7814,17 @@ output_state_alts_table (automaton_t automaton)
if (arc->insn->first_ainsn_with_given_equivalence_num)
add_vect_el (&state_alts_vect, arc->insn, arc->state_alts);
}
add_vect (automaton->state_alts_table, (*state_ptr)->order_state_num,
VLA_HWINT_BEGIN (state_alts_vect),
VLA_HWINT_LENGTH (state_alts_vect));
add_vect (automaton->state_alts_table,
VEC_index (state_t, output_states_vect, i)->order_state_num,
state_alts_vect);
}
output_state_ainsn_table
(automaton->state_alts_table, (char *) "state insn alternatives",
(automaton->state_alts_table, "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);
VEC_free (state_t,heap, output_states_vect);
VEC_free (vect_el_t,heap, state_alts_vect);
}
/* The current number of passing states to find minimal issue delay
......@@ -8013,41 +7903,38 @@ output_min_issue_delay_table (automaton_t automaton)
vla_hwint_t compressed_min_issue_delay_vect;
vect_el_t min_delay;
ainsn_t ainsn;
state_t *state_ptr;
int i;
size_t i, min_issue_delay_len;
size_t compressed_min_issue_delay_len;
size_t cfactor;
/* Create vect of pointers to states ordered by num of transitions
from the state (state with the maximum num is the first). */
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
output_states_vect = 0;
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)
min_issue_delay_len = (VEC_length (state_t, output_states_vect)
* automaton->insn_equiv_classes_num);
i++)
VLA_HWINT (min_issue_delay_vect, i) = 0;
min_issue_delay_vect = VEC_alloc (vect_el_t,heap, min_issue_delay_len);
for (i = 0; i < min_issue_delay_len; i++)
VEC_quick_push (vect_el_t, min_issue_delay_vect, 0);
automaton->max_min_delay = 0;
for (ainsn = automaton->ainsn_list; ainsn != NULL; ainsn = ainsn->next_ainsn)
if (ainsn->first_ainsn_with_given_equivalence_num)
{
for (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++)
for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
VEC_index (state_t, output_states_vect, i)->min_insn_issue_delay = -1;
for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
{
min_delay = min_issue_delay (*state_ptr, ainsn);
state_t s = VEC_index (state_t, output_states_vect, i);
min_delay = min_issue_delay (s, ainsn);
if (automaton->max_min_delay < min_delay)
automaton->max_min_delay = min_delay;
VLA_HWINT (min_issue_delay_vect,
(*state_ptr)->order_state_num
VEC_replace (vect_el_t, min_issue_delay_vect,
s->order_state_num
* automaton->insn_equiv_classes_num
+ ainsn->insn_equiv_class_num) = min_delay;
+ ainsn->insn_equiv_class_num,
min_delay);
}
}
fprintf (output_file, "/* Vector of min issue delay of insns. */\n");
......@@ -8058,37 +7945,36 @@ output_min_issue_delay_table (automaton_t automaton)
fprintf (output_file, "[] ATTRIBUTE_UNUSED = {\n");
/* Compress the vector. */
if (automaton->max_min_delay < 2)
automaton->min_issue_delay_table_compression_factor = 8;
cfactor = 8;
else if (automaton->max_min_delay < 4)
automaton->min_issue_delay_table_compression_factor = 4;
cfactor = 4;
else if (automaton->max_min_delay < 16)
automaton->min_issue_delay_table_compression_factor = 2;
cfactor = 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));
cfactor = 1;
automaton->min_issue_delay_table_compression_factor = cfactor;
compressed_min_issue_delay_len = (min_issue_delay_len+cfactor-1) / cfactor;
compressed_min_issue_delay_vect
= VEC_alloc (vect_el_t,heap, compressed_min_issue_delay_len);
for (i = 0; i < compressed_min_issue_delay_len; i++)
VEC_quick_push (vect_el_t, compressed_min_issue_delay_vect, 0);
for (i = 0; i < min_issue_delay_len; i++)
{
size_t ci = i / cfactor;
vect_el_t x = VEC_index (vect_el_t, min_issue_delay_vect, i);
vect_el_t cx = VEC_index (vect_el_t, compressed_min_issue_delay_vect, ci);
cx |= x << (8 - (i % cfactor + 1) * (8 / cfactor));
VEC_replace (vect_el_t, compressed_min_issue_delay_vect, ci, cx);
}
output_vect (compressed_min_issue_delay_vect);
fprintf (output_file, "};\n\n");
VLA_PTR_DELETE (output_states_vect);
VLA_HWINT_DELETE (min_issue_delay_vect);
VLA_HWINT_DELETE (compressed_min_issue_delay_vect);
VEC_free (state_t,heap, output_states_vect);
VEC_free (vect_el_t,heap, min_issue_delay_vect);
VEC_free (vect_el_t,heap, compressed_min_issue_delay_vect);
}
#ifndef NDEBUG
......@@ -8102,29 +7988,30 @@ static int locked_states_num;
static void
output_dead_lock_vect (automaton_t automaton)
{
state_t *state_ptr;
size_t i;
arc_t arc;
vla_hwint_t dead_lock_vect;
vla_hwint_t dead_lock_vect = 0;
/* Create vect of pointers to states ordered by num of
transitions from the state (state with the maximum num is the
first). */
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
output_states_vect = 0;
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++)
VEC_safe_grow (vect_el_t,heap, dead_lock_vect,
VEC_length (state_t, output_states_vect));
for (i = 0; i < VEC_length (state_t, output_states_vect); i++)
{
arc = first_out_arc (*state_ptr);
state_t s = VEC_index (state_t, output_states_vect, i);
arc = first_out_arc (s);
gcc_assert (arc);
VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num)
= (next_out_arc (arc) == NULL
VEC_replace (vect_el_t, dead_lock_vect, s->order_state_num,
(next_out_arc (arc) == NULL
&& (arc->insn->insn_reserv_decl
== DECL_INSN_RESERV (advance_cycle_insn_decl)) ? 1 : 0);
== DECL_INSN_RESERV (advance_cycle_insn_decl))
? 1 : 0));
#ifndef NDEBUG
if (VLA_HWINT (dead_lock_vect, (*state_ptr)->order_state_num))
if (VEC_index (vect_el_t,dead_lock_vect, s->order_state_num))
locked_states_num++;
#endif
}
......@@ -8134,11 +8021,10 @@ output_dead_lock_vect (automaton_t automaton)
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));
output_vect (dead_lock_vect);
fprintf (output_file, "};\n\n");
VLA_HWINT_DELETE (dead_lock_vect);
VLA_PTR_DELETE (output_states_vect);
VEC_free (state_t,heap, output_states_vect);
VEC_free (vect_el_t,heap, dead_lock_vect);
}
/* Form and output vector representing reserved units of the states of
......@@ -8146,34 +8032,38 @@ output_dead_lock_vect (automaton_t automaton)
static void
output_reserved_units_table (automaton_t automaton)
{
state_t *curr_state_ptr;
vla_hwint_t reserved_units_table;
size_t state_byte_size;
vla_hwint_t reserved_units_table = 0;
int state_byte_size;
int reserved_units_size;
size_t n;
int i;
/* Create vect of pointers to states. */
VLA_PTR_CREATE (output_states_vect, 1500, "output states vector");
output_states_vect = 0;
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++)
reserved_units_size = (VEC_length (state_t, output_states_vect)
* state_byte_size);
reserved_units_table = VEC_alloc (vect_el_t,heap, reserved_units_size);
for (i = 0; i < reserved_units_size; i++)
VEC_quick_push (vect_el_t, reserved_units_table, 0);
for (n = 0; n < VEC_length (state_t, output_states_vect); n++)
{
state_t s = VEC_index (state_t, output_states_vect, n);
for (i = 0; i < description->units_num; i++)
if (units_array [i]->query_p
&& first_cycle_unit_presence (*curr_state_ptr, 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));
&& first_cycle_unit_presence (s, i))
{
int ri = (s->order_state_num * state_byte_size
+ units_array [i]->query_num / 8);
vect_el_t x = VEC_index (vect_el_t, reserved_units_table, ri);
x += 1 << (units_array [i]->query_num % 8);
VEC_replace (vect_el_t, reserved_units_table, ri, x);
}
}
fprintf (output_file, "/* Vector for reserved units of states. */\n");
fprintf (output_file, "static const ");
......@@ -8181,11 +8071,11 @@ output_reserved_units_table (automaton_t automaton)
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));
output_vect (reserved_units_table);
fprintf (output_file, "};\n\n");
VLA_HWINT_DELETE (reserved_units_table);
VLA_PTR_DELETE (output_states_vect);
VEC_free (state_t,heap, output_states_vect);
VEC_free (vect_el_t,heap, reserved_units_table);
}
/* The function outputs all tables representing DFA(s) used for fast
......@@ -9225,7 +9115,7 @@ static void
output_automaton_units (automaton_t automaton)
{
decl_t decl;
char *name;
const char *name;
int curr_line_length;
int there_is_an_automaton_unit;
int i;
......@@ -9263,14 +9153,13 @@ output_automaton_units (automaton_t automaton)
/* 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;
static VEC(reserv_sets_t,heap) *state_reservs;
/* The function forms `state_reservs' for STATE. */
static void
add_state_reservs (state_t state)
{
alt_state_t curr_alt_state;
reserv_sets_t reservs;
if (state->component_states != NULL)
for (curr_alt_state = state->component_states;
......@@ -9278,10 +9167,7 @@ add_state_reservs (state_t state)
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);
}
VEC_safe_push (reserv_sets_t,heap, state_reservs, state->reservs);
}
/* The function outputs readable representation of all out arcs of
......@@ -9291,7 +9177,7 @@ output_state_arcs (state_t state)
{
arc_t arc;
ainsn_t ainsn;
char *insn_name;
const char *insn_name;
int curr_line_length;
for (arc = first_out_arc (state); arc != NULL; arc = next_out_arc (arc))
......@@ -9347,21 +9233,17 @@ state_reservs_cmp (const void *reservs_ptr_1, const void *reservs_ptr_2)
static void
remove_state_duplicate_reservs (void)
{
reserv_sets_t *reservs_ptr;
reserv_sets_t *last_formed_reservs_ptr;
size_t i, j;
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)
for (i = 1, j = 0; i < VEC_length (reserv_sets_t, state_reservs); i++)
if (reserv_sets_cmp (VEC_index (reserv_sets_t, state_reservs, j),
VEC_index (reserv_sets_t, state_reservs, i)))
{
++last_formed_reservs_ptr;
*last_formed_reservs_ptr = *reservs_ptr;
j++;
VEC_replace (reserv_sets_t, state_reservs, j,
VEC_index (reserv_sets_t, state_reservs, i));
}
VLA_PTR_SHORTEN (state_reservs, reservs_ptr - last_formed_reservs_ptr - 1);
VEC_truncate (reserv_sets_t, state_reservs, j + 1);
}
/* The following function output readable representation of DFA(s)
......@@ -9371,27 +9253,28 @@ remove_state_duplicate_reservs (void)
static void
output_state (state_t state)
{
reserv_sets_t *reservs_ptr;
size_t i;
state_reservs = 0;
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),
qsort (VEC_address (reserv_sets_t, state_reservs),
VEC_length (reserv_sets_t, state_reservs),
sizeof (reserv_sets_t), state_reservs_cmp);
remove_state_duplicate_reservs ();
for (reservs_ptr = VLA_PTR_BEGIN (state_reservs);
reservs_ptr <= (reserv_sets_t *) VLA_PTR_LAST (state_reservs);
reservs_ptr++)
for (i = 1; i < VEC_length (reserv_sets_t, state_reservs); i++)
{
fprintf (output_description_file, " ");
output_reserv_sets (output_description_file, *reservs_ptr);
output_reserv_sets (output_description_file,
VEC_index (reserv_sets_t, state_reservs, i));
fprintf (output_description_file, "\n");
}
fprintf (output_description_file, "\n");
output_state_arcs (state);
VLA_PTR_DELETE (state_reservs);
VEC_free (reserv_sets_t,heap, state_reservs);
}
/* The following function output readable representation of
......@@ -9456,14 +9339,14 @@ output_statistics (FILE *f)
#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),
(long) VEC_length (vect_el_t, automaton->trans_table->comb_vect),
(long) VEC_length (vect_el_t, automaton->trans_table->full_vect),
(comb_vect_p (automaton->trans_table)
? "use comb vect" : "use simple vect"));
fprintf
(f, "%5ld 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),
(long) VEC_length (vect_el_t, automaton->state_alts_table->comb_vect),
(long) VEC_length (vect_el_t, automaton->state_alts_table->full_vect),
(comb_vect_p (automaton->state_alts_table)
? "use comb vect" : "use simple vect"));
fprintf
......@@ -9471,13 +9354,13 @@ output_statistics (FILE *f)
(long) 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);
+= VEC_length (vect_el_t, automaton->trans_table->comb_vect);
transition_full_vect_els
+= VLA_HWINT_LENGTH (automaton->trans_table->full_vect);
+= VEC_length (vect_el_t, automaton->trans_table->full_vect);
state_alts_comb_vect_els
+= VLA_HWINT_LENGTH (automaton->state_alts_table->comb_vect);
+= VEC_length (vect_el_t, automaton->state_alts_table->comb_vect);
state_alts_full_vect_els
+= VLA_HWINT_LENGTH (automaton->state_alts_table->full_vect);
+= VEC_length (vect_el_t, automaton->state_alts_table->full_vect);
min_issue_delay_vect_els
+= states_num * automaton->insn_equiv_classes_num;
#endif
......@@ -9773,7 +9656,7 @@ initiate_automaton_gen (int argc, char **argv)
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 ();
......@@ -9838,14 +9721,14 @@ check_automata_insn_issues (void)
/* The following vla is used for storing pointers to all achieved
states. */
static vla_ptr_t automaton_states;
static VEC(state_t,heap) *automaton_states;
/* This function is called by function pass_states to add an achieved
STATE. */
static void
add_automaton_state (state_t state)
{
VLA_PTR_ADD (automaton_states, state);
VEC_safe_push (state_t,heap, automaton_states, state);
}
/* The following function forms list of important automata (whose
......@@ -9854,29 +9737,27 @@ static void
form_important_insn_automata_lists (void)
{
automaton_t automaton;
state_t *state_ptr;
decl_t decl;
ainsn_t ainsn;
arc_t arc;
int i;
size_t n;
VLA_PTR_CREATE (automaton_states, 1500,
"automaton states for forming important insn automata sets");
automaton_states = 0;
/* Mark important ainsns. */
for (automaton = description->first_automaton;
automaton != NULL;
automaton = automaton->next_automaton)
{
VLA_PTR_NULLIFY (automaton_states);
VEC_truncate (state_t, automaton_states, 0);
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 (n = 0; n < VEC_length (state_t, automaton_states); n++)
{
for (arc = first_out_arc (*state_ptr);
state_t s = VEC_index (state_t, automaton_states, n);
for (arc = first_out_arc (s);
arc != NULL;
arc = next_out_arc (arc))
if (arc->to_state != *state_ptr)
if (arc->to_state != s)
{
gcc_assert (arc->insn->first_insn_with_same_reservs);
for (ainsn = arc->insn;
......@@ -9886,7 +9767,8 @@ form_important_insn_automata_lists (void)
}
}
}
VLA_PTR_DELETE (automaton_states);
VEC_free (state_t,heap, automaton_states);
/* Create automata sets for the insns. */
for (i = 0; i < description->decls_num; i++)
{
......@@ -9922,12 +9804,12 @@ expand_automata (void)
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);
+ sizeof (decl_t) * VEC_length (decl_t, decls));
description->decls_num = VEC_length (decl_t, decls);
description->query_units_num = 0;
for (i = 0; i < description->decls_num; i++)
{
description->decls [i] = VLA_PTR (decls, i);
description->decls [i] = VEC_index (decl_t, decls, i);
if (description->decls [i]->mode == dm_unit
&& DECL_UNIT (description->decls [i])->query_p)
DECL_UNIT (description->decls [i])->query_num
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment