OSDN Git Service

Apply https://gcc.gnu.org/ml/gcc-patches/2012-09/msg00777/aarch64-int-iterators-backp...
[pf3gnuchains/gcc-fork.git] / gcc / doc / md.texi
1 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000, 2001,
2 @c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 @c Free Software Foundation, Inc.
4 @c This is part of the GCC manual.
5 @c For copying conditions, see the file gcc.texi.
6
7 @ifset INTERNALS
8 @node Machine Desc
9 @chapter Machine Descriptions
10 @cindex machine descriptions
11
12 A machine description has two parts: a file of instruction patterns
13 (@file{.md} file) and a C header file of macro definitions.
14
15 The @file{.md} file for a target machine contains a pattern for each
16 instruction that the target machine supports (or at least each instruction
17 that is worth telling the compiler about).  It may also contain comments.
18 A semicolon causes the rest of the line to be a comment, unless the semicolon
19 is inside a quoted string.
20
21 See the next chapter for information on the C header file.
22
23 @menu
24 * Overview::            How the machine description is used.
25 * Patterns::            How to write instruction patterns.
26 * Example::             An explained example of a @code{define_insn} pattern.
27 * RTL Template::        The RTL template defines what insns match a pattern.
28 * Output Template::     The output template says how to make assembler code
29                         from such an insn.
30 * Output Statement::    For more generality, write C code to output
31                         the assembler code.
32 * Predicates::          Controlling what kinds of operands can be used
33                         for an insn.
34 * Constraints::         Fine-tuning operand selection.
35 * Standard Names::      Names mark patterns to use for code generation.
36 * Pattern Ordering::    When the order of patterns makes a difference.
37 * Dependent Patterns::  Having one pattern may make you need another.
38 * Jump Patterns::       Special considerations for patterns for jump insns.
39 * Looping Patterns::    How to define patterns for special looping insns.
40 * Insn Canonicalizations::Canonicalization of Instructions
41 * Expander Definitions::Generating a sequence of several RTL insns
42                         for a standard operation.
43 * Insn Splitting::      Splitting Instructions into Multiple Instructions.
44 * Including Patterns::  Including Patterns in Machine Descriptions.
45 * Peephole Definitions::Defining machine-specific peephole optimizations.
46 * Insn Attributes::     Specifying the value of attributes for generated insns.
47 * Conditional Execution::Generating @code{define_insn} patterns for
48                          predication.
49 * Constant Definitions::Defining symbolic constants that can be used in the
50                         md file.
51 * Iterators::           Using iterators to generate patterns from a template.
52 @end menu
53
54 @node Overview
55 @section Overview of How the Machine Description is Used
56
57 There are three main conversions that happen in the compiler:
58
59 @enumerate
60
61 @item
62 The front end reads the source code and builds a parse tree.
63
64 @item
65 The parse tree is used to generate an RTL insn list based on named
66 instruction patterns.
67
68 @item
69 The insn list is matched against the RTL templates to produce assembler
70 code.
71
72 @end enumerate
73
74 For the generate pass, only the names of the insns matter, from either a
75 named @code{define_insn} or a @code{define_expand}.  The compiler will
76 choose the pattern with the right name and apply the operands according
77 to the documentation later in this chapter, without regard for the RTL
78 template or operand constraints.  Note that the names the compiler looks
79 for are hard-coded in the compiler---it will ignore unnamed patterns and
80 patterns with names it doesn't know about, but if you don't provide a
81 named pattern it needs, it will abort.
82
83 If a @code{define_insn} is used, the template given is inserted into the
84 insn list.  If a @code{define_expand} is used, one of three things
85 happens, based on the condition logic.  The condition logic may manually
86 create new insns for the insn list, say via @code{emit_insn()}, and
87 invoke @code{DONE}.  For certain named patterns, it may invoke @code{FAIL} to tell the
88 compiler to use an alternate way of performing that task.  If it invokes
89 neither @code{DONE} nor @code{FAIL}, the template given in the pattern
90 is inserted, as if the @code{define_expand} were a @code{define_insn}.
91
92 Once the insn list is generated, various optimization passes convert,
93 replace, and rearrange the insns in the insn list.  This is where the
94 @code{define_split} and @code{define_peephole} patterns get used, for
95 example.
96
97 Finally, the insn list's RTL is matched up with the RTL templates in the
98 @code{define_insn} patterns, and those patterns are used to emit the
99 final assembly code.  For this purpose, each named @code{define_insn}
100 acts like it's unnamed, since the names are ignored.
101
102 @node Patterns
103 @section Everything about Instruction Patterns
104 @cindex patterns
105 @cindex instruction patterns
106
107 @findex define_insn
108 Each instruction pattern contains an incomplete RTL expression, with pieces
109 to be filled in later, operand constraints that restrict how the pieces can
110 be filled in, and an output pattern or C code to generate the assembler
111 output, all wrapped up in a @code{define_insn} expression.
112
113 A @code{define_insn} is an RTL expression containing four or five operands:
114
115 @enumerate
116 @item
117 An optional name.  The presence of a name indicate that this instruction
118 pattern can perform a certain standard job for the RTL-generation
119 pass of the compiler.  This pass knows certain names and will use
120 the instruction patterns with those names, if the names are defined
121 in the machine description.
122
123 The absence of a name is indicated by writing an empty string
124 where the name should go.  Nameless instruction patterns are never
125 used for generating RTL code, but they may permit several simpler insns
126 to be combined later on.
127
128 Names that are not thus known and used in RTL-generation have no
129 effect; they are equivalent to no name at all.
130
131 For the purpose of debugging the compiler, you may also specify a
132 name beginning with the @samp{*} character.  Such a name is used only
133 for identifying the instruction in RTL dumps; it is entirely equivalent
134 to having a nameless pattern for all other purposes.
135
136 @item
137 The @dfn{RTL template} (@pxref{RTL Template}) is a vector of incomplete
138 RTL expressions which show what the instruction should look like.  It is
139 incomplete because it may contain @code{match_operand},
140 @code{match_operator}, and @code{match_dup} expressions that stand for
141 operands of the instruction.
142
143 If the vector has only one element, that element is the template for the
144 instruction pattern.  If the vector has multiple elements, then the
145 instruction pattern is a @code{parallel} expression containing the
146 elements described.
147
148 @item
149 @cindex pattern conditions
150 @cindex conditions, in patterns
151 A condition.  This is a string which contains a C expression that is
152 the final test to decide whether an insn body matches this pattern.
153
154 @cindex named patterns and conditions
155 For a named pattern, the condition (if present) may not depend on
156 the data in the insn being matched, but only the target-machine-type
157 flags.  The compiler needs to test these conditions during
158 initialization in order to learn exactly which named instructions are
159 available in a particular run.
160
161 @findex operands
162 For nameless patterns, the condition is applied only when matching an
163 individual insn, and only after the insn has matched the pattern's
164 recognition template.  The insn's operands may be found in the vector
165 @code{operands}.  For an insn where the condition has once matched, it
166 can't be used to control register allocation, for example by excluding
167 certain hard registers or hard register combinations.
168
169 @item
170 The @dfn{output template}: a string that says how to output matching
171 insns as assembler code.  @samp{%} in this string specifies where
172 to substitute the value of an operand.  @xref{Output Template}.
173
174 When simple substitution isn't general enough, you can specify a piece
175 of C code to compute the output.  @xref{Output Statement}.
176
177 @item
178 Optionally, a vector containing the values of attributes for insns matching
179 this pattern.  @xref{Insn Attributes}.
180 @end enumerate
181
182 @node Example
183 @section Example of @code{define_insn}
184 @cindex @code{define_insn} example
185
186 Here is an actual example of an instruction pattern, for the 68000/68020.
187
188 @smallexample
189 (define_insn "tstsi"
190   [(set (cc0)
191         (match_operand:SI 0 "general_operand" "rm"))]
192   ""
193   "*
194 @{
195   if (TARGET_68020 || ! ADDRESS_REG_P (operands[0]))
196     return \"tstl %0\";
197   return \"cmpl #0,%0\";
198 @}")
199 @end smallexample
200
201 @noindent
202 This can also be written using braced strings:
203
204 @smallexample
205 (define_insn "tstsi"
206   [(set (cc0)
207         (match_operand:SI 0 "general_operand" "rm"))]
208   ""
209 @{
210   if (TARGET_68020 || ! ADDRESS_REG_P (operands[0]))
211     return "tstl %0";
212   return "cmpl #0,%0";
213 @})
214 @end smallexample
215
216 This is an instruction that sets the condition codes based on the value of
217 a general operand.  It has no condition, so any insn whose RTL description
218 has the form shown may be handled according to this pattern.  The name
219 @samp{tstsi} means ``test a @code{SImode} value'' and tells the RTL generation
220 pass that, when it is necessary to test such a value, an insn to do so
221 can be constructed using this pattern.
222
223 The output control string is a piece of C code which chooses which
224 output template to return based on the kind of operand and the specific
225 type of CPU for which code is being generated.
226
227 @samp{"rm"} is an operand constraint.  Its meaning is explained below.
228
229 @node RTL Template
230 @section RTL Template
231 @cindex RTL insn template
232 @cindex generating insns
233 @cindex insns, generating
234 @cindex recognizing insns
235 @cindex insns, recognizing
236
237 The RTL template is used to define which insns match the particular pattern
238 and how to find their operands.  For named patterns, the RTL template also
239 says how to construct an insn from specified operands.
240
241 Construction involves substituting specified operands into a copy of the
242 template.  Matching involves determining the values that serve as the
243 operands in the insn being matched.  Both of these activities are
244 controlled by special expression types that direct matching and
245 substitution of the operands.
246
247 @table @code
248 @findex match_operand
249 @item (match_operand:@var{m} @var{n} @var{predicate} @var{constraint})
250 This expression is a placeholder for operand number @var{n} of
251 the insn.  When constructing an insn, operand number @var{n}
252 will be substituted at this point.  When matching an insn, whatever
253 appears at this position in the insn will be taken as operand
254 number @var{n}; but it must satisfy @var{predicate} or this instruction
255 pattern will not match at all.
256
257 Operand numbers must be chosen consecutively counting from zero in
258 each instruction pattern.  There may be only one @code{match_operand}
259 expression in the pattern for each operand number.  Usually operands
260 are numbered in the order of appearance in @code{match_operand}
261 expressions.  In the case of a @code{define_expand}, any operand numbers
262 used only in @code{match_dup} expressions have higher values than all
263 other operand numbers.
264
265 @var{predicate} is a string that is the name of a function that
266 accepts two arguments, an expression and a machine mode.
267 @xref{Predicates}.  During matching, the function will be called with
268 the putative operand as the expression and @var{m} as the mode
269 argument (if @var{m} is not specified, @code{VOIDmode} will be used,
270 which normally causes @var{predicate} to accept any mode).  If it
271 returns zero, this instruction pattern fails to match.
272 @var{predicate} may be an empty string; then it means no test is to be
273 done on the operand, so anything which occurs in this position is
274 valid.
275
276 Most of the time, @var{predicate} will reject modes other than @var{m}---but
277 not always.  For example, the predicate @code{address_operand} uses
278 @var{m} as the mode of memory ref that the address should be valid for.
279 Many predicates accept @code{const_int} nodes even though their mode is
280 @code{VOIDmode}.
281
282 @var{constraint} controls reloading and the choice of the best register
283 class to use for a value, as explained later (@pxref{Constraints}).
284 If the constraint would be an empty string, it can be omitted.
285
286 People are often unclear on the difference between the constraint and the
287 predicate.  The predicate helps decide whether a given insn matches the
288 pattern.  The constraint plays no role in this decision; instead, it
289 controls various decisions in the case of an insn which does match.
290
291 @findex match_scratch
292 @item (match_scratch:@var{m} @var{n} @var{constraint})
293 This expression is also a placeholder for operand number @var{n}
294 and indicates that operand must be a @code{scratch} or @code{reg}
295 expression.
296
297 When matching patterns, this is equivalent to
298
299 @smallexample
300 (match_operand:@var{m} @var{n} "scratch_operand" @var{pred})
301 @end smallexample
302
303 but, when generating RTL, it produces a (@code{scratch}:@var{m})
304 expression.
305
306 If the last few expressions in a @code{parallel} are @code{clobber}
307 expressions whose operands are either a hard register or
308 @code{match_scratch}, the combiner can add or delete them when
309 necessary.  @xref{Side Effects}.
310
311 @findex match_dup
312 @item (match_dup @var{n})
313 This expression is also a placeholder for operand number @var{n}.
314 It is used when the operand needs to appear more than once in the
315 insn.
316
317 In construction, @code{match_dup} acts just like @code{match_operand}:
318 the operand is substituted into the insn being constructed.  But in
319 matching, @code{match_dup} behaves differently.  It assumes that operand
320 number @var{n} has already been determined by a @code{match_operand}
321 appearing earlier in the recognition template, and it matches only an
322 identical-looking expression.
323
324 Note that @code{match_dup} should not be used to tell the compiler that
325 a particular register is being used for two operands (example:
326 @code{add} that adds one register to another; the second register is
327 both an input operand and the output operand).  Use a matching
328 constraint (@pxref{Simple Constraints}) for those.  @code{match_dup} is for the cases where one
329 operand is used in two places in the template, such as an instruction
330 that computes both a quotient and a remainder, where the opcode takes
331 two input operands but the RTL template has to refer to each of those
332 twice; once for the quotient pattern and once for the remainder pattern.
333
334 @findex match_operator
335 @item (match_operator:@var{m} @var{n} @var{predicate} [@var{operands}@dots{}])
336 This pattern is a kind of placeholder for a variable RTL expression
337 code.
338
339 When constructing an insn, it stands for an RTL expression whose
340 expression code is taken from that of operand @var{n}, and whose
341 operands are constructed from the patterns @var{operands}.
342
343 When matching an expression, it matches an expression if the function
344 @var{predicate} returns nonzero on that expression @emph{and} the
345 patterns @var{operands} match the operands of the expression.
346
347 Suppose that the function @code{commutative_operator} is defined as
348 follows, to match any expression whose operator is one of the
349 commutative arithmetic operators of RTL and whose mode is @var{mode}:
350
351 @smallexample
352 int
353 commutative_integer_operator (x, mode)
354      rtx x;
355      enum machine_mode mode;
356 @{
357   enum rtx_code code = GET_CODE (x);
358   if (GET_MODE (x) != mode)
359     return 0;
360   return (GET_RTX_CLASS (code) == RTX_COMM_ARITH
361           || code == EQ || code == NE);
362 @}
363 @end smallexample
364
365 Then the following pattern will match any RTL expression consisting
366 of a commutative operator applied to two general operands:
367
368 @smallexample
369 (match_operator:SI 3 "commutative_operator"
370   [(match_operand:SI 1 "general_operand" "g")
371    (match_operand:SI 2 "general_operand" "g")])
372 @end smallexample
373
374 Here the vector @code{[@var{operands}@dots{}]} contains two patterns
375 because the expressions to be matched all contain two operands.
376
377 When this pattern does match, the two operands of the commutative
378 operator are recorded as operands 1 and 2 of the insn.  (This is done
379 by the two instances of @code{match_operand}.)  Operand 3 of the insn
380 will be the entire commutative expression: use @code{GET_CODE
381 (operands[3])} to see which commutative operator was used.
382
383 The machine mode @var{m} of @code{match_operator} works like that of
384 @code{match_operand}: it is passed as the second argument to the
385 predicate function, and that function is solely responsible for
386 deciding whether the expression to be matched ``has'' that mode.
387
388 When constructing an insn, argument 3 of the gen-function will specify
389 the operation (i.e.@: the expression code) for the expression to be
390 made.  It should be an RTL expression, whose expression code is copied
391 into a new expression whose operands are arguments 1 and 2 of the
392 gen-function.  The subexpressions of argument 3 are not used;
393 only its expression code matters.
394
395 When @code{match_operator} is used in a pattern for matching an insn,
396 it usually best if the operand number of the @code{match_operator}
397 is higher than that of the actual operands of the insn.  This improves
398 register allocation because the register allocator often looks at
399 operands 1 and 2 of insns to see if it can do register tying.
400
401 There is no way to specify constraints in @code{match_operator}.  The
402 operand of the insn which corresponds to the @code{match_operator}
403 never has any constraints because it is never reloaded as a whole.
404 However, if parts of its @var{operands} are matched by
405 @code{match_operand} patterns, those parts may have constraints of
406 their own.
407
408 @findex match_op_dup
409 @item (match_op_dup:@var{m} @var{n}[@var{operands}@dots{}])
410 Like @code{match_dup}, except that it applies to operators instead of
411 operands.  When constructing an insn, operand number @var{n} will be
412 substituted at this point.  But in matching, @code{match_op_dup} behaves
413 differently.  It assumes that operand number @var{n} has already been
414 determined by a @code{match_operator} appearing earlier in the
415 recognition template, and it matches only an identical-looking
416 expression.
417
418 @findex match_parallel
419 @item (match_parallel @var{n} @var{predicate} [@var{subpat}@dots{}])
420 This pattern is a placeholder for an insn that consists of a
421 @code{parallel} expression with a variable number of elements.  This
422 expression should only appear at the top level of an insn pattern.
423
424 When constructing an insn, operand number @var{n} will be substituted at
425 this point.  When matching an insn, it matches if the body of the insn
426 is a @code{parallel} expression with at least as many elements as the
427 vector of @var{subpat} expressions in the @code{match_parallel}, if each
428 @var{subpat} matches the corresponding element of the @code{parallel},
429 @emph{and} the function @var{predicate} returns nonzero on the
430 @code{parallel} that is the body of the insn.  It is the responsibility
431 of the predicate to validate elements of the @code{parallel} beyond
432 those listed in the @code{match_parallel}.
433
434 A typical use of @code{match_parallel} is to match load and store
435 multiple expressions, which can contain a variable number of elements
436 in a @code{parallel}.  For example,
437
438 @smallexample
439 (define_insn ""
440   [(match_parallel 0 "load_multiple_operation"
441      [(set (match_operand:SI 1 "gpc_reg_operand" "=r")
442            (match_operand:SI 2 "memory_operand" "m"))
443       (use (reg:SI 179))
444       (clobber (reg:SI 179))])]
445   ""
446   "loadm 0,0,%1,%2")
447 @end smallexample
448
449 This example comes from @file{a29k.md}.  The function
450 @code{load_multiple_operation} is defined in @file{a29k.c} and checks
451 that subsequent elements in the @code{parallel} are the same as the
452 @code{set} in the pattern, except that they are referencing subsequent
453 registers and memory locations.
454
455 An insn that matches this pattern might look like:
456
457 @smallexample
458 (parallel
459  [(set (reg:SI 20) (mem:SI (reg:SI 100)))
460   (use (reg:SI 179))
461   (clobber (reg:SI 179))
462   (set (reg:SI 21)
463        (mem:SI (plus:SI (reg:SI 100)
464                         (const_int 4))))
465   (set (reg:SI 22)
466        (mem:SI (plus:SI (reg:SI 100)
467                         (const_int 8))))])
468 @end smallexample
469
470 @findex match_par_dup
471 @item (match_par_dup @var{n} [@var{subpat}@dots{}])
472 Like @code{match_op_dup}, but for @code{match_parallel} instead of
473 @code{match_operator}.
474
475 @end table
476
477 @node Output Template
478 @section Output Templates and Operand Substitution
479 @cindex output templates
480 @cindex operand substitution
481
482 @cindex @samp{%} in template
483 @cindex percent sign
484 The @dfn{output template} is a string which specifies how to output the
485 assembler code for an instruction pattern.  Most of the template is a
486 fixed string which is output literally.  The character @samp{%} is used
487 to specify where to substitute an operand; it can also be used to
488 identify places where different variants of the assembler require
489 different syntax.
490
491 In the simplest case, a @samp{%} followed by a digit @var{n} says to output
492 operand @var{n} at that point in the string.
493
494 @samp{%} followed by a letter and a digit says to output an operand in an
495 alternate fashion.  Four letters have standard, built-in meanings described
496 below.  The machine description macro @code{PRINT_OPERAND} can define
497 additional letters with nonstandard meanings.
498
499 @samp{%c@var{digit}} can be used to substitute an operand that is a
500 constant value without the syntax that normally indicates an immediate
501 operand.
502
503 @samp{%n@var{digit}} is like @samp{%c@var{digit}} except that the value of
504 the constant is negated before printing.
505
506 @samp{%a@var{digit}} can be used to substitute an operand as if it were a
507 memory reference, with the actual operand treated as the address.  This may
508 be useful when outputting a ``load address'' instruction, because often the
509 assembler syntax for such an instruction requires you to write the operand
510 as if it were a memory reference.
511
512 @samp{%l@var{digit}} is used to substitute a @code{label_ref} into a jump
513 instruction.
514
515 @samp{%=} outputs a number which is unique to each instruction in the
516 entire compilation.  This is useful for making local labels to be
517 referred to more than once in a single template that generates multiple
518 assembler instructions.
519
520 @samp{%} followed by a punctuation character specifies a substitution that
521 does not use an operand.  Only one case is standard: @samp{%%} outputs a
522 @samp{%} into the assembler code.  Other nonstandard cases can be
523 defined in the @code{PRINT_OPERAND} macro.  You must also define
524 which punctuation characters are valid with the
525 @code{PRINT_OPERAND_PUNCT_VALID_P} macro.
526
527 @cindex \
528 @cindex backslash
529 The template may generate multiple assembler instructions.  Write the text
530 for the instructions, with @samp{\;} between them.
531
532 @cindex matching operands
533 When the RTL contains two operands which are required by constraint to match
534 each other, the output template must refer only to the lower-numbered operand.
535 Matching operands are not always identical, and the rest of the compiler
536 arranges to put the proper RTL expression for printing into the lower-numbered
537 operand.
538
539 One use of nonstandard letters or punctuation following @samp{%} is to
540 distinguish between different assembler languages for the same machine; for
541 example, Motorola syntax versus MIT syntax for the 68000.  Motorola syntax
542 requires periods in most opcode names, while MIT syntax does not.  For
543 example, the opcode @samp{movel} in MIT syntax is @samp{move.l} in Motorola
544 syntax.  The same file of patterns is used for both kinds of output syntax,
545 but the character sequence @samp{%.} is used in each place where Motorola
546 syntax wants a period.  The @code{PRINT_OPERAND} macro for Motorola syntax
547 defines the sequence to output a period; the macro for MIT syntax defines
548 it to do nothing.
549
550 @cindex @code{#} in template
551 As a special case, a template consisting of the single character @code{#}
552 instructs the compiler to first split the insn, and then output the
553 resulting instructions separately.  This helps eliminate redundancy in the
554 output templates.   If you have a @code{define_insn} that needs to emit
555 multiple assembler instructions, and there is a matching @code{define_split}
556 already defined, then you can simply use @code{#} as the output template
557 instead of writing an output template that emits the multiple assembler
558 instructions.
559
560 If the macro @code{ASSEMBLER_DIALECT} is defined, you can use construct
561 of the form @samp{@{option0|option1|option2@}} in the templates.  These
562 describe multiple variants of assembler language syntax.
563 @xref{Instruction Output}.
564
565 @node Output Statement
566 @section C Statements for Assembler Output
567 @cindex output statements
568 @cindex C statements for assembler output
569 @cindex generating assembler output
570
571 Often a single fixed template string cannot produce correct and efficient
572 assembler code for all the cases that are recognized by a single
573 instruction pattern.  For example, the opcodes may depend on the kinds of
574 operands; or some unfortunate combinations of operands may require extra
575 machine instructions.
576
577 If the output control string starts with a @samp{@@}, then it is actually
578 a series of templates, each on a separate line.  (Blank lines and
579 leading spaces and tabs are ignored.)  The templates correspond to the
580 pattern's constraint alternatives (@pxref{Multi-Alternative}).  For example,
581 if a target machine has a two-address add instruction @samp{addr} to add
582 into a register and another @samp{addm} to add a register to memory, you
583 might write this pattern:
584
585 @smallexample
586 (define_insn "addsi3"
587   [(set (match_operand:SI 0 "general_operand" "=r,m")
588         (plus:SI (match_operand:SI 1 "general_operand" "0,0")
589                  (match_operand:SI 2 "general_operand" "g,r")))]
590   ""
591   "@@
592    addr %2,%0
593    addm %2,%0")
594 @end smallexample
595
596 @cindex @code{*} in template
597 @cindex asterisk in template
598 If the output control string starts with a @samp{*}, then it is not an
599 output template but rather a piece of C program that should compute a
600 template.  It should execute a @code{return} statement to return the
601 template-string you want.  Most such templates use C string literals, which
602 require doublequote characters to delimit them.  To include these
603 doublequote characters in the string, prefix each one with @samp{\}.
604
605 If the output control string is written as a brace block instead of a
606 double-quoted string, it is automatically assumed to be C code.  In that
607 case, it is not necessary to put in a leading asterisk, or to escape the
608 doublequotes surrounding C string literals.
609
610 The operands may be found in the array @code{operands}, whose C data type
611 is @code{rtx []}.
612
613 It is very common to select different ways of generating assembler code
614 based on whether an immediate operand is within a certain range.  Be
615 careful when doing this, because the result of @code{INTVAL} is an
616 integer on the host machine.  If the host machine has more bits in an
617 @code{int} than the target machine has in the mode in which the constant
618 will be used, then some of the bits you get from @code{INTVAL} will be
619 superfluous.  For proper results, you must carefully disregard the
620 values of those bits.
621
622 @findex output_asm_insn
623 It is possible to output an assembler instruction and then go on to output
624 or compute more of them, using the subroutine @code{output_asm_insn}.  This
625 receives two arguments: a template-string and a vector of operands.  The
626 vector may be @code{operands}, or it may be another array of @code{rtx}
627 that you declare locally and initialize yourself.
628
629 @findex which_alternative
630 When an insn pattern has multiple alternatives in its constraints, often
631 the appearance of the assembler code is determined mostly by which alternative
632 was matched.  When this is so, the C code can test the variable
633 @code{which_alternative}, which is the ordinal number of the alternative
634 that was actually satisfied (0 for the first, 1 for the second alternative,
635 etc.).
636
637 For example, suppose there are two opcodes for storing zero, @samp{clrreg}
638 for registers and @samp{clrmem} for memory locations.  Here is how
639 a pattern could use @code{which_alternative} to choose between them:
640
641 @smallexample
642 (define_insn ""
643   [(set (match_operand:SI 0 "general_operand" "=r,m")
644         (const_int 0))]
645   ""
646   @{
647   return (which_alternative == 0
648           ? "clrreg %0" : "clrmem %0");
649   @})
650 @end smallexample
651
652 The example above, where the assembler code to generate was
653 @emph{solely} determined by the alternative, could also have been specified
654 as follows, having the output control string start with a @samp{@@}:
655
656 @smallexample
657 @group
658 (define_insn ""
659   [(set (match_operand:SI 0 "general_operand" "=r,m")
660         (const_int 0))]
661   ""
662   "@@
663    clrreg %0
664    clrmem %0")
665 @end group
666 @end smallexample
667
668 @node Predicates
669 @section Predicates
670 @cindex predicates
671 @cindex operand predicates
672 @cindex operator predicates
673
674 A predicate determines whether a @code{match_operand} or
675 @code{match_operator} expression matches, and therefore whether the
676 surrounding instruction pattern will be used for that combination of
677 operands.  GCC has a number of machine-independent predicates, and you
678 can define machine-specific predicates as needed.  By convention,
679 predicates used with @code{match_operand} have names that end in
680 @samp{_operand}, and those used with @code{match_operator} have names
681 that end in @samp{_operator}.
682
683 All predicates are Boolean functions (in the mathematical sense) of
684 two arguments: the RTL expression that is being considered at that
685 position in the instruction pattern, and the machine mode that the
686 @code{match_operand} or @code{match_operator} specifies.  In this
687 section, the first argument is called @var{op} and the second argument
688 @var{mode}.  Predicates can be called from C as ordinary two-argument
689 functions; this can be useful in output templates or other
690 machine-specific code.
691
692 Operand predicates can allow operands that are not actually acceptable
693 to the hardware, as long as the constraints give reload the ability to
694 fix them up (@pxref{Constraints}).  However, GCC will usually generate
695 better code if the predicates specify the requirements of the machine
696 instructions as closely as possible.  Reload cannot fix up operands
697 that must be constants (``immediate operands''); you must use a
698 predicate that allows only constants, or else enforce the requirement
699 in the extra condition.
700
701 @cindex predicates and machine modes
702 @cindex normal predicates
703 @cindex special predicates
704 Most predicates handle their @var{mode} argument in a uniform manner.
705 If @var{mode} is @code{VOIDmode} (unspecified), then @var{op} can have
706 any mode.  If @var{mode} is anything else, then @var{op} must have the
707 same mode, unless @var{op} is a @code{CONST_INT} or integer
708 @code{CONST_DOUBLE}.  These RTL expressions always have
709 @code{VOIDmode}, so it would be counterproductive to check that their
710 mode matches.  Instead, predicates that accept @code{CONST_INT} and/or
711 integer @code{CONST_DOUBLE} check that the value stored in the
712 constant will fit in the requested mode.
713
714 Predicates with this behavior are called @dfn{normal}.
715 @command{genrecog} can optimize the instruction recognizer based on
716 knowledge of how normal predicates treat modes.  It can also diagnose
717 certain kinds of common errors in the use of normal predicates; for
718 instance, it is almost always an error to use a normal predicate
719 without specifying a mode.
720
721 Predicates that do something different with their @var{mode} argument
722 are called @dfn{special}.  The generic predicates
723 @code{address_operand} and @code{pmode_register_operand} are special
724 predicates.  @command{genrecog} does not do any optimizations or
725 diagnosis when special predicates are used.
726
727 @menu
728 * Machine-Independent Predicates::  Predicates available to all back ends.
729 * Defining Predicates::             How to write machine-specific predicate
730                                     functions.
731 @end menu
732
733 @node Machine-Independent Predicates
734 @subsection Machine-Independent Predicates
735 @cindex machine-independent predicates
736 @cindex generic predicates
737
738 These are the generic predicates available to all back ends.  They are
739 defined in @file{recog.c}.  The first category of predicates allow
740 only constant, or @dfn{immediate}, operands.
741
742 @defun immediate_operand
743 This predicate allows any sort of constant that fits in @var{mode}.
744 It is an appropriate choice for instructions that take operands that
745 must be constant.
746 @end defun
747
748 @defun const_int_operand
749 This predicate allows any @code{CONST_INT} expression that fits in
750 @var{mode}.  It is an appropriate choice for an immediate operand that
751 does not allow a symbol or label.
752 @end defun
753
754 @defun const_double_operand
755 This predicate accepts any @code{CONST_DOUBLE} expression that has
756 exactly @var{mode}.  If @var{mode} is @code{VOIDmode}, it will also
757 accept @code{CONST_INT}.  It is intended for immediate floating point
758 constants.
759 @end defun
760
761 @noindent
762 The second category of predicates allow only some kind of machine
763 register.
764
765 @defun register_operand
766 This predicate allows any @code{REG} or @code{SUBREG} expression that
767 is valid for @var{mode}.  It is often suitable for arithmetic
768 instruction operands on a RISC machine.
769 @end defun
770
771 @defun pmode_register_operand
772 This is a slight variant on @code{register_operand} which works around
773 a limitation in the machine-description reader.
774
775 @smallexample
776 (match_operand @var{n} "pmode_register_operand" @var{constraint})
777 @end smallexample
778
779 @noindent
780 means exactly what
781
782 @smallexample
783 (match_operand:P @var{n} "register_operand" @var{constraint})
784 @end smallexample
785
786 @noindent
787 would mean, if the machine-description reader accepted @samp{:P}
788 mode suffixes.  Unfortunately, it cannot, because @code{Pmode} is an
789 alias for some other mode, and might vary with machine-specific
790 options.  @xref{Misc}.
791 @end defun
792
793 @defun scratch_operand
794 This predicate allows hard registers and @code{SCRATCH} expressions,
795 but not pseudo-registers.  It is used internally by @code{match_scratch};
796 it should not be used directly.
797 @end defun
798
799 @noindent
800 The third category of predicates allow only some kind of memory reference.
801
802 @defun memory_operand
803 This predicate allows any valid reference to a quantity of mode
804 @var{mode} in memory, as determined by the weak form of
805 @code{GO_IF_LEGITIMATE_ADDRESS} (@pxref{Addressing Modes}).
806 @end defun
807
808 @defun address_operand
809 This predicate is a little unusual; it allows any operand that is a
810 valid expression for the @emph{address} of a quantity of mode
811 @var{mode}, again determined by the weak form of
812 @code{GO_IF_LEGITIMATE_ADDRESS}.  To first order, if
813 @samp{@w{(mem:@var{mode} (@var{exp}))}} is acceptable to
814 @code{memory_operand}, then @var{exp} is acceptable to
815 @code{address_operand}.  Note that @var{exp} does not necessarily have
816 the mode @var{mode}.
817 @end defun
818
819 @defun indirect_operand
820 This is a stricter form of @code{memory_operand} which allows only
821 memory references with a @code{general_operand} as the address
822 expression.  New uses of this predicate are discouraged, because
823 @code{general_operand} is very permissive, so it's hard to tell what
824 an @code{indirect_operand} does or does not allow.  If a target has
825 different requirements for memory operands for different instructions,
826 it is better to define target-specific predicates which enforce the
827 hardware's requirements explicitly.
828 @end defun
829
830 @defun push_operand
831 This predicate allows a memory reference suitable for pushing a value
832 onto the stack.  This will be a @code{MEM} which refers to
833 @code{stack_pointer_rtx}, with a side-effect in its address expression
834 (@pxref{Incdec}); which one is determined by the
835 @code{STACK_PUSH_CODE} macro (@pxref{Frame Layout}).
836 @end defun
837
838 @defun pop_operand
839 This predicate allows a memory reference suitable for popping a value
840 off the stack.  Again, this will be a @code{MEM} referring to
841 @code{stack_pointer_rtx}, with a side-effect in its address
842 expression.  However, this time @code{STACK_POP_CODE} is expected.
843 @end defun
844
845 @noindent
846 The fourth category of predicates allow some combination of the above
847 operands.
848
849 @defun nonmemory_operand
850 This predicate allows any immediate or register operand valid for @var{mode}.
851 @end defun
852
853 @defun nonimmediate_operand
854 This predicate allows any register or memory operand valid for @var{mode}.
855 @end defun
856
857 @defun general_operand
858 This predicate allows any immediate, register, or memory operand
859 valid for @var{mode}.
860 @end defun
861
862 @noindent
863 Finally, there are two generic operator predicates.
864
865 @defun comparison_operator
866 This predicate matches any expression which performs an arithmetic
867 comparison in @var{mode}; that is, @code{COMPARISON_P} is true for the
868 expression code.
869 @end defun
870
871 @defun ordered_comparison_operator
872 This predicate matches any expression which performs an arithmetic
873 comparison in @var{mode} and whose expression code is valid for integer
874 modes; that is, the expression code will be one of @code{eq}, @code{ne},
875 @code{lt}, @code{ltu}, @code{le}, @code{leu}, @code{gt}, @code{gtu},
876 @code{ge}, @code{geu}.
877 @end defun
878
879 @node Defining Predicates
880 @subsection Defining Machine-Specific Predicates
881 @cindex defining predicates
882 @findex define_predicate
883 @findex define_special_predicate
884
885 Many machines have requirements for their operands that cannot be
886 expressed precisely using the generic predicates.  You can define
887 additional predicates using @code{define_predicate} and
888 @code{define_special_predicate} expressions.  These expressions have
889 three operands:
890
891 @itemize @bullet
892 @item
893 The name of the predicate, as it will be referred to in
894 @code{match_operand} or @code{match_operator} expressions.
895
896 @item
897 An RTL expression which evaluates to true if the predicate allows the
898 operand @var{op}, false if it does not.  This expression can only use
899 the following RTL codes:
900
901 @table @code
902 @item MATCH_OPERAND
903 When written inside a predicate expression, a @code{MATCH_OPERAND}
904 expression evaluates to true if the predicate it names would allow
905 @var{op}.  The operand number and constraint are ignored.  Due to
906 limitations in @command{genrecog}, you can only refer to generic
907 predicates and predicates that have already been defined.
908
909 @item MATCH_CODE
910 This expression evaluates to true if @var{op} or a specified
911 subexpression of @var{op} has one of a given list of RTX codes.
912
913 The first operand of this expression is a string constant containing a
914 comma-separated list of RTX code names (in lower case).  These are the
915 codes for which the @code{MATCH_CODE} will be true.
916
917 The second operand is a string constant which indicates what
918 subexpression of @var{op} to examine.  If it is absent or the empty
919 string, @var{op} itself is examined.  Otherwise, the string constant
920 must be a sequence of digits and/or lowercase letters.  Each character
921 indicates a subexpression to extract from the current expression; for
922 the first character this is @var{op}, for the second and subsequent
923 characters it is the result of the previous character.  A digit
924 @var{n} extracts @samp{@w{XEXP (@var{e}, @var{n})}}; a letter @var{l}
925 extracts @samp{@w{XVECEXP (@var{e}, 0, @var{n})}} where @var{n} is the
926 alphabetic ordinal of @var{l} (0 for `a', 1 for 'b', and so on).  The
927 @code{MATCH_CODE} then examines the RTX code of the subexpression
928 extracted by the complete string.  It is not possible to extract
929 components of an @code{rtvec} that is not at position 0 within its RTX
930 object.
931
932 @item MATCH_TEST
933 This expression has one operand, a string constant containing a C
934 expression.  The predicate's arguments, @var{op} and @var{mode}, are
935 available with those names in the C expression.  The @code{MATCH_TEST}
936 evaluates to true if the C expression evaluates to a nonzero value.
937 @code{MATCH_TEST} expressions must not have side effects.
938
939 @item  AND
940 @itemx IOR
941 @itemx NOT
942 @itemx IF_THEN_ELSE
943 The basic @samp{MATCH_} expressions can be combined using these
944 logical operators, which have the semantics of the C operators
945 @samp{&&}, @samp{||}, @samp{!}, and @samp{@w{? :}} respectively.  As
946 in Common Lisp, you may give an @code{AND} or @code{IOR} expression an
947 arbitrary number of arguments; this has exactly the same effect as
948 writing a chain of two-argument @code{AND} or @code{IOR} expressions.
949 @end table
950
951 @item
952 An optional block of C code, which should execute
953 @samp{@w{return true}} if the predicate is found to match and
954 @samp{@w{return false}} if it does not.  It must not have any side
955 effects.  The predicate arguments, @var{op} and @var{mode}, are
956 available with those names.
957
958 If a code block is present in a predicate definition, then the RTL
959 expression must evaluate to true @emph{and} the code block must
960 execute @samp{@w{return true}} for the predicate to allow the operand.
961 The RTL expression is evaluated first; do not re-check anything in the
962 code block that was checked in the RTL expression.
963 @end itemize
964
965 The program @command{genrecog} scans @code{define_predicate} and
966 @code{define_special_predicate} expressions to determine which RTX
967 codes are possibly allowed.  You should always make this explicit in
968 the RTL predicate expression, using @code{MATCH_OPERAND} and
969 @code{MATCH_CODE}.
970
971 Here is an example of a simple predicate definition, from the IA64
972 machine description:
973
974 @smallexample
975 @group
976 ;; @r{True if @var{op} is a @code{SYMBOL_REF} which refers to the sdata section.}
977 (define_predicate "small_addr_symbolic_operand"
978   (and (match_code "symbol_ref")
979        (match_test "SYMBOL_REF_SMALL_ADDR_P (op)")))
980 @end group
981 @end smallexample
982
983 @noindent
984 And here is another, showing the use of the C block.
985
986 @smallexample
987 @group
988 ;; @r{True if @var{op} is a register operand that is (or could be) a GR reg.}
989 (define_predicate "gr_register_operand"
990   (match_operand 0 "register_operand")
991 @{
992   unsigned int regno;
993   if (GET_CODE (op) == SUBREG)
994     op = SUBREG_REG (op);
995
996   regno = REGNO (op);
997   return (regno >= FIRST_PSEUDO_REGISTER || GENERAL_REGNO_P (regno));
998 @})
999 @end group
1000 @end smallexample
1001
1002 Predicates written with @code{define_predicate} automatically include
1003 a test that @var{mode} is @code{VOIDmode}, or @var{op} has the same
1004 mode as @var{mode}, or @var{op} is a @code{CONST_INT} or
1005 @code{CONST_DOUBLE}.  They do @emph{not} check specifically for
1006 integer @code{CONST_DOUBLE}, nor do they test that the value of either
1007 kind of constant fits in the requested mode.  This is because
1008 target-specific predicates that take constants usually have to do more
1009 stringent value checks anyway.  If you need the exact same treatment
1010 of @code{CONST_INT} or @code{CONST_DOUBLE} that the generic predicates
1011 provide, use a @code{MATCH_OPERAND} subexpression to call
1012 @code{const_int_operand}, @code{const_double_operand}, or
1013 @code{immediate_operand}.
1014
1015 Predicates written with @code{define_special_predicate} do not get any
1016 automatic mode checks, and are treated as having special mode handling
1017 by @command{genrecog}.
1018
1019 The program @command{genpreds} is responsible for generating code to
1020 test predicates.  It also writes a header file containing function
1021 declarations for all machine-specific predicates.  It is not necessary
1022 to declare these predicates in @file{@var{cpu}-protos.h}.
1023 @end ifset
1024
1025 @c Most of this node appears by itself (in a different place) even
1026 @c when the INTERNALS flag is clear.  Passages that require the internals
1027 @c manual's context are conditionalized to appear only in the internals manual.
1028 @ifset INTERNALS
1029 @node Constraints
1030 @section Operand Constraints
1031 @cindex operand constraints
1032 @cindex constraints
1033
1034 Each @code{match_operand} in an instruction pattern can specify
1035 constraints for the operands allowed.  The constraints allow you to
1036 fine-tune matching within the set of operands allowed by the
1037 predicate.
1038
1039 @end ifset
1040 @ifclear INTERNALS
1041 @node Constraints
1042 @section Constraints for @code{asm} Operands
1043 @cindex operand constraints, @code{asm}
1044 @cindex constraints, @code{asm}
1045 @cindex @code{asm} constraints
1046
1047 Here are specific details on what constraint letters you can use with
1048 @code{asm} operands.
1049 @end ifclear
1050 Constraints can say whether
1051 an operand may be in a register, and which kinds of register; whether the
1052 operand can be a memory reference, and which kinds of address; whether the
1053 operand may be an immediate constant, and which possible values it may
1054 have.  Constraints can also require two operands to match.
1055 Side-effects aren't allowed in operands of inline @code{asm}, unless
1056 @samp{<} or @samp{>} constraints are used, because there is no guarantee
1057 that the side-effects will happen exactly once in an instruction that can update
1058 the addressing register.
1059
1060 @ifset INTERNALS
1061 @menu
1062 * Simple Constraints::  Basic use of constraints.
1063 * Multi-Alternative::   When an insn has two alternative constraint-patterns.
1064 * Class Preferences::   Constraints guide which hard register to put things in.
1065 * Modifiers::           More precise control over effects of constraints.
1066 * Disable Insn Alternatives:: Disable insn alternatives using the @code{enabled} attribute.
1067 * Machine Constraints:: Existing constraints for some particular machines.
1068 * Define Constraints::  How to define machine-specific constraints.
1069 * C Constraint Interface:: How to test constraints from C code.
1070 @end menu
1071 @end ifset
1072
1073 @ifclear INTERNALS
1074 @menu
1075 * Simple Constraints::  Basic use of constraints.
1076 * Multi-Alternative::   When an insn has two alternative constraint-patterns.
1077 * Modifiers::           More precise control over effects of constraints.
1078 * Machine Constraints:: Special constraints for some particular machines.
1079 @end menu
1080 @end ifclear
1081
1082 @node Simple Constraints
1083 @subsection Simple Constraints
1084 @cindex simple constraints
1085
1086 The simplest kind of constraint is a string full of letters, each of
1087 which describes one kind of operand that is permitted.  Here are
1088 the letters that are allowed:
1089
1090 @table @asis
1091 @item whitespace
1092 Whitespace characters are ignored and can be inserted at any position
1093 except the first.  This enables each alternative for different operands to
1094 be visually aligned in the machine description even if they have different
1095 number of constraints and modifiers.
1096
1097 @cindex @samp{m} in constraint
1098 @cindex memory references in constraints
1099 @item @samp{m}
1100 A memory operand is allowed, with any kind of address that the machine
1101 supports in general.
1102 Note that the letter used for the general memory constraint can be
1103 re-defined by a back end using the @code{TARGET_MEM_CONSTRAINT} macro.
1104
1105 @cindex offsettable address
1106 @cindex @samp{o} in constraint
1107 @item @samp{o}
1108 A memory operand is allowed, but only if the address is
1109 @dfn{offsettable}.  This means that adding a small integer (actually,
1110 the width in bytes of the operand, as determined by its machine mode)
1111 may be added to the address and the result is also a valid memory
1112 address.
1113
1114 @cindex autoincrement/decrement addressing
1115 For example, an address which is constant is offsettable; so is an
1116 address that is the sum of a register and a constant (as long as a
1117 slightly larger constant is also within the range of address-offsets
1118 supported by the machine); but an autoincrement or autodecrement
1119 address is not offsettable.  More complicated indirect/indexed
1120 addresses may or may not be offsettable depending on the other
1121 addressing modes that the machine supports.
1122
1123 Note that in an output operand which can be matched by another
1124 operand, the constraint letter @samp{o} is valid only when accompanied
1125 by both @samp{<} (if the target machine has predecrement addressing)
1126 and @samp{>} (if the target machine has preincrement addressing).
1127
1128 @cindex @samp{V} in constraint
1129 @item @samp{V}
1130 A memory operand that is not offsettable.  In other words, anything that
1131 would fit the @samp{m} constraint but not the @samp{o} constraint.
1132
1133 @cindex @samp{<} in constraint
1134 @item @samp{<}
1135 A memory operand with autodecrement addressing (either predecrement or
1136 postdecrement) is allowed.  In inline @code{asm} this constraint is only
1137 allowed if the operand is used exactly once in an instruction that can
1138 handle the side-effects.  Not using an operand with @samp{<} in constraint
1139 string in the inline @code{asm} pattern at all or using it in multiple
1140 instructions isn't valid, because the side-effects wouldn't be performed
1141 or would be performed more than once.  Furthermore, on some targets
1142 the operand with @samp{<} in constraint string must be accompanied by
1143 special instruction suffixes like @code{%U0} instruction suffix on PowerPC
1144 or @code{%P0} on IA-64.
1145
1146 @cindex @samp{>} in constraint
1147 @item @samp{>}
1148 A memory operand with autoincrement addressing (either preincrement or
1149 postincrement) is allowed.  In inline @code{asm} the same restrictions
1150 as for @samp{<} apply.
1151
1152 @cindex @samp{r} in constraint
1153 @cindex registers in constraints
1154 @item @samp{r}
1155 A register operand is allowed provided that it is in a general
1156 register.
1157
1158 @cindex constants in constraints
1159 @cindex @samp{i} in constraint
1160 @item @samp{i}
1161 An immediate integer operand (one with constant value) is allowed.
1162 This includes symbolic constants whose values will be known only at
1163 assembly time or later.
1164
1165 @cindex @samp{n} in constraint
1166 @item @samp{n}
1167 An immediate integer operand with a known numeric value is allowed.
1168 Many systems cannot support assembly-time constants for operands less
1169 than a word wide.  Constraints for these operands should use @samp{n}
1170 rather than @samp{i}.
1171
1172 @cindex @samp{I} in constraint
1173 @item @samp{I}, @samp{J}, @samp{K}, @dots{} @samp{P}
1174 Other letters in the range @samp{I} through @samp{P} may be defined in
1175 a machine-dependent fashion to permit immediate integer operands with
1176 explicit integer values in specified ranges.  For example, on the
1177 68000, @samp{I} is defined to stand for the range of values 1 to 8.
1178 This is the range permitted as a shift count in the shift
1179 instructions.
1180
1181 @cindex @samp{E} in constraint
1182 @item @samp{E}
1183 An immediate floating operand (expression code @code{const_double}) is
1184 allowed, but only if the target floating point format is the same as
1185 that of the host machine (on which the compiler is running).
1186
1187 @cindex @samp{F} in constraint
1188 @item @samp{F}
1189 An immediate floating operand (expression code @code{const_double} or
1190 @code{const_vector}) is allowed.
1191
1192 @cindex @samp{G} in constraint
1193 @cindex @samp{H} in constraint
1194 @item @samp{G}, @samp{H}
1195 @samp{G} and @samp{H} may be defined in a machine-dependent fashion to
1196 permit immediate floating operands in particular ranges of values.
1197
1198 @cindex @samp{s} in constraint
1199 @item @samp{s}
1200 An immediate integer operand whose value is not an explicit integer is
1201 allowed.
1202
1203 This might appear strange; if an insn allows a constant operand with a
1204 value not known at compile time, it certainly must allow any known
1205 value.  So why use @samp{s} instead of @samp{i}?  Sometimes it allows
1206 better code to be generated.
1207
1208 For example, on the 68000 in a fullword instruction it is possible to
1209 use an immediate operand; but if the immediate value is between @minus{}128
1210 and 127, better code results from loading the value into a register and
1211 using the register.  This is because the load into the register can be
1212 done with a @samp{moveq} instruction.  We arrange for this to happen
1213 by defining the letter @samp{K} to mean ``any integer outside the
1214 range @minus{}128 to 127'', and then specifying @samp{Ks} in the operand
1215 constraints.
1216
1217 @cindex @samp{g} in constraint
1218 @item @samp{g}
1219 Any register, memory or immediate integer operand is allowed, except for
1220 registers that are not general registers.
1221
1222 @cindex @samp{X} in constraint
1223 @item @samp{X}
1224 @ifset INTERNALS
1225 Any operand whatsoever is allowed, even if it does not satisfy
1226 @code{general_operand}.  This is normally used in the constraint of
1227 a @code{match_scratch} when certain alternatives will not actually
1228 require a scratch register.
1229 @end ifset
1230 @ifclear INTERNALS
1231 Any operand whatsoever is allowed.
1232 @end ifclear
1233
1234 @cindex @samp{0} in constraint
1235 @cindex digits in constraint
1236 @item @samp{0}, @samp{1}, @samp{2}, @dots{} @samp{9}
1237 An operand that matches the specified operand number is allowed.  If a
1238 digit is used together with letters within the same alternative, the
1239 digit should come last.
1240
1241 This number is allowed to be more than a single digit.  If multiple
1242 digits are encountered consecutively, they are interpreted as a single
1243 decimal integer.  There is scant chance for ambiguity, since to-date
1244 it has never been desirable that @samp{10} be interpreted as matching
1245 either operand 1 @emph{or} operand 0.  Should this be desired, one
1246 can use multiple alternatives instead.
1247
1248 @cindex matching constraint
1249 @cindex constraint, matching
1250 This is called a @dfn{matching constraint} and what it really means is
1251 that the assembler has only a single operand that fills two roles
1252 @ifset INTERNALS
1253 considered separate in the RTL insn.  For example, an add insn has two
1254 input operands and one output operand in the RTL, but on most CISC
1255 @end ifset
1256 @ifclear INTERNALS
1257 which @code{asm} distinguishes.  For example, an add instruction uses
1258 two input operands and an output operand, but on most CISC
1259 @end ifclear
1260 machines an add instruction really has only two operands, one of them an
1261 input-output operand:
1262
1263 @smallexample
1264 addl #35,r12
1265 @end smallexample
1266
1267 Matching constraints are used in these circumstances.
1268 More precisely, the two operands that match must include one input-only
1269 operand and one output-only operand.  Moreover, the digit must be a
1270 smaller number than the number of the operand that uses it in the
1271 constraint.
1272
1273 @ifset INTERNALS
1274 For operands to match in a particular case usually means that they
1275 are identical-looking RTL expressions.  But in a few special cases
1276 specific kinds of dissimilarity are allowed.  For example, @code{*x}
1277 as an input operand will match @code{*x++} as an output operand.
1278 For proper results in such cases, the output template should always
1279 use the output-operand's number when printing the operand.
1280 @end ifset
1281
1282 @cindex load address instruction
1283 @cindex push address instruction
1284 @cindex address constraints
1285 @cindex @samp{p} in constraint
1286 @item @samp{p}
1287 An operand that is a valid memory address is allowed.  This is
1288 for ``load address'' and ``push address'' instructions.
1289
1290 @findex address_operand
1291 @samp{p} in the constraint must be accompanied by @code{address_operand}
1292 as the predicate in the @code{match_operand}.  This predicate interprets
1293 the mode specified in the @code{match_operand} as the mode of the memory
1294 reference for which the address would be valid.
1295
1296 @cindex other register constraints
1297 @cindex extensible constraints
1298 @item @var{other-letters}
1299 Other letters can be defined in machine-dependent fashion to stand for
1300 particular classes of registers or other arbitrary operand types.
1301 @samp{d}, @samp{a} and @samp{f} are defined on the 68000/68020 to stand
1302 for data, address and floating point registers.
1303 @end table
1304
1305 @ifset INTERNALS
1306 In order to have valid assembler code, each operand must satisfy
1307 its constraint.  But a failure to do so does not prevent the pattern
1308 from applying to an insn.  Instead, it directs the compiler to modify
1309 the code so that the constraint will be satisfied.  Usually this is
1310 done by copying an operand into a register.
1311
1312 Contrast, therefore, the two instruction patterns that follow:
1313
1314 @smallexample
1315 (define_insn ""
1316   [(set (match_operand:SI 0 "general_operand" "=r")
1317         (plus:SI (match_dup 0)
1318                  (match_operand:SI 1 "general_operand" "r")))]
1319   ""
1320   "@dots{}")
1321 @end smallexample
1322
1323 @noindent
1324 which has two operands, one of which must appear in two places, and
1325
1326 @smallexample
1327 (define_insn ""
1328   [(set (match_operand:SI 0 "general_operand" "=r")
1329         (plus:SI (match_operand:SI 1 "general_operand" "0")
1330                  (match_operand:SI 2 "general_operand" "r")))]
1331   ""
1332   "@dots{}")
1333 @end smallexample
1334
1335 @noindent
1336 which has three operands, two of which are required by a constraint to be
1337 identical.  If we are considering an insn of the form
1338
1339 @smallexample
1340 (insn @var{n} @var{prev} @var{next}
1341   (set (reg:SI 3)
1342        (plus:SI (reg:SI 6) (reg:SI 109)))
1343   @dots{})
1344 @end smallexample
1345
1346 @noindent
1347 the first pattern would not apply at all, because this insn does not
1348 contain two identical subexpressions in the right place.  The pattern would
1349 say, ``That does not look like an add instruction; try other patterns''.
1350 The second pattern would say, ``Yes, that's an add instruction, but there
1351 is something wrong with it''.  It would direct the reload pass of the
1352 compiler to generate additional insns to make the constraint true.  The
1353 results might look like this:
1354
1355 @smallexample
1356 (insn @var{n2} @var{prev} @var{n}
1357   (set (reg:SI 3) (reg:SI 6))
1358   @dots{})
1359
1360 (insn @var{n} @var{n2} @var{next}
1361   (set (reg:SI 3)
1362        (plus:SI (reg:SI 3) (reg:SI 109)))
1363   @dots{})
1364 @end smallexample
1365
1366 It is up to you to make sure that each operand, in each pattern, has
1367 constraints that can handle any RTL expression that could be present for
1368 that operand.  (When multiple alternatives are in use, each pattern must,
1369 for each possible combination of operand expressions, have at least one
1370 alternative which can handle that combination of operands.)  The
1371 constraints don't need to @emph{allow} any possible operand---when this is
1372 the case, they do not constrain---but they must at least point the way to
1373 reloading any possible operand so that it will fit.
1374
1375 @itemize @bullet
1376 @item
1377 If the constraint accepts whatever operands the predicate permits,
1378 there is no problem: reloading is never necessary for this operand.
1379
1380 For example, an operand whose constraints permit everything except
1381 registers is safe provided its predicate rejects registers.
1382
1383 An operand whose predicate accepts only constant values is safe
1384 provided its constraints include the letter @samp{i}.  If any possible
1385 constant value is accepted, then nothing less than @samp{i} will do;
1386 if the predicate is more selective, then the constraints may also be
1387 more selective.
1388
1389 @item
1390 Any operand expression can be reloaded by copying it into a register.
1391 So if an operand's constraints allow some kind of register, it is
1392 certain to be safe.  It need not permit all classes of registers; the
1393 compiler knows how to copy a register into another register of the
1394 proper class in order to make an instruction valid.
1395
1396 @cindex nonoffsettable memory reference
1397 @cindex memory reference, nonoffsettable
1398 @item
1399 A nonoffsettable memory reference can be reloaded by copying the
1400 address into a register.  So if the constraint uses the letter
1401 @samp{o}, all memory references are taken care of.
1402
1403 @item
1404 A constant operand can be reloaded by allocating space in memory to
1405 hold it as preinitialized data.  Then the memory reference can be used
1406 in place of the constant.  So if the constraint uses the letters
1407 @samp{o} or @samp{m}, constant operands are not a problem.
1408
1409 @item
1410 If the constraint permits a constant and a pseudo register used in an insn
1411 was not allocated to a hard register and is equivalent to a constant,
1412 the register will be replaced with the constant.  If the predicate does
1413 not permit a constant and the insn is re-recognized for some reason, the
1414 compiler will crash.  Thus the predicate must always recognize any
1415 objects allowed by the constraint.
1416 @end itemize
1417
1418 If the operand's predicate can recognize registers, but the constraint does
1419 not permit them, it can make the compiler crash.  When this operand happens
1420 to be a register, the reload pass will be stymied, because it does not know
1421 how to copy a register temporarily into memory.
1422
1423 If the predicate accepts a unary operator, the constraint applies to the
1424 operand.  For example, the MIPS processor at ISA level 3 supports an
1425 instruction which adds two registers in @code{SImode} to produce a
1426 @code{DImode} result, but only if the registers are correctly sign
1427 extended.  This predicate for the input operands accepts a
1428 @code{sign_extend} of an @code{SImode} register.  Write the constraint
1429 to indicate the type of register that is required for the operand of the
1430 @code{sign_extend}.
1431 @end ifset
1432
1433 @node Multi-Alternative
1434 @subsection Multiple Alternative Constraints
1435 @cindex multiple alternative constraints
1436
1437 Sometimes a single instruction has multiple alternative sets of possible
1438 operands.  For example, on the 68000, a logical-or instruction can combine
1439 register or an immediate value into memory, or it can combine any kind of
1440 operand into a register; but it cannot combine one memory location into
1441 another.
1442
1443 These constraints are represented as multiple alternatives.  An alternative
1444 can be described by a series of letters for each operand.  The overall
1445 constraint for an operand is made from the letters for this operand
1446 from the first alternative, a comma, the letters for this operand from
1447 the second alternative, a comma, and so on until the last alternative.
1448 @ifset INTERNALS
1449 Here is how it is done for fullword logical-or on the 68000:
1450
1451 @smallexample
1452 (define_insn "iorsi3"
1453   [(set (match_operand:SI 0 "general_operand" "=m,d")
1454         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
1455                 (match_operand:SI 2 "general_operand" "dKs,dmKs")))]
1456   @dots{})
1457 @end smallexample
1458
1459 The first alternative has @samp{m} (memory) for operand 0, @samp{0} for
1460 operand 1 (meaning it must match operand 0), and @samp{dKs} for operand
1461 2.  The second alternative has @samp{d} (data register) for operand 0,
1462 @samp{0} for operand 1, and @samp{dmKs} for operand 2.  The @samp{=} and
1463 @samp{%} in the constraints apply to all the alternatives; their
1464 meaning is explained in the next section (@pxref{Class Preferences}).
1465 @end ifset
1466
1467 @c FIXME Is this ? and ! stuff of use in asm()?  If not, hide unless INTERNAL
1468 If all the operands fit any one alternative, the instruction is valid.
1469 Otherwise, for each alternative, the compiler counts how many instructions
1470 must be added to copy the operands so that that alternative applies.
1471 The alternative requiring the least copying is chosen.  If two alternatives
1472 need the same amount of copying, the one that comes first is chosen.
1473 These choices can be altered with the @samp{?} and @samp{!} characters:
1474
1475 @table @code
1476 @cindex @samp{?} in constraint
1477 @cindex question mark
1478 @item ?
1479 Disparage slightly the alternative that the @samp{?} appears in,
1480 as a choice when no alternative applies exactly.  The compiler regards
1481 this alternative as one unit more costly for each @samp{?} that appears
1482 in it.
1483
1484 @cindex @samp{!} in constraint
1485 @cindex exclamation point
1486 @item !
1487 Disparage severely the alternative that the @samp{!} appears in.
1488 This alternative can still be used if it fits without reloading,
1489 but if reloading is needed, some other alternative will be used.
1490 @end table
1491
1492 @ifset INTERNALS
1493 When an insn pattern has multiple alternatives in its constraints, often
1494 the appearance of the assembler code is determined mostly by which
1495 alternative was matched.  When this is so, the C code for writing the
1496 assembler code can use the variable @code{which_alternative}, which is
1497 the ordinal number of the alternative that was actually satisfied (0 for
1498 the first, 1 for the second alternative, etc.).  @xref{Output Statement}.
1499 @end ifset
1500
1501 @ifset INTERNALS
1502 @node Class Preferences
1503 @subsection Register Class Preferences
1504 @cindex class preference constraints
1505 @cindex register class preference constraints
1506
1507 @cindex voting between constraint alternatives
1508 The operand constraints have another function: they enable the compiler
1509 to decide which kind of hardware register a pseudo register is best
1510 allocated to.  The compiler examines the constraints that apply to the
1511 insns that use the pseudo register, looking for the machine-dependent
1512 letters such as @samp{d} and @samp{a} that specify classes of registers.
1513 The pseudo register is put in whichever class gets the most ``votes''.
1514 The constraint letters @samp{g} and @samp{r} also vote: they vote in
1515 favor of a general register.  The machine description says which registers
1516 are considered general.
1517
1518 Of course, on some machines all registers are equivalent, and no register
1519 classes are defined.  Then none of this complexity is relevant.
1520 @end ifset
1521
1522 @node Modifiers
1523 @subsection Constraint Modifier Characters
1524 @cindex modifiers in constraints
1525 @cindex constraint modifier characters
1526
1527 @c prevent bad page break with this line
1528 Here are constraint modifier characters.
1529
1530 @table @samp
1531 @cindex @samp{=} in constraint
1532 @item =
1533 Means that this operand is write-only for this instruction: the previous
1534 value is discarded and replaced by output data.
1535
1536 @cindex @samp{+} in constraint
1537 @item +
1538 Means that this operand is both read and written by the instruction.
1539
1540 When the compiler fixes up the operands to satisfy the constraints,
1541 it needs to know which operands are inputs to the instruction and
1542 which are outputs from it.  @samp{=} identifies an output; @samp{+}
1543 identifies an operand that is both input and output; all other operands
1544 are assumed to be input only.
1545
1546 If you specify @samp{=} or @samp{+} in a constraint, you put it in the
1547 first character of the constraint string.
1548
1549 @cindex @samp{&} in constraint
1550 @cindex earlyclobber operand
1551 @item &
1552 Means (in a particular alternative) that this operand is an
1553 @dfn{earlyclobber} operand, which is modified before the instruction is
1554 finished using the input operands.  Therefore, this operand may not lie
1555 in a register that is used as an input operand or as part of any memory
1556 address.
1557
1558 @samp{&} applies only to the alternative in which it is written.  In
1559 constraints with multiple alternatives, sometimes one alternative
1560 requires @samp{&} while others do not.  See, for example, the
1561 @samp{movdf} insn of the 68000.
1562
1563 An input operand can be tied to an earlyclobber operand if its only
1564 use as an input occurs before the early result is written.  Adding
1565 alternatives of this form often allows GCC to produce better code
1566 when only some of the inputs can be affected by the earlyclobber.
1567 See, for example, the @samp{mulsi3} insn of the ARM@.
1568
1569 @samp{&} does not obviate the need to write @samp{=}.
1570
1571 @cindex @samp{%} in constraint
1572 @item %
1573 Declares the instruction to be commutative for this operand and the
1574 following operand.  This means that the compiler may interchange the
1575 two operands if that is the cheapest way to make all operands fit the
1576 constraints.
1577 @ifset INTERNALS
1578 This is often used in patterns for addition instructions
1579 that really have only two operands: the result must go in one of the
1580 arguments.  Here for example, is how the 68000 halfword-add
1581 instruction is defined:
1582
1583 @smallexample
1584 (define_insn "addhi3"
1585   [(set (match_operand:HI 0 "general_operand" "=m,r")
1586      (plus:HI (match_operand:HI 1 "general_operand" "%0,0")
1587               (match_operand:HI 2 "general_operand" "di,g")))]
1588   @dots{})
1589 @end smallexample
1590 @end ifset
1591 GCC can only handle one commutative pair in an asm; if you use more,
1592 the compiler may fail.  Note that you need not use the modifier if
1593 the two alternatives are strictly identical; this would only waste
1594 time in the reload pass.  The modifier is not operational after
1595 register allocation, so the result of @code{define_peephole2}
1596 and @code{define_split}s performed after reload cannot rely on
1597 @samp{%} to make the intended insn match.
1598
1599 @cindex @samp{#} in constraint
1600 @item #
1601 Says that all following characters, up to the next comma, are to be
1602 ignored as a constraint.  They are significant only for choosing
1603 register preferences.
1604
1605 @cindex @samp{*} in constraint
1606 @item *
1607 Says that the following character should be ignored when choosing
1608 register preferences.  @samp{*} has no effect on the meaning of the
1609 constraint as a constraint, and no effect on reloading.
1610
1611 @ifset INTERNALS
1612 Here is an example: the 68000 has an instruction to sign-extend a
1613 halfword in a data register, and can also sign-extend a value by
1614 copying it into an address register.  While either kind of register is
1615 acceptable, the constraints on an address-register destination are
1616 less strict, so it is best if register allocation makes an address
1617 register its goal.  Therefore, @samp{*} is used so that the @samp{d}
1618 constraint letter (for data register) is ignored when computing
1619 register preferences.
1620
1621 @smallexample
1622 (define_insn "extendhisi2"
1623   [(set (match_operand:SI 0 "general_operand" "=*d,a")
1624         (sign_extend:SI
1625          (match_operand:HI 1 "general_operand" "0,g")))]
1626   @dots{})
1627 @end smallexample
1628 @end ifset
1629 @end table
1630
1631 @node Machine Constraints
1632 @subsection Constraints for Particular Machines
1633 @cindex machine specific constraints
1634 @cindex constraints, machine specific
1635
1636 Whenever possible, you should use the general-purpose constraint letters
1637 in @code{asm} arguments, since they will convey meaning more readily to
1638 people reading your code.  Failing that, use the constraint letters
1639 that usually have very similar meanings across architectures.  The most
1640 commonly used constraints are @samp{m} and @samp{r} (for memory and
1641 general-purpose registers respectively; @pxref{Simple Constraints}), and
1642 @samp{I}, usually the letter indicating the most common
1643 immediate-constant format.
1644
1645 Each architecture defines additional constraints.  These constraints
1646 are used by the compiler itself for instruction generation, as well as
1647 for @code{asm} statements; therefore, some of the constraints are not
1648 particularly useful for @code{asm}.  Here is a summary of some of the
1649 machine-dependent constraints available on some particular machines;
1650 it includes both constraints that are useful for @code{asm} and
1651 constraints that aren't.  The compiler source file mentioned in the
1652 table heading for each architecture is the definitive reference for
1653 the meanings of that architecture's constraints.
1654
1655 @table @emph
1656 @item ARM family---@file{config/arm/arm.h}
1657 @table @code
1658 @item f
1659 Floating-point register
1660
1661 @item w
1662 VFP floating-point register
1663
1664 @item F
1665 One of the floating-point constants 0.0, 0.5, 1.0, 2.0, 3.0, 4.0, 5.0
1666 or 10.0
1667
1668 @item G
1669 Floating-point constant that would satisfy the constraint @samp{F} if it
1670 were negated
1671
1672 @item I
1673 Integer that is valid as an immediate operand in a data processing
1674 instruction.  That is, an integer in the range 0 to 255 rotated by a
1675 multiple of 2
1676
1677 @item J
1678 Integer in the range @minus{}4095 to 4095
1679
1680 @item K
1681 Integer that satisfies constraint @samp{I} when inverted (ones complement)
1682
1683 @item L
1684 Integer that satisfies constraint @samp{I} when negated (twos complement)
1685
1686 @item M
1687 Integer in the range 0 to 32
1688
1689 @item Q
1690 A memory reference where the exact address is in a single register
1691 (`@samp{m}' is preferable for @code{asm} statements)
1692
1693 @item R
1694 An item in the constant pool
1695
1696 @item S
1697 A symbol in the text segment of the current file
1698
1699 @item Uv
1700 A memory reference suitable for VFP load/store insns (reg+constant offset)
1701
1702 @item Uy
1703 A memory reference suitable for iWMMXt load/store instructions.
1704
1705 @item Uq
1706 A memory reference suitable for the ARMv4 ldrsb instruction.
1707 @end table
1708
1709 @item AVR family---@file{config/avr/constraints.md}
1710 @table @code
1711 @item l
1712 Registers from r0 to r15
1713
1714 @item a
1715 Registers from r16 to r23
1716
1717 @item d
1718 Registers from r16 to r31
1719
1720 @item w
1721 Registers from r24 to r31.  These registers can be used in @samp{adiw} command
1722
1723 @item e
1724 Pointer register (r26--r31)
1725
1726 @item b
1727 Base pointer register (r28--r31)
1728
1729 @item q
1730 Stack pointer register (SPH:SPL)
1731
1732 @item t
1733 Temporary register r0
1734
1735 @item x
1736 Register pair X (r27:r26)
1737
1738 @item y
1739 Register pair Y (r29:r28)
1740
1741 @item z
1742 Register pair Z (r31:r30)
1743
1744 @item I
1745 Constant greater than @minus{}1, less than 64
1746
1747 @item J
1748 Constant greater than @minus{}64, less than 1
1749
1750 @item K
1751 Constant integer 2
1752
1753 @item L
1754 Constant integer 0
1755
1756 @item M
1757 Constant that fits in 8 bits
1758
1759 @item N
1760 Constant integer @minus{}1
1761
1762 @item O
1763 Constant integer 8, 16, or 24
1764
1765 @item P
1766 Constant integer 1
1767
1768 @item G
1769 A floating point constant 0.0
1770
1771 @item Q
1772 A memory address based on Y or Z pointer with displacement.
1773 @end table
1774
1775 @item Epiphany---@file{config/epiphany/constraints.md}
1776 @table @code
1777 @item U16
1778 An unsigned 16-bit constant.
1779
1780 @item K
1781 An unsigned 5-bit constant.
1782
1783 @item L
1784 A signed 11-bit constant.
1785
1786 @item Cm1
1787 A signed 11-bit constant added to @minus{}1.
1788 Can only match when the @option{-m1reg-@var{reg}} option is active.
1789
1790 @item Cl1
1791 Left-shift of @minus{}1, i.e., a bit mask with a block of leading ones, the rest
1792 being a block of trailing zeroes.
1793 Can only match when the @option{-m1reg-@var{reg}} option is active.
1794
1795 @item Cr1
1796 Right-shift of @minus{}1, i.e., a bit mask with a trailing block of ones, the
1797 rest being zeroes.  Or to put it another way, one less than a power of two.
1798 Can only match when the @option{-m1reg-@var{reg}} option is active.
1799
1800 @item Cal
1801 Constant for arithmetic/logical operations.
1802 This is like @code{i}, except that for position independent code,
1803 no symbols / expressions needing relocations are allowed.
1804
1805 @item Csy
1806 Symbolic constant for call/jump instruction.
1807
1808 @item Rcs
1809 The register class usable in short insns.  This is a register class
1810 constraint, and can thus drive register allocation.
1811 This constraint won't match unless @option{-mprefer-short-insn-regs} is
1812 in effect.
1813
1814 @item Rsc
1815 The the register class of registers that can be used to hold a
1816 sibcall call address.  I.e., a caller-saved register.
1817
1818 @item Rct
1819 Core control register class.
1820
1821 @item Rgs
1822 The register group usable in short insns.
1823 This constraint does not use a register class, so that it only
1824 passively matches suitable registers, and doesn't drive register allocation.
1825
1826 @ifset INTERNALS
1827 @item Car
1828 Constant suitable for the addsi3_r pattern.  This is a valid offset
1829 For byte, halfword, or word addressing.
1830 @end ifset
1831
1832 @item Rra
1833 Matches the return address if it can be replaced with the link register.
1834
1835 @item Rcc
1836 Matches the integer condition code register.
1837
1838 @item Sra
1839 Matches the return address if it is in a stack slot.
1840
1841 @item Cfm
1842 Matches control register values to switch fp mode, which are encapsulated in
1843 @code{UNSPEC_FP_MODE}.
1844 @end table
1845
1846 @item CR16 Architecture---@file{config/cr16/cr16.h}
1847 @table @code
1848
1849 @item b
1850 Registers from r0 to r14 (registers without stack pointer)
1851
1852 @item t
1853 Register from r0 to r11 (all 16-bit registers)
1854
1855 @item p
1856 Register from r12 to r15 (all 32-bit registers)
1857
1858 @item I
1859 Signed constant that fits in 4 bits
1860
1861 @item J
1862 Signed constant that fits in 5 bits
1863
1864 @item K
1865 Signed constant that fits in 6 bits
1866
1867 @item L
1868 Unsigned constant that fits in 4 bits
1869
1870 @item M
1871 Signed constant that fits in 32 bits
1872
1873 @item N
1874 Check for 64 bits wide constants for add/sub instructions
1875
1876 @item G
1877 Floating point constant that is legal for store immediate
1878 @end table
1879
1880 @item Hewlett-Packard PA-RISC---@file{config/pa/pa.h}
1881 @table @code
1882 @item a
1883 General register 1
1884
1885 @item f
1886 Floating point register
1887
1888 @item q
1889 Shift amount register
1890
1891 @item x
1892 Floating point register (deprecated)
1893
1894 @item y
1895 Upper floating point register (32-bit), floating point register (64-bit)
1896
1897 @item Z
1898 Any register
1899
1900 @item I
1901 Signed 11-bit integer constant
1902
1903 @item J
1904 Signed 14-bit integer constant
1905
1906 @item K
1907 Integer constant that can be deposited with a @code{zdepi} instruction
1908
1909 @item L
1910 Signed 5-bit integer constant
1911
1912 @item M
1913 Integer constant 0
1914
1915 @item N
1916 Integer constant that can be loaded with a @code{ldil} instruction
1917
1918 @item O
1919 Integer constant whose value plus one is a power of 2
1920
1921 @item P
1922 Integer constant that can be used for @code{and} operations in @code{depi}
1923 and @code{extru} instructions
1924
1925 @item S
1926 Integer constant 31
1927
1928 @item U
1929 Integer constant 63
1930
1931 @item G
1932 Floating-point constant 0.0
1933
1934 @item A
1935 A @code{lo_sum} data-linkage-table memory operand
1936
1937 @item Q
1938 A memory operand that can be used as the destination operand of an
1939 integer store instruction
1940
1941 @item R
1942 A scaled or unscaled indexed memory operand
1943
1944 @item T
1945 A memory operand for floating-point loads and stores
1946
1947 @item W
1948 A register indirect memory operand
1949 @end table
1950
1951 @item picoChip family---@file{picochip.h}
1952 @table @code
1953 @item k
1954 Stack register.
1955
1956 @item f
1957 Pointer register.  A register which can be used to access memory without
1958 supplying an offset.  Any other register can be used to access memory,
1959 but will need a constant offset.  In the case of the offset being zero,
1960 it is more efficient to use a pointer register, since this reduces code
1961 size.
1962
1963 @item t
1964 A twin register.  A register which may be paired with an adjacent
1965 register to create a 32-bit register.
1966
1967 @item a
1968 Any absolute memory address (e.g., symbolic constant, symbolic
1969 constant + offset).
1970
1971 @item I
1972 4-bit signed integer.
1973
1974 @item J
1975 4-bit unsigned integer.
1976
1977 @item K
1978 8-bit signed integer.
1979
1980 @item M
1981 Any constant whose absolute value is no greater than 4-bits.
1982
1983 @item N
1984 10-bit signed integer
1985
1986 @item O
1987 16-bit signed integer.
1988
1989 @end table
1990
1991 @item PowerPC and IBM RS6000---@file{config/rs6000/rs6000.h}
1992 @table @code
1993 @item b
1994 Address base register
1995
1996 @item d
1997 Floating point register (containing 64-bit value)
1998
1999 @item f
2000 Floating point register (containing 32-bit value)
2001
2002 @item v
2003 Altivec vector register
2004
2005 @item wd
2006 VSX vector register to hold vector double data
2007
2008 @item wf
2009 VSX vector register to hold vector float data
2010
2011 @item ws
2012 VSX vector register to hold scalar float data
2013
2014 @item wa
2015 Any VSX register
2016
2017 @item h
2018 @samp{MQ}, @samp{CTR}, or @samp{LINK} register
2019
2020 @item q
2021 @samp{MQ} register
2022
2023 @item c
2024 @samp{CTR} register
2025
2026 @item l
2027 @samp{LINK} register
2028
2029 @item x
2030 @samp{CR} register (condition register) number 0
2031
2032 @item y
2033 @samp{CR} register (condition register)
2034
2035 @item z
2036 @samp{XER[CA]} carry bit (part of the XER register)
2037
2038 @item I
2039 Signed 16-bit constant
2040
2041 @item J
2042 Unsigned 16-bit constant shifted left 16 bits (use @samp{L} instead for
2043 @code{SImode} constants)
2044
2045 @item K
2046 Unsigned 16-bit constant
2047
2048 @item L
2049 Signed 16-bit constant shifted left 16 bits
2050
2051 @item M
2052 Constant larger than 31
2053
2054 @item N
2055 Exact power of 2
2056
2057 @item O
2058 Zero
2059
2060 @item P
2061 Constant whose negation is a signed 16-bit constant
2062
2063 @item G
2064 Floating point constant that can be loaded into a register with one
2065 instruction per word
2066
2067 @item H
2068 Integer/Floating point constant that can be loaded into a register using
2069 three instructions
2070
2071 @item m
2072 Memory operand.
2073 Normally, @code{m} does not allow addresses that update the base register.
2074 If @samp{<} or @samp{>} constraint is also used, they are allowed and
2075 therefore on PowerPC targets in that case it is only safe
2076 to use @samp{m<>} in an @code{asm} statement if that @code{asm} statement
2077 accesses the operand exactly once.  The @code{asm} statement must also
2078 use @samp{%U@var{<opno>}} as a placeholder for the ``update'' flag in the
2079 corresponding load or store instruction.  For example:
2080
2081 @smallexample
2082 asm ("st%U0 %1,%0" : "=m<>" (mem) : "r" (val));
2083 @end smallexample
2084
2085 is correct but:
2086
2087 @smallexample
2088 asm ("st %1,%0" : "=m<>" (mem) : "r" (val));
2089 @end smallexample
2090
2091 is not.
2092
2093 @item es
2094 A ``stable'' memory operand; that is, one which does not include any
2095 automodification of the base register.  This used to be useful when
2096 @samp{m} allowed automodification of the base register, but as those are now only
2097 allowed when @samp{<} or @samp{>} is used, @samp{es} is basically the same
2098 as @samp{m} without @samp{<} and @samp{>}.
2099
2100 @item Q
2101 Memory operand that is an offset from a register (it is usually better
2102 to use @samp{m} or @samp{es} in @code{asm} statements)
2103
2104 @item Z
2105 Memory operand that is an indexed or indirect from a register (it is
2106 usually better to use @samp{m} or @samp{es} in @code{asm} statements)
2107
2108 @item R
2109 AIX TOC entry
2110
2111 @item a
2112 Address operand that is an indexed or indirect from a register (@samp{p} is
2113 preferable for @code{asm} statements)
2114
2115 @item S
2116 Constant suitable as a 64-bit mask operand
2117
2118 @item T
2119 Constant suitable as a 32-bit mask operand
2120
2121 @item U
2122 System V Release 4 small data area reference
2123
2124 @item t
2125 AND masks that can be performed by two rldic@{l, r@} instructions
2126
2127 @item W
2128 Vector constant that does not require memory
2129
2130 @item j
2131 Vector constant that is all zeros.
2132
2133 @end table
2134
2135 @item Intel 386---@file{config/i386/constraints.md}
2136 @table @code
2137 @item R
2138 Legacy register---the eight integer registers available on all
2139 i386 processors (@code{a}, @code{b}, @code{c}, @code{d},
2140 @code{si}, @code{di}, @code{bp}, @code{sp}).
2141
2142 @item q
2143 Any register accessible as @code{@var{r}l}.  In 32-bit mode, @code{a},
2144 @code{b}, @code{c}, and @code{d}; in 64-bit mode, any integer register.
2145
2146 @item Q
2147 Any register accessible as @code{@var{r}h}: @code{a}, @code{b},
2148 @code{c}, and @code{d}.
2149
2150 @ifset INTERNALS
2151 @item l
2152 Any register that can be used as the index in a base+index memory
2153 access: that is, any general register except the stack pointer.
2154 @end ifset
2155
2156 @item a
2157 The @code{a} register.
2158
2159 @item b
2160 The @code{b} register.
2161
2162 @item c
2163 The @code{c} register.
2164
2165 @item d
2166 The @code{d} register.
2167
2168 @item S
2169 The @code{si} register.
2170
2171 @item D
2172 The @code{di} register.
2173
2174 @item A
2175 The @code{a} and @code{d} registers.  This class is used for instructions
2176 that return double word results in the @code{ax:dx} register pair.  Single
2177 word values will be allocated either in @code{ax} or @code{dx}.
2178 For example on i386 the following implements @code{rdtsc}:
2179
2180 @smallexample
2181 unsigned long long rdtsc (void)
2182 @{
2183   unsigned long long tick;
2184   __asm__ __volatile__("rdtsc":"=A"(tick));
2185   return tick;
2186 @}
2187 @end smallexample
2188
2189 This is not correct on x86_64 as it would allocate tick in either @code{ax}
2190 or @code{dx}.  You have to use the following variant instead:
2191
2192 @smallexample
2193 unsigned long long rdtsc (void)
2194 @{
2195   unsigned int tickl, tickh;
2196   __asm__ __volatile__("rdtsc":"=a"(tickl),"=d"(tickh));
2197   return ((unsigned long long)tickh << 32)|tickl;
2198 @}
2199 @end smallexample
2200
2201
2202 @item f
2203 Any 80387 floating-point (stack) register.
2204
2205 @item t
2206 Top of 80387 floating-point stack (@code{%st(0)}).
2207
2208 @item u
2209 Second from top of 80387 floating-point stack (@code{%st(1)}).
2210
2211 @item y
2212 Any MMX register.
2213
2214 @item x
2215 Any SSE register.
2216
2217 @item Yz
2218 First SSE register (@code{%xmm0}).
2219
2220 @ifset INTERNALS
2221 @item Y2
2222 Any SSE register, when SSE2 is enabled.
2223
2224 @item Yi
2225 Any SSE register, when SSE2 and inter-unit moves are enabled.
2226
2227 @item Ym
2228 Any MMX register, when inter-unit moves are enabled.
2229 @end ifset
2230
2231 @item I
2232 Integer constant in the range 0 @dots{} 31, for 32-bit shifts.
2233
2234 @item J
2235 Integer constant in the range 0 @dots{} 63, for 64-bit shifts.
2236
2237 @item K
2238 Signed 8-bit integer constant.
2239
2240 @item L
2241 @code{0xFF} or @code{0xFFFF}, for andsi as a zero-extending move.
2242
2243 @item M
2244 0, 1, 2, or 3 (shifts for the @code{lea} instruction).
2245
2246 @item N
2247 Unsigned 8-bit integer constant (for @code{in} and @code{out}
2248 instructions).
2249
2250 @ifset INTERNALS
2251 @item O
2252 Integer constant in the range 0 @dots{} 127, for 128-bit shifts.
2253 @end ifset
2254
2255 @item G
2256 Standard 80387 floating point constant.
2257
2258 @item C
2259 Standard SSE floating point constant.
2260
2261 @item e
2262 32-bit signed integer constant, or a symbolic reference known
2263 to fit that range (for immediate operands in sign-extending x86-64
2264 instructions).
2265
2266 @item Z
2267 32-bit unsigned integer constant, or a symbolic reference known
2268 to fit that range (for immediate operands in zero-extending x86-64
2269 instructions).
2270
2271 @end table
2272
2273 @item Intel IA-64---@file{config/ia64/ia64.h}
2274 @table @code
2275 @item a
2276 General register @code{r0} to @code{r3} for @code{addl} instruction
2277
2278 @item b
2279 Branch register
2280
2281 @item c
2282 Predicate register (@samp{c} as in ``conditional'')
2283
2284 @item d
2285 Application register residing in M-unit
2286
2287 @item e
2288 Application register residing in I-unit
2289
2290 @item f
2291 Floating-point register
2292
2293 @item m
2294 Memory operand.  If used together with @samp{<} or @samp{>},
2295 the operand can have postincrement and postdecrement which
2296 require printing with @samp{%Pn} on IA-64.
2297
2298 @item G
2299 Floating-point constant 0.0 or 1.0
2300
2301 @item I
2302 14-bit signed integer constant
2303
2304 @item J
2305 22-bit signed integer constant
2306
2307 @item K
2308 8-bit signed integer constant for logical instructions
2309
2310 @item L
2311 8-bit adjusted signed integer constant for compare pseudo-ops
2312
2313 @item M
2314 6-bit unsigned integer constant for shift counts
2315
2316 @item N
2317 9-bit signed integer constant for load and store postincrements
2318
2319 @item O
2320 The constant zero
2321
2322 @item P
2323 0 or @minus{}1 for @code{dep} instruction
2324
2325 @item Q
2326 Non-volatile memory for floating-point loads and stores
2327
2328 @item R
2329 Integer constant in the range 1 to 4 for @code{shladd} instruction
2330
2331 @item S
2332 Memory operand except postincrement and postdecrement.  This is
2333 now roughly the same as @samp{m} when not used together with @samp{<}
2334 or @samp{>}.
2335 @end table
2336
2337 @item FRV---@file{config/frv/frv.h}
2338 @table @code
2339 @item a
2340 Register in the class @code{ACC_REGS} (@code{acc0} to @code{acc7}).
2341
2342 @item b
2343 Register in the class @code{EVEN_ACC_REGS} (@code{acc0} to @code{acc7}).
2344
2345 @item c
2346 Register in the class @code{CC_REGS} (@code{fcc0} to @code{fcc3} and
2347 @code{icc0} to @code{icc3}).
2348
2349 @item d
2350 Register in the class @code{GPR_REGS} (@code{gr0} to @code{gr63}).
2351
2352 @item e
2353 Register in the class @code{EVEN_REGS} (@code{gr0} to @code{gr63}).
2354 Odd registers are excluded not in the class but through the use of a machine
2355 mode larger than 4 bytes.
2356
2357 @item f
2358 Register in the class @code{FPR_REGS} (@code{fr0} to @code{fr63}).
2359
2360 @item h
2361 Register in the class @code{FEVEN_REGS} (@code{fr0} to @code{fr63}).
2362 Odd registers are excluded not in the class but through the use of a machine
2363 mode larger than 4 bytes.
2364
2365 @item l
2366 Register in the class @code{LR_REG} (the @code{lr} register).
2367
2368 @item q
2369 Register in the class @code{QUAD_REGS} (@code{gr2} to @code{gr63}).
2370 Register numbers not divisible by 4 are excluded not in the class but through
2371 the use of a machine mode larger than 8 bytes.
2372
2373 @item t
2374 Register in the class @code{ICC_REGS} (@code{icc0} to @code{icc3}).
2375
2376 @item u
2377 Register in the class @code{FCC_REGS} (@code{fcc0} to @code{fcc3}).
2378
2379 @item v
2380 Register in the class @code{ICR_REGS} (@code{cc4} to @code{cc7}).
2381
2382 @item w
2383 Register in the class @code{FCR_REGS} (@code{cc0} to @code{cc3}).
2384
2385 @item x
2386 Register in the class @code{QUAD_FPR_REGS} (@code{fr0} to @code{fr63}).
2387 Register numbers not divisible by 4 are excluded not in the class but through
2388 the use of a machine mode larger than 8 bytes.
2389
2390 @item z
2391 Register in the class @code{SPR_REGS} (@code{lcr} and @code{lr}).
2392
2393 @item A
2394 Register in the class @code{QUAD_ACC_REGS} (@code{acc0} to @code{acc7}).
2395
2396 @item B
2397 Register in the class @code{ACCG_REGS} (@code{accg0} to @code{accg7}).
2398
2399 @item C
2400 Register in the class @code{CR_REGS} (@code{cc0} to @code{cc7}).
2401
2402 @item G
2403 Floating point constant zero
2404
2405 @item I
2406 6-bit signed integer constant
2407
2408 @item J
2409 10-bit signed integer constant
2410
2411 @item L
2412 16-bit signed integer constant
2413
2414 @item M
2415 16-bit unsigned integer constant
2416
2417 @item N
2418 12-bit signed integer constant that is negative---i.e.@: in the
2419 range of @minus{}2048 to @minus{}1
2420
2421 @item O
2422 Constant zero
2423
2424 @item P
2425 12-bit signed integer constant that is greater than zero---i.e.@: in the
2426 range of 1 to 2047.
2427
2428 @end table
2429
2430 @item Blackfin family---@file{config/bfin/constraints.md}
2431 @table @code
2432 @item a
2433 P register
2434
2435 @item d
2436 D register
2437
2438 @item z
2439 A call clobbered P register.
2440
2441 @item q@var{n}
2442 A single register.  If @var{n} is in the range 0 to 7, the corresponding D
2443 register.  If it is @code{A}, then the register P0.
2444
2445 @item D
2446 Even-numbered D register
2447
2448 @item W
2449 Odd-numbered D register
2450
2451 @item e
2452 Accumulator register.
2453
2454 @item A
2455 Even-numbered accumulator register.
2456
2457 @item B
2458 Odd-numbered accumulator register.
2459
2460 @item b
2461 I register
2462
2463 @item v
2464 B register
2465
2466 @item f
2467 M register
2468
2469 @item c
2470 Registers used for circular buffering, i.e. I, B, or L registers.
2471
2472 @item C
2473 The CC register.
2474
2475 @item t
2476 LT0 or LT1.
2477
2478 @item k
2479 LC0 or LC1.
2480
2481 @item u
2482 LB0 or LB1.
2483
2484 @item x
2485 Any D, P, B, M, I or L register.
2486
2487 @item y
2488 Additional registers typically used only in prologues and epilogues: RETS,
2489 RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and USP.
2490
2491 @item w
2492 Any register except accumulators or CC.
2493
2494 @item Ksh
2495 Signed 16 bit integer (in the range @minus{}32768 to 32767)
2496
2497 @item Kuh
2498 Unsigned 16 bit integer (in the range 0 to 65535)
2499
2500 @item Ks7
2501 Signed 7 bit integer (in the range @minus{}64 to 63)
2502
2503 @item Ku7
2504 Unsigned 7 bit integer (in the range 0 to 127)
2505
2506 @item Ku5
2507 Unsigned 5 bit integer (in the range 0 to 31)
2508
2509 @item Ks4
2510 Signed 4 bit integer (in the range @minus{}8 to 7)
2511
2512 @item Ks3
2513 Signed 3 bit integer (in the range @minus{}3 to 4)
2514
2515 @item Ku3
2516 Unsigned 3 bit integer (in the range 0 to 7)
2517
2518 @item P@var{n}
2519 Constant @var{n}, where @var{n} is a single-digit constant in the range 0 to 4.
2520
2521 @item PA
2522 An integer equal to one of the MACFLAG_XXX constants that is suitable for
2523 use with either accumulator.
2524
2525 @item PB
2526 An integer equal to one of the MACFLAG_XXX constants that is suitable for
2527 use only with accumulator A1.
2528
2529 @item M1
2530 Constant 255.
2531
2532 @item M2
2533 Constant 65535.
2534
2535 @item J
2536 An integer constant with exactly a single bit set.
2537
2538 @item L
2539 An integer constant with all bits set except exactly one.
2540
2541 @item H
2542
2543 @item Q
2544 Any SYMBOL_REF.
2545 @end table
2546
2547 @item M32C---@file{config/m32c/m32c.c}
2548 @table @code
2549 @item Rsp
2550 @itemx Rfb
2551 @itemx Rsb
2552 @samp{$sp}, @samp{$fb}, @samp{$sb}.
2553
2554 @item Rcr
2555 Any control register, when they're 16 bits wide (nothing if control
2556 registers are 24 bits wide)
2557
2558 @item Rcl
2559 Any control register, when they're 24 bits wide.
2560
2561 @item R0w
2562 @itemx R1w
2563 @itemx R2w
2564 @itemx R3w
2565 $r0, $r1, $r2, $r3.
2566
2567 @item R02
2568 $r0 or $r2, or $r2r0 for 32 bit values.
2569
2570 @item R13
2571 $r1 or $r3, or $r3r1 for 32 bit values.
2572
2573 @item Rdi
2574 A register that can hold a 64 bit value.
2575
2576 @item Rhl
2577 $r0 or $r1 (registers with addressable high/low bytes)
2578
2579 @item R23
2580 $r2 or $r3
2581
2582 @item Raa
2583 Address registers
2584
2585 @item Raw
2586 Address registers when they're 16 bits wide.
2587
2588 @item Ral
2589 Address registers when they're 24 bits wide.
2590
2591 @item Rqi
2592 Registers that can hold QI values.
2593
2594 @item Rad
2595 Registers that can be used with displacements ($a0, $a1, $sb).
2596
2597 @item Rsi
2598 Registers that can hold 32 bit values.
2599
2600 @item Rhi
2601 Registers that can hold 16 bit values.
2602
2603 @item Rhc
2604 Registers chat can hold 16 bit values, including all control
2605 registers.
2606
2607 @item Rra
2608 $r0 through R1, plus $a0 and $a1.
2609
2610 @item Rfl
2611 The flags register.
2612
2613 @item Rmm
2614 The memory-based pseudo-registers $mem0 through $mem15.
2615
2616 @item Rpi
2617 Registers that can hold pointers (16 bit registers for r8c, m16c; 24
2618 bit registers for m32cm, m32c).
2619
2620 @item Rpa
2621 Matches multiple registers in a PARALLEL to form a larger register.
2622 Used to match function return values.
2623
2624 @item Is3
2625 @minus{}8 @dots{} 7
2626
2627 @item IS1
2628 @minus{}128 @dots{} 127
2629
2630 @item IS2
2631 @minus{}32768 @dots{} 32767
2632
2633 @item IU2
2634 0 @dots{} 65535
2635
2636 @item In4
2637 @minus{}8 @dots{} @minus{}1 or 1 @dots{} 8
2638
2639 @item In5
2640 @minus{}16 @dots{} @minus{}1 or 1 @dots{} 16
2641
2642 @item In6
2643 @minus{}32 @dots{} @minus{}1 or 1 @dots{} 32
2644
2645 @item IM2
2646 @minus{}65536 @dots{} @minus{}1
2647
2648 @item Ilb
2649 An 8 bit value with exactly one bit set.
2650
2651 @item Ilw
2652 A 16 bit value with exactly one bit set.
2653
2654 @item Sd
2655 The common src/dest memory addressing modes.
2656
2657 @item Sa
2658 Memory addressed using $a0 or $a1.
2659
2660 @item Si
2661 Memory addressed with immediate addresses.
2662
2663 @item Ss
2664 Memory addressed using the stack pointer ($sp).
2665
2666 @item Sf
2667 Memory addressed using the frame base register ($fb).
2668
2669 @item Ss
2670 Memory addressed using the small base register ($sb).
2671
2672 @item S1
2673 $r1h
2674 @end table
2675
2676 @item MeP---@file{config/mep/constraints.md}
2677 @table @code
2678
2679 @item a
2680 The $sp register.
2681
2682 @item b
2683 The $tp register.
2684
2685 @item c
2686 Any control register.
2687
2688 @item d
2689 Either the $hi or the $lo register.
2690
2691 @item em
2692 Coprocessor registers that can be directly loaded ($c0-$c15).
2693
2694 @item ex
2695 Coprocessor registers that can be moved to each other.
2696
2697 @item er
2698 Coprocessor registers that can be moved to core registers.
2699
2700 @item h
2701 The $hi register.
2702
2703 @item j
2704 The $rpc register.
2705
2706 @item l
2707 The $lo register.
2708
2709 @item t
2710 Registers which can be used in $tp-relative addressing.
2711
2712 @item v
2713 The $gp register.
2714
2715 @item x
2716 The coprocessor registers.
2717
2718 @item y
2719 The coprocessor control registers.
2720
2721 @item z
2722 The $0 register.
2723
2724 @item A
2725 User-defined register set A.
2726
2727 @item B
2728 User-defined register set B.
2729
2730 @item C
2731 User-defined register set C.
2732
2733 @item D
2734 User-defined register set D.
2735
2736 @item I
2737 Offsets for $gp-rel addressing.
2738
2739 @item J
2740 Constants that can be used directly with boolean insns.
2741
2742 @item K
2743 Constants that can be moved directly to registers.
2744
2745 @item L
2746 Small constants that can be added to registers.
2747
2748 @item M
2749 Long shift counts.
2750
2751 @item N
2752 Small constants that can be compared to registers.
2753
2754 @item O
2755 Constants that can be loaded into the top half of registers.
2756
2757 @item S
2758 Signed 8-bit immediates.
2759
2760 @item T
2761 Symbols encoded for $tp-rel or $gp-rel addressing.
2762
2763 @item U
2764 Non-constant addresses for loading/saving coprocessor registers.
2765
2766 @item W
2767 The top half of a symbol's value.
2768
2769 @item Y
2770 A register indirect address without offset.
2771
2772 @item Z
2773 Symbolic references to the control bus.
2774
2775 @end table
2776
2777 @item MicroBlaze---@file{config/microblaze/constraints.md}
2778 @table @code
2779 @item d
2780 A general register (@code{r0} to @code{r31}).
2781
2782 @item z
2783 A status register (@code{rmsr}, @code{$fcc1} to @code{$fcc7}).
2784
2785 @end table
2786
2787 @item MIPS---@file{config/mips/constraints.md}
2788 @table @code
2789 @item d
2790 An address register.  This is equivalent to @code{r} unless
2791 generating MIPS16 code.
2792
2793 @item f
2794 A floating-point register (if available).
2795
2796 @item h
2797 Formerly the @code{hi} register.  This constraint is no longer supported.
2798
2799 @item l
2800 The @code{lo} register.  Use this register to store values that are
2801 no bigger than a word.
2802
2803 @item x
2804 The concatenated @code{hi} and @code{lo} registers.  Use this register
2805 to store doubleword values.
2806
2807 @item c
2808 A register suitable for use in an indirect jump.  This will always be
2809 @code{$25} for @option{-mabicalls}.
2810
2811 @item v
2812 Register @code{$3}.  Do not use this constraint in new code;
2813 it is retained only for compatibility with glibc.
2814
2815 @item y
2816 Equivalent to @code{r}; retained for backwards compatibility.
2817
2818 @item z
2819 A floating-point condition code register.
2820
2821 @item I
2822 A signed 16-bit constant (for arithmetic instructions).
2823
2824 @item J
2825 Integer zero.
2826
2827 @item K
2828 An unsigned 16-bit constant (for logic instructions).
2829
2830 @item L
2831 A signed 32-bit constant in which the lower 16 bits are zero.
2832 Such constants can be loaded using @code{lui}.
2833
2834 @item M
2835 A constant that cannot be loaded using @code{lui}, @code{addiu}
2836 or @code{ori}.
2837
2838 @item N
2839 A constant in the range @minus{}65535 to @minus{}1 (inclusive).
2840
2841 @item O
2842 A signed 15-bit constant.
2843
2844 @item P
2845 A constant in the range 1 to 65535 (inclusive).
2846
2847 @item G
2848 Floating-point zero.
2849
2850 @item R
2851 An address that can be used in a non-macro load or store.
2852 @end table
2853
2854 @item Motorola 680x0---@file{config/m68k/constraints.md}
2855 @table @code
2856 @item a
2857 Address register
2858
2859 @item d
2860 Data register
2861
2862 @item f
2863 68881 floating-point register, if available
2864
2865 @item I
2866 Integer in the range 1 to 8
2867
2868 @item J
2869 16-bit signed number
2870
2871 @item K
2872 Signed number whose magnitude is greater than 0x80
2873
2874 @item L
2875 Integer in the range @minus{}8 to @minus{}1
2876
2877 @item M
2878 Signed number whose magnitude is greater than 0x100
2879
2880 @item N
2881 Range 24 to 31, rotatert:SI 8 to 1 expressed as rotate
2882
2883 @item O
2884 16 (for rotate using swap)
2885
2886 @item P
2887 Range 8 to 15, rotatert:HI 8 to 1 expressed as rotate
2888
2889 @item R
2890 Numbers that mov3q can handle
2891
2892 @item G
2893 Floating point constant that is not a 68881 constant
2894
2895 @item S
2896 Operands that satisfy 'm' when -mpcrel is in effect
2897
2898 @item T
2899 Operands that satisfy 's' when -mpcrel is not in effect
2900
2901 @item Q
2902 Address register indirect addressing mode
2903
2904 @item U
2905 Register offset addressing
2906
2907 @item W
2908 const_call_operand
2909
2910 @item Cs
2911 symbol_ref or const
2912
2913 @item Ci
2914 const_int
2915
2916 @item C0
2917 const_int 0
2918
2919 @item Cj
2920 Range of signed numbers that don't fit in 16 bits
2921
2922 @item Cmvq
2923 Integers valid for mvq
2924
2925 @item Capsw
2926 Integers valid for a moveq followed by a swap
2927
2928 @item Cmvz
2929 Integers valid for mvz
2930
2931 @item Cmvs
2932 Integers valid for mvs
2933
2934 @item Ap
2935 push_operand
2936
2937 @item Ac
2938 Non-register operands allowed in clr
2939
2940 @end table
2941
2942 @item Moxie---@file{config/moxie/constraints.md}
2943 @table @code
2944 @item A
2945 An absolute address
2946
2947 @item B
2948 An offset address
2949
2950 @item W
2951 A register indirect memory operand
2952
2953 @item I
2954 A constant in the range of 0 to 255.
2955
2956 @item N
2957 A constant in the range of 0 to @minus{}255.
2958
2959 @end table
2960
2961 @item PDP-11---@file{config/pdp11/constraints.md}
2962 @table @code
2963 @item a
2964 Floating point registers AC0 through AC3.  These can be loaded from/to
2965 memory with a single instruction.
2966
2967 @item d
2968 Odd numbered general registers (R1, R3, R5).  These are used for
2969 16-bit multiply operations.
2970
2971 @item f
2972 Any of the floating point registers (AC0 through AC5).
2973
2974 @item G
2975 Floating point constant 0.
2976
2977 @item I
2978 An integer constant that fits in 16 bits.
2979
2980 @item J
2981 An integer constant whose low order 16 bits are zero.
2982
2983 @item K
2984 An integer constant that does not meet the constraints for codes
2985 @samp{I} or @samp{J}.
2986
2987 @item L
2988 The integer constant 1.
2989
2990 @item M
2991 The integer constant @minus{}1.
2992
2993 @item N
2994 The integer constant 0.
2995
2996 @item O
2997 Integer constants @minus{}4 through @minus{}1 and 1 through 4; shifts by these
2998 amounts are handled as multiple single-bit shifts rather than a single
2999 variable-length shift.
3000
3001 @item Q
3002 A memory reference which requires an additional word (address or
3003 offset) after the opcode.
3004
3005 @item R
3006 A memory reference that is encoded within the opcode.
3007
3008 @end table
3009
3010 @item RL78---@file{config/rl78/constraints.md}
3011 @table @code
3012
3013 @item Int3
3014 An integer constant in the range 1 @dots{} 7.
3015 @item Int8
3016 An integer constant in the range 0 @dots{} 255.
3017 @item J
3018 An integer constant in the range @minus{}255 @dots{} 0
3019 @item K
3020 The integer constant 1.
3021 @item L
3022 The integer constant -1.
3023 @item M
3024 The integer constant 0.
3025 @item N
3026 The integer constant 2.
3027 @item O
3028 The integer constant -2.
3029 @item P
3030 An integer constant in the range 1 @dots{} 15.
3031 @item Qbi
3032 The built-in compare types--eq, ne, gtu, ltu, geu, and leu.
3033 @item Qsc
3034 The synthetic compare types--gt, lt, ge, and le.
3035 @item Wab
3036 A memory reference with an absolute address.
3037 @item Wbc
3038 A memory reference using @code{BC} as a base register, with an optional offset.
3039 @item Wca
3040 A memory reference using @code{AX}, @code{BC}, @code{DE}, or @code{HL} for the address, for calls.
3041 @item Wcv
3042 A memory reference using any 16-bit register pair for the address, for calls.
3043 @item Wd2
3044 A memory reference using @code{DE} as a base register, with an optional offset.
3045 @item Wde
3046 A memory reference using @code{DE} as a base register, without any offset.
3047 @item Wfr
3048 Any memory reference to an address in the far address space.
3049 @item Wh1
3050 A memory reference using @code{HL} as a base register, with an optional one-byte offset.
3051 @item Whb
3052 A memory reference using @code{HL} as a base register, with @code{B} or @code{C} as the index register.
3053 @item Whl
3054 A memory reference using @code{HL} as a base register, without any offset.
3055 @item Ws1
3056 A memory reference using @code{SP} as a base register, with an optional one-byte offset.
3057 @item Y
3058 Any memory reference to an address in the near address space.
3059 @item A
3060 The @code{AX} register.
3061 @item B
3062 The @code{BC} register.
3063 @item D
3064 The @code{DE} register.
3065 @item R
3066 @code{A} through @code{L} registers.
3067 @item S
3068 The @code{SP} register.
3069 @item T
3070 The @code{HL} register.
3071 @item Z08W
3072 The 16-bit @code{R8} register.
3073 @item Z10W
3074 The 16-bit @code{R10} register.
3075 @item Zint
3076 The registers reserved for interrupts (@code{R24} to @code{R31}).
3077 @item a
3078 The @code{A} register.
3079 @item b
3080 The @code{B} register.
3081 @item c
3082 The @code{C} register.
3083 @item d
3084 The @code{D} register.
3085 @item e
3086 The @code{E} register.
3087 @item h
3088 The @code{H} register.
3089 @item l
3090 The @code{L} register.
3091 @item v
3092 The virtual registers.
3093 @item w
3094 The @code{PSW} register.
3095 @item x
3096 The @code{X} register.
3097
3098 @end table
3099
3100 @item RX---@file{config/rx/constraints.md}
3101 @table @code
3102 @item Q
3103 An address which does not involve register indirect addressing or
3104 pre/post increment/decrement addressing.
3105
3106 @item Symbol
3107 A symbol reference.
3108
3109 @item Int08
3110 A constant in the range @minus{}256 to 255, inclusive.
3111
3112 @item Sint08
3113 A constant in the range @minus{}128 to 127, inclusive.
3114
3115 @item Sint16
3116 A constant in the range @minus{}32768 to 32767, inclusive.
3117
3118 @item Sint24
3119 A constant in the range @minus{}8388608 to 8388607, inclusive.
3120
3121 @item Uint04
3122 A constant in the range 0 to 15, inclusive.
3123
3124 @end table
3125
3126 @need 1000
3127 @item SPARC---@file{config/sparc/sparc.h}
3128 @table @code
3129 @item f
3130 Floating-point register on the SPARC-V8 architecture and
3131 lower floating-point register on the SPARC-V9 architecture.
3132
3133 @item e
3134 Floating-point register.  It is equivalent to @samp{f} on the
3135 SPARC-V8 architecture and contains both lower and upper
3136 floating-point registers on the SPARC-V9 architecture.
3137
3138 @item c
3139 Floating-point condition code register.
3140
3141 @item d
3142 Lower floating-point register.  It is only valid on the SPARC-V9
3143 architecture when the Visual Instruction Set is available.
3144
3145 @item b
3146 Floating-point register.  It is only valid on the SPARC-V9 architecture
3147 when the Visual Instruction Set is available.
3148
3149 @item h
3150 64-bit global or out register for the SPARC-V8+ architecture.
3151
3152 @item D
3153 A vector constant
3154
3155 @item I
3156 Signed 13-bit constant
3157
3158 @item J
3159 Zero
3160
3161 @item K
3162 32-bit constant with the low 12 bits clear (a constant that can be
3163 loaded with the @code{sethi} instruction)
3164
3165 @item L
3166 A constant in the range supported by @code{movcc} instructions
3167
3168 @item M
3169 A constant in the range supported by @code{movrcc} instructions
3170
3171 @item N
3172 Same as @samp{K}, except that it verifies that bits that are not in the
3173 lower 32-bit range are all zero.  Must be used instead of @samp{K} for
3174 modes wider than @code{SImode}
3175
3176 @item O
3177 The constant 4096
3178
3179 @item G
3180 Floating-point zero
3181
3182 @item H
3183 Signed 13-bit constant, sign-extended to 32 or 64 bits
3184
3185 @item Q
3186 Floating-point constant whose integral representation can
3187 be moved into an integer register using a single sethi
3188 instruction
3189
3190 @item R
3191 Floating-point constant whose integral representation can
3192 be moved into an integer register using a single mov
3193 instruction
3194
3195 @item S
3196 Floating-point constant whose integral representation can
3197 be moved into an integer register using a high/lo_sum
3198 instruction sequence
3199
3200 @item T
3201 Memory address aligned to an 8-byte boundary
3202
3203 @item U
3204 Even register
3205
3206 @item W
3207 Memory address for @samp{e} constraint registers
3208
3209 @item Y
3210 Vector zero
3211
3212 @end table
3213
3214 @item SPU---@file{config/spu/spu.h}
3215 @table @code
3216 @item a
3217 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is treated as a 64 bit value.
3218
3219 @item c
3220 An immediate for and/xor/or instructions.  const_int is treated as a 64 bit value.
3221
3222 @item d
3223 An immediate for the @code{iohl} instruction.  const_int is treated as a 64 bit value.
3224
3225 @item f
3226 An immediate which can be loaded with @code{fsmbi}.
3227
3228 @item A
3229 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is treated as a 32 bit value.
3230
3231 @item B
3232 An immediate for most arithmetic instructions.  const_int is treated as a 32 bit value.
3233
3234 @item C
3235 An immediate for and/xor/or instructions.  const_int is treated as a 32 bit value.
3236
3237 @item D
3238 An immediate for the @code{iohl} instruction.  const_int is treated as a 32 bit value.
3239
3240 @item I
3241 A constant in the range [@minus{}64, 63] for shift/rotate instructions.
3242
3243 @item J
3244 An unsigned 7-bit constant for conversion/nop/channel instructions.
3245
3246 @item K
3247 A signed 10-bit constant for most arithmetic instructions.
3248
3249 @item M
3250 A signed 16 bit immediate for @code{stop}.
3251
3252 @item N
3253 An unsigned 16-bit constant for @code{iohl} and @code{fsmbi}.
3254
3255 @item O
3256 An unsigned 7-bit constant whose 3 least significant bits are 0.
3257
3258 @item P
3259 An unsigned 3-bit constant for 16-byte rotates and shifts
3260
3261 @item R
3262 Call operand, reg, for indirect calls
3263
3264 @item S
3265 Call operand, symbol, for relative calls.
3266
3267 @item T
3268 Call operand, const_int, for absolute calls.
3269
3270 @item U
3271 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is sign extended to 128 bit.
3272
3273 @item W
3274 An immediate for shift and rotate instructions.  const_int is treated as a 32 bit value.
3275
3276 @item Y
3277 An immediate for and/xor/or instructions.  const_int is sign extended as a 128 bit.
3278
3279 @item Z
3280 An immediate for the @code{iohl} instruction.  const_int is sign extended to 128 bit.
3281
3282 @end table
3283
3284 @item S/390 and zSeries---@file{config/s390/s390.h}
3285 @table @code
3286 @item a
3287 Address register (general purpose register except r0)
3288
3289 @item c
3290 Condition code register
3291
3292 @item d
3293 Data register (arbitrary general purpose register)
3294
3295 @item f
3296 Floating-point register
3297
3298 @item I
3299 Unsigned 8-bit constant (0--255)
3300
3301 @item J
3302 Unsigned 12-bit constant (0--4095)
3303
3304 @item K
3305 Signed 16-bit constant (@minus{}32768--32767)
3306
3307 @item L
3308 Value appropriate as displacement.
3309 @table @code
3310 @item (0..4095)
3311 for short displacement
3312 @item (@minus{}524288..524287)
3313 for long displacement
3314 @end table
3315
3316 @item M
3317 Constant integer with a value of 0x7fffffff.
3318
3319 @item N
3320 Multiple letter constraint followed by 4 parameter letters.
3321 @table @code
3322 @item 0..9:
3323 number of the part counting from most to least significant
3324 @item H,Q:
3325 mode of the part
3326 @item D,S,H:
3327 mode of the containing operand
3328 @item 0,F:
3329 value of the other parts (F---all bits set)
3330 @end table
3331 The constraint matches if the specified part of a constant
3332 has a value different from its other parts.
3333
3334 @item Q
3335 Memory reference without index register and with short displacement.
3336
3337 @item R
3338 Memory reference with index register and short displacement.
3339
3340 @item S
3341 Memory reference without index register but with long displacement.
3342
3343 @item T
3344 Memory reference with index register and long displacement.
3345
3346 @item U
3347 Pointer with short displacement.
3348
3349 @item W
3350 Pointer with long displacement.
3351
3352 @item Y
3353 Shift count operand.
3354
3355 @end table
3356
3357 @item Score family---@file{config/score/score.h}
3358 @table @code
3359 @item d
3360 Registers from r0 to r32.
3361
3362 @item e
3363 Registers from r0 to r16.
3364
3365 @item t
3366 r8---r11 or r22---r27 registers.
3367
3368 @item h
3369 hi register.
3370
3371 @item l
3372 lo register.
3373
3374 @item x
3375 hi + lo register.
3376
3377 @item q
3378 cnt register.
3379
3380 @item y
3381 lcb register.
3382
3383 @item z
3384 scb register.
3385
3386 @item a
3387 cnt + lcb + scb register.
3388
3389 @item c
3390 cr0---cr15 register.
3391
3392 @item b
3393 cp1 registers.
3394
3395 @item f
3396 cp2 registers.
3397
3398 @item i
3399 cp3 registers.
3400
3401 @item j
3402 cp1 + cp2 + cp3 registers.
3403
3404 @item I
3405 High 16-bit constant (32-bit constant with 16 LSBs zero).
3406
3407 @item J
3408 Unsigned 5 bit integer (in the range 0 to 31).
3409
3410 @item K
3411 Unsigned 16 bit integer (in the range 0 to 65535).
3412
3413 @item L
3414 Signed 16 bit integer (in the range @minus{}32768 to 32767).
3415
3416 @item M
3417 Unsigned 14 bit integer (in the range 0 to 16383).
3418
3419 @item N
3420 Signed 14 bit integer (in the range @minus{}8192 to 8191).
3421
3422 @item Z
3423 Any SYMBOL_REF.
3424 @end table
3425
3426 @item Xstormy16---@file{config/stormy16/stormy16.h}
3427 @table @code
3428 @item a
3429 Register r0.
3430
3431 @item b
3432 Register r1.
3433
3434 @item c
3435 Register r2.
3436
3437 @item d
3438 Register r8.
3439
3440 @item e
3441 Registers r0 through r7.
3442
3443 @item t
3444 Registers r0 and r1.
3445
3446 @item y
3447 The carry register.
3448
3449 @item z
3450 Registers r8 and r9.
3451
3452 @item I
3453 A constant between 0 and 3 inclusive.
3454
3455 @item J
3456 A constant that has exactly one bit set.
3457
3458 @item K
3459 A constant that has exactly one bit clear.
3460
3461 @item L
3462 A constant between 0 and 255 inclusive.
3463
3464 @item M
3465 A constant between @minus{}255 and 0 inclusive.
3466
3467 @item N
3468 A constant between @minus{}3 and 0 inclusive.
3469
3470 @item O
3471 A constant between 1 and 4 inclusive.
3472
3473 @item P
3474 A constant between @minus{}4 and @minus{}1 inclusive.
3475
3476 @item Q
3477 A memory reference that is a stack push.
3478
3479 @item R
3480 A memory reference that is a stack pop.
3481
3482 @item S
3483 A memory reference that refers to a constant address of known value.
3484
3485 @item T
3486 The register indicated by Rx (not implemented yet).
3487
3488 @item U
3489 A constant that is not between 2 and 15 inclusive.
3490
3491 @item Z
3492 The constant 0.
3493
3494 @end table
3495
3496 @item TI C6X family---@file{config/c6x/constraints.md}
3497 @table @code
3498 @item a
3499 Register file A (A0--A31).
3500
3501 @item b
3502 Register file B (B0--B31).
3503
3504 @item A
3505 Predicate registers in register file A (A0--A2 on C64X and
3506 higher, A1 and A2 otherwise).
3507
3508 @item B
3509 Predicate registers in register file B (B0--B2).
3510
3511 @item C
3512 A call-used register in register file B (B0--B9, B16--B31).
3513
3514 @item Da
3515 Register file A, excluding predicate registers (A3--A31,
3516 plus A0 if not C64X or higher).
3517
3518 @item Db
3519 Register file B, excluding predicate registers (B3--B31).
3520
3521 @item Iu4
3522 Integer constant in the range 0 @dots{} 15.
3523
3524 @item Iu5
3525 Integer constant in the range 0 @dots{} 31.
3526
3527 @item In5
3528 Integer constant in the range @minus{}31 @dots{} 0.
3529
3530 @item Is5
3531 Integer constant in the range @minus{}16 @dots{} 15.
3532
3533 @item I5x
3534 Integer constant that can be the operand of an ADDA or a SUBA insn.
3535
3536 @item IuB
3537 Integer constant in the range 0 @dots{} 65535.
3538
3539 @item IsB
3540 Integer constant in the range @minus{}32768 @dots{} 32767.
3541
3542 @item IsC
3543 Integer constant in the range @math{-2^{20}} @dots{} @math{2^{20} - 1}.
3544
3545 @item Jc
3546 Integer constant that is a valid mask for the clr instruction.
3547
3548 @item Js
3549 Integer constant that is a valid mask for the set instruction.
3550
3551 @item Q
3552 Memory location with A base register.
3553
3554 @item R
3555 Memory location with B base register.
3556
3557 @ifset INTERNALS
3558 @item S0
3559 On C64x+ targets, a GP-relative small data reference.
3560
3561 @item S1
3562 Any kind of @code{SYMBOL_REF}, for use in a call address.
3563
3564 @item Si
3565 Any kind of immediate operand, unless it matches the S0 constraint.
3566
3567 @item T
3568 Memory location with B base register, but not using a long offset.
3569
3570 @item W
3571 A memory operand with an address that can't be used in an unaligned access.
3572
3573 @end ifset
3574 @item Z
3575 Register B14 (aka DP).
3576
3577 @end table
3578
3579 @item TILE-Gx---@file{config/tilegx/constraints.md}
3580 @table @code
3581 @item R00
3582 @itemx R01
3583 @itemx R02
3584 @itemx R03
3585 @itemx R04
3586 @itemx R05
3587 @itemx R06
3588 @itemx R07
3589 @itemx R08
3590 @itemx R09
3591 @itemx R10
3592 Each of these represents a register constraint for an individual
3593 register, from r0 to r10.
3594
3595 @item I
3596 Signed 8-bit integer constant.
3597
3598 @item J
3599 Signed 16-bit integer constant.
3600
3601 @item K
3602 Unsigned 16-bit integer constant.
3603
3604 @item L
3605 Integer constant that fits in one signed byte when incremented by one
3606 (@minus{}129 @dots{} 126).
3607
3608 @item m
3609 Memory operand.  If used together with @samp{<} or @samp{>}, the
3610 operand can have postincrement which requires printing with @samp{%In}
3611 and @samp{%in} on TILE-Gx.  For example:
3612
3613 @smallexample
3614 asm ("st_add %I0,%1,%i0" : "=m<>" (*mem) : "r" (val));
3615 @end smallexample
3616
3617 @item M
3618 A bit mask suitable for the BFINS instruction.
3619
3620 @item N
3621 Integer constant that is a byte tiled out eight times.
3622
3623 @item O
3624 The integer zero constant.
3625
3626 @item P
3627 Integer constant that is a sign-extended byte tiled out as four shorts.
3628
3629 @item Q
3630 Integer constant that fits in one signed byte when incremented
3631 (@minus{}129 @dots{} 126), but excluding -1.
3632
3633 @item S
3634 Integer constant that has all 1 bits consecutive and starting at bit 0.
3635
3636 @item T
3637 A 16-bit fragment of a got, tls, or pc-relative reference.
3638
3639 @item U
3640 Memory operand except postincrement.  This is roughly the same as
3641 @samp{m} when not used together with @samp{<} or @samp{>}.
3642
3643 @item W
3644 An 8-element vector constant with identical elements.
3645
3646 @item Y
3647 A 4-element vector constant with identical elements.
3648
3649 @item Z0
3650 The integer constant 0xffffffff.
3651
3652 @item Z1
3653 The integer constant 0xffffffff00000000.
3654
3655 @end table
3656
3657 @item TILEPro---@file{config/tilepro/constraints.md}
3658 @table @code
3659 @item R00
3660 @itemx R01
3661 @itemx R02
3662 @itemx R03
3663 @itemx R04
3664 @itemx R05
3665 @itemx R06
3666 @itemx R07
3667 @itemx R08
3668 @itemx R09
3669 @itemx R10
3670 Each of these represents a register constraint for an individual
3671 register, from r0 to r10.
3672
3673 @item I
3674 Signed 8-bit integer constant.
3675
3676 @item J
3677 Signed 16-bit integer constant.
3678
3679 @item K
3680 Nonzero integer constant with low 16 bits zero.
3681
3682 @item L
3683 Integer constant that fits in one signed byte when incremented by one
3684 (@minus{}129 @dots{} 126).
3685
3686 @item m
3687 Memory operand.  If used together with @samp{<} or @samp{>}, the
3688 operand can have postincrement which requires printing with @samp{%In}
3689 and @samp{%in} on TILEPro.  For example:
3690
3691 @smallexample
3692 asm ("swadd %I0,%1,%i0" : "=m<>" (mem) : "r" (val));
3693 @end smallexample
3694
3695 @item M
3696 A bit mask suitable for the MM instruction.
3697
3698 @item N
3699 Integer constant that is a byte tiled out four times.
3700
3701 @item O
3702 The integer zero constant.
3703
3704 @item P
3705 Integer constant that is a sign-extended byte tiled out as two shorts.
3706
3707 @item Q
3708 Integer constant that fits in one signed byte when incremented
3709 (@minus{}129 @dots{} 126), but excluding -1.
3710
3711 @item T
3712 A symbolic operand, or a 16-bit fragment of a got, tls, or pc-relative
3713 reference.
3714
3715 @item U
3716 Memory operand except postincrement.  This is roughly the same as
3717 @samp{m} when not used together with @samp{<} or @samp{>}.
3718
3719 @item W
3720 A 4-element vector constant with identical elements.
3721
3722 @item Y
3723 A 2-element vector constant with identical elements.
3724
3725 @end table
3726
3727 @item Xtensa---@file{config/xtensa/constraints.md}
3728 @table @code
3729 @item a
3730 General-purpose 32-bit register
3731
3732 @item b
3733 One-bit boolean register
3734
3735 @item A
3736 MAC16 40-bit accumulator register
3737
3738 @item I
3739 Signed 12-bit integer constant, for use in MOVI instructions
3740
3741 @item J
3742 Signed 8-bit integer constant, for use in ADDI instructions
3743
3744 @item K
3745 Integer constant valid for BccI instructions
3746
3747 @item L
3748 Unsigned constant valid for BccUI instructions
3749
3750 @end table
3751
3752 @end table
3753
3754 @ifset INTERNALS
3755 @node Disable Insn Alternatives
3756 @subsection Disable insn alternatives using the @code{enabled} attribute
3757 @cindex enabled
3758
3759 The @code{enabled} insn attribute may be used to disable certain insn
3760 alternatives for machine-specific reasons.  This is useful when adding
3761 new instructions to an existing pattern which are only available for
3762 certain cpu architecture levels as specified with the @code{-march=}
3763 option.
3764
3765 If an insn alternative is disabled, then it will never be used.  The
3766 compiler treats the constraints for the disabled alternative as
3767 unsatisfiable.
3768
3769 In order to make use of the @code{enabled} attribute a back end has to add
3770 in the machine description files:
3771
3772 @enumerate
3773 @item
3774 A definition of the @code{enabled} insn attribute.  The attribute is
3775 defined as usual using the @code{define_attr} command.  This
3776 definition should be based on other insn attributes and/or target flags.
3777 The @code{enabled} attribute is a numeric attribute and should evaluate to
3778 @code{(const_int 1)} for an enabled alternative and to
3779 @code{(const_int 0)} otherwise.
3780 @item
3781 A definition of another insn attribute used to describe for what
3782 reason an insn alternative might be available or
3783 not.  E.g. @code{cpu_facility} as in the example below.
3784 @item
3785 An assignment for the second attribute to each insn definition
3786 combining instructions which are not all available under the same
3787 circumstances.  (Note: It obviously only makes sense for definitions
3788 with more than one alternative.  Otherwise the insn pattern should be
3789 disabled or enabled using the insn condition.)
3790 @end enumerate
3791
3792 E.g. the following two patterns could easily be merged using the @code{enabled}
3793 attribute:
3794
3795 @smallexample
3796
3797 (define_insn "*movdi_old"
3798   [(set (match_operand:DI 0 "register_operand" "=d")
3799         (match_operand:DI 1 "register_operand" " d"))]
3800   "!TARGET_NEW"
3801   "lgr %0,%1")
3802
3803 (define_insn "*movdi_new"
3804   [(set (match_operand:DI 0 "register_operand" "=d,f,d")
3805         (match_operand:DI 1 "register_operand" " d,d,f"))]
3806   "TARGET_NEW"
3807   "@@
3808    lgr  %0,%1
3809    ldgr %0,%1
3810    lgdr %0,%1")
3811
3812 @end smallexample
3813
3814 to:
3815
3816 @smallexample
3817
3818 (define_insn "*movdi_combined"
3819   [(set (match_operand:DI 0 "register_operand" "=d,f,d")
3820         (match_operand:DI 1 "register_operand" " d,d,f"))]
3821   ""
3822   "@@
3823    lgr  %0,%1
3824    ldgr %0,%1
3825    lgdr %0,%1"
3826   [(set_attr "cpu_facility" "*,new,new")])
3827
3828 @end smallexample
3829
3830 with the @code{enabled} attribute defined like this:
3831
3832 @smallexample
3833
3834 (define_attr "cpu_facility" "standard,new" (const_string "standard"))
3835
3836 (define_attr "enabled" ""
3837   (cond [(eq_attr "cpu_facility" "standard") (const_int 1)
3838          (and (eq_attr "cpu_facility" "new")
3839               (ne (symbol_ref "TARGET_NEW") (const_int 0)))
3840          (const_int 1)]
3841         (const_int 0)))
3842
3843 @end smallexample
3844
3845 @end ifset
3846
3847 @ifset INTERNALS
3848 @node Define Constraints
3849 @subsection Defining Machine-Specific Constraints
3850 @cindex defining constraints
3851 @cindex constraints, defining
3852
3853 Machine-specific constraints fall into two categories: register and
3854 non-register constraints.  Within the latter category, constraints
3855 which allow subsets of all possible memory or address operands should
3856 be specially marked, to give @code{reload} more information.
3857
3858 Machine-specific constraints can be given names of arbitrary length,
3859 but they must be entirely composed of letters, digits, underscores
3860 (@samp{_}), and angle brackets (@samp{< >}).  Like C identifiers, they
3861 must begin with a letter or underscore.
3862
3863 In order to avoid ambiguity in operand constraint strings, no
3864 constraint can have a name that begins with any other constraint's
3865 name.  For example, if @code{x} is defined as a constraint name,
3866 @code{xy} may not be, and vice versa.  As a consequence of this rule,
3867 no constraint may begin with one of the generic constraint letters:
3868 @samp{E F V X g i m n o p r s}.
3869
3870 Register constraints correspond directly to register classes.
3871 @xref{Register Classes}.  There is thus not much flexibility in their
3872 definitions.
3873
3874 @deffn {MD Expression} define_register_constraint name regclass docstring