gcc/rtl.def

   1 /* This file contains the definitions and documentation for the
   2    Register Transfer Expressions (rtx's) that make up the
   3    Register Transfer Language (rtl) used in the Back End of the GNU compiler.
   4    Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2004
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 02111-1307, USA.  */
  23
  24
  25 /* Expression definitions and descriptions for all targets are in this file.
  26    Some will not be used for some targets.
  27
  28    The fields in the cpp macro call "DEF_RTL_EXPR()"
  29    are used to create declarations in the C source of the compiler.
  30
  31    The fields are:
  32
  33    1.  The internal name of the rtx used in the C source.
  34    It is a tag in the enumeration "enum rtx_code" defined in "rtl.h".
  35    By convention these are in UPPER_CASE.
  36
  37    2.  The name of the rtx in the external ASCII format read by
  38    read_rtx(), and printed by print_rtx().
  39    These names are stored in rtx_name[].
  40    By convention these are the internal (field 1) names in lower_case.
  41
  42    3.  The print format, and type of each rtx->u.fld[] (field) in this rtx.
  43    These formats are stored in rtx_format[].
  44    The meaning of the formats is documented in front of this array in rtl.c
  45
  46    4.  The class of the rtx.  These are stored in rtx_class and are accessed
  47    via the GET_RTX_CLASS macro.  They are defined as follows:
  48
  49      RTX_CONST_OBJ
  50          an rtx code that can be used to represent a constant object
  51          (e.g, CONST_INT)
  52      RTX_OBJ
  53          an rtx code that can be used to represent an object (e.g, REG, MEM)
  54      RTX_COMPARE
  55          an rtx code for a comparison (e.g, LT, GT)
  56      RTX_COMM_COMPARE
  57          an rtx code for a commutative comparison (e.g, EQ, NE, ORDERED)
  58      RTX_UNARY
  59          an rtx code for a unary arithmetic expression (e.g, NEG, NOT)
  60      RTX_COMM_ARITH
  61          an rtx code for a commutative binary operation (e.g,, PLUS, MULT)
  62      RTX_TERNARY
  63          an rtx code for a non-bitfield three input operation (IF_THEN_ELSE)
  64      RTX_BIN_ARITH
  65          an rtx code for a non-commutative binary operation (e.g., MINUS, DIV)
  66      RTX_BITFIELD_OPS
  67          an rtx code for a bit-field operation (ZERO_EXTRACT, SIGN_EXTRACT)
  68      RTX_INSN
  69          an rtx code for a machine insn (INSN, JUMP_INSN, CALL_INSN)
  70      RTX_MATCH
  71          an rtx code for something that matches in insns (e.g, MATCH_DUP)
  72      RTX_AUTOINC
  73          an rtx code for autoincrement addressing modes (e.g. POST_DEC)
  74      RTX_EXTRA
  75          everything else
  76
  77    */
  78
  79 /* ---------------------------------------------------------------------
  80    Expressions (and "meta" expressions) used for structuring the
  81    rtl representation of a program.
  82    --------------------------------------------------------------------- */
  83
  84 /* an expression code name unknown to the reader */
  85 DEF_RTL_EXPR(UNKNOWN, "UnKnown", "*", RTX_EXTRA)
  86
  87 /* (NIL) is used by rtl reader and printer to represent a null pointer.  */
  88
  89 DEF_RTL_EXPR(NIL, "nil", "*", RTX_EXTRA)
  90
  91
  92 /* include a file */
  93
  94 DEF_RTL_EXPR(INCLUDE, "include", "s", RTX_EXTRA)
  95
  96 /* ---------------------------------------------------------------------
  97    Expressions used in constructing lists.
  98    --------------------------------------------------------------------- */
  99
 100 /* a linked list of expressions */
 101 DEF_RTL_EXPR(EXPR_LIST, "expr_list", "ee", RTX_EXTRA)
 102
 103 /* a linked list of instructions.
 104    The insns are represented in print by their uids.  */
 105 DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA)
 106
 107 /* ----------------------------------------------------------------------
 108    Expression types for machine descriptions.
 109    These do not appear in actual rtl code in the compiler.
 110    ---------------------------------------------------------------------- */
 111
 112 /* Appears only in machine descriptions.
 113    Means use the function named by the second arg (the string)
 114    as a predicate; if matched, store the structure that was matched
 115    in the operand table at index specified by the first arg (the integer).
 116    If the second arg is the null string, the structure is just stored.
 117
 118    A third string argument indicates to the register allocator restrictions
 119    on where the operand can be allocated.
 120
 121    If the target needs no restriction on any instruction this field should
 122    be the null string.
 123
 124    The string is prepended by:
 125    '=' to indicate the operand is only written to.
 126    '+' to indicate the operand is both read and written to.
 127
 128    Each character in the string represents an allocable class for an operand.
 129    'g' indicates the operand can be any valid class.
 130    'i' indicates the operand can be immediate (in the instruction) data.
 131    'r' indicates the operand can be in a register.
 132    'm' indicates the operand can be in memory.
 133    'o' a subset of the 'm' class.  Those memory addressing modes that
 134        can be offset at compile time (have a constant added to them).
 135
 136    Other characters indicate target dependent operand classes and
 137    are described in each target's machine description.
 138
 139    For instructions with more than one operand, sets of classes can be
 140    separated by a comma to indicate the appropriate multi-operand constraints.
 141    There must be a 1 to 1 correspondence between these sets of classes in
 142    all operands for an instruction.
 143    */
 144 DEF_RTL_EXPR(MATCH_OPERAND, "match_operand", "iss", RTX_MATCH)
 145
 146 /* Appears only in machine descriptions.
 147    Means match a SCRATCH or a register.  When used to generate rtl, a
 148    SCRATCH is generated.  As for MATCH_OPERAND, the mode specifies
 149    the desired mode and the first argument is the operand number.
 150    The second argument is the constraint.  */
 151 DEF_RTL_EXPR(MATCH_SCRATCH, "match_scratch", "is", RTX_MATCH)
 152
 153 /* Appears only in machine descriptions.
 154    Means match only something equal to what is stored in the operand table
 155    at the index specified by the argument.  */
 156 DEF_RTL_EXPR(MATCH_DUP, "match_dup", "i", RTX_MATCH)
 157
 158 /* Appears only in machine descriptions.
 159    Means apply a predicate, AND match recursively the operands of the rtx.
 160    Operand 0 is the operand-number, as in match_operand.
 161    Operand 1 is a predicate to apply (as a string, a function name).
 162    Operand 2 is a vector of expressions, each of which must match
 163    one subexpression of the rtx this construct is matching.  */
 164 DEF_RTL_EXPR(MATCH_OPERATOR, "match_operator", "isE", RTX_MATCH)
 165
 166 /* Appears only in machine descriptions.
 167    Means to match a PARALLEL of arbitrary length.  The predicate is applied
 168    to the PARALLEL and the initial expressions in the PARALLEL are matched.
 169    Operand 0 is the operand-number, as in match_operand.
 170    Operand 1 is a predicate to apply to the PARALLEL.
 171    Operand 2 is a vector of expressions, each of which must match the
 172    corresponding element in the PARALLEL.  */
 173 DEF_RTL_EXPR(MATCH_PARALLEL, "match_parallel", "isE", RTX_MATCH)
 174
 175 /* Appears only in machine descriptions.
 176    Means match only something equal to what is stored in the operand table
 177    at the index specified by the argument.  For MATCH_OPERATOR.  */
 178 DEF_RTL_EXPR(MATCH_OP_DUP, "match_op_dup", "iE", RTX_MATCH)
 179
 180 /* Appears only in machine descriptions.
 181    Means match only something equal to what is stored in the operand table
 182    at the index specified by the argument.  For MATCH_PARALLEL.  */
 183 DEF_RTL_EXPR(MATCH_PAR_DUP, "match_par_dup", "iE", RTX_MATCH)
 184
 185 /* Appears only in machine descriptions.
 186    Defines the pattern for one kind of instruction.
 187    Operand:
 188    0: names this instruction.
 189       If the name is the null string, the instruction is in the
 190       machine description just to be recognized, and will never be emitted by
 191       the tree to rtl expander.
 192    1: is the pattern.
 193    2: is a string which is a C expression
 194       giving an additional condition for recognizing this pattern.
 195       A null string means no extra condition.
 196    3: is the action to execute if this pattern is matched.
 197       If this assembler code template starts with a * then it is a fragment of
 198       C code to run to decide on a template to use.  Otherwise, it is the
 199       template to use.
 200    4: optionally, a vector of attributes for this insn.
 201      */
 202 DEF_RTL_EXPR(DEFINE_INSN, "define_insn", "sEsTV", RTX_EXTRA)
 203
 204 /* Definition of a peephole optimization.
 205    1st operand: vector of insn patterns to match
 206    2nd operand: C expression that must be true
 207    3rd operand: template or C code to produce assembler output.
 208    4: optionally, a vector of attributes for this insn.
 209      */
 210 DEF_RTL_EXPR(DEFINE_PEEPHOLE, "define_peephole", "EsTV", RTX_EXTRA)
 211
 212 /* Definition of a split operation.
 213    1st operand: insn pattern to match
 214    2nd operand: C expression that must be true
 215    3rd operand: vector of insn patterns to place into a SEQUENCE
 216    4th operand: optionally, some C code to execute before generating the
 217         insns.  This might, for example, create some RTX's and store them in
 218         elements of `recog_data.operand' for use by the vector of
 219         insn-patterns.
 220         (`operands' is an alias here for `recog_data.operand').  */
 221 DEF_RTL_EXPR(DEFINE_SPLIT, "define_split", "EsES", RTX_EXTRA)
 222
 223 /* Definition of an insn and associated split.
 224    This is the concatenation, with a few modifications, of a define_insn
 225    and a define_split which share the same pattern.
 226    Operand:
 227    0: names this instruction.
 228       If the name is the null string, the instruction is in the
 229       machine description just to be recognized, and will never be emitted by
 230       the tree to rtl expander.
 231    1: is the pattern.
 232    2: is a string which is a C expression
 233       giving an additional condition for recognizing this pattern.
 234       A null string means no extra condition.
 235    3: is the action to execute if this pattern is matched.
 236       If this assembler code template starts with a * then it is a fragment of
 237       C code to run to decide on a template to use.  Otherwise, it is the
 238       template to use.
 239    4: C expression that must be true for split.  This may start with "&&"
 240       in which case the split condition is the logical and of the insn
 241       condition and what follows the "&&" of this operand.
 242    5: vector of insn patterns to place into a SEQUENCE
 243    6: optionally, some C code to execute before generating the
 244         insns.  This might, for example, create some RTX's and store them in
 245         elements of `recog_data.operand' for use by the vector of
 246         insn-patterns.
 247         (`operands' is an alias here for `recog_data.operand').
 248    7: optionally, a vector of attributes for this insn.  */
 249 DEF_RTL_EXPR(DEFINE_INSN_AND_SPLIT, "define_insn_and_split", "sEsTsESV", RTX_EXTRA)
 250
 251 /* Definition of an RTL peephole operation.
 252    Follows the same arguments as define_split.  */
 253 DEF_RTL_EXPR(DEFINE_PEEPHOLE2, "define_peephole2", "EsES", RTX_EXTRA)
 254
 255 /* Define how to generate multiple insns for a standard insn name.
 256    1st operand: the insn name.
 257    2nd operand: vector of insn-patterns.
 258         Use match_operand to substitute an element of `recog_data.operand'.
 259    3rd operand: C expression that must be true for this to be available.
 260         This may not test any operands.
 261    4th operand: Extra C code to execute before generating the insns.
 262         This might, for example, create some RTX's and store them in
 263         elements of `recog_data.operand' for use by the vector of
 264         insn-patterns.
 265         (`operands' is an alias here for `recog_data.operand').  */
 266 DEF_RTL_EXPR(DEFINE_EXPAND, "define_expand", "sEss", RTX_EXTRA)
 267
 268 /* Define a requirement for delay slots.
 269    1st operand: Condition involving insn attributes that, if true,
 270                 indicates that the insn requires the number of delay slots
 271                 shown.
 272    2nd operand: Vector whose length is the three times the number of delay
 273                 slots required.
 274                 Each entry gives three conditions, each involving attributes.
 275                 The first must be true for an insn to occupy that delay slot
 276                 location.  The second is true for all insns that can be
 277                 annulled if the branch is true and the third is true for all
 278                 insns that can be annulled if the branch is false.
 279
 280    Multiple DEFINE_DELAYs may be present.  They indicate differing
 281    requirements for delay slots.  */
 282 DEF_RTL_EXPR(DEFINE_DELAY, "define_delay", "eE", RTX_EXTRA)
 283
 284 /* Define attribute computation for `asm' instructions.  */
 285 DEF_RTL_EXPR(DEFINE_ASM_ATTRIBUTES, "define_asm_attributes", "V", RTX_EXTRA)
 286
 287 /* Definition of a conditional execution meta operation.  Automatically
 288    generates new instances of DEFINE_INSN, selected by having attribute
 289    "predicable" true.  The new pattern will contain a COND_EXEC and the
 290    predicate at top-level.
 291
 292    Operand:
 293    0: The predicate pattern.  The top-level form should match a
 294       relational operator.  Operands should have only one alternative.
 295    1: A C expression giving an additional condition for recognizing
 296       the generated pattern.
 297    2: A template or C code to produce assembler output.  */
 298 DEF_RTL_EXPR(DEFINE_COND_EXEC, "define_cond_exec", "Ess", RTX_EXTRA)
 299
 300 /* SEQUENCE appears in the result of a `gen_...' function
 301    for a DEFINE_EXPAND that wants to make several insns.
 302    Its elements are the bodies of the insns that should be made.
 303    `emit_insn' takes the SEQUENCE apart and makes separate insns.  */
 304 DEF_RTL_EXPR(SEQUENCE, "sequence", "E", RTX_EXTRA)
 305
 306 /* Refers to the address of its argument.  This is only used in alias.c.  */
 307 DEF_RTL_EXPR(ADDRESS, "address", "e", RTX_MATCH)
 308
 309 /* ----------------------------------------------------------------------
 310    Constructions for CPU pipeline description described by NDFAs.
 311    These do not appear in actual rtl code in the compiler.
 312    ---------------------------------------------------------------------- */
 313
 314 /* (define_cpu_unit string [string]) describes cpu functional
 315    units (separated by comma).
 316
 317    1st operand: Names of cpu functional units.
 318    2nd operand: Name of automaton (see comments for DEFINE_AUTOMATON).
 319
 320    All define_reservations, define_cpu_units, and
 321    define_query_cpu_units should have unique names which may not be
 322    "nothing".  */
 323 DEF_RTL_EXPR(DEFINE_CPU_UNIT, "define_cpu_unit", "sS", RTX_EXTRA)
 324
 325 /* (define_query_cpu_unit string [string]) describes cpu functional
 326    units analogously to define_cpu_unit.  The reservation of such
 327    units can be queried for automaton state.  */
 328 DEF_RTL_EXPR(DEFINE_QUERY_CPU_UNIT, "define_query_cpu_unit", "sS", RTX_EXTRA)
 329
 330 /* (exclusion_set string string) means that each CPU functional unit
 331    in the first string can not be reserved simultaneously with any
 332    unit whose name is in the second string and vise versa.  CPU units
 333    in the string are separated by commas.  For example, it is useful
 334    for description CPU with fully pipelined floating point functional
 335    unit which can execute simultaneously only single floating point
 336    insns or only double floating point insns.  All CPU functional
 337    units in a set should belong to the same automaton.  */
 338 DEF_RTL_EXPR(EXCLUSION_SET, "exclusion_set", "ss", RTX_EXTRA)
 339
 340 /* (presence_set string string) means that each CPU functional unit in
 341    the first string can not be reserved unless at least one of pattern
 342    of units whose names are in the second string is reserved.  This is
 343    an asymmetric relation.  CPU units or unit patterns in the strings
 344    are separated by commas.  Pattern is one unit name or unit names
 345    separated by white-spaces.
 346
 347    For example, it is useful for description that slot1 is reserved
 348    after slot0 reservation for a VLIW processor.  We could describe it
 349    by the following construction
 350
 351       (presence_set "slot1" "slot0")
 352
 353    Or slot1 is reserved only after slot0 and unit b0 reservation.  In
 354    this case we could write
 355
 356       (presence_set "slot1" "slot0 b0")
 357
 358    All CPU functional units in a set should belong to the same
 359    automaton.  */
 360 DEF_RTL_EXPR(PRESENCE_SET, "presence_set", "ss", RTX_EXTRA)
 361
 362 /* (final_presence_set string string) is analogous to `presence_set'.
 363    The difference between them is when checking is done.  When an
 364    instruction is issued in given automaton state reflecting all
 365    current and planned unit reservations, the automaton state is
 366    changed.  The first state is a source state, the second one is a
 367    result state.  Checking for `presence_set' is done on the source
 368    state reservation, checking for `final_presence_set' is done on the
 369    result reservation.  This construction is useful to describe a
 370    reservation which is actually two subsequent reservations.  For
 371    example, if we use
 372
 373       (presence_set "slot1" "slot0")
 374
 375    the following insn will be never issued (because slot1 requires
 376    slot0 which is absent in the source state).
 377
 378       (define_reservation "insn_and_nop" "slot0 + slot1")
 379
 380    but it can be issued if we use analogous `final_presence_set'.  */
 381 DEF_RTL_EXPR(FINAL_PRESENCE_SET, "final_presence_set", "ss", RTX_EXTRA)
 382
 383 /* (absence_set string string) means that each CPU functional unit in
 384    the first string can be reserved only if each pattern of units
 385    whose names are in the second string is not reserved.  This is an
 386    asymmetric relation (actually exclusion set is analogous to this
 387    one but it is symmetric).  CPU units or unit patterns in the string
 388    are separated by commas.  Pattern is one unit name or unit names
 389    separated by white-spaces.
 390
 391    For example, it is useful for description that slot0 can not be
 392    reserved after slot1 or slot2 reservation for a VLIW processor.  We
 393    could describe it by the following construction
 394
 395       (absence_set "slot2" "slot0, slot1")
 396
 397    Or slot2 can not be reserved if slot0 and unit b0 are reserved or
 398    slot1 and unit b1 are reserved .  In this case we could write
 399
 400       (absence_set "slot2" "slot0 b0, slot1 b1")
 401
 402    All CPU functional units in a set should to belong the same
 403    automaton.  */
 404 DEF_RTL_EXPR(ABSENCE_SET, "absence_set", "ss", RTX_EXTRA)
 405
 406 /* (final_absence_set string string) is analogous to `absence_set' but
 407    checking is done on the result (state) reservation.  See comments
 408    for `final_presence_set'.  */
 409 DEF_RTL_EXPR(FINAL_ABSENCE_SET, "final_absence_set", "ss", RTX_EXTRA)
 410
 411 /* (define_bypass number out_insn_names in_insn_names) names bypass
 412    with given latency (the first number) from insns given by the first
 413    string (see define_insn_reservation) into insns given by the second
 414    string.  Insn names in the strings are separated by commas.  The
 415    third operand is optional name of function which is additional
 416    guard for the bypass.  The function will get the two insns as
 417    parameters.  If the function returns zero the bypass will be
 418    ignored for this case.  Additional guard is necessary to recognize
 419    complicated bypasses, e.g. when consumer is load address.  */
 420 DEF_RTL_EXPR(DEFINE_BYPASS, "define_bypass", "issS", RTX_EXTRA)
 421
 422 /* (define_automaton string) describes names of automata generated and
 423    used for pipeline hazards recognition.  The names are separated by
 424    comma.  Actually it is possibly to generate the single automaton
 425    but unfortunately it can be very large.  If we use more one
 426    automata, the summary size of the automata usually is less than the
 427    single one.  The automaton name is used in define_cpu_unit and
 428    define_query_cpu_unit.  All automata should have unique names.  */
 429 DEF_RTL_EXPR(DEFINE_AUTOMATON, "define_automaton", "s", RTX_EXTRA)
 430
 431 /* (automata_option string) describes option for generation of
 432    automata.  Currently there are the following options:
 433
 434    o "no-minimization" which makes no minimization of automata.  This
 435      is only worth to do when we are debugging the description and
 436      need to look more accurately at reservations of states.
 437
 438    o "time" which means printing additional time statistics about
 439       generation of automata.
 440
 441    o "v" which means generation of file describing the result
 442      automata.  The file has suffix `.dfa' and can be used for the
 443      description verification and debugging.
 444
 445    o "w" which means generation of warning instead of error for
 446      non-critical errors.
 447
 448    o "ndfa" which makes nondeterministic finite state automata.
 449
 450    o "progress" which means output of a progress bar showing how many
 451      states were generated so far for automaton being processed.  */
 452 DEF_RTL_EXPR(AUTOMATA_OPTION, "automata_option", "s", RTX_EXTRA)
 453
 454 /* (define_reservation string string) names reservation (the first
 455    string) of cpu functional units (the 2nd string).  Sometimes unit
 456    reservations for different insns contain common parts.  In such
 457    case, you can describe common part and use its name (the 1st
 458    parameter) in regular expression in define_insn_reservation.  All
 459    define_reservations, define_cpu_units, and define_query_cpu_units
 460    should have unique names which may not be "nothing".  */
 461 DEF_RTL_EXPR(DEFINE_RESERVATION, "define_reservation", "ss", RTX_EXTRA)
 462
 463 /* (define_insn_reservation name default_latency condition regexpr)
 464    describes reservation of cpu functional units (the 3nd operand) for
 465    instruction which is selected by the condition (the 2nd parameter).
 466    The first parameter is used for output of debugging information.
 467    The reservations are described by a regular expression according
 468    the following syntax:
 469
 470        regexp = regexp "," oneof
 471               | oneof
 472
 473        oneof = oneof "|" allof
 474              | allof
 475
 476        allof = allof "+" repeat
 477              | repeat
 478
 479        repeat = element "*" number
 480               | element
 481
 482        element = cpu_function_unit_name
 483                | reservation_name
 484                | result_name
 485                | "nothing"
 486                | "(" regexp ")"
 487
 488        1. "," is used for describing start of the next cycle in
 489        reservation.
 490
 491        2. "|" is used for describing the reservation described by the
 492        first regular expression *or* the reservation described by the
 493        second regular expression *or* etc.
 494
 495        3. "+" is used for describing the reservation described by the
 496        first regular expression *and* the reservation described by the
 497        second regular expression *and* etc.
 498
 499        4. "*" is used for convenience and simply means sequence in
 500        which the regular expression are repeated NUMBER times with
 501        cycle advancing (see ",").
 502
 503        5. cpu functional unit name which means its reservation.
 504
 505        6. reservation name -- see define_reservation.
 506
 507        7. string "nothing" means no units reservation.  */
 508
 509 DEF_RTL_EXPR(DEFINE_INSN_RESERVATION, "define_insn_reservation", "sies", RTX_EXTRA)
 510
 511 /* ----------------------------------------------------------------------
 512    Expressions used for insn attributes.  These also do not appear in
 513    actual rtl code in the compiler.
 514    ---------------------------------------------------------------------- */
 515
 516 /* Definition of an insn attribute.
 517    1st operand: name of the attribute
 518    2nd operand: comma-separated list of possible attribute values
 519    3rd operand: expression for the default value of the attribute.  */
 520 DEF_RTL_EXPR(DEFINE_ATTR, "define_attr", "sse", RTX_EXTRA)
 521
 522 /* Marker for the name of an attribute.  */
 523 DEF_RTL_EXPR(ATTR, "attr", "s", RTX_EXTRA)
 524
 525 /* For use in the last (optional) operand of DEFINE_INSN or DEFINE_PEEPHOLE and
 526    in DEFINE_ASM_INSN to specify an attribute to assign to insns matching that
 527    pattern.
 528
 529    (set_attr "name" "value") is equivalent to
 530    (set (attr "name") (const_string "value"))  */
 531 DEF_RTL_EXPR(SET_ATTR, "set_attr", "ss", RTX_EXTRA)
 532
 533 /* In the last operand of DEFINE_INSN and DEFINE_PEEPHOLE, this can be used to
 534    specify that attribute values are to be assigned according to the
 535    alternative matched.
 536
 537    The following three expressions are equivalent:
 538
 539    (set (attr "att") (cond [(eq_attrq "alternative" "1") (const_string "a1")
 540                             (eq_attrq "alternative" "2") (const_string "a2")]
 541                            (const_string "a3")))
 542    (set_attr_alternative "att" [(const_string "a1") (const_string "a2")
 543                                  (const_string "a3")])
 544    (set_attr "att" "a1,a2,a3")
 545  */
 546 DEF_RTL_EXPR(SET_ATTR_ALTERNATIVE, "set_attr_alternative", "sE", RTX_EXTRA)
 547
 548 /* A conditional expression true if the value of the specified attribute of
 549    the current insn equals the specified value.  The first operand is the
 550    attribute name and the second is the comparison value.  */
 551 DEF_RTL_EXPR(EQ_ATTR, "eq_attr", "ss", RTX_EXTRA)
 552
 553 /* A special case of the above representing a set of alternatives.  The first
 554    operand is bitmap of the set, the second one is the default value.  */
 555 DEF_RTL_EXPR(EQ_ATTR_ALT, "eq_attr_alt", "ii", RTX_EXTRA)
 556
 557 /* A conditional expression which is true if the specified flag is
 558    true for the insn being scheduled in reorg.
 559
 560    genattr.c defines the following flags which can be tested by
 561    (attr_flag "foo") expressions in eligible_for_delay.
 562
 563    forward, backward, very_likely, likely, very_unlikely, and unlikely.  */
 564
 565 DEF_RTL_EXPR (ATTR_FLAG, "attr_flag", "s", RTX_EXTRA)
 566
 567 /* ----------------------------------------------------------------------
 568    Expression types used for things in the instruction chain.
 569
 570    All formats must start with "iuu" to handle the chain.
 571    Each insn expression holds an rtl instruction and its semantics
 572    during back-end processing.
 573    See macros's in "rtl.h" for the meaning of each rtx->u.fld[].
 574
 575    ---------------------------------------------------------------------- */
 576
 577 /* An instruction that cannot jump.  */
 578 DEF_RTL_EXPR(INSN, "insn", "iuuBieiee", RTX_INSN)
 579
 580 /* An instruction that can possibly jump.
 581    Fields ( rtx->u.fld[] ) have exact same meaning as INSN's.  */
 582 DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "iuuBieiee0", RTX_INSN)
 583
 584 /* An instruction that can possibly call a subroutine
 585    but which will not change which instruction comes next
 586    in the current function.
 587    Field ( rtx->u.fld[9] ) is CALL_INSN_FUNCTION_USAGE.
 588    All other fields ( rtx->u.fld[] ) have exact same meaning as INSN's.  */
 589 DEF_RTL_EXPR(CALL_INSN, "call_insn", "iuuBieieee", RTX_INSN)
 590
 591 /* A marker that indicates that control will not flow through.  */
 592 DEF_RTL_EXPR(BARRIER, "barrier", "iuu000000", RTX_EXTRA)
 593
 594 /* Holds a label that is followed by instructions.
 595    Operand:
 596    4: is used in jump.c for the use-count of the label.
 597    5: is used in flow.c to point to the chain of label_ref's to this label.
 598    6: is a number that is unique in the entire compilation.
 599    7: is the user-given name of the label, if any.  */
 600 DEF_RTL_EXPR(CODE_LABEL, "code_label", "iuuB00is", RTX_EXTRA)
 601
 602 #ifdef USE_MAPPED_LOCATION
 603 /* Say where in the code a source line starts, for symbol table's sake.
 604    Operand:
 605    4: unused if line number > 0, note-specific data otherwise.
 606    5: line number if > 0, enum note_insn otherwise.
 607    6: CODE_LABEL_NUMBER if line number == NOTE_INSN_DELETED_LABEL.  */
 608 #else
 609 /* Say where in the code a source line starts, for symbol table's sake.
 610    Operand:
 611    4: filename, if line number > 0, note-specific data otherwise.
 612    5: line number if > 0, enum note_insn otherwise.
 613    6: unique number if line number == note_insn_deleted_label.  */
 614 #endif
 615 DEF_RTL_EXPR(NOTE, "note", "iuuB0ni", RTX_EXTRA)
 616
 617 /* ----------------------------------------------------------------------
 618    Top level constituents of INSN, JUMP_INSN and CALL_INSN.
 619    ---------------------------------------------------------------------- */
 620
 621 /* Conditionally execute code.
 622    Operand 0 is the condition that if true, the code is executed.
 623    Operand 1 is the code to be executed (typically a SET).
 624
 625    Semantics are that there are no side effects if the condition
 626    is false.  This pattern is created automatically by the if_convert
 627    pass run after reload or by target-specific splitters.  */
 628 DEF_RTL_EXPR(COND_EXEC, "cond_exec", "ee", RTX_EXTRA)
 629
 630 /* Several operations to be done in parallel (perhaps under COND_EXEC).  */
 631 DEF_RTL_EXPR(PARALLEL, "parallel", "E", RTX_EXTRA)
 632
 633 /* A string that is passed through to the assembler as input.
 634      One can obviously pass comments through by using the
 635      assembler comment syntax.
 636      These occur in an insn all by themselves as the PATTERN.
 637      They also appear inside an ASM_OPERANDS
 638      as a convenient way to hold a string.  */
 639 DEF_RTL_EXPR(ASM_INPUT, "asm_input", "s", RTX_EXTRA)
 640
 641 #ifdef USE_MAPPED_LOCATION
 642 /* An assembler instruction with operands.
 643    1st operand is the instruction template.
 644    2nd operand is the constraint for the output.
 645    3rd operand is the number of the output this expression refers to.
 646      When an insn stores more than one value, a separate ASM_OPERANDS
 647      is made for each output; this integer distinguishes them.
 648    4th is a vector of values of input operands.
 649    5th is a vector of modes and constraints for the input operands.
 650      Each element is an ASM_INPUT containing a constraint string
 651      and whose mode indicates the mode of the input operand.
 652    6th is the source line number.  */
 653 DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEi", RTX_EXTRA)
 654 #else
 655 /* An assembler instruction with operands.
 656    1st operand is the instruction template.
 657    2nd operand is the constraint for the output.
 658    3rd operand is the number of the output this expression refers to.
 659      When an insn stores more than one value, a separate ASM_OPERANDS
 660      is made for each output; this integer distinguishes them.
 661    4th is a vector of values of input operands.
 662    5th is a vector of modes and constraints for the input operands.
 663      Each element is an ASM_INPUT containing a constraint string
 664      and whose mode indicates the mode of the input operand.
 665    6th is the name of the containing source file.
 666    7th is the source line number.  */
 667 DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEsi", RTX_EXTRA)
 668 #endif
 669
 670 /* A machine-specific operation.
 671    1st operand is a vector of operands being used by the operation so that
 672      any needed reloads can be done.
 673    2nd operand is a unique value saying which of a number of machine-specific
 674      operations is to be performed.
 675    (Note that the vector must be the first operand because of the way that
 676    genrecog.c record positions within an insn.)
 677    This can occur all by itself in a PATTERN, as a component of a PARALLEL,
 678    or inside an expression.  */
 679 DEF_RTL_EXPR(UNSPEC, "unspec", "Ei", RTX_EXTRA)
 680
 681 /* Similar, but a volatile operation and one which may trap.  */
 682 DEF_RTL_EXPR(UNSPEC_VOLATILE, "unspec_volatile", "Ei", RTX_EXTRA)
 683
 684 /* Vector of addresses, stored as full words.  */
 685 /* Each element is a LABEL_REF to a CODE_LABEL whose address we want.  */
 686 DEF_RTL_EXPR(ADDR_VEC, "addr_vec", "E", RTX_EXTRA)
 687
 688 /* Vector of address differences X0 - BASE, X1 - BASE, ...
 689    First operand is BASE; the vector contains the X's.
 690    The machine mode of this rtx says how much space to leave
 691    for each difference and is adjusted by branch shortening if
 692    CASE_VECTOR_SHORTEN_MODE is defined.
 693    The third and fourth operands store the target labels with the
 694    minimum and maximum addresses respectively.
 695    The fifth operand stores flags for use by branch shortening.
 696   Set at the start of shorten_branches:
 697    min_align: the minimum alignment for any of the target labels.
 698    base_after_vec: true iff BASE is after the ADDR_DIFF_VEC.
 699    min_after_vec: true iff minimum addr target label is after the ADDR_DIFF_VEC.
 700    max_after_vec: true iff maximum addr target label is after the ADDR_DIFF_VEC.
 701    min_after_base: true iff minimum address target label is after BASE.
 702    max_after_base: true iff maximum address target label is after BASE.
 703   Set by the actual branch shortening process:
 704    offset_unsigned: true iff offsets have to be treated as unsigned.
 705    scale: scaling that is necessary to make offsets fit into the mode.
 706
 707    The third, fourth and fifth operands are only valid when
 708    CASE_VECTOR_SHORTEN_MODE is defined, and only in an optimizing
 709    compilations.  */
 710
 711 DEF_RTL_EXPR(ADDR_DIFF_VEC, "addr_diff_vec", "eEee0", RTX_EXTRA)
 712
 713 /* Memory prefetch, with attributes supported on some targets.
 714    Operand 1 is the address of the memory to fetch.
 715    Operand 2 is 1 for a write access, 0 otherwise.
 716    Operand 3 is the level of temporal locality; 0 means there is no
 717    temporal locality and 1, 2, and 3 are for increasing levels of temporal
 718    locality.
 719
 720    The attributes specified by operands 2 and 3 are ignored for targets
 721    whose prefetch instructions do not support them.  */
 722 DEF_RTL_EXPR(PREFETCH, "prefetch", "eee", RTX_EXTRA)
 723
 724 /* ----------------------------------------------------------------------
 725    At the top level of an instruction (perhaps under PARALLEL).
 726    ---------------------------------------------------------------------- */
 727
 728 /* Assignment.
 729    Operand 1 is the location (REG, MEM, PC, CC0 or whatever) assigned to.
 730    Operand 2 is the value stored there.
 731    ALL assignment must use SET.
 732    Instructions that do multiple assignments must use multiple SET,
 733    under PARALLEL.  */
 734 DEF_RTL_EXPR(SET, "set", "ee", RTX_EXTRA)
 735
 736 /* Indicate something is used in a way that we don't want to explain.
 737    For example, subroutine calls will use the register
 738    in which the static chain is passed.  */
 739 DEF_RTL_EXPR(USE, "use", "e", RTX_EXTRA)
 740
 741 /* Indicate something is clobbered in a way that we don't want to explain.
 742    For example, subroutine calls will clobber some physical registers
 743    (the ones that are by convention not saved).  */
 744 DEF_RTL_EXPR(CLOBBER, "clobber", "e", RTX_EXTRA)
 745
 746 /* Call a subroutine.
 747    Operand 1 is the address to call.
 748    Operand 2 is the number of arguments.  */
 749
 750 DEF_RTL_EXPR(CALL, "call", "ee", RTX_EXTRA)
 751
 752 /* Return from a subroutine.  */
 753
 754 DEF_RTL_EXPR(RETURN, "return", "", RTX_EXTRA)
 755
 756 /* Conditional trap.
 757    Operand 1 is the condition.
 758    Operand 2 is the trap code.
 759    For an unconditional trap, make the condition (const_int 1).  */
 760 DEF_RTL_EXPR(TRAP_IF, "trap_if", "ee", RTX_EXTRA)
 761
 762 /* Placeholder for _Unwind_Resume before we know if a function call
 763    or a branch is needed.  Operand 1 is the exception region from
 764    which control is flowing.  */
 765 DEF_RTL_EXPR(RESX, "resx", "i", RTX_EXTRA)
 766
 767 /* ----------------------------------------------------------------------
 768    Primitive values for use in expressions.
 769    ---------------------------------------------------------------------- */
 770
 771 /* numeric integer constant */
 772 DEF_RTL_EXPR(CONST_INT, "const_int", "w", RTX_CONST_OBJ)
 773
 774 /* numeric floating point constant.
 775    Operands hold the value.  They are all 'w' and there may be from 2 to 6;
 776    see real.h.  */
 777 DEF_RTL_EXPR(CONST_DOUBLE, "const_double", CONST_DOUBLE_FORMAT, RTX_CONST_OBJ)
 778
 779 /* Describes a vector constant.  */
 780 DEF_RTL_EXPR(CONST_VECTOR, "const_vector", "E", RTX_EXTRA)
 781
 782 /* String constant.  Used only for attributes right now.  */
 783 DEF_RTL_EXPR(CONST_STRING, "const_string", "s", RTX_OBJ)
 784
 785 /* This is used to encapsulate an expression whose value is constant
 786    (such as the sum of a SYMBOL_REF and a CONST_INT) so that it will be
 787    recognized as a constant operand rather than by arithmetic instructions.  */
 788
 789 DEF_RTL_EXPR(CONST, "const", "e", RTX_CONST_OBJ)
 790
 791 /* program counter.  Ordinary jumps are represented
 792    by a SET whose first operand is (PC).  */
 793 DEF_RTL_EXPR(PC, "pc", "", RTX_OBJ)
 794
 795 /* Used in the cselib routines to describe a value.  */
 796 DEF_RTL_EXPR(VALUE, "value", "0", RTX_OBJ)
 797
 798 /* A register.  The "operand" is the register number, accessed with
 799    the REGNO macro.  If this number is less than FIRST_PSEUDO_REGISTER
 800    than a hardware register is being referred to.  The second operand
 801    holds the original register number - this will be different for a
 802    pseudo register that got turned into a hard register.
 803    This rtx needs to have as many (or more) fields as a MEM, since we
 804    can change REG rtx's into MEMs during reload.  */
 805 DEF_RTL_EXPR(REG, "reg", "i00", RTX_OBJ)
 806
 807 /* A scratch register.  This represents a register used only within a
 808    single insn.  It will be turned into a REG during register allocation
 809    or reload unless the constraint indicates that the register won't be
 810    needed, in which case it can remain a SCRATCH.  This code is
 811    marked as having one operand so it can be turned into a REG.  */
 812 DEF_RTL_EXPR(SCRATCH, "scratch", "0", RTX_OBJ)
 813
 814 /* One word of a multi-word value.
 815    The first operand is the complete value; the second says which word.
 816    The WORDS_BIG_ENDIAN flag controls whether word number 0
 817    (as numbered in a SUBREG) is the most or least significant word.
 818
 819    This is also used to refer to a value in a different machine mode.
 820    For example, it can be used to refer to a SImode value as if it were
 821    Qimode, or vice versa.  Then the word number is always 0.  */
 822 DEF_RTL_EXPR(SUBREG, "subreg", "ei", RTX_EXTRA)
 823
 824 /* This one-argument rtx is used for move instructions
 825    that are guaranteed to alter only the low part of a destination.
 826    Thus, (SET (SUBREG:HI (REG...)) (MEM:HI ...))
 827    has an unspecified effect on the high part of REG,
 828    but (SET (STRICT_LOW_PART (SUBREG:HI (REG...))) (MEM:HI ...))
 829    is guaranteed to alter only the bits of REG that are in HImode.
 830
 831    The actual instruction used is probably the same in both cases,
 832    but the register constraints may be tighter when STRICT_LOW_PART
 833    is in use.  */
 834
 835 DEF_RTL_EXPR(STRICT_LOW_PART, "strict_low_part", "e", RTX_EXTRA)
 836
 837 /* (CONCAT a b) represents the virtual concatenation of a and b
 838    to make a value that has as many bits as a and b put together.
 839    This is used for complex values.  Normally it appears only
 840    in DECL_RTLs and during RTL generation, but not in the insn chain.  */
 841 DEF_RTL_EXPR(CONCAT, "concat", "ee", RTX_OBJ)
 842
 843 /* A memory location; operand is the address.  The second operand is the
 844    alias set to which this MEM belongs.  We use `0' instead of `w' for this
 845    field so that the field need not be specified in machine descriptions.  */
 846 DEF_RTL_EXPR(MEM, "mem", "e0", RTX_OBJ)
 847
 848 /* Reference to an assembler label in the code for this function.
 849    The operand is a CODE_LABEL found in the insn chain.
 850    The unprinted fields 1 and 2 are used in flow.c for the
 851    LABEL_NEXTREF and CONTAINING_INSN.  */
 852 DEF_RTL_EXPR(LABEL_REF, "label_ref", "u00", RTX_CONST_OBJ)
 853
 854 /* Reference to a named label:
 855    Operand 0: label name
 856    Operand 1: flags (see SYMBOL_FLAG_* in rtl.h)
 857    Operand 2: tree from which this symbol is derived, or null.
 858    This is either a DECL node, or some kind of constant.  */
 859 DEF_RTL_EXPR(SYMBOL_REF, "symbol_ref", "s00", RTX_CONST_OBJ)
 860
 861 /* The condition code register is represented, in our imagination,
 862    as a register holding a value that can be compared to zero.
 863    In fact, the machine has already compared them and recorded the
 864    results; but instructions that look at the condition code
 865    pretend to be looking at the entire value and comparing it.  */
 866 DEF_RTL_EXPR(CC0, "cc0", "", RTX_OBJ)
 867
 868 /* ----------------------------------------------------------------------
 869    Expressions for operators in an rtl pattern
 870    ---------------------------------------------------------------------- */
 871
 872 /* if_then_else.  This is used in representing ordinary
 873    conditional jump instructions.
 874      Operand:
 875      0:  condition
 876      1:  then expr
 877      2:  else expr */
 878 DEF_RTL_EXPR(IF_THEN_ELSE, "if_then_else", "eee", RTX_TERNARY)
 879
 880 /* General conditional. The first operand is a vector composed of pairs of
 881    expressions.  The first element of each pair is evaluated, in turn.
 882    The value of the conditional is the second expression of the first pair
 883    whose first expression evaluates nonzero.  If none of the expressions is
 884    true, the second operand will be used as the value of the conditional.
 885
 886    This should be replaced with use of IF_THEN_ELSE.  */
 887 DEF_RTL_EXPR(COND, "cond", "Ee", RTX_EXTRA)
 888
 889 /* Comparison, produces a condition code result.  */
 890 DEF_RTL_EXPR(COMPARE, "compare", "ee", RTX_BIN_ARITH)
 891
 892 /* plus */
 893 DEF_RTL_EXPR(PLUS, "plus", "ee", RTX_COMM_ARITH)
 894
 895 /* Operand 0 minus operand 1.  */
 896 DEF_RTL_EXPR(MINUS, "minus", "ee", RTX_BIN_ARITH)
 897
 898 /* Minus operand 0.  */
 899 DEF_RTL_EXPR(NEG, "neg", "e", RTX_UNARY)
 900
 901 DEF_RTL_EXPR(MULT, "mult", "ee", RTX_COMM_ARITH)
 902
 903 /* Operand 0 divided by operand 1.  */
 904 DEF_RTL_EXPR(DIV, "div", "ee", RTX_BIN_ARITH)
 905 /* Remainder of operand 0 divided by operand 1.  */
 906 DEF_RTL_EXPR(MOD, "mod", "ee", RTX_BIN_ARITH)
 907
 908 /* Unsigned divide and remainder.  */
 909 DEF_RTL_EXPR(UDIV, "udiv", "ee", RTX_BIN_ARITH)
 910 DEF_RTL_EXPR(UMOD, "umod", "ee", RTX_BIN_ARITH)
 911
 912 /* Bitwise operations.  */
 913 DEF_RTL_EXPR(AND, "and", "ee", RTX_COMM_ARITH)
 914
 915 DEF_RTL_EXPR(IOR, "ior", "ee", RTX_COMM_ARITH)
 916
 917 DEF_RTL_EXPR(XOR, "xor", "ee", RTX_COMM_ARITH)
 918
 919 DEF_RTL_EXPR(NOT, "not", "e", RTX_UNARY)
 920
 921 /* Operand:
 922      0:  value to be shifted.
 923      1:  number of bits.  */
 924 DEF_RTL_EXPR(ASHIFT, "ashift", "ee", RTX_BIN_ARITH) /* shift left */
 925 DEF_RTL_EXPR(ROTATE, "rotate", "ee", RTX_BIN_ARITH) /* rotate left */
 926 DEF_RTL_EXPR(ASHIFTRT, "ashiftrt", "ee", RTX_BIN_ARITH) /* arithmetic shift right */
 927 DEF_RTL_EXPR(LSHIFTRT, "lshiftrt", "ee", RTX_BIN_ARITH) /* logical shift right */
 928 DEF_RTL_EXPR(ROTATERT, "rotatert", "ee", RTX_BIN_ARITH) /* rotate right */
 929
 930 /* Minimum and maximum values of two operands.  We need both signed and
 931    unsigned forms.  (We cannot use MIN for SMIN because it conflicts
 932    with a macro of the same name.) */
 933
 934 DEF_RTL_EXPR(SMIN, "smin", "ee", RTX_COMM_ARITH)
 935 DEF_RTL_EXPR(SMAX, "smax", "ee", RTX_COMM_ARITH)
 936 DEF_RTL_EXPR(UMIN, "umin", "ee", RTX_COMM_ARITH)
 937 DEF_RTL_EXPR(UMAX, "umax", "ee", RTX_COMM_ARITH)
 938
 939 /* These unary operations are used to represent incrementation
 940    and decrementation as they occur in memory addresses.
 941    The amount of increment or decrement are not represented
 942    because they can be understood from the machine-mode of the
 943    containing MEM.  These operations exist in only two cases:
 944    1. pushes onto the stack.
 945    2. created automatically by the life_analysis pass in flow.c.  */
 946 DEF_RTL_EXPR(PRE_DEC, "pre_dec", "e", RTX_AUTOINC)
 947 DEF_RTL_EXPR(PRE_INC, "pre_inc", "e", RTX_AUTOINC)
 948 DEF_RTL_EXPR(POST_DEC, "post_dec", "e", RTX_AUTOINC)
 949 DEF_RTL_EXPR(POST_INC, "post_inc", "e", RTX_AUTOINC)
 950
 951 /* These binary operations are used to represent generic address
 952    side-effects in memory addresses, except for simple incrementation
 953    or decrementation which use the above operations.  They are
 954    created automatically by the life_analysis pass in flow.c.
 955    The first operand is a REG which is used as the address.
 956    The second operand is an expression that is assigned to the
 957    register, either before (PRE_MODIFY) or after (POST_MODIFY)
 958    evaluating the address.
 959    Currently, the compiler can only handle second operands of the
 960    form (plus (reg) (reg)) and (plus (reg) (const_int)), where
 961    the first operand of the PLUS has to be the same register as
 962    the first operand of the *_MODIFY.  */
 963 DEF_RTL_EXPR(PRE_MODIFY, "pre_modify", "ee", RTX_AUTOINC)
 964 DEF_RTL_EXPR(POST_MODIFY, "post_modify", "ee", RTX_AUTOINC)
 965
 966 /* Comparison operations.  The ordered comparisons exist in two
 967    flavors, signed and unsigned.  */
 968 DEF_RTL_EXPR(NE, "ne", "ee", RTX_COMM_COMPARE)
 969 DEF_RTL_EXPR(EQ, "eq", "ee", RTX_COMM_COMPARE)
 970 DEF_RTL_EXPR(GE, "ge", "ee", RTX_COMPARE)
 971 DEF_RTL_EXPR(GT, "gt", "ee", RTX_COMPARE)
 972 DEF_RTL_EXPR(LE, "le", "ee", RTX_COMPARE)
 973 DEF_RTL_EXPR(LT, "lt", "ee", RTX_COMPARE)
 974 DEF_RTL_EXPR(GEU, "geu", "ee", RTX_COMPARE)
 975 DEF_RTL_EXPR(GTU, "gtu", "ee", RTX_COMPARE)
 976 DEF_RTL_EXPR(LEU, "leu", "ee", RTX_COMPARE)
 977 DEF_RTL_EXPR(LTU, "ltu", "ee", RTX_COMPARE)
 978
 979 /* Additional floating point unordered comparison flavors.  */
 980 DEF_RTL_EXPR(UNORDERED, "unordered", "ee", RTX_COMM_COMPARE)
 981 DEF_RTL_EXPR(ORDERED, "ordered", "ee", RTX_COMM_COMPARE)
 982
 983 /* These are equivalent to unordered or ...  */
 984 DEF_RTL_EXPR(UNEQ, "uneq", "ee", RTX_COMM_COMPARE)
 985 DEF_RTL_EXPR(UNGE, "unge", "ee", RTX_COMPARE)
 986 DEF_RTL_EXPR(UNGT, "ungt", "ee", RTX_COMPARE)
 987 DEF_RTL_EXPR(UNLE, "unle", "ee", RTX_COMPARE)
 988 DEF_RTL_EXPR(UNLT, "unlt", "ee", RTX_COMPARE)
 989
 990 /* This is an ordered NE, ie !UNEQ, ie false for NaN.  */
 991 DEF_RTL_EXPR(LTGT, "ltgt", "ee", RTX_COMM_COMPARE)
 992
 993 /* Represents the result of sign-extending the sole operand.
 994    The machine modes of the operand and of the SIGN_EXTEND expression
 995    determine how much sign-extension is going on.  */
 996 DEF_RTL_EXPR(SIGN_EXTEND, "sign_extend", "e", RTX_UNARY)
 997
 998 /* Similar for zero-extension (such as unsigned short to int).  */
 999 DEF_RTL_EXPR(ZERO_EXTEND, "zero_extend", "e", RTX_UNARY)
1000
1001 /* Similar but here the operand has a wider mode.  */
1002 DEF_RTL_EXPR(TRUNCATE, "truncate", "e", RTX_UNARY)
1003
1004 /* Similar for extending floating-point values (such as SFmode to DFmode).  */
1005 DEF_RTL_EXPR(FLOAT_EXTEND, "float_extend", "e", RTX_UNARY)
1006 DEF_RTL_EXPR(FLOAT_TRUNCATE, "float_truncate", "e", RTX_UNARY)
1007
1008 /* Conversion of fixed point operand to floating point value.  */
1009 DEF_RTL_EXPR(FLOAT, "float", "e", RTX_UNARY)
1010
1011 /* With fixed-point machine mode:
1012    Conversion of floating point operand to fixed point value.
1013    Value is defined only when the operand's value is an integer.
1014    With floating-point machine mode (and operand with same mode):
1015    Operand is rounded toward zero to produce an integer value
1016    represented in floating point.  */
1017 DEF_RTL_EXPR(FIX, "fix", "e", RTX_UNARY)
1018
1019 /* Conversion of unsigned fixed point operand to floating point value.  */
1020 DEF_RTL_EXPR(UNSIGNED_FLOAT, "unsigned_float", "e", RTX_UNARY)
1021
1022 /* With fixed-point machine mode:
1023    Conversion of floating point operand to *unsigned* fixed point value.
1024    Value is defined only when the operand's value is an integer.  */
1025 DEF_RTL_EXPR(UNSIGNED_FIX, "unsigned_fix", "e", RTX_UNARY)
1026
1027 /* Absolute value */
1028 DEF_RTL_EXPR(ABS, "abs", "e", RTX_UNARY)
1029
1030 /* Square root */
1031 DEF_RTL_EXPR(SQRT, "sqrt", "e", RTX_UNARY)
1032
1033 /* Find first bit that is set.
1034    Value is 1 + number of trailing zeros in the arg.,
1035    or 0 if arg is 0.  */
1036 DEF_RTL_EXPR(FFS, "ffs", "e", RTX_UNARY)
1037
1038 /* Count leading zeros.  */
1039 DEF_RTL_EXPR(CLZ, "clz", "e", RTX_UNARY)
1040
1041 /* Count trailing zeros.  */
1042 DEF_RTL_EXPR(CTZ, "ctz", "e", RTX_UNARY)
1043
1044 /* Population count (number of 1 bits).  */
1045 DEF_RTL_EXPR(POPCOUNT, "popcount", "e", RTX_UNARY)
1046
1047 /* Population parity (number of 1 bits modulo 2).  */
1048 DEF_RTL_EXPR(PARITY, "parity", "e", RTX_UNARY)
1049
1050 /* Reference to a signed bit-field of specified size and position.
1051    Operand 0 is the memory unit (usually SImode or QImode) which
1052    contains the field's first bit.  Operand 1 is the width, in bits.
1053    Operand 2 is the number of bits in the memory unit before the
1054    first bit of this field.
1055    If BITS_BIG_ENDIAN is defined, the first bit is the msb and
1056    operand 2 counts from the msb of the memory unit.
1057    Otherwise, the first bit is the lsb and operand 2 counts from
1058    the lsb of the memory unit.  */
1059 DEF_RTL_EXPR(SIGN_EXTRACT, "sign_extract", "eee", RTX_BITFIELD_OPS)
1060
1061 /* Similar for unsigned bit-field.  */
1062 DEF_RTL_EXPR(ZERO_EXTRACT, "zero_extract", "eee", RTX_BITFIELD_OPS)
1063
1064 /* For RISC machines.  These save memory when splitting insns.  */
1065
1066 /* HIGH are the high-order bits of a constant expression.  */
1067 DEF_RTL_EXPR(HIGH, "high", "e", RTX_CONST_OBJ)
1068
1069 /* LO_SUM is the sum of a register and the low-order bits
1070    of a constant expression.  */
1071 DEF_RTL_EXPR(LO_SUM, "lo_sum", "ee", RTX_OBJ)
1072
1073 /* Header for range information.  Operand 0 is the NOTE_INSN_RANGE_BEG insn.
1074    Operand 1 is the NOTE_INSN_RANGE_END insn.  Operand 2 is a vector of all of
1075    the registers that can be substituted within this range.  Operand 3 is the
1076    number of calls in the range.  Operand 4 is the number of insns in the
1077    range.  Operand 5 is the unique range number for this range.  Operand 6 is
1078    the basic block # of the start of the live range.  Operand 7 is the basic
1079    block # of the end of the live range.  Operand 8 is the loop depth.  Operand
1080    9 is a bitmap of the registers live at the start of the range.  Operand 10
1081    is a bitmap of the registers live at the end of the range.  Operand 11 is
1082    marker number for the start of the range.  Operand 12 is the marker number
1083    for the end of the range.  */
1084 DEF_RTL_EXPR(RANGE_INFO, "range_info", "uuEiiiiiibbii", RTX_EXTRA)
1085
1086 /* Registers that can be substituted within the range.  Operand 0 is the
1087    original pseudo register number.  Operand 1 will be filled in with the
1088    pseudo register the value is copied for the duration of the range.  Operand
1089    2 is the number of references within the range to the register.  Operand 3
1090    is the number of sets or clobbers of the register in the range.  Operand 4
1091    is the number of deaths the register has.  Operand 5 is the copy flags that
1092    give the status of whether a copy is needed from the original register to
1093    the new register at the beginning of the range, or whether a copy from the
1094    new register back to the original at the end of the range.  Operand 6 is the
1095    live length.  Operand 7 is the number of calls that this register is live
1096    across.  Operand 8 is the symbol node of the variable if the register is a
1097    user variable.  Operand 9 is the block node that the variable is declared
1098    in if the register is a user variable.  */
1099 DEF_RTL_EXPR(RANGE_REG, "range_reg", "iiiiiiiitt", RTX_EXTRA)
1100
1101 /* Information about a local variable's ranges.  Operand 0 is an EXPR_LIST of
1102    the different ranges a variable is in where it is copied to a different
1103    pseudo register.  Operand 1 is the block that the variable is declared in.
1104    Operand 2 is the number of distinct ranges.  */
1105 DEF_RTL_EXPR(RANGE_VAR, "range_var", "eti", RTX_EXTRA)
1106
1107 /* Information about the registers that are live at the current point.  Operand
1108    0 is the live bitmap.  Operand 1 is the original block number.  */
1109 DEF_RTL_EXPR(RANGE_LIVE, "range_live", "bi", RTX_EXTRA)
1110
1111 /* Describes a merge operation between two vector values.
1112    Operands 0 and 1 are the vectors to be merged, operand 2 is a bitmask
1113    that specifies where the parts of the result are taken from.  Set bits
1114    indicate operand 0, clear bits indicate operand 1.  The parts are defined
1115    by the mode of the vectors.  */
1116 DEF_RTL_EXPR(VEC_MERGE, "vec_merge", "eee", RTX_TERNARY)
1117
1118 /* Describes an operation that selects parts of a vector.
1119    Operands 0 is the source vector, operand 1 is a PARALLEL that contains
1120    a CONST_INT for each of the subparts of the result vector, giving the
1121    number of the source subpart that should be stored into it.  */
1122 DEF_RTL_EXPR(VEC_SELECT, "vec_select", "ee", RTX_BIN_ARITH)
1123
1124 /* Describes a vector concat operation.  Operands 0 and 1 are the source
1125    vectors, the result is a vector that is as long as operands 0 and 1
1126    combined and is the concatenation of the two source vectors.  */
1127 DEF_RTL_EXPR(VEC_CONCAT, "vec_concat", "ee", RTX_BIN_ARITH)
1128
1129 /* Describes an operation that converts a small vector into a larger one by
1130    duplicating the input values.  The output vector mode must have the same
1131    submodes as the input vector mode, and the number of output parts must be
1132    an integer multiple of the number of input parts.  */
1133 DEF_RTL_EXPR(VEC_DUPLICATE, "vec_duplicate", "e", RTX_UNARY)
1134
1135 /* Addition with signed saturation */
1136 DEF_RTL_EXPR(SS_PLUS, "ss_plus", "ee", RTX_COMM_ARITH)
1137
1138 /* Addition with unsigned saturation */
1139 DEF_RTL_EXPR(US_PLUS, "us_plus", "ee", RTX_COMM_ARITH)
1140
1141 /* Operand 0 minus operand 1, with signed saturation.  */
1142 DEF_RTL_EXPR(SS_MINUS, "ss_minus", "ee", RTX_BIN_ARITH)
1143
1144 /* Operand 0 minus operand 1, with unsigned saturation.  */
1145 DEF_RTL_EXPR(US_MINUS, "us_minus", "ee", RTX_BIN_ARITH)
1146
1147 /* Signed saturating truncate.  */
1148 DEF_RTL_EXPR(SS_TRUNCATE, "ss_truncate", "e", RTX_UNARY)
1149
1150 /* Unsigned saturating truncate.  */
1151 DEF_RTL_EXPR(US_TRUNCATE, "us_truncate", "e", RTX_UNARY)
1152
1153 /* Information about the variable and its location.  */
1154 DEF_RTL_EXPR(VAR_LOCATION, "var_location", "te", RTX_EXTRA)
1155
1156 /*
1157 Local variables:
1158 mode:c
1159 End:
1160 */