Data Structures
struct	queue_elem
struct	std_pred_table

Typedefs
typedef const char (	constraints_handler_t )(const char *, int)

Functions
static struct queue_elem *	queue_pattern (rtx, struct queue_elem **, const char , int)
static void	remove_constraints (rtx)
static void	process_rtx (rtx, int)
static int	is_predicable (struct queue_elem *)
static void	identify_predicable_attribute (void)
static int	n_alternatives (const char *)
static void	collect_insn_data (rtx, int , int )
static rtx	alter_predicate_for_insn (rtx, int, int, int)
static const char *	alter_test_for_insn (struct queue_elem , struct queue_elem )
static char *	shift_output_template (char , const char , int)
static const char *	alter_output_for_insn (struct queue_elem , struct queue_elem , int, int)
static void	process_one_cond_exec (struct queue_elem *)
static void	process_define_cond_exec (void)
static void	init_predicate_table (void)
static void	record_insn_name (int, const char *)
static bool	has_subst_attribute (struct queue_elem , struct queue_elem )
static bool	subst_pattern_match (rtx, rtx, int)
static int	get_alternatives_number (rtx, int *, int)
static const char *	alter_output_for_subst_insn (rtx, int)
static void	alter_attrs_for_subst_insn (struct queue_elem *, int)
static void	process_substs_on_one_elem (struct queue_elem , struct queue_elem )
static rtx	subst_dup (rtx, int, int)
static void	process_define_subst (void)
static const char *	duplicate_alternatives (const char *, int)
static const char *	duplicate_each_alternative (const char *str, int n_dup)
static rtx	alter_constraints (rtx, int, constraints_handler_t)
static rtx	adjust_operands_numbers (rtx)
static rtx	replace_duplicating_operands_in_pattern (rtx)
rtx	gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED(mode), HOST_WIDE_INT arg)
static void	compute_predicate_codes ()
static bool	valid_predicate_name_p ()
static void	process_define_predicate ()
static void	remove_from_queue ()
static void	add_define_attr ()
static void	remove_constraints ()
static void	process_rtx ()
static int	is_predicable ()
static void	change_subst_attribute (struct queue_elem elem, struct queue_elem subst_elem, const char *new_value)
static bool	has_subst_attribute ()
static bool	subst_pattern_match ()
static int	n_alternatives ()
static int	get_alternatives_number ()
static void	collect_insn_data ()
static rtx	alter_predicate_for_insn ()
static rtx	alter_constraints ()
static rtx	modify_attr_enabled_ce ()
static void	alter_attrs_for_insn ()
static void	alter_attrs_for_subst_insn ()
static char *	shift_output_template ()
static const char *	duplicate_alternatives ()
static const char *	duplicate_each_alternative ()
static const char *	alter_output_for_subst_insn ()
static void	process_one_cond_exec ()
static void	mark_operands_from_match_dup ()
static void	mark_operands_used_in_match_dup ()
static int	find_first_unused_number_of_operand ()
static void	renumerate_operands_in_pattern ()
static rtx	adjust_operands_numbers ()
static rtx	generate_match_dup ()
static rtx	replace_duplicating_operands_in_pattern ()
static rtx	subst_dup ()
static void	rtx_handle_directive ()
static int	htab_eq_string ()
static void	add_mnemonic_string ()
static void	gen_mnemonic_setattr ()
static int	mnemonic_htab_callback ()
static void	gen_mnemonic_attr ()
static void	check_define_attr_duplicates ()
bool	init_rtx_reader_args_cb (int argc, char *argv, bool(parse_opt)(const char *))
bool	init_rtx_reader_args ()
rtx	read_md_rtx ()
hashval_t	hash_c_test ()
int	cmp_c_test ()
int	maybe_eval_c_test ()
void	add_c_test ()
void	traverse_c_tests ()
static hashval_t	hash_struct_pred_data ()
static int	eq_struct_pred_data ()
struct pred_data *	lookup_predicate ()
void	add_predicate_code ()
void	add_predicate ()
const char *	get_insn_name ()
static void	record_insn_name ()
static void	get_pattern_stats_1 ()
void	get_pattern_stats ()

Variables
static rtx	operand_data [MAX_OPERANDS]
static rtx	match_operand_entries_in_pattern [MAX_OPERANDS]
static char	used_operands_numbers [MAX_OPERANDS]
int	target_flags
int	insn_elision = 1
static struct obstack	obstack
struct obstack *	rtl_obstack = &obstack
static int	sequence_num
static int	predicable_default
static const char *	predicable_true
static const char *	predicable_false
static const char *	subst_true = "yes"
static const char *	subst_false = "no"
static htab_t	condition_table
static struct queue_elem *	define_attr_queue
static struct queue_elem **	define_attr_tail = &define_attr_queue
static struct queue_elem *	define_pred_queue
static struct queue_elem **	define_pred_tail = &define_pred_queue
static struct queue_elem *	define_insn_queue
static struct queue_elem **	define_insn_tail = &define_insn_queue
static struct queue_elem *	define_cond_exec_queue
static struct queue_elem **	define_cond_exec_tail = &define_cond_exec_queue
static struct queue_elem *	define_subst_queue
static struct queue_elem **	define_subst_tail = &define_subst_queue
static struct queue_elem *	other_queue
static struct queue_elem **	other_tail = &other_queue
static struct queue_elem *	define_subst_attr_queue
static struct queue_elem **	define_subst_attr_tail = &define_subst_attr_queue
static char	did_you_mean_codes [NUM_RTX_CODE]
static htab_t	predicate_table
struct pred_data *	first_predicate
static struct pred_data **	last_predicate = &first_predicate
static struct std_pred_table	std_preds []
static char **	insn_name_ptr = 0
static int	insn_name_ptr_size = 0

Typedef Documentation

typedef const char*(* constraints_handler_t)(const char *, int)

Function Documentation

void add_c_test ( )

Record the C test expression EXPR in the condition_table, with
   value VAL.  Duplicates clobber previous entries.

References condition_table, c_test::expr, and c_test::value.

Referenced by main(), and read_conditions().

static void add_define_attr ( )

static

Build a define_attr for an binary attribute with name NAME and
   possible values "yes" and "no", and queue it.

References queue_elem::data, define_attr_queue, queue_elem::filename, queue_elem::lineno, and queue_elem::next.

Referenced by alter_attrs_for_insn().

static void add_mnemonic_string ( )

static

Add mnemonic STR with length LEN to the mnemonic hash table
   MNEMONIC_HTAB.  A trailing zero end character is appendend to STR
   and a permanent heap copy of STR is created.

References len, and memcpy().

Referenced by gen_mnemonic_attr(), and gen_mnemonic_setattr().

void add_predicate ( )

References error(), pred_data::name, and pred_data::next.

Referenced by init_predicate_table(), and process_define_predicate().

void add_predicate_code ( )

Record that predicate PRED can accept CODE.

References pred_data::allows_non_const, pred_data::allows_non_lvalue, pred_data::codes, pred_data::num_codes, RTX_CONST_OBJ, and pred_data::singleton.

Referenced by init_predicate_table(), and process_define_predicate().

static rtx adjust_operands_numbers ( rtx )

static

Referenced by process_substs_on_one_elem().

static rtx adjust_operands_numbers ( )

static

If output pattern of define_subst contains MATCH_DUP, then this
   expression would be replaced with the pattern, matched with
   MATCH_OPERAND from input pattern.  This pattern could contain any
   number of MATCH_OPERANDs, MATCH_OPERATORs etc., so it's possible
   that a MATCH_OPERAND from output_pattern (if any) would have the
   same number, as MATCH_OPERAND from copied pattern.  To avoid such
   indexes overlapping, we assign new indexes to MATCH_OPERANDs,
   laying in the output pattern outside of MATCH_DUPs.

References mark_operands_used_in_match_dup(), and renumerate_operands_in_pattern().

static void alter_attrs_for_insn ( )

static

Alter the attribute vector of INSN, which is a COND_EXEC variant created
   from a define_insn pattern.  We must modify the "predicable" attribute
   to be named "ce_enabled", and also change any "enabled" attribute that's
   present so that it takes ce_enabled into account.
   We rely on the fact that INSN was created with copy_rtx, and modify data
   in-place.

References add_define_attr(), queue_elem::data, modify_attr_enabled_ce(), queue_elem::next, rtvec_alloc(), and SET.

Referenced by process_one_cond_exec().

static void alter_attrs_for_subst_insn	(	struct queue_elem *	,
		int
	)

static

Referenced by process_substs_on_one_elem().

static void alter_attrs_for_subst_insn ( )

static

As number of constraints is changed after define_subst, we need to
   process attributes as well - we need to duplicate them the same way
   that we duplicated constraints in original pattern
   ELEM is a queue element, containing our rtl-template,
   N_DUP - multiplication factor.

References queue_elem::data, duplicate_alternatives(), error_with_line(), queue_elem::lineno, and SET.

static rtx alter_constraints	(	rtx	,
		int	,
		constraints_handler_t
	)

static

Referenced by alter_constraints(), process_substs_on_one_elem(), and subst_dup().

static rtx alter_constraints ( )

static

Duplicate constraints in PATTERN.  If pattern is from original
   rtl-template, we need to duplicate each alternative - for that we
   need to use duplicate_each_alternative () as a functor ALTER.
   If pattern is from output-pattern of define_subst, we need to
   duplicate constraints in another way - with duplicate_alternatives ().
   N_DUP is multiplication factor.

References alter_constraints(), and len.

static const char * alter_output_for_insn	(	struct queue_elem *	ce_elem,
		struct queue_elem *	insn_elem,
		int	alt,
		int	max_op
	)

static

References queue_elem::data, len, memcpy(), shift_output_template(), and strlen().

Referenced by process_one_cond_exec().

static const char* alter_output_for_subst_insn	(	rtx	,
		int
	)

static

Referenced by process_substs_on_one_elem().

static const char* alter_output_for_subst_insn ( )

static

Alter the output of INSN whose pattern was modified by
   DEFINE_SUBST.  We must replicate output strings according
   to the new number of alternatives ALT in substituted pattern.
   If ALT equals 1, output has one alternative or defined by C
   code, then output is returned without any changes.

References memcpy(), and strlen().

static rtx alter_predicate_for_insn	(	rtx	,
		int	,
		int	,
		int
	)

static

Referenced by alter_predicate_for_insn(), and process_one_cond_exec().

static rtx alter_predicate_for_insn ( )

static

References alter_predicate_for_insn(), error_with_line(), len, memcpy(), n_alternatives(), and strlen().

static const char * alter_test_for_insn	(	struct queue_elem *	ce_elem,
		struct queue_elem *	insn_elem
	)

static

References queue_elem::data, and join_c_conditions().

Referenced by process_one_cond_exec().

static void change_subst_attribute	(	struct queue_elem *	elem,
		struct queue_elem *	subst_elem,
		const char *	new_value
	)

static

Find attribute SUBST in ELEM and assign NEW_VALUE to it.

References queue_elem::data.

Referenced by process_substs_on_one_elem().

static void check_define_attr_duplicates ( )

static

Check if there are DEFINE_ATTRs with the same name.

References queue_elem::data, error_with_line(), htab_eq_string(), queue_elem::lineno, and queue_elem::next.

Referenced by init_rtx_reader_args_cb().

int cmp_c_test ( )

Compare two c_test expression structures.

References c_test::expr.

Referenced by init_rtx_reader_args_cb().

static void collect_insn_data	(	rtx	,
		int *	,
		int *
	)

static

Referenced by collect_insn_data(), and process_one_cond_exec().

static void collect_insn_data ( )

static

Determine how many alternatives there are in INSN, and how many
   operands.

References collect_insn_data(), len, and n_alternatives().

static void compute_predicate_codes ( )

static

Recursively calculate the set of rtx codes accepted by the
   predicate expression EXP, writing the result to CODES.  LINENO is
   the line number on which the directive containing EXP appeared.

References pred_data::codes, error_with_line(), lookup_predicate(), memset(), message_with_line(), NUM_RTX_CODE, and scan_comma_elt().

Referenced by process_define_predicate().

static const char* duplicate_alternatives	(	const char *	,
		int
	)

static

Referenced by alter_attrs_for_subst_insn(), and subst_dup().

static const char* duplicate_alternatives ( )

static

From string STR "a,b,c" produce "a,b,c,a,b,c,a,b,c", i.e. original
   string, duplicated N_DUP times.

References len, memcpy(), and strlen().

static const char* duplicate_each_alternative	(	const char *	str,
		int	n_dup
	)

static

Referenced by process_substs_on_one_elem().

static const char* duplicate_each_alternative ( )

static

From string STR "a,b,c" produce "a,a,a,b,b,b,c,c,c", i.e. string where
   each alternative from the original string is duplicated N_DUP times.

References len, memcpy(), and strlen().

static int eq_struct_pred_data ( )

static

References pred_data::name.

Referenced by init_predicate_table().

static int find_first_unused_number_of_operand ( )

static

This is subroutine of renumerate_operands_in_pattern.
   It finds first not-occupied operand-index.

References used_operands_numbers.

Referenced by renumerate_operands_in_pattern().

static void gen_mnemonic_attr ( )

static

Generate (set_attr "mnemonic" "..") RTXs and append them to every
   insn definition in case the back end requests it by defining the
   mnemonic attribute.  The values for the attribute will be extracted
   from the output patterns of the insn definitions as far as
   possible.

References add_mnemonic_string(), queue_elem::data, define_attr_tail, free(), gen_mnemonic_setattr(), have_error, htab_eq_string(), mnemonic_htab_callback(), queue_elem::next, scan_comma_elt(), and string_obstack.

Referenced by init_rtx_reader_args_cb().

static void gen_mnemonic_setattr ( )

static

Scan INSN for mnemonic strings and add them to the mnemonic hash
   table in MNEMONIC_HTAB.

   The mnemonics cannot be found if they are emitted using C code.

   If a mnemonic string contains ';' or a newline the string assumed
   to consist of more than a single instruction.  The attribute value
   will then be set to the user defined default value.

References add_mnemonic_string(), rtvec_alloc(), string_obstack, and strlen().

Referenced by gen_mnemonic_attr().

rtx gen_rtx_CONST_INT	(	enum machine_mode	ARG_UNUSEDmode,
		HOST_WIDE_INT	arg
	)

Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
   the gensupport programs.

static rtx generate_match_dup ( )

static

Generate RTL expression
   (match_dup OPNO)

Referenced by replace_duplicating_operands_in_pattern().

static int get_alternatives_number	(	rtx	,
		int *	,
		int
	)

static

Referenced by get_alternatives_number(), and process_substs_on_one_elem().

static int get_alternatives_number ( )

static

The routine scans rtl PATTERN, find match_operand in it and counts
   number of alternatives.  If PATTERN contains several match_operands
   with different number of alternatives, error is emitted, and the
   routine returns 0.  If all match_operands in PATTERN have the same
   number of alternatives, it's stored in N_ALT, and the routine returns 1.
   Argument LINENO is used in when the error is emitted.

References error_with_line(), get_alternatives_number(), len, and n_alternatives().

const char* get_insn_name ( )

Referenced by curr_insn_transform(), main(), merge_accept_insn(), print_rtx(), and write_action().

void get_pattern_stats ( )

Make STATS describe the operands that appear in instruction pattern
   PATTERN.

References get_pattern_stats_1(), len, pattern_stats::max_dup_opno, pattern_stats::max_opno, pattern_stats::max_scratch_opno, pattern_stats::num_dups, pattern_stats::num_generator_args, pattern_stats::num_insn_operands, and pattern_stats::num_operand_vars.

Referenced by gen_expand(), gen_insn(), gen_peephole(), and gen_split().

static void get_pattern_stats_1 ( )

static

Make STATS describe the operands that appear in rtx X.

References len, pattern_stats::max_dup_opno, pattern_stats::max_opno, pattern_stats::max_scratch_opno, and pattern_stats::num_dups.

Referenced by get_pattern_stats().

static bool has_subst_attribute	(	struct queue_elem *	,
		struct queue_elem *
	)

static

Referenced by process_substs_on_one_elem().

static bool has_subst_attribute ( )

static

Return true if ELEM has the attribute with the name of DEFINE_SUBST
   represented by SUBST_ELEM and this attribute has value SUBST_TRUE.
   DEFINE_SUBST isn't applied to patterns without such attribute.  In other
   words, we suppose the default value of the attribute to be 'no' since it is
   always generated automaticaly in read-rtl.c.

References queue_elem::data, error_with_line(), queue_elem::lineno, SET, subst_false, and subst_true.

hashval_t hash_c_test ( )

Helper functions for insn elision.

Compute a hash function of a c_test structure, which is keyed
   by its ->expr field.

References c_test::expr, and len.

Referenced by init_rtx_reader_args_cb().

static hashval_t hash_struct_pred_data ( )

static

References pred_data::name.

Referenced by init_predicate_table().

static int htab_eq_string ( )

static

Comparison function for the mnemonic hash table.

Referenced by check_define_attr_duplicates(), and gen_mnemonic_attr().

static void identify_predicable_attribute ( )

static

Examine the attribute "predicable"; discover its boolean values
   and its default.

References queue_elem::data, error_with_line(), free(), queue_elem::lineno, queue_elem::next, predicable_default, predicable_false, and predicable_true.

Referenced by process_define_cond_exec().

static void init_predicate_table ( )

static

Initialize the table of predicate definitions, starting with
   the information we have on generic predicates.

References add_predicate(), add_predicate_code(), pred_data::codes, std_pred_table::codes, eq_struct_pred_data(), free(), hash_struct_pred_data(), pred_data::name, std_pred_table::name, NUM_RTX_CODE, RTX_CONST_OBJ, pred_data::special, and std_pred_table::special.

Referenced by init_rtx_reader_args_cb().

bool init_rtx_reader_args ( )

Programs that don't have their own options can use this entry point
   instead.

References init_rtx_reader_args_cb().

Referenced by main().

bool init_rtx_reader_args_cb	(	int	argc,
		char **	argv,
		bool()(const char )	parse_opt
	)

The entry point for initializing the reader.

References check_define_attr_duplicates(), cmp_c_test(), condition_table, gen_mnemonic_attr(), hash_c_test(), have_error, init_predicate_table(), process_define_cond_exec(), process_define_subst(), read_md_files(), rtl_obstack, rtx_handle_directive(), and sequence_num.

Referenced by init_rtx_reader_args(), and main().

static int is_predicable ( struct queue_elem * )

static

Referenced by process_one_cond_exec().

static int is_predicable ( )

static

Return true if attribute PREDICABLE is true for ELEM, which holds
   a DEFINE_INSN.

References queue_elem::data, error_with_line(), queue_elem::lineno, predicable_default, predicable_false, predicable_true, and SET.

struct pred_data* lookup_predicate ( )

read

References pred_data::name.

Referenced by add_to_sequence(), compute_predicate_codes(), mark_mode_tests(), output_operand_data(), subst_pattern_match(), and validate_pattern().

static void mark_operands_from_match_dup ( )

static

This is a subroutine of mark_operands_used_in_match_dup.
   This routine is marks all MATCH_OPERANDs inside PATTERN as occupied.

References len, and used_operands_numbers.

Referenced by mark_operands_used_in_match_dup().

static void mark_operands_used_in_match_dup ( )

static

This is a subroutine of adjust_operands_numbers.
   It goes through all expressions in PATTERN and when MATCH_DUP is
   met, all MATCH_OPERANDs inside it is marked as occupied.  The
   process of marking is done by routin mark_operands_from_match_dup.

References len, and mark_operands_from_match_dup().

Referenced by adjust_operands_numbers().

int maybe_eval_c_test ( )

Given a string representing a C test expression, look it up in the
   condition_table and report whether or not its value is known
   at compile time.  Returns a tristate: 1 for known true, 0 for
   known false, -1 for unknown.

References condition_table, c_test::expr, and c_test::value.

Referenced by gen_insn(), gen_proto(), make_insn_sequence(), and read_md_rtx().

static int mnemonic_htab_callback ( )

static

This function is called for the elements in the mnemonic hashtable
   and generates a comma separated list of the mnemonics.

References string_obstack, and strlen().

Referenced by gen_mnemonic_attr().

static rtx modify_attr_enabled_ce ( )

static

Modify VAL, which is an attribute expression for the "enabled" attribute,
   to take "ce_enabled" into account.  Return the new expression.

Referenced by alter_attrs_for_insn().

static int n_alternatives ( const char * )

static

Referenced by alter_predicate_for_insn(), collect_insn_data(), curr_insn_transform(), find_reloads(), get_alternatives_number(), lra_set_insn_recog_data(), output_asm_name(), and process_alt_operands().

static int n_alternatives ( )

static

Return the number of alternatives in constraint S.

static void process_define_cond_exec ( )

static

If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
   patterns appropriately.

References have_error, identify_predicable_attribute(), queue_elem::next, and process_one_cond_exec().

Referenced by init_rtx_reader_args_cb().

static void process_define_predicate ( )

static

Process define_predicate directive DESC, which appears on line number
   LINENO.  Compute the set of codes that can be matched, and record this
   as a known predicate.

References add_predicate(), add_predicate_code(), pred_data::c_block, pred_data::codes, compute_predicate_codes(), error_with_line(), pred_data::exp, pred_data::name, NUM_RTX_CODE, pred_data::special, and valid_predicate_name_p().

Referenced by process_rtx().

static void process_define_subst ( )

static

If we have any DEFINE_SUBST patterns, expand DEFINE_INSN and
   DEFINE_EXPAND patterns appropriately.

References queue_elem::data, error_with_line(), queue_elem::lineno, queue_elem::next, and process_substs_on_one_elem().

Referenced by init_rtx_reader_args_cb().

static void process_one_cond_exec ( struct queue_elem * )

static

Referenced by process_define_cond_exec().

static void process_one_cond_exec ( )

static

Replicate insns as appropriate for the given DEFINE_COND_EXEC.

References alter_attrs_for_insn(), alter_output_for_insn(), alter_predicate_for_insn(), alter_test_for_insn(), collect_insn_data(), copy_rtx(), queue_elem::data, error_with_line(), queue_elem::filename, is_predicable(), queue_elem::lineno, queue_elem::next, queue_pattern(), read_md_filename, rtvec_alloc(), queue_elem::split, and strlen().

static void process_rtx	(	rtx	,
		int
	)

static

Referenced by rtx_handle_directive().

static void process_rtx ( )

static

Process a top level rtx in some way, queuing as appropriate.

References copy_md_ptr_loc(), copy_rtx(), join_c_conditions(), process_define_predicate(), queue_pattern(), read_md_filename, remove_constraints(), rtvec_alloc(), and queue_elem::split.

static void process_substs_on_one_elem	(	struct queue_elem *	elem,
		struct queue_elem *	queue
	)

static

Try to apply define_substs to the given ELEM.
   Only define_substs, specified via attributes would be applied.
   If attribute, requiring define_subst, is set, but no define_subst
   was applied, ELEM would be deleted.

References adjust_operands_numbers(), alter_attrs_for_subst_insn(), alter_constraints(), alter_output_for_subst_insn(), change_subst_attribute(), copy_rtx(), queue_elem::data, duplicate_each_alternative(), get_alternatives_number(), has_subst_attribute(), join_c_conditions(), queue_elem::lineno, match_operand_entries_in_pattern, memset(), queue_elem::next, remove_constraints(), remove_from_queue(), replace_duplicating_operands_in_pattern(), rtvec_alloc(), subst_dup(), subst_false, subst_pattern_match(), and used_operands_numbers.

Referenced by process_define_subst().

static struct queue_elem * queue_pattern	(	rtx	pattern,
		struct queue_elem ***	list_tail,
		const char *	filename,
		int	lineno
	)

staticread

Queue PATTERN on LIST_TAIL.  Return the address of the new queue
   element.

References queue_elem::data, queue_elem::filename, queue_elem::lineno, queue_elem::next, and queue_elem::split.

Referenced by process_one_cond_exec(), and process_rtx().

rtx read_md_rtx ( )

The entry point for reading a single rtx from an md file.  Return
   the rtx, or NULL if the md file has been fully processed.
   Return the line where the rtx was found in LINENO.
   Return the number of code generating rtx'en read since the start
   of the md file in SEQNR.

References queue_elem::data, define_attr_queue, define_insn_queue, define_pred_queue, queue_elem::filename, free(), insn_elision, queue_elem::lineno, maybe_eval_c_test(), queue_elem::next, other_queue, queue, read_md_filename, record_insn_name(), and sequence_num.

Referenced by main().

static void record_insn_name	(	int	,
		const char *
	)

static

Referenced by read_md_rtx().

static void record_insn_name ( )

static

References memset(), and strlen().

static void remove_constraints ( rtx )

static

Referenced by process_rtx(), process_substs_on_one_elem(), and remove_constraints().

static void remove_constraints ( )

static

Recursively remove constraints from an rtx.

References remove_constraints().

static void remove_from_queue ( )

static

Remove element ELEM from QUEUE.

References queue_elem::next.

Referenced by process_substs_on_one_elem().

static void renumerate_operands_in_pattern ( )

static

This is subroutine of adjust_operands_numbers.
   It visits all expressions in PATTERN and assigns not-occupied
   operand indexes to MATCH_OPERANDs and MATCH_OPERATORs of this
   PATTERN.

References find_first_unused_number_of_operand(), len, and used_operands_numbers.

Referenced by adjust_operands_numbers().

static rtx replace_duplicating_operands_in_pattern ( rtx )

static

Referenced by process_substs_on_one_elem(), and replace_duplicating_operands_in_pattern().

static rtx replace_duplicating_operands_in_pattern ( )

static

This routine checks all match_operands in PATTERN and if some of
   have the same index, it replaces all of them except the first one  to
   match_dup.
   Usually, match_operands with the same indexes are forbidden, but
   after define_subst copy an RTL-expression from original template,
   indexes of existed and just-copied match_operands could coincide.
   To fix it, we replace one of them with match_dup.

References error(), generate_match_dup(), len, match_operand_entries_in_pattern, and replace_duplicating_operands_in_pattern().

static void rtx_handle_directive ( )

static

A read_md_files callback for reading an rtx.

References queue_elem::lineno, process_rtx(), queue, and read_rtx().

Referenced by init_rtx_reader_args_cb().

static char* shift_output_template	(	char *	,
		const char *	,
		int
	)

static

Referenced by alter_output_for_insn().

static char* shift_output_template ( )

static

Adjust all of the operand numbers in SRC to match the shift they'll
   get from an operand displacement of DISP.  Return a pointer after the
   adjusted string.

static rtx subst_dup	(	rtx	,
		int	,
		int
	)

static

Referenced by process_substs_on_one_elem(), and subst_dup().

static rtx subst_dup ( )

static

The routine modifies given input PATTERN of define_subst, replacing
   MATCH_DUP and MATCH_OP_DUP with operands from define_insn original
   pattern, whose operands are stored in OPERAND_DATA array.
   It also duplicates constraints in operands - constraints from
   define_insn operands are duplicated N_SUBST_ALT times, constraints
   from define_subst operands are duplicated N_ALT times.
   After the duplication, returned output rtl-pattern contains every
   combination of input constraints Vs constraints from define_subst
   output.

References alter_constraints(), copy_rtx(), duplicate_alternatives(), len, and subst_dup().

static bool subst_pattern_match	(	rtx	,
		rtx	,
		int
	)

static

Referenced by process_substs_on_one_elem(), and subst_pattern_match().

static bool subst_pattern_match ( )

static

Compare RTL-template of original define_insn X to input RTL-template of
   define_subst PT.  Return 1 if the templates match, 0 otherwise.
   During the comparison, the routine also fills global_array OPERAND_DATA.

References error_with_line(), len, lookup_predicate(), and subst_pattern_match().

void traverse_c_tests ( )

For every C test, call CALLBACK with two arguments: a pointer to
   the condition structure and INFO.  Stops when CALLBACK returns zero.

References condition_table.

Referenced by write_conditions().

static bool valid_predicate_name_p ( )

static

Return true if NAME is a valid predicate name.

Referenced by process_define_predicate().

Variable Documentation

htab_t condition_table

static

Referenced by add_c_test(), init_rtx_reader_args_cb(), maybe_eval_c_test(), and traverse_c_tests().

struct queue_elem* define_attr_queue

static

Referenced by add_define_attr(), and read_md_rtx().

struct queue_elem** define_attr_tail = &define_attr_queue

static

Referenced by gen_mnemonic_attr().

struct queue_elem* define_cond_exec_queue

static

struct queue_elem** define_cond_exec_tail = &define_cond_exec_queue

static

struct queue_elem* define_insn_queue

static

Referenced by read_md_rtx().

struct queue_elem** define_insn_tail = &define_insn_queue

static

struct queue_elem* define_pred_queue

static

Referenced by read_md_rtx().

struct queue_elem** define_pred_tail = &define_pred_queue

static

struct queue_elem* define_subst_attr_queue

static

struct queue_elem** define_subst_attr_tail = &define_subst_attr_queue

static

struct queue_elem* define_subst_queue

static

struct queue_elem** define_subst_tail = &define_subst_queue

static

char did_you_mean_codes[NUM_RTX_CODE]

static

0 means no warning about that code yet, 1 means warned.

struct pred_data* first_predicate

int insn_elision = 1

Set this to 0 to disable automatic elision of insn patterns which
   can never be used in this configuration.  See genconditions.c.
   Must be set before calling init_md_reader.

Referenced by main(), and read_md_rtx().

char** insn_name_ptr = 0

static

These functions allow linkage with print-rtl.c.  Also, some generators
   like to annotate their output with insn names.

Holds an array of names indexed by insn_code_number.

int insn_name_ptr_size = 0

static

struct pred_data** last_predicate = &first_predicate

static

rtx match_operand_entries_in_pattern[MAX_OPERANDS]

static

Referenced by process_substs_on_one_elem(), and replace_duplicating_operands_in_pattern().

struct obstack obstack

static

rtx operand_data[MAX_OPERANDS]

static

struct queue_elem* other_queue

static

Referenced by read_md_rtx().

struct queue_elem** other_tail = &other_queue

static

int predicable_default

static

Referenced by identify_predicable_attribute(), and is_predicable().

const char* predicable_false

static

Referenced by identify_predicable_attribute(), and is_predicable().

const char* predicable_true

static

Referenced by identify_predicable_attribute(), and is_predicable().

htab_t predicate_table

static

Helper functions for define_predicate and define_special_predicate
   processing.  Shared between genrecog.c and genpreds.c.

struct obstack* rtl_obstack = &obstack

Referenced by add_constraint(), attr_rtx_1(), init_rtx_reader_args_cb(), mangle(), optimize_attrs(), simplify_cond(), simplify_test_exp_in_temp(), and write_predicate_subfunction().

int sequence_num

static

Counter for patterns that generate code: define_insn, define_expand,
   define_split, define_peephole, and define_peephole2.  See read_md_rtx().
   Any define_insn_and_splits are already in separate queues so that the
   insn and the splitter get a unique number also.

Referenced by init_rtx_reader_args_cb(), and read_md_rtx().

struct std_pred_table std_preds[]

static

Initial value:

 {
  {"general_operand", false, true, {SUBREG, REG, MEM}},
  {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}},
  {"register_operand", false, false, {SUBREG, REG}},
  {"pmode_register_operand", true, false, {SUBREG, REG}},
  {"scratch_operand", false, false, {SCRATCH, REG}},
  {"immediate_operand", false, true, {UNKNOWN}},
  {"const_int_operand", false, false, {CONST_INT}},
  {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}},
  {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}},
  {"nonmemory_operand", false, true, {SUBREG, REG}},
  {"push_operand", false, false, {MEM}},
  {"pop_operand", false, false, {MEM}},
  {"memory_operand", false, false, {SUBREG, MEM}},
  {"indirect_operand", false, false, {SUBREG, MEM}},
  {"ordered_comparison_operator", false, false, {EQ, NE,
                                                 LE, LT, GE, GT,
                                                 LEU, LTU, GEU, GTU}},
  {"comparison_operator", false, false, {EQ, NE,
                                         LE, LT, GE, GT,
                                         LEU, LTU, GEU, GTU,
                                         UNORDERED, ORDERED,
                                         UNEQ, UNGE, UNGT,
                                         UNLE, UNLT, LTGT}}
}

const char* subst_false = "no"

static

Referenced by has_subst_attribute(), and process_substs_on_one_elem().

const char* subst_true = "yes"

static

Referenced by has_subst_attribute().

int target_flags

In case some macros used by files we include need it, define this here.

Referenced by default_get_pch_validity(), default_pch_valid_p(), and option_affects_pch_p().

char used_operands_numbers[MAX_OPERANDS]

static

Referenced by find_first_unused_number_of_operand(), mark_operands_from_match_dup(), process_substs_on_one_elem(), and renumerate_operands_in_pattern().

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation