GCC Middle and Back End API Reference
genattrtab.c File Reference

Data Structures

struct  insn_def
struct  insn_ent
struct  attr_value
struct  attr_desc
struct  delay_desc
struct  attr_value_list
struct  attr_hash
struct  insn_reserv
struct  bypass_list


static char * attr_string (const char *, int)
static char * attr_printf (unsigned int, const char *,...) ATTRIBUTE_PRINTF_2
static rtx make_numeric_value (int)
static struct attr_descfind_attr (const char **, int)
static rtx mk_attr_alt (int)
static char * next_comma_elt (const char **)
static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int)
static rtx copy_boolean (rtx)
static int compares_alternatives_p (rtx)
static void make_internal_attr (const char *, rtx, int)
static void insert_insn_ent (struct attr_value *, struct insn_ent *)
static void walk_attr_value (rtx)
static int max_attr_value (rtx, int *)
static int min_attr_value (rtx, int *)
static int or_attr_value (rtx, int *)
static rtx simplify_test_exp (rtx, int, int)
static rtx simplify_test_exp_in_temp (rtx, int, int)
static rtx copy_rtx_unchanging (rtx)
static bool attr_alt_subset_p (rtx, rtx)
static bool attr_alt_subset_of_compl_p (rtx, rtx)
static void clear_struct_flag (rtx)
static void write_attr_valueq (FILE *, struct attr_desc *, const char *)
static struct attr_valuefind_most_used (struct attr_desc *)
static void write_attr_set (FILE *, struct attr_desc *, int, rtx, const char *, const char *, rtx, int, int, unsigned int)
static void write_attr_case (FILE *, struct attr_desc *, struct attr_value *, int, const char *, const char *, int, rtx)
static void write_attr_value (FILE *, struct attr_desc *, rtx)
static void write_upcase (FILE *, const char *)
static void write_indent (FILE *, int)
static rtx identity_fn (rtx)
static rtx zero_fn (rtx)
static rtx one_fn (rtx)
static rtx max_fn (rtx)
static rtx min_fn (rtx)
static void attr_hash_add_rtx ()
static void attr_hash_add_string ()
static rtx attr_rtx_1 ()
static rtx attr_rtx ()
static char * attr_printf ()
static rtx attr_eq ()
static const char * attr_numeral ()
static char * attr_string ()
static int attr_equal_p ()
static rtx attr_copy_rtx ()
static rtx check_attr_test ()
static rtx check_attr_value ()
static rtx convert_set_attr_alternative ()
static rtx convert_set_attr ()
static void check_defs ()
static rtx make_canonical ()
static rtx copy_boolean ()
static struct attr_valueget_attr_value ()
static void expand_delays ()
static void fill_attr ()
static rtx substitute_address (rtx exp, rtx(*no_address_fn)(rtx), rtx(*address_fn)(rtx))
static void make_length_attrs ()
static rtx identity_fn ()
static rtx zero_fn ()
static rtx one_fn ()
static rtx max_fn ()
static rtx min_fn ()
static void write_length_unit_log ()
static int attr_rtx_cost ()
static rtx simplify_cond ()
static void remove_insn_ent ()
static void insert_insn_ent ()
static rtx insert_right_side ()
static int compute_alternative_mask ()
static rtx make_alternative_compare ()
static rtx evaluate_eq_attr (rtx exp, struct attr_desc *attr, rtx value, int insn_code, int insn_index)
static rtx simplify_and_tree ()
static rtx simplify_or_tree ()
static rtx simplify_test_exp_in_temp ()
static bool attr_alt_subset_p ()
static bool attr_alt_subset_of_compl_p ()
static rtx attr_alt_intersection ()
static rtx attr_alt_union ()
static rtx attr_alt_complement ()
static rtx mk_attr_alt ()
static rtx simplify_test_exp ()
static int tests_attr_p ()
static int get_attr_order ()
static void optimize_attrs ()
static void clear_struct_flag ()
static void add_attr_value ()
static void gen_attr ()
static int count_alternatives ()
static int compares_alternatives_p ()
static void gen_insn ()
static void gen_delay ()
static void find_attrs_to_cache ()
static unsigned int write_test_expr ()
static int max_attr_value ()
static int min_attr_value ()
static int or_attr_value ()
static void walk_attr_value ()
static void write_attr_get ()
static rtx eliminate_known_true ()
static void write_insn_cases ()
static void write_attr_valueq ()
static void write_attr_value ()
static void write_upcase ()
static void write_indent ()
static void write_eligible_delay ()
static char * next_comma_elt ()
static struct attr_descfind_attr ()
static void make_internal_attr ()
static struct attr_valuefind_most_used ()
static rtx make_numeric_value ()
static rtx copy_rtx_unchanging ()
static void write_const_num_delay_slots ()
static void gen_insn_reserv ()
static void gen_bypass_1 ()
static void gen_bypass ()
static void process_bypasses ()
static bool check_tune_attr ()
static struct attr_descfind_tune_attr ()
static void make_automaton_attrs ()
static void write_header ()
static FILE * open_outfile ()
static bool handle_arg ()
int main ()


static struct obstack obstack1 obstack2
static struct obstackhash_obstack = &obstack1
static struct obstacktemp_obstack = &obstack2
static struct attr_descattrs [MAX_ATTRS_INDEX]
static struct insn_defdefs
static struct delay_descdelays
struct attr_value_list ** insn_code_values
static int insn_code_number
static int insn_index_number
static int got_define_asm_attributes
static int must_extract
static int must_constrain
static int address_used
static int length_used
static int num_delays
static int have_annul_true
static int have_annul_false
static int num_insn_ents
static int * insn_n_alternatives
static int * insn_alternatives
static rtx true_rtx
static rtx false_rtx
static const char * alternative_name
static const char * length_str
static const char * delay_type_str
static const char * delay_1_0_str
static const char * num_delay_slots_str
static const char * attr_file_name = NULL
static const char * dfa_file_name = NULL
static const char * latency_file_name = NULL
static FILE * attr_file
static FILE * dfa_file
static FILE * latency_file
static struct attr_hashattr_hash_table [RTL_HASH_SIZE]
static const char * cached_attrs [32]
static int cached_attr_count
static unsigned int attrs_seen_once
static unsigned int attrs_seen_more_than_once
static unsigned int attrs_to_cache
static unsigned int attrs_cached_inside
static unsigned int attrs_cached_after
static struct insn_reservall_insn_reservs = 0
static struct insn_reserv ** last_insn_reserv_p = &all_insn_reservs
static size_t n_insn_reservs
static struct bypass_listall_bypasses
static size_t n_bypasses

Function Documentation

static void add_attr_value ( )
   Add attribute value NAME to the beginning of ATTR's list.  

References count_alternatives(), insn_def::def, defs, exp(), insn_code_number, insn_index_number, insn_def::lineno, and insn_def::num_alternatives.

static rtx attr_alt_complement ( )
   Return EQ_ATTR_ALT expression representing complement of S.  

References compute_alternative_mask(), fatal(), and insn_alternatives.

static rtx attr_alt_intersection ( )
   Return EQ_ATTR_ALT expression representing intersection of S1 and S2.  
static bool attr_alt_subset_of_compl_p ( rtx  ,
static bool attr_alt_subset_of_compl_p ( )
   Returns true if S1 is a subset of complement of S2.  

References exp(), and false_rtx.

static bool attr_alt_subset_p ( rtx  ,
static bool attr_alt_subset_p ( )
   Returns true if S1 is a subset of S2.  
static rtx attr_alt_union ( )
   Return EQ_ATTR_ALT expression representing union of S1 and S2.  
static rtx attr_copy_rtx ( )
   Copy an attribute value expression,
   descending to all depths, but not copying any
   permanent hashed subexpressions.  
     No need to copy a permanent object.  

References rtvec_alloc().

Referenced by get_attr_order().

static rtx attr_eq ( )
static int attr_equal_p ( )
   Check two rtx's for equality of contents,
   taking advantage of the fact that if both are hashed
   then they can't be equal unless they are the same object.  
static void attr_hash_add_rtx ( )
   Add an entry to the hash table for RTL with hash code HASHCODE.  

References attr_hash::hashcode.

static void attr_hash_add_string ( )
   Add an entry to the hash table for STRING with hash code HASHCODE.  

References attr_hash::hashcode, HOST_WIDE_INT, attr_hash::next, attr_hash::rtl, and attr_hash::u.

static const char* attr_numeral ( )
static char* attr_printf ( unsigned  int,
const char *  ,
static char* attr_printf ( )
   Create a new string printed with the printf line arguments into a space
   of at most LEN bytes:

   rtx attr_printf (len, format, [arg1, ..., argn])  

References attr_hash::hashcode, len, and attr_hash::next.

static rtx attr_rtx ( )
static rtx attr_rtx_1 ( )
   Generate an RTL expression, but avoid duplicates.
   Set the ATTR_PERMANENT_P flag for these permanent objects.

   In some cases we cannot uniquify; then we return an ordinary
   impermanent rtx with ATTR_PERMANENT_P clear.

   Args are as follows:

   rtx attr_rtx (code, [element1, ..., elementn])  
     For each of several cases, search the hash table for an existing entry.
     Use that entry if one is found; otherwise create a new RTL and add it
     to the table.  
         A permanent object cannot point to impermanent ones.  
         A permanent object cannot point to impermanent ones.  

References hash_obstack, and rtl_obstack.

static int attr_rtx_cost ( )
   Compute approximate cost of the expression.  Used to decide whether
   expression is cheap enough for inline.  
         Alternatives don't result into function call.  

Referenced by get_attr_order(), and max_fn().

static char* attr_string ( const char *  ,
   Forward declarations of functions used before their definitions, only.  
static char* attr_string ( )
   Return a permanent (possibly shared) copy of a string STR (not assumed
   to be null terminated) with LEN bytes.  
     Compute the hash code.  
     Search the table for the string.  
     Not found; create a permanent copy and add it to the hash table.  

References rtx_equal_p().

static rtx check_attr_test ( )
   Given a test expression for an attribute, ensure it is validly formed.
   IS_CONST indicates whether the expression is constant for each compiler
   run (a constant expression may not test any particular insn).

   Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
   and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")).  Do the latter
   test first so that (eq_attr "att" "!a1,a2,a3") works as expected.

   Update the string address in EQ_ATTR expression to be the same used
   in the attribute (or `alternative_name') to speed up subsequent
   `find_attr' calls and eliminate most `strcmp' calls.

   Return the new expression, if any.  
         Handle negation test.  
             Copy this just to make it permanent,
             so expressions using it can be permanent too.  
             It shouldn't be possible to simplify the value given to a
             constant attribute, so don't expand this until it's time to
             write the test expression.  
                 Make an IOR tree of the possible values.  
         Either TRUE or FALSE.  
         These cases can't be simplified.  
         These cases can't be simplified.  
             These cases are valid for constant attributes, but can't be

References fatal().

static rtx check_attr_value ( )
   Given an expression, ensure that it is validly formed and that all named
   attribute values are valid for the given attribute.  Issue a fatal error
   if not.  If no attribute is specified, assume a numeric attribute.

   Return a perhaps modified replacement expression for the value.  
         Fall through.  
         A constant SYMBOL_REF is valid as a constant attribute test and
         is expanded later by make_canonical into a COND.  In a non-constant
         attribute test, it is left be.  

Referenced by check_defs().

static void check_defs ( )
   Scan all definitions, checking for validity.  Also, convert any SET_ATTR
   and SET_ATTR_ALTERNATIVE expressions to the corresponding SET

References check_attr_value(), copy_boolean(), attr_desc::default_val, fatal(), attr_desc::is_const, make_canonical(), make_numeric_value(), rtvec_alloc(), and attr_value::value.

static bool check_tune_attr ( )
   Check that attribute NAME is used in define_insn_reservation condition
   EXP.  Return true if it is.  

References insn_reserv::condexp, insn_reserv::default_latency, insn_reserv::insn_num, and make_numeric_value().

static void clear_struct_flag ( rtx  )

Referenced by get_attr_order(), and optimize_attrs().

static void clear_struct_flag ( )
   Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions.  
     Compare the elements.  If any pair of corresponding elements
     fail to match, return 0 for the whole things.  
static int compares_alternatives_p ( rtx  )
static int compares_alternatives_p ( )
   Returns nonzero if the given expression contains an EQ_ATTR with the
   `alternative' attribute.  
static int compute_alternative_mask ( )
   If we have an expression which AND's a bunch of
        (not (eq_attrq "alternative" "n"))
   terms, we may have covered all or all but one of the possible alternatives.
   If so, we can optimize.  Similarly for IOR's of EQ_ATTR.

   This routine is passed an expression and either AND or IOR.  It returns a
   bitmask indicating which alternatives are mentioned within EXP.  

References attr_rtx(), attr_desc::enum_name, and attr_desc::name.

Referenced by attr_alt_complement().

static rtx convert_set_attr ( )
   Given a SET_ATTR, convert to the appropriate SET.  If a comma-separated
   list of values is given, convert to SET_ATTR_ALTERNATIVE first.  
     See how many alternative specified.  
     Process each comma-separated name.  
static rtx convert_set_attr_alternative ( )
   Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
   It becomes a COND with each test being (eq_attr "alternative" "n") 
     Make a COND with all tests but the last.  Select the last value via the
static rtx copy_boolean ( rtx  )

Referenced by check_defs().

static rtx copy_boolean ( )
static rtx copy_rtx_unchanging ( rtx  )
static rtx copy_rtx_unchanging ( )
static int count_alternatives ( )
   Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
   alternatives in the constraints.  Assume all MATCH_OPERANDs have the same
   number of alternatives as this should be checked elsewhere.  

References alternative_name, cached_attr_count, find_attr(), and find_attrs_to_cache().

Referenced by add_attr_value().

static rtx eliminate_known_true ( )
   Given an AND tree of known true terms (because we are inside an `if' with
   that as the condition or are in an `else' clause) and an expression,
   replace any known true terms with TRUE.  Use `simplify_and_tree' to do
   the bulk of the work.  

Referenced by walk_attr_value().

static rtx evaluate_eq_attr ( rtx  exp,
struct attr_desc attr,
rtx  value,
int  insn_code,
int  insn_index 
   If we are processing an (eq_attr "attr" "value") test, we find the value
   of "attr" for this insn code.  From that value, we can compute a test
   showing when the EQ_ATTR will be true.  This routine performs that
   computation.  If a test condition involves an address, we leave the EQ_ATTR
   intact because addresses are only valid for the `length' attribute.

   EXP is the EQ_ATTR expression and ATTR is the attribute to which
   it refers.  VALUE is the value of that attribute for the insn
   corresponding to INSN_CODE and INSN_INDEX.  
         We construct an IOR of all the cases for which the
         requested attribute value is present.  Since we start with
         FALSE, if it is not present, FALSE will be returned.

         Each case is the AND of the NOT's of the previous conditions with the
         current condition; in the default case the current condition is TRUE.

         For each possible COND value, call ourselves recursively.

         The extra TRUE and FALSE expressions will be eliminated by another
         call to the simplification routine.  
             Add this condition into the AND expression.  
         Handle the default case.  
     If uses an address, must return original expression.  But set the
     ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again.  
static void expand_delays ( )
   After all DEFINE_DELAYs have been read in, create internal attributes
   to generate the required routines.

   First, we compute the number of delay slots for each insn (as a COND of
   each of the test expressions in DEFINE_DELAYs).  Then, if more than one
   delay type is specified, we compute a similar function giving the
   DEFINE_DELAY ordinal for each insn.

   Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
   tells whether a given insn can be in that delay slot.

   Normal attribute filling and optimization expands these to contain the
   information needed to handle delay slots.  
     First, generate data for `num_delay_slots' function.  
     If more than one delay type, do the same for computing the delay type.  
     For each delay possibility and delay slot, compute an eligibility
     attribute for non-annulled insns and for each type of annulled (annul
     if true and annul if false).  
static void fill_attr ( )
   Once all attributes and insns have been read and checked, we construct for
   each attribute value a list of all the insns that have that value for
   the attribute.  
     Don't fill constant attributes.  The value is independent of
     any particular insn.  
         If no value is specified for this insn for this attribute, use the
static struct attr_desc* find_attr ( const char **  ,
static struct attr_desc* find_attr ( )
   Return a `struct attr_desc' pointer for a given named attribute.  If CREATE
   is nonzero, build a new attribute, if one does not exist.  *NAME_P is
   replaced by a pointer to a canonical copy of the string.  
     Before we resort to using `strcmp', see if the string address matches
     anywhere.  In most cases, it should have been canonicalized to do so.  
     Otherwise, do it the slow way.  

References gen_bypass_1().

static void find_attrs_to_cache ( )
   Finds non-const attributes that could be possibly cached.
   When create is TRUE, fills in cached_attrs array.

Referenced by count_alternatives(), and walk_attr_value().

static struct attr_value* find_most_used ( struct attr_desc )
static struct attr_value* find_most_used ( )
   Find the most used value of an attribute.  
static struct attr_desc* find_tune_attr ( )
   Try to find a const attribute (usually cpu or tune) that is used
   in all define_insn_reservation conditions.  

References insn_reserv::condexp, and make_numeric_value().

static void gen_attr ( )
   Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR.  
     Make a new attribute structure.  Check for duplicate by looking at
     attr->default_val, since it is initialized by this routine.  
         Get rid of the CONST node.  It is allowed only at top-level.  
     Set up the default value.  
static void gen_bypass ( )
static void gen_bypass_1 ( )

Referenced by find_attr().

static void gen_delay ( )
   Process a DEFINE_DELAY.  Validate the vector length, check if annul
   true or annul false is specified, and make a `struct delay_desc'.  
static void gen_insn ( )

References comparison_operator(), and write_test_expr().

Referenced by main().

static void gen_insn_reserv ( )
   Store information from a DEFINE_INSN_RESERVATION for future
   attribute generation.  
static int get_attr_order ( )
   Calculate a topological sorting of all attributes so that
   all attributes only depend on attributes in front of it.
   Place the result in *RET (which is a pointer to an array of
   attr_desc pointers), and return the size of that array.  
     We have only few attributes hence we can live with the inner
     loop being O(n^2), unlike the normal fast variants of topological
               Let's see if I depends on anything interesting.  
                       Something in I depends on K.  
                   Nothing in I depended on anything intersting, so
                   it's done.  

References attr_value_list::attr, attr_copy_rtx(), attr_rtx_cost(), attr_value_list::av, clear_struct_flag(), insn_ent::def, get_attr_value(), attr_value_list::ie, insert_insn_ent(), insn_def::insn_code, insn_def::insn_index, attr_value_list::next, obstack, remove_insn_ent(), rtl_obstack, simplify_cond(), temp_obstack, and attr_value::value.

static struct attr_value* get_attr_value ( )
   Given a value and an attribute description, return a `struct attr_value *'
   that represents that value.  This is either an existing structure, if the
   value has been previously encountered, or a newly-created structure.

   `insn_code' is the code of an insn whose attribute has the specified
   value (-2 if not processing an insn).  We ensure that all insns for
   a given value have the same number of alternatives if the value checks

References delay_desc::def, and make_numeric_value().

Referenced by get_attr_order(), and substitute_address().

static bool handle_arg ( )
static rtx identity_fn ( rtx  )

Referenced by substitute_address().

static rtx identity_fn ( )
   Utility functions called from above routine.  
static void insert_insn_ent ( struct attr_value ,
struct insn_ent  
static void insert_insn_ent ( )
   Insert an insn entry in an attribute value list.  
static rtx insert_right_side ( enum  rtx_code,
rtx  ,
rtx  ,
int  ,

Referenced by walk_attr_value().

static rtx insert_right_side ( )
   This is a utility routine to take an expression that is a tree of either
   AND or IOR expressions and insert a new term.  The new term will be
   inserted at the right side of the first node whose code does not match
   the root.  A new node will be created with the root's code.  Its left
   side will be the old right side and its right side will be the new

   If the `term' is itself a tree, all its leaves will be inserted.  
     Avoid consing in some special cases.  
           Make a copy of this expression and call recursively.  
         Insert the new term.  
int main ( )
     Set up true and false rtx's 
     Read the machine description.  
     If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one.  
     Expand DEFINE_DELAY information into new attribute.  
     Make `insn_alternatives'.  
     Make `insn_n_alternatives'.  
     Construct extra attributes for automata.  
     Prepare to write out attribute subroutines by checking everything stored
     away and building the attribute cases.  
     Construct extra attributes for `length'.  
     Perform any possible optimizations to speed up compilation.  
     Now write out all the `gen_attr_...' routines.  Do these before the
     special routines so that they get defined before they are used.  
     Write out delay eligibility information, if DEFINE_DELAY present.
     (The function to compute the number of delay slots will be written
     Write out constant delay slot info.  
static rtx make_alternative_compare ( )
   Given I, a single-bit mask, return RTX to compare the `alternative'
   attribute with the value represented by that bit.  

Referenced by mk_attr_alt().

static void make_automaton_attrs ( )
   Create all of the attributes that describe automaton properties.
   Write the DFA and latency function prototypes to  the files that
   need to have them, and write the init_sched_attrs().  
         Write the prototypes for all DFA functions.  
         Write the prototypes for all latency functions.  
         Write the prototypes for all automaton functions.  
static rtx make_canonical ( )
   Given a valid expression for an attribute value, remove any IF_THEN_ELSE
   expressions by converting them into a COND.  This removes cases from this
   program.  Also, replace an attribute value of "*" with the default attribute
         The SYMBOL_REF is constant for a given run, so mark it as unchanging.
         This makes the COND something that won't be considered an arbitrary
         expression by walk_attr_value.  
         Fall through to COND case since this is now a COND.  
           First, check for degenerate COND.  

Referenced by check_defs().

static void make_internal_attr ( const char *  ,
rtx  ,

Referenced by substitute_address().

static void make_internal_attr ( )
   Create internal attribute with the given default value.  
static void make_length_attrs ( )
   Make new attributes from the `length' attribute.  The following are made,
   each corresponding to a function called from `shorten_branches' or

   *insn_default_length         This is the length of the insn to be returned
                                by `get_attr_length' before `shorten_branches'
                                has been called.  In each case where the length
                                depends on relative addresses, the largest
                                possible is used.  This routine is also used
                                to compute the initial size of the insn.

   *insn_variable_length_p      This returns 1 if the insn's length depends
                                on relative addresses, zero otherwise.

   *insn_current_length         This is only called when it is known that the
                                insn has a variable length and returns the
                                current length, based on relative addresses.
     See if length attribute is defined.  If so, it must be numeric.  Make
     it special so we don't output anything for it.  
     Make each new attribute, in turn.  

References make_numeric_value(), max_attr_value(), and unknown.

static rtx make_numeric_value ( int  )
static rtx make_numeric_value ( )
   Return (attr_value "n") 
static int max_attr_value ( rtx  ,
int *   

Referenced by make_length_attrs().

static int max_attr_value ( )
   Given an attribute value, return the maximum CONST_STRING argument
   encountered.  Set *UNKNOWNP and return INT_MAX if the value is unknown.  
static rtx max_fn ( rtx  )

Referenced by substitute_address().

static rtx max_fn ( )

References attr_rtx_cost().

static int min_attr_value ( rtx  ,
int *   
static int min_attr_value ( )
   Given an attribute value, return the minimum CONST_STRING argument
   encountered.  Set *UNKNOWNP and return 0 if the value is unknown.  
static rtx min_fn ( rtx  )

Referenced by substitute_address().

static rtx min_fn ( )
static rtx mk_attr_alt ( int  )
static rtx mk_attr_alt ( )
   Return EQ_ATTR_ALT expression representing set containing elements set
   in E.  

References attr_rtx(), make_alternative_compare(), and simplify_and_tree().

static char* next_comma_elt ( const char **  )
static char* next_comma_elt ( )
   This page contains miscellaneous utility routines.  
   Given a pointer to a (char *), return a malloc'ed string containing the
   next comma-separated element.  Advance the pointer to after the string
   scanned, or the end-of-string.  Return NULL if at end of string.  
static rtx one_fn ( rtx  )

Referenced by substitute_address().

static rtx one_fn ( )
static FILE* open_outfile ( )
static void optimize_attrs ( )
   Optimize the attribute lists by seeing if we can determine conditional
   values from the known values of other attributes.  This will save subroutine
   calls during the compilation.  
     For each insn code, make a list of all the insn_ent's for it,
     for all values for all attributes.  
     Make 2 extra elements, for "code" values -2 and -1.  
     Offset the table address so we can index by -2 or -1.  
     Create the chain of insn*attr values such that we see dependend
     attributes after their dependencies.  As we use a stack via the
     next pointers start from the end of the topological order.  
     Sanity check on num_insn_ents.  
     Process one insn code at a time.  
         Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
         We use it to mean "already simplified for this insn".  
             If we created a new value for this instruction, and it's
             cheaper than the old value, and overall cheap, use that
             one as specific value for the current instruction.
             The last test is to avoid exploding the get_attr_ function
             sizes for no much gain.  

References clear_struct_flag().

static int or_attr_value ( rtx  ,
int *   
static int or_attr_value ( )
   Given an attribute value, return the result of ORing together all
   CONST_STRING arguments encountered.  Set *UNKNOWNP and return -1
   if the numeric value is not known.  
static void process_bypasses ( )
   Find and mark all of the bypassed insns.  
     The reservation list is likely to be much longer than the bypass
static void remove_insn_ent ( )
   Remove an insn entry from an attribute value.  

Referenced by get_attr_order().

static rtx simplify_and_tree ( )
   This routine is called when an AND of a term with a tree of AND's is
   encountered.  If the term or its complement is present in the tree, it
   can be replaced with TRUE or FALSE, respectively.

   Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
   be true and hence are complementary.

   There is one special case:  If we see
        (and (not (eq_attr "att" "v1"))
             (eq_attr "att" "v2"))
   this can be replaced by (eq_attr "att" "v2").  To do this we need to
   replace the term, not anything in the AND tree.  So we pass a pointer to
   the term.  
         For the IOR case, we do the same as above, except that we can
         only eliminate `term' if both sides of the IOR would do so.  
     Check for simplifications.  Do some extra checking here since this
     routine is called so many times.  

Referenced by mk_attr_alt().

static rtx simplify_cond ( )
   Take a COND expression and see if any of the conditions in it can be
   simplified.  If any are known true or known false for the particular insn
   code, the COND can be further simplified.

   Also call ourselves on any COND operations that are values of this COND.

   We do not modify EXP; rather, we make and return a new rtx.  
     We store the desired contents here,
     then build a new expression if they don't match EXP.  
     This lets us free all storage allocated below, if appropriate.  
     See if default value needs simplification.  
     Simplify the subexpressions, and see what tests we can get rid of.  
         Simplify this test.  
         See if this value may need simplification.  
         Look for ways to delete or combine this test.  
             If test is true, make this value the default
             and discard this + any following tests.  
             If test is false, discard it and its value.  
             If this value and the value for the prev test are the same,
             merge the tests.  
             Delete this test/value.  
     If the last test in a COND has the same value
     as the default value, that test isn't needed.  
     See if we changed anything.  

Referenced by get_attr_order().

static rtx simplify_or_tree ( )
   Similar to `simplify_and_tree', but for IOR trees.  
         For the AND case, we do the same as above, except that we can
         only eliminate `term' if both sides of the AND would do so.  
static rtx simplify_test_exp ( rtx  ,
int  ,
static rtx simplify_test_exp ( )
   Given an expression, see if it can be simplified for a particular insn
   code based on the values of other attributes being tested.  This can
   eliminate nested get_attr_... calls.

   Note that if an endless recursion is specified in the patterns, the
   optimization will loop.  However, it will do so in precisely the cases where
   an infinite recursion loop could occur during compilation.  It's better that
   it occurs here!  
     Don't re-simplify something we already simplified.  
         If either side is an IOR and we have (eq_attr "alternative" ..")
         present on both sides, apply the distributive law since this will
         yield simplifications.  
         Try with the term on both sides.  
         See if all or all but one of the insn's alternatives are specified
         in this tree.  Optimize if so.  
             If all alternatives are excluded, this is false.  
                 If just one excluded, AND a comparison with that one to the
                 front of the tree.  The others will be eliminated by
                 optimization.  We do not want to do this if the insn has one
                 alternative and we have tested none of them!  
         Test for simple cases where the distributive law is useful.  I.e.,
            convert (ior (and (x) (y))
                         (and (x) (z)))
            to      (and (x)
                         (ior (y) (z)))
            convert (ior (and (y) (x))
                         (and (z) (x)))
            to      (and (ior (y) (z))
         Note that we want the common term to stay at the end.
         See if all or all but one of the insn's alternatives are specified
         in this tree.  Optimize if so.  
             If all alternatives are included, this is true.  
                 If just one excluded, IOR a comparison with that one to the
                 front of the tree.  The others will be eliminated by
                 optimization.  We do not want to do this if the insn has one
                 alternative and we have tested none of them!  
         Try to apply De`Morgan's laws.  
         Look at the value for this insn code in the specified attribute.
         We normally can replace this comparison with the condition that
         would give this insn the values being tested for.  
     We have already simplified this expression.  Simplifying it again
     won't buy anything unless we weren't given a valid insn code
     to process (i.e., we are canonicalizing something.).  
static rtx simplify_test_exp_in_temp ( rtx  ,
int  ,
static rtx simplify_test_exp_in_temp ( )
   Simplify test expression and use temporary obstack in order to avoid
   memory bloat.  Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
   and avoid unnecessary copying if possible.  
static rtx substitute_address ( rtx  exp,
rtx(*)(rtx no_address_fn,
rtx(*)(rtx address_fn 
   Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
   test that checks relative positions of insns (uses MATCH_DUP or PC).
   If so, replace it with what is obtained by passing the expression to
   ADDRESS_FN.  If not but it is a COND or IF_THEN_ELSE, call this routine
   recursively on each value (including the default value).  Otherwise,
   return the value returned by NO_ADDRESS_FN applied to EXP.  
         See if any tests use addresses.  
         Make a new copy of this COND, replacing each element.  

References insn_ent::def, attr_desc::default_val, fatal(), find_attr(), attr_value::first_insn, attr_desc::first_value, get_attr_value(), identity_fn(), insert_insn_ent(), insn_def::insn_code, attr_desc::is_const, attr_desc::is_numeric, attr_desc::is_special, length_str, make_internal_attr(), max_fn(), min_fn(), insn_ent::next, attr_value::next, one_fn(), attr_value::value, and zero_fn().

static int tests_attr_p ( )
   Return 1 if any EQ_ATTR subexpression of P refers to ATTR,
   otherwise return 0.  
static void walk_attr_value ( rtx  )
static void walk_attr_value ( )
   Scan an attribute value, possibly a conditional, and record what actions
   will be required to do any conditional tests in it.

   Specifically, set
        `must_extract'    if we need to extract the insn operands
        `must_constrain'  if we must compute `which_alternative'
        `address_used'    if an address expression was used
        `length_used'     if an (eq_attr "length" ...) was used
           Since this is an arbitrary expression, it can look at anything.
           However, constant expressions do not depend on any particular

References attr_rtx(), attrs_cached_after, attrs_seen_more_than_once, attr_desc::default_val, eliminate_known_true(), find_attrs_to_cache(), insert_right_side(), write_indent(), and write_test_expr().

static void write_attr_case ( FILE *  outf,
struct attr_desc attr,
struct attr_value av,
int  write_case_lines,
const char *  prefix,
const char *  suffix,
int  indent,
rtx  known_true 
   Write out the computation for one attribute value.  
     See what we have to do to output this value.  
static void write_attr_get ( )
   Write out a function to obtain the attribute for a given INSN.  
     Find the most used attribute value.  Handle that as the `default' of the
     switch we will generate.  
     Write out start of function, then all values with explicit `case' lines,
     then a `default', then the value with the most uses.  
     If the attribute name starts with a star, the remainder is the name of
     the subroutine to use, instead of `get_attr_...'.  
     Find attributes that are worth caching in the conditions.  
     Remove those that aren't worth caching from the array.  
static void write_attr_set ( FILE *  outf,
struct attr_desc attr,
int  indent,
rtx  value,
const char *  prefix,
const char *  suffix,
rtx  known_true,
int  insn_code,
int  insn_index,
unsigned int  attrs_cached 
   Write out a series of tests and assignment statements to perform tests and
   sets of an attribute value.  We are passed an indentation amount and prefix
   and suffix strings to write around each attribute value (e.g., "return"
   and ";").  
         Assume the default value will be the default of the COND unless we
         find an always true expression.  
             Reset our_known_true after some time to not accumulate
             too much cruft (slowing down genattrtab).  
             If the test expression is always true or if the next `known_true'
             expression is always false, this is the last case, so break
             out and let this value be the `else' case.  
             Compute the expression to pass to our recursive call as being
             known true.  
             If this is always false, skip it.  
static void write_attr_value ( FILE *  ,
struct attr_desc ,
static void write_attr_value ( )
static void write_attr_valueq ( FILE *  ,
struct attr_desc ,
const char *   
static void write_attr_valueq ( )
   Utilities to write in various forms.  
static void write_const_num_delay_slots ( )
   Determine if an insn has a constant number of delay slots, i.e., the
   number of delay slots is not a function of the length of the insn.  

References attr_desc::default_val, and attr_value::value.

static void write_eligible_delay ( )
   Write a subroutine that is given an insn that requires a delay slot, a
   delay slot ordinal, and a candidate insn.  It returns nonzero if the
   candidate can be placed in the specified delay slot of the insn.

   We can write as many as three subroutines.  `eligible_for_delay'
   handles normal delay slots, `eligible_for_annul_true' indicates that
   the specified insn can be annulled if the branch is true, and likewise
   for `eligible_for_annul_false'.

   KIND is a string distinguishing these three cases ("delay", "annul_true",
   or "annul_false").  
     Compute the maximum number of delay slots required.  We use the delay
     ordinal times this number plus one, plus the slot number as an index into
     the appropriate predicate to test.  
     Write function prelude.  
     Allow dbr_schedule to pass labels, etc.  This can happen if try_split
     converts a compound instruction into a loop.  
     If more than one delay type, find out which type the delay insn is.  
         Ensure matched.  Otherwise, shouldn't have been called.  
     If just one type of delay slot, write simple switch.  
         Write a nested CASE.  The first indicates which condition we need to
         test, and the inner CASE tests the condition.  
static void write_header ( void  )
static void write_indent ( FILE *  ,

Referenced by walk_attr_value().

static void write_indent ( )
static void write_insn_cases ( )
   Write a series of case statements for every instruction in list IE.
   INDENT is the amount of indentation to write before each case.  
static void write_length_unit_log ( )
static unsigned int write_test_expr ( )
     In order not to worry about operator precedence, surround our part of
     the expression with parentheses.  
       Binary operators.  
         Fall through.  
             For if (something && (cached_x = get_attr_x (insn)) == X)
             cached_x is only known to be initialized in then block.  
               For if (something || (cached_x = get_attr_x (insn)) == X)
               cached_x is only known to be initialized in else block
               and else if conditions.  
               For if ((something || (cached_x = get_attr_x (insn)) == X)
                       && something_else)
               cached_x is not know to be initialized anywhere.  
         Special-case (not (eq_attrq "alternative" "x")) 
         Otherwise, fall through to normal unary operator.  
       Unary operators.  
       Comparison test of an attribute with a value.  Most of these will
       have been removed by optimization.   Handle "alternative"
       specially and give error if EQ_ATTR present inside a comparison.  
         Now is the time to expand the value of a constant attribute.  
       Comparison test of flags for define_delays.  
       See if an operand matches a predicate.  
         If only a mode is given, just ensure the mode matches the operand.
         If neither a mode nor predicate is given, error.  
       Constant integer.  
       A random C expression.  
       The address of the branch target.  
         The address of the current insn.  We implement this actually as the
         address of the current insn for backward branches, but the last
         address of the next insn for forward branches, and both with
         adjustments that account for the worst-case possible stretching of
         intervening alignments between this insn and its destination.  

Referenced by gen_insn(), and walk_attr_value().

static void write_upcase ( FILE *  ,
const char *   
static void write_upcase ( )
         The argument of TOUPPER should not have side effects.  
static rtx zero_fn ( rtx  )

Referenced by substitute_address().

static rtx zero_fn ( )

Variable Documentation

int address_used
struct bypass_list* all_bypasses
struct insn_reserv* all_insn_reservs = 0
const char* alternative_name
   Used to reduce calls to `strcmp' 

Referenced by count_alternatives().

FILE* attr_file
const char* attr_file_name = NULL
   This gen* file is unique, in that it writes out multiple files.

   Before GCC 4.8, insn-attrtab.c was written out containing many large
   functions and tables.  This made insn-attrtab.c _the_ bottle-neck in
   a parallel build, and even made it impossible to build GCC on machines
   with relatively small RAM space (PR other/29442).  Therefore, the
   atrribute functions/tables are now written out to three separate
   files: all "*insn_default_latency" functions go to LATENCY_FILE_NAME,
   all "*internal_dfa_insn_code" functions go to DFA_FILE_NAME, and the
   rest goes to ATTR_FILE_NAME.  
struct attr_hash* attr_hash_table[RTL_HASH_SIZE]
struct attr_desc* attrs[MAX_ATTRS_INDEX]
unsigned int attrs_cached_after

Referenced by walk_attr_value().

unsigned int attrs_cached_inside
unsigned int attrs_seen_more_than_once

Referenced by walk_attr_value().

unsigned int attrs_seen_once
   Bitmasks of possibly cached attributes.  
unsigned int attrs_to_cache
int cached_attr_count
   Number of such attributes.  

Referenced by count_alternatives().

const char* cached_attrs[32]
   Names of attributes that could be possibly cached.  
struct insn_def* defs
const char* delay_1_0_str
const char* delay_type_str
struct delay_desc* delays
FILE * dfa_file
const char* dfa_file_name = NULL
rtx false_rtx
int got_define_asm_attributes
struct obstack* hash_obstack = &obstack1

Referenced by attr_rtx_1().

int have_annul_false
int have_annul_true
int* insn_alternatives
   Stores, for each insn code, a bitmap that has bits on for each possible

Referenced by attr_alt_complement().

int insn_code_number
   Other variables.  

Referenced by add_attr_value(), likely_spilled_retval_p(), and main().

struct attr_value_list** insn_code_values
int insn_index_number

Referenced by add_attr_value().

int* insn_n_alternatives
   Stores, for each insn code, the number of constraint alternatives.  
struct insn_reserv** last_insn_reserv_p = &all_insn_reservs
FILE * latency_file
const char* latency_file_name = NULL
const char* length_str

Referenced by substitute_address().

int length_used
int must_constrain
int must_extract
size_t n_bypasses
size_t n_insn_reservs
const char* num_delay_slots_str
int num_delays

Referenced by copy_boolean().

int num_insn_ents
struct obstack obstack1 obstack2
struct obstack* temp_obstack = &obstack2

Referenced by get_attr_order().

rtx true_rtx
   Used to simplify expressions.  

Referenced by find_comparison_args().