GNU Compiler Collection (GCC) Internals: Defining Attributes

Next: Expressions, Up: Insn Attributes [Contents][Index]

#### 16.19.1 Defining Attributes and their Values

The `define_attr` expression is used to define each attribute required by the target machine. It looks like:

    (define_attr name list-of-values default)

name is a string specifying the name of the attribute being defined. Some attributes are used in a special way by the rest of the compiler. The `enabled` attribute can be used to conditionally enable or disable insn alternatives (see Disable Insn Alternatives). The `predicable` attribute, together with a suitable `define_cond_exec` (see Conditional Execution), can be used to automatically generate conditional variants of instruction patterns. The `mnemonic` attribute can be used to check for the instruction mnemonic (see Mnemonic Attribute). The compiler internally uses the names `ce_enabled` and `nonce_enabled`, so they should not be used elsewhere as alternative names.

list-of-values is either a string that specifies a comma-separated list of values that can be assigned to the attribute, or a null string to indicate that the attribute takes numeric values.

default is an attribute expression that gives the value of this attribute for insns that match patterns whose definition does not include an explicit value for this attribute. See Attr Example, for more information on the handling of defaults. See Constant Attributes, for information on attributes that do not depend on any particular insn.

For each defined attribute, a number of definitions are written to the `insn-attr.h` file. For cases where an explicit set of values is specified for an attribute, the following are defined:

- A ‘`#define`’ is written for the symbol ‘`HAVE_ATTR_name`’.
- An enumerated class is defined for ‘`attr_name`’ with elements of the form ‘`upper-name_upper-value`’ where the attribute name and value are first converted to uppercase.
- A function ‘`get_attr_name`’ is defined that is passed an insn and returns the attribute value for that insn.

For example, if the following is present in the `md` file:

    (define_attr "type" "branch,fp,load,store,arith" …)

the following lines will be written to the file `insn-attr.h`.

    #define HAVE_ATTR_type 1
    enum attr_type {TYPE_BRANCH, TYPE_FP, TYPE_LOAD,
                     TYPE_STORE, TYPE_ARITH};
    extern enum attr_type get_attr_type ();

If the attribute takes numeric values, no `enum` type will be defined and the function to obtain the attribute’s value will return `int`.

There are attributes which are tied to a specific meaning. These attributes are not free to use for other purposes:

`length`

  The `length` attribute is used to calculate the length of emitted code chunks. This is especially important when verifying branch distances. See Insn Lengths.

`enabled`

  The `enabled` attribute can be defined to prevent certain alternatives of an insn definition from being used during code generation. See Disable Insn Alternatives.

`mnemonic`

  The `mnemonic` attribute can be defined to implement instruction specific checks in e.g. the pipeline description. See Mnemonic Attribute.

For each of these special attributes, the corresponding ‘`HAVE_ATTR_name`’ ‘`#define`’ is also written when the attribute is not defined; in that case, it is defined as ‘`0`’.

Another way of defining an attribute is to use:

    (define_enum_attr "attr" "enum" default)

This works in just the same way as `define_attr`, except that the list of values is taken from a separate enumeration called enum (see define_enum). This form allows you to use the same list of values for several attributes without having to repeat the list each time. For example:

    (define_enum "processor" [
      model_a
      model_b
      …
    ])
    (define_enum_attr "arch" "processor"
      (const (symbol_ref "target_arch")))
    (define_enum_attr "tune" "processor"
      (const (symbol_ref "target_tune")))

defines the same attributes as:

    (define_attr "arch" "model_a,model_b,…"
      (const (symbol_ref "target_arch")))
    (define_attr "tune" "model_a,model_b,…"
      (const (symbol_ref "target_tune")))

but without duplicating the processor list. The second example defines two separate C enums (`attr_arch` and `attr_tune`) whereas the first defines a single C enum (`processor`).

Next: Expressions, Up: Insn Attributes [Contents][Index]