Machine-Independent Predicates (GNU Compiler Collection (GCC) Internals)

#### 18.8.1 Machine-Independent Predicates ¶

These are the generic predicates available to all back ends. They are defined in `recog.cc`. The first category of predicates allow only constant, or immediate, operands.

Function: immediate_operand ¶

  This predicate allows any sort of constant that fits in mode. It is an appropriate choice for instructions that take operands that must be constant.

Function: const_int_operand ¶

  This predicate allows any `CONST_INT` expression that fits in mode. It is an appropriate choice for an immediate operand that does not allow a symbol or label.

Function: const_double_operand ¶

  This predicate accepts any `CONST_DOUBLE` expression that has exactly mode. If mode is `VOIDmode`, it will also accept `CONST_INT`. It is intended for immediate floating point constants.

The second category of predicates allow only some kind of machine register.

Function: register_operand ¶

  This predicate allows any `REG` or `SUBREG` expression that is valid for mode. It is often suitable for arithmetic instruction operands on a RISC machine.

Function: pmode_register_operand ¶

  This is a slight variant on `register_operand` which works around a limitation in the machine-description reader.

      (match_operand n "pmode_register_operand" constraint)

  means exactly what

      (match_operand:P n "register_operand" constraint)

  would mean, if the machine-description reader accepted ‘`:P`’ mode suffixes. Unfortunately, it cannot, because `Pmode` is an alias for some other mode, and might vary with machine-specific options. See Miscellaneous Parameters.

Function: scratch_operand ¶

  This predicate allows hard registers and `SCRATCH` expressions, but not pseudo-registers. It is used internally by `match_scratch`; it should not be used directly.

The third category of predicates allow only some kind of memory reference.

Function: memory_operand ¶

  This predicate allows any valid reference to a quantity of mode mode in memory, as determined by the weak form of `GO_IF_LEGITIMATE_ADDRESS` (see Addressing Modes).

Function: address_operand ¶

  This predicate is a little unusual; it allows any operand that is a valid expression for the address of a quantity of mode mode, again determined by the weak form of `GO_IF_LEGITIMATE_ADDRESS`. To first order, if ‘`(mem:mode (exp))`’ is acceptable to `memory_operand`, then exp is acceptable to `address_operand`. Note that exp does not necessarily have the mode mode.

Function: indirect_operand ¶

  This is a stricter form of `memory_operand` which allows only memory references with a `general_operand` as the address expression. New uses of this predicate are discouraged, because `general_operand` is very permissive, so it’s hard to tell what an `indirect_operand` does or does not allow. If a target has different requirements for memory operands for different instructions, it is better to define target-specific predicates which enforce the hardware’s requirements explicitly.

Function: push_operand ¶

  This predicate allows a memory reference suitable for pushing a value onto the stack. This will be a `MEM` which refers to `stack_pointer_rtx`, with a side effect in its address expression (see Embedded Side-Effects on Addresses); which one is determined by the `STACK_PUSH_CODE` macro (see Basic Stack Layout).

Function: pop_operand ¶

  This predicate allows a memory reference suitable for popping a value off the stack. Again, this will be a `MEM` referring to `stack_pointer_rtx`, with a side effect in its address expression. However, this time `STACK_POP_CODE` is expected.

The fourth category of predicates allow some combination of the above operands.

Function: nonmemory_operand ¶

  This predicate allows any immediate or register operand valid for mode.

Function: nonimmediate_operand ¶

  This predicate allows any register or memory operand valid for mode.

Function: general_operand ¶

  This predicate allows any immediate, register, or memory operand valid for mode.

Finally, there are two generic operator predicates.

Function: comparison_operator ¶

  This predicate matches any expression which performs an arithmetic comparison in mode; that is, `COMPARISON_P` is true for the expression code.

Function: ordered_comparison_operator ¶

  This predicate matches any expression which performs an arithmetic comparison in mode and whose expression code is valid for integer modes; that is, the expression code will be one of `eq`, `ne`, `lt`, `ltu`, `le`, `leu`, `gt`, `gtu`, `ge`, `geu`.