gcc/doc/md.texi

527 constant value without the syntax that normally indicates an immediate
531 the constant is negated before printing.
649 @code{int} than the target machine has in the mode in which the constant
659 that you declare locally and initialize yourself.
760 constant will fit in the requested mode.
788 only constant, or @dfn{immediate}, operands.
791 This predicate allows any sort of constant that fits in @var{mode}.
793 must be constant.
961 The first operand of this expression is a string constant containing a
965 The second operand is a string constant which indicates what
967 string, @var{op} itself is examined.  Otherwise, the string constant
981 This expression has one operand, a string constant containing a C
1055 kind of constant fits in the requested mode.  This is because
1101 operand may be an immediate constant, and which possible values it may
1163 For example, an address which is constant is offsettable; so is an
1164 address that is the sum of a register and a constant (as long as a
1165 slightly larger constant is also within the range of address-offsets
1209 An immediate integer operand (one with constant value) is allowed.
1215 An immediate integer operand with a known numeric value is allowed.
1251 This might appear strange; if an insn allows a constant operand with a
1431 An operand whose predicate accepts only constant values is safe
1433 constant value is accepted, then nothing less than @samp{i} will do;
1452 A constant operand can be reloaded by allocating space in memory to
1454 in place of the constant.  So if the constraint uses the letters
1455 @samp{o} or @samp{m}, constant operands are not a problem.
1458 If the constraint permits a constant and a pseudo register used in an insn
1459 was not allocated to a hard register and is equivalent to a constant,
1460 the register will be replaced with the constant.  If the predicate does
1461 not permit a constant and the insn is re-recognized for some reason, the
1729 immediate-constant format.
1764 Integer constant that is valid as an immediate operand in an @code{ADD}
1768 Integer constant that is valid as an immediate operand in a @code{SUB}
1772 Integer constant that can be used with a 32-bit logical instruction
1775 Integer constant that can be used with a 64-bit logical instruction
1778 Integer constant that is valid as an immediate operand in a 32-bit @code{MOV}
1783 Integer constant that is valid as an immediate operand in a 64-bit @code{MOV}
1790 Floating point constant zero
1793 Integer constant zero
1818 Immediate constant @minus{}1
1824 Immediate constant that can be inlined in an instruction encoding: integer
1836 Immediate 64-bit constant that can be split into two @samp{A} constants
1839 Immediate 64-bit constant that can be split into two @samp{B} constants
1919 A signed 12-bit integer constant.
1922 constant for arithmetic/logical operations.  This might be any constant
1927 A 3-bit unsigned integer constant.
1930 A 6-bit unsigned integer constant.
1933 One's complement of a 6-bit unsigned integer constant.
1936 Two's complement of a 6-bit unsigned integer constant.
1939 A 5-bit unsigned integer constant.
1942 A 7-bit unsigned integer constant.
1945 A 8-bit unsigned integer constant.
1979 The floating-point constant 0.0
2003 An item in the constant pool
2009 A memory reference suitable for VFP load/store insns (reg+constant offset)
2078 A floating point constant 0.0
2173 Constant @var{n}, where @var{n} is a single-digit constant in the range 0 to 4.
2190 An integer constant with exactly a single bit set.
2193 An integer constant with all bits set except exactly one.
2214 Signed constant that fits in 4 bits
2217 Signed constant that fits in 5 bits
2220 Signed constant that fits in 6 bits
2223 Unsigned constant that fits in 4 bits
2226 Signed constant that fits in 32 bits
2232 Floating point constant that is legal for store immediate
2266 than inline asm, such as constraints representing constant integer
2274 An unsigned 16-bit constant.
2277 An unsigned 5-bit constant.
2280 A signed 11-bit constant.
2283 A signed 11-bit constant added to @minus{}1.
2302 Symbolic constant for call/jump instruction.
2408 Floating point constant zero
2411 6-bit signed integer constant
2414 10-bit signed integer constant
2417 16-bit signed integer constant
2420 16-bit unsigned integer constant
2423 12-bit signed integer constant that is negative---i.e.@: in the
2430 12-bit signed integer constant that is greater than zero---i.e.@: in the
2453 The constant zero or one
2456 A 16-bit signed constant (@minus{}32768 @dots{} 32767)
2465 A 16-bit unsigned constant, multiple of 4 (0 @dots{} 65532)
2468 A 20-bit signed constant (@minus{}524288 @dots{} 524287)
2471 A constant for a bitfield width (1 @dots{} 16)
2474 A 10-bit signed constant (@minus{}512 @dots{} 511)
2499 Signed 11-bit integer constant
2502 Signed 14-bit integer constant
2505 Integer constant that can be deposited with a @code{zdepi} instruction
2508 Signed 5-bit integer constant
2511 Integer constant 0
2514 Integer constant that can be loaded with a @code{ldil} instruction
2517 Integer constant whose value plus one is a power of 2
2520 Integer constant that can be used for @code{and} operations in @code{depi}
2524 Integer constant 31
2527 Integer constant 63
2530 Floating-point constant 0.0
2575 Floating-point constant 0.0 or 1.0
2578 14-bit signed integer constant
2581 22-bit signed integer constant
2584 8-bit signed integer constant for logical instructions
2587 8-bit adjusted signed integer constant for compare pseudo-ops
2590 6-bit unsigned integer constant for shift counts
2593 9-bit signed integer constant for load and store postincrements
2596 The constant zero
2605 Integer constant in the range 1 to 4 for @code{shladd} instruction
2787 A signed 16-bit constant (for arithmetic instructions).
2793 An unsigned 16-bit constant (for logic instructions).
2796 A signed 32-bit constant in which the lower 16 bits are zero.
2800 A constant that cannot be loaded using @code{lui}, @code{addiu}
2804 A constant in the range @minus{}65535 to @minus{}1 (inclusive).
2807 A signed 15-bit constant.
2810 A constant in the range 1 to 65535 (inclusive).
2867 Floating point constant that is not a 68881 constant
2928 A constant in the range of 0 to 255.
2931 A constant in the range of 0 to @minus{}255.
2945 Integer constant 1.
2948 Integer constant -1^20..1^19.
2951 Integer constant 1-4.
3007 A constant which is not in the range of imm15u but ok for bclr instruction.
3009 A constant which is not in the range of imm15u but ok for bset instruction.
3011 A constant which is not in the range of imm15u but ok for btgl instruction.
3013 A constant whose compliment value is in the range of imm15u
3119 Signed 16-bit constant shifted left 16 bits. (Used with @code{l.movhi})
3149 Floating point constant 0.
3156 An integer constant that fits in 16 bits.
3159 An integer constant whose low order 16 bits are zero.
3162 An integer constant that does not meet the constraints for codes
3166 The integer constant 1.
3169 The integer constant @minus{}1.
3172 The integer constant 0.
3268 Signed 5-bit constant integer that can be loaded into an Altivec register.
3271 Int constant that is the element number of the 64-bit scalar in a vector.
3274 Vector constant that can be loaded with the XXSPLTIB instruction.
3280 Int constant that is the element number mfvsrld accesses in a vector.
3283 Match vector constant with all 1's if the XXLORC instruction is available.
3292 Vector constant that can be loaded with XXSPLTIB & sign extension.
3302 A signed 16-bit constant.
3305 An unsigned 16-bit constant shifted left 16 bits (use @code{L} instead
3309 An unsigned 16-bit constant.
3312 A signed 16-bit constant shifted left 16 bits.
3316 An integer constant greater than 31.
3322 The integer constant zero.
3325 A constant whose negation is a signed 16-bit constant.
3329 A signed 34-bit integer constant if prefixed instructions are supported.
3333 A floating point constant that can be loaded into a register with one
3337 A floating point constant that can be loaded into a register using
3396 A vector constant that does not require memory.
3399 The zero vector constant.
3407 An unsigned 8-bit integer constant.
3410 An unsigned 16-bit integer constant.
3413 An unsigned 5-bit integer constant (for shift counts).
3416 A text segment (program memory) constant label.
3419 Integer constant zero.
3427 An integer constant in the range 1 @dots{} 7.
3429 An integer constant in the range 0 @dots{} 255.
3431 An integer constant in the range @minus{}255 @dots{} 0
3433 The integer constant 1.
3435 The integer constant -1.
3437 The integer constant 0.
3439 The integer constant 2.
3441 The integer constant -2.
3443 An integer constant in the range 1 @dots{} 15.
3543 A constant in the range @minus{}256 to 255, inclusive.
3546 A constant in the range @minus{}128 to 127, inclusive.
3549 A constant in the range @minus{}32768 to 32767, inclusive.
3552 A constant in the range @minus{}8388608 to 8388607, inclusive.
3555 A constant in the range 0 to 15, inclusive.
3574 Unsigned 8-bit constant (0--255)
3577 Unsigned 12-bit constant (0--4095)
3580 Signed 16-bit constant (@minus{}32768--32767)
3606 The constraint matches if the specified part of a constant
3659 The constant all-ones, for floating-point.
3662 Signed 5-bit constant
3665 A vector constant
3668 Signed 13-bit constant
3674 32-bit constant with the low 12 bits clear (a constant that can be
3678 A constant in the range supported by @code{movcc} instructions (11-bit
3682 A constant in the range supported by @code{movrcc} instructions (10-bit
3691 The constant 4096
3697 Signed 13-bit constant, sign-extended to 32 or 64 bits
3700 The constant -1
3703 Floating-point constant whose integral representation can
3708 Floating-point constant whose integral representation can
3713 Floating-point constant whose integral representation can
3760 Integer constant in the range 0 @dots{} 15.
3763 Integer constant in the range 0 @dots{} 31.
3766 Integer constant in the range @minus{}31 @dots{} 0.
3769 Integer constant in the range @minus{}16 @dots{} 15.
3772 Integer constant that can be the operand of an ADDA or a SUBA insn.
3775 Integer constant in the range 0 @dots{} 65535.
3778 Integer constant in the range @minus{}32768 @dots{} 32767.
3781 Integer constant in the range @math{-2^{20}} @dots{} @math{2^{20} - 1}.
3784 Integer constant that is a valid mask for the clr instruction.
3787 Integer constant that is a valid mask for the set instruction.
3834 Signed 8-bit integer constant.
3837 Signed 16-bit integer constant.
3840 Unsigned 16-bit integer constant.
3843 Integer constant that fits in one signed byte when incremented by one
3859 Integer constant that is a byte tiled out eight times.
3862 The integer zero constant.
3865 Integer constant that is a sign-extended byte tiled out as four shorts.
3868 Integer constant that fits in one signed byte when incremented
3872 Integer constant that has all 1 bits consecutive and starting at bit 0.
3882 An 8-element vector constant with identical elements.
3885 A 4-element vector constant with identical elements.
3888 The integer constant 0xffffffff.
3891 The integer constant 0xffffffff00000000.
3912 Signed 8-bit integer constant.
3915 Signed 16-bit integer constant.
3918 Nonzero integer constant with low 16 bits zero.
3921 Integer constant that fits in one signed byte when incremented by one
3937 Integer constant that is a byte tiled out four times.
3940 The integer zero constant.
3943 Integer constant that is a sign-extended byte tiled out as two shorts.
3946 Integer constant that fits in one signed byte when incremented
3958 A 4-element vector constant with identical elements.
3961 A 2-element vector constant with identical elements.
3994 Floating-point constant 0.0
3997 Integer constant in the range 0 .. 65535 (16-bit immediate)
4000 Integer constant in the range 1 .. 31 (5-bit immediate)
4003 Integer constant in the range @minus{}65535 .. @minus{}1 (16-bit negative immediate)
4006 Integer constant @minus{}1
4009 Integer constant 0
4012 Integer constant 32
4181 SSE constant -1 operand.
4185 Integer constant in the range 0 @dots{} 31, for 32-bit shifts.
4188 Integer constant in the range 0 @dots{} 63, for 64-bit shifts.
4191 Signed 8-bit integer constant.
4200 Unsigned 8-bit integer constant (for @code{in} and @code{out}
4205 Integer constant in the range 0 @dots{} 127, for 128-bit shifts.
4209 Standard 80387 floating point constant.
4212 SSE constant zero operand.
4215 32-bit signed integer constant, or a symbolic reference known
4220 32-bit signed integer constant, or a symbolic reference known
4225 32-bit unsigned integer constant, or a symbolic reference known
4230 128-bit integer constant where both the high and low 64-bit word
4234 32-bit unsigned integer constant, or a symbolic reference known
4273 A constant between 0 and 3 inclusive.
4276 A constant that has exactly one bit set.
4279 A constant that has exactly one bit clear.
4282 A constant between 0 and 255 inclusive.
4285 A constant between @minus{}255 and 0 inclusive.
4288 A constant between @minus{}3 and 0 inclusive.
4291 A constant between 1 and 4 inclusive.
4294 A constant between @minus{}4 and @minus{}1 inclusive.
4303 A memory reference that refers to a constant address of known value.
4309 A constant that is not between 2 and 15 inclusive.
4312 The constant 0.
4328 Signed 12-bit integer constant, for use in MOVI instructions
4331 Signed 8-bit integer constant, for use in ADDI instructions
4334 Integer constant valid for BccI instructions
4337 Unsigned constant valid for BccUI instructions
4650 in the abstract sense, or a constant from @code{enum constraint_num};
4656 enumeration constant: @samp{CONSTRAINT_} plus the mangled name of the
4849 is the first memory location, and operand 2 is a constant: the
4873 operand 2 is a constant: the number of consecutive registers.
5031 Initialize the vector to given values.  Operand 0 is the vector to initialize
5043 This pattern only handles duplicates of non-constant inputs.  Constant
5084 respectively.  Operand 4 is a constant integer that provides the known
5190 the analogous operation for constant selectors.
5599 with N signed/unsigned elements of size S@.  Operand 2 is a constant.  Shift
6293 initialize the memory with is the third operand. Targets that only support the
6294 clearing of memory should reject any value that is not the constant 0.  See
6366 and operand 3 is a constant describing the known alignment
6531 for operands 2 and 3 and the constant is never zero for operand 2.
6555 for operands 1 and 2 and the constant is never zero for operand 1.
6694 branch---for example, it may copy a constant one to the target and branching
6860 The lower bound for indices in the table, an integer constant.
6994 A save area is a @code{mem} that is at a constant offset from
7080 This pattern, if defined, contains additional code needed to initialize
7196 is a constant 1 if the prefetch is preparing for a write to the memory
7197 address, or a constant 0 otherwise.  Operand 2 is the expected degree of
7280 target can initialize all of the optabs at once with
7354 For less capable targets, any value operand that is not the constant 1
7375 the constant 0 should be rejected with @code{FAIL}, and the true contents
7672 constant value.
7696 extend a constant value could match either pattern.  The pattern it
7700 will be incorrect if the constant value does not actually fit that mode.
7706 If a constraint in a pattern allows a constant, the reload pass may
7707 replace a register with a constant permitted by the constraint in some
7854 with constant 1 (as in the example above).
7857 constant zero.
7860 with constant zero.  For this case, GCC will attach a @code{REG_NONNEG}
7904 For commutative and comparison operators, a constant is always made the
7905 second operand.  If a machine only supports a constant as the second
7906 operand, only patterns that match a constant in the second operand need
7937 For the @code{compare} operator, a constant is always the second operand
8020 The sum of three items, one of which is a constant, will only appear in
8024 (plus:@var{m} (plus:@var{m} @var{x} @var{y}) @var{constant})
8254 @code{const_int} because the constant value is too large to be legitimate
8310 addition of a large constant in two insns on a RISC machine, the way to
8436 an equality comparison of a register and a large constant:
8451   /* @r{Get the constant we are comparing against, C, and see what it
8452      looks like sign-extended to 16 bits.  Then see what constant
8579 known to be equivalent to an all-true constant and isn't used by the
8608 The splitter in this case simply replaces operand 1 with the constant
9086 * Constant Attributes:: Defining attributes that are constant.
9121 indicate that the attribute takes numeric values.
9164 If the attribute takes numeric values, no @code{enum} type will be
9243 The integer @var{i} specifies the value of a numeric attribute.  @var{i}
9246 The value of a numeric attribute can be specified either with a
9254 The string @var{value} specifies a constant attribute value.
9260 If the attribute whose value is being specified is numeric, @var{value}
9309 The test is true if C expression @var{c-expr} is true.  In non-constant
9451 for numeric attributes, as @code{eq_attr} and @code{attr_flag}
9452 produce more efficient code for non-numeric attributes.
9630 attribute, is defined.  This attribute must be defined to have numeric
9715 @cindex constant attributes
9719 is constant for a given run of the compiler.  Constant attributes may be
9736 The routine generated for constant attributes has no parameters as it
9738 the value of a constant attribute may use the @code{symbol_ref} form,
9897 constant.  In most cases this approach is adequate.  The second kind
10433 the insns must be a simple constant, not a complex expressions.  It
10688 @cindex constant definitions
10699 constants to the table.  It is an error to redefine a constant with
11177 defines a pseudo integer constant @var{name} that can be instantiated as
11181 each @var{int} has to be a constant defined using define_constant or