OSDN Git Service

* MAINTAINERS: Add myself as a maintainer for the RX port.
[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
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
1056 @ifset INTERNALS
1057 @menu
1058 * Simple Constraints::  Basic use of constraints.
1059 * Multi-Alternative::   When an insn has two alternative constraint-patterns.
1060 * Class Preferences::   Constraints guide which hard register to put things in.
1061 * Modifiers::           More precise control over effects of constraints.
1062 * Disable Insn Alternatives:: Disable insn alternatives using the @code{enabled} attribute.
1063 * Machine Constraints:: Existing constraints for some particular machines.
1064 * Define Constraints::  How to define machine-specific constraints.
1065 * C Constraint Interface:: How to test constraints from C code.
1066 @end menu
1067 @end ifset
1068
1069 @ifclear INTERNALS
1070 @menu
1071 * Simple Constraints::  Basic use of constraints.
1072 * Multi-Alternative::   When an insn has two alternative constraint-patterns.
1073 * Modifiers::           More precise control over effects of constraints.
1074 * Machine Constraints:: Special constraints for some particular machines.
1075 @end menu
1076 @end ifclear
1077
1078 @node Simple Constraints
1079 @subsection Simple Constraints
1080 @cindex simple constraints
1081
1082 The simplest kind of constraint is a string full of letters, each of
1083 which describes one kind of operand that is permitted.  Here are
1084 the letters that are allowed:
1085
1086 @table @asis
1087 @item whitespace
1088 Whitespace characters are ignored and can be inserted at any position
1089 except the first.  This enables each alternative for different operands to
1090 be visually aligned in the machine description even if they have different
1091 number of constraints and modifiers.
1092
1093 @cindex @samp{m} in constraint
1094 @cindex memory references in constraints
1095 @item @samp{m}
1096 A memory operand is allowed, with any kind of address that the machine
1097 supports in general.
1098 Note that the letter used for the general memory constraint can be
1099 re-defined by a back end using the @code{TARGET_MEM_CONSTRAINT} macro.
1100
1101 @cindex offsettable address
1102 @cindex @samp{o} in constraint
1103 @item @samp{o}
1104 A memory operand is allowed, but only if the address is
1105 @dfn{offsettable}.  This means that adding a small integer (actually,
1106 the width in bytes of the operand, as determined by its machine mode)
1107 may be added to the address and the result is also a valid memory
1108 address.
1109
1110 @cindex autoincrement/decrement addressing
1111 For example, an address which is constant is offsettable; so is an
1112 address that is the sum of a register and a constant (as long as a
1113 slightly larger constant is also within the range of address-offsets
1114 supported by the machine); but an autoincrement or autodecrement
1115 address is not offsettable.  More complicated indirect/indexed
1116 addresses may or may not be offsettable depending on the other
1117 addressing modes that the machine supports.
1118
1119 Note that in an output operand which can be matched by another
1120 operand, the constraint letter @samp{o} is valid only when accompanied
1121 by both @samp{<} (if the target machine has predecrement addressing)
1122 and @samp{>} (if the target machine has preincrement addressing).
1123
1124 @cindex @samp{V} in constraint
1125 @item @samp{V}
1126 A memory operand that is not offsettable.  In other words, anything that
1127 would fit the @samp{m} constraint but not the @samp{o} constraint.
1128
1129 @cindex @samp{<} in constraint
1130 @item @samp{<}
1131 A memory operand with autodecrement addressing (either predecrement or
1132 postdecrement) is allowed.
1133
1134 @cindex @samp{>} in constraint
1135 @item @samp{>}
1136 A memory operand with autoincrement addressing (either preincrement or
1137 postincrement) is allowed.
1138
1139 @cindex @samp{r} in constraint
1140 @cindex registers in constraints
1141 @item @samp{r}
1142 A register operand is allowed provided that it is in a general
1143 register.
1144
1145 @cindex constants in constraints
1146 @cindex @samp{i} in constraint
1147 @item @samp{i}
1148 An immediate integer operand (one with constant value) is allowed.
1149 This includes symbolic constants whose values will be known only at
1150 assembly time or later.
1151
1152 @cindex @samp{n} in constraint
1153 @item @samp{n}
1154 An immediate integer operand with a known numeric value is allowed.
1155 Many systems cannot support assembly-time constants for operands less
1156 than a word wide.  Constraints for these operands should use @samp{n}
1157 rather than @samp{i}.
1158
1159 @cindex @samp{I} in constraint
1160 @item @samp{I}, @samp{J}, @samp{K}, @dots{} @samp{P}
1161 Other letters in the range @samp{I} through @samp{P} may be defined in
1162 a machine-dependent fashion to permit immediate integer operands with
1163 explicit integer values in specified ranges.  For example, on the
1164 68000, @samp{I} is defined to stand for the range of values 1 to 8.
1165 This is the range permitted as a shift count in the shift
1166 instructions.
1167
1168 @cindex @samp{E} in constraint
1169 @item @samp{E}
1170 An immediate floating operand (expression code @code{const_double}) is
1171 allowed, but only if the target floating point format is the same as
1172 that of the host machine (on which the compiler is running).
1173
1174 @cindex @samp{F} in constraint
1175 @item @samp{F}
1176 An immediate floating operand (expression code @code{const_double} or
1177 @code{const_vector}) is allowed.
1178
1179 @cindex @samp{G} in constraint
1180 @cindex @samp{H} in constraint
1181 @item @samp{G}, @samp{H}
1182 @samp{G} and @samp{H} may be defined in a machine-dependent fashion to
1183 permit immediate floating operands in particular ranges of values.
1184
1185 @cindex @samp{s} in constraint
1186 @item @samp{s}
1187 An immediate integer operand whose value is not an explicit integer is
1188 allowed.
1189
1190 This might appear strange; if an insn allows a constant operand with a
1191 value not known at compile time, it certainly must allow any known
1192 value.  So why use @samp{s} instead of @samp{i}?  Sometimes it allows
1193 better code to be generated.
1194
1195 For example, on the 68000 in a fullword instruction it is possible to
1196 use an immediate operand; but if the immediate value is between @minus{}128
1197 and 127, better code results from loading the value into a register and
1198 using the register.  This is because the load into the register can be
1199 done with a @samp{moveq} instruction.  We arrange for this to happen
1200 by defining the letter @samp{K} to mean ``any integer outside the
1201 range @minus{}128 to 127'', and then specifying @samp{Ks} in the operand
1202 constraints.
1203
1204 @cindex @samp{g} in constraint
1205 @item @samp{g}
1206 Any register, memory or immediate integer operand is allowed, except for
1207 registers that are not general registers.
1208
1209 @cindex @samp{X} in constraint
1210 @item @samp{X}
1211 @ifset INTERNALS
1212 Any operand whatsoever is allowed, even if it does not satisfy
1213 @code{general_operand}.  This is normally used in the constraint of
1214 a @code{match_scratch} when certain alternatives will not actually
1215 require a scratch register.
1216 @end ifset
1217 @ifclear INTERNALS
1218 Any operand whatsoever is allowed.
1219 @end ifclear
1220
1221 @cindex @samp{0} in constraint
1222 @cindex digits in constraint
1223 @item @samp{0}, @samp{1}, @samp{2}, @dots{} @samp{9}
1224 An operand that matches the specified operand number is allowed.  If a
1225 digit is used together with letters within the same alternative, the
1226 digit should come last.
1227
1228 This number is allowed to be more than a single digit.  If multiple
1229 digits are encountered consecutively, they are interpreted as a single
1230 decimal integer.  There is scant chance for ambiguity, since to-date
1231 it has never been desirable that @samp{10} be interpreted as matching
1232 either operand 1 @emph{or} operand 0.  Should this be desired, one
1233 can use multiple alternatives instead.
1234
1235 @cindex matching constraint
1236 @cindex constraint, matching
1237 This is called a @dfn{matching constraint} and what it really means is
1238 that the assembler has only a single operand that fills two roles
1239 @ifset INTERNALS
1240 considered separate in the RTL insn.  For example, an add insn has two
1241 input operands and one output operand in the RTL, but on most CISC
1242 @end ifset
1243 @ifclear INTERNALS
1244 which @code{asm} distinguishes.  For example, an add instruction uses
1245 two input operands and an output operand, but on most CISC
1246 @end ifclear
1247 machines an add instruction really has only two operands, one of them an
1248 input-output operand:
1249
1250 @smallexample
1251 addl #35,r12
1252 @end smallexample
1253
1254 Matching constraints are used in these circumstances.
1255 More precisely, the two operands that match must include one input-only
1256 operand and one output-only operand.  Moreover, the digit must be a
1257 smaller number than the number of the operand that uses it in the
1258 constraint.
1259
1260 @ifset INTERNALS
1261 For operands to match in a particular case usually means that they
1262 are identical-looking RTL expressions.  But in a few special cases
1263 specific kinds of dissimilarity are allowed.  For example, @code{*x}
1264 as an input operand will match @code{*x++} as an output operand.
1265 For proper results in such cases, the output template should always
1266 use the output-operand's number when printing the operand.
1267 @end ifset
1268
1269 @cindex load address instruction
1270 @cindex push address instruction
1271 @cindex address constraints
1272 @cindex @samp{p} in constraint
1273 @item @samp{p}
1274 An operand that is a valid memory address is allowed.  This is
1275 for ``load address'' and ``push address'' instructions.
1276
1277 @findex address_operand
1278 @samp{p} in the constraint must be accompanied by @code{address_operand}
1279 as the predicate in the @code{match_operand}.  This predicate interprets
1280 the mode specified in the @code{match_operand} as the mode of the memory
1281 reference for which the address would be valid.
1282
1283 @cindex other register constraints
1284 @cindex extensible constraints
1285 @item @var{other-letters}
1286 Other letters can be defined in machine-dependent fashion to stand for
1287 particular classes of registers or other arbitrary operand types.
1288 @samp{d}, @samp{a} and @samp{f} are defined on the 68000/68020 to stand
1289 for data, address and floating point registers.
1290 @end table
1291
1292 @ifset INTERNALS
1293 In order to have valid assembler code, each operand must satisfy
1294 its constraint.  But a failure to do so does not prevent the pattern
1295 from applying to an insn.  Instead, it directs the compiler to modify
1296 the code so that the constraint will be satisfied.  Usually this is
1297 done by copying an operand into a register.
1298
1299 Contrast, therefore, the two instruction patterns that follow:
1300
1301 @smallexample
1302 (define_insn ""
1303   [(set (match_operand:SI 0 "general_operand" "=r")
1304         (plus:SI (match_dup 0)
1305                  (match_operand:SI 1 "general_operand" "r")))]
1306   ""
1307   "@dots{}")
1308 @end smallexample
1309
1310 @noindent
1311 which has two operands, one of which must appear in two places, and
1312
1313 @smallexample
1314 (define_insn ""
1315   [(set (match_operand:SI 0 "general_operand" "=r")
1316         (plus:SI (match_operand:SI 1 "general_operand" "0")
1317                  (match_operand:SI 2 "general_operand" "r")))]
1318   ""
1319   "@dots{}")
1320 @end smallexample
1321
1322 @noindent
1323 which has three operands, two of which are required by a constraint to be
1324 identical.  If we are considering an insn of the form
1325
1326 @smallexample
1327 (insn @var{n} @var{prev} @var{next}
1328   (set (reg:SI 3)
1329        (plus:SI (reg:SI 6) (reg:SI 109)))
1330   @dots{})
1331 @end smallexample
1332
1333 @noindent
1334 the first pattern would not apply at all, because this insn does not
1335 contain two identical subexpressions in the right place.  The pattern would
1336 say, ``That does not look like an add instruction; try other patterns''.
1337 The second pattern would say, ``Yes, that's an add instruction, but there
1338 is something wrong with it''.  It would direct the reload pass of the
1339 compiler to generate additional insns to make the constraint true.  The
1340 results might look like this:
1341
1342 @smallexample
1343 (insn @var{n2} @var{prev} @var{n}
1344   (set (reg:SI 3) (reg:SI 6))
1345   @dots{})
1346
1347 (insn @var{n} @var{n2} @var{next}
1348   (set (reg:SI 3)
1349        (plus:SI (reg:SI 3) (reg:SI 109)))
1350   @dots{})
1351 @end smallexample
1352
1353 It is up to you to make sure that each operand, in each pattern, has
1354 constraints that can handle any RTL expression that could be present for
1355 that operand.  (When multiple alternatives are in use, each pattern must,
1356 for each possible combination of operand expressions, have at least one
1357 alternative which can handle that combination of operands.)  The
1358 constraints don't need to @emph{allow} any possible operand---when this is
1359 the case, they do not constrain---but they must at least point the way to
1360 reloading any possible operand so that it will fit.
1361
1362 @itemize @bullet
1363 @item
1364 If the constraint accepts whatever operands the predicate permits,
1365 there is no problem: reloading is never necessary for this operand.
1366
1367 For example, an operand whose constraints permit everything except
1368 registers is safe provided its predicate rejects registers.
1369
1370 An operand whose predicate accepts only constant values is safe
1371 provided its constraints include the letter @samp{i}.  If any possible
1372 constant value is accepted, then nothing less than @samp{i} will do;
1373 if the predicate is more selective, then the constraints may also be
1374 more selective.
1375
1376 @item
1377 Any operand expression can be reloaded by copying it into a register.
1378 So if an operand's constraints allow some kind of register, it is
1379 certain to be safe.  It need not permit all classes of registers; the
1380 compiler knows how to copy a register into another register of the
1381 proper class in order to make an instruction valid.
1382
1383 @cindex nonoffsettable memory reference
1384 @cindex memory reference, nonoffsettable
1385 @item
1386 A nonoffsettable memory reference can be reloaded by copying the
1387 address into a register.  So if the constraint uses the letter
1388 @samp{o}, all memory references are taken care of.
1389
1390 @item
1391 A constant operand can be reloaded by allocating space in memory to
1392 hold it as preinitialized data.  Then the memory reference can be used
1393 in place of the constant.  So if the constraint uses the letters
1394 @samp{o} or @samp{m}, constant operands are not a problem.
1395
1396 @item
1397 If the constraint permits a constant and a pseudo register used in an insn
1398 was not allocated to a hard register and is equivalent to a constant,
1399 the register will be replaced with the constant.  If the predicate does
1400 not permit a constant and the insn is re-recognized for some reason, the
1401 compiler will crash.  Thus the predicate must always recognize any
1402 objects allowed by the constraint.
1403 @end itemize
1404
1405 If the operand's predicate can recognize registers, but the constraint does
1406 not permit them, it can make the compiler crash.  When this operand happens
1407 to be a register, the reload pass will be stymied, because it does not know
1408 how to copy a register temporarily into memory.
1409
1410 If the predicate accepts a unary operator, the constraint applies to the
1411 operand.  For example, the MIPS processor at ISA level 3 supports an
1412 instruction which adds two registers in @code{SImode} to produce a
1413 @code{DImode} result, but only if the registers are correctly sign
1414 extended.  This predicate for the input operands accepts a
1415 @code{sign_extend} of an @code{SImode} register.  Write the constraint
1416 to indicate the type of register that is required for the operand of the
1417 @code{sign_extend}.
1418 @end ifset
1419
1420 @node Multi-Alternative
1421 @subsection Multiple Alternative Constraints
1422 @cindex multiple alternative constraints
1423
1424 Sometimes a single instruction has multiple alternative sets of possible
1425 operands.  For example, on the 68000, a logical-or instruction can combine
1426 register or an immediate value into memory, or it can combine any kind of
1427 operand into a register; but it cannot combine one memory location into
1428 another.
1429
1430 These constraints are represented as multiple alternatives.  An alternative
1431 can be described by a series of letters for each operand.  The overall
1432 constraint for an operand is made from the letters for this operand
1433 from the first alternative, a comma, the letters for this operand from
1434 the second alternative, a comma, and so on until the last alternative.
1435 @ifset INTERNALS
1436 Here is how it is done for fullword logical-or on the 68000:
1437
1438 @smallexample
1439 (define_insn "iorsi3"
1440   [(set (match_operand:SI 0 "general_operand" "=m,d")
1441         (ior:SI (match_operand:SI 1 "general_operand" "%0,0")
1442                 (match_operand:SI 2 "general_operand" "dKs,dmKs")))]
1443   @dots{})
1444 @end smallexample
1445
1446 The first alternative has @samp{m} (memory) for operand 0, @samp{0} for
1447 operand 1 (meaning it must match operand 0), and @samp{dKs} for operand
1448 2.  The second alternative has @samp{d} (data register) for operand 0,
1449 @samp{0} for operand 1, and @samp{dmKs} for operand 2.  The @samp{=} and
1450 @samp{%} in the constraints apply to all the alternatives; their
1451 meaning is explained in the next section (@pxref{Class Preferences}).
1452 @end ifset
1453
1454 @c FIXME Is this ? and ! stuff of use in asm()?  If not, hide unless INTERNAL
1455 If all the operands fit any one alternative, the instruction is valid.
1456 Otherwise, for each alternative, the compiler counts how many instructions
1457 must be added to copy the operands so that that alternative applies.
1458 The alternative requiring the least copying is chosen.  If two alternatives
1459 need the same amount of copying, the one that comes first is chosen.
1460 These choices can be altered with the @samp{?} and @samp{!} characters:
1461
1462 @table @code
1463 @cindex @samp{?} in constraint
1464 @cindex question mark
1465 @item ?
1466 Disparage slightly the alternative that the @samp{?} appears in,
1467 as a choice when no alternative applies exactly.  The compiler regards
1468 this alternative as one unit more costly for each @samp{?} that appears
1469 in it.
1470
1471 @cindex @samp{!} in constraint
1472 @cindex exclamation point
1473 @item !
1474 Disparage severely the alternative that the @samp{!} appears in.
1475 This alternative can still be used if it fits without reloading,
1476 but if reloading is needed, some other alternative will be used.
1477 @end table
1478
1479 @ifset INTERNALS
1480 When an insn pattern has multiple alternatives in its constraints, often
1481 the appearance of the assembler code is determined mostly by which
1482 alternative was matched.  When this is so, the C code for writing the
1483 assembler code can use the variable @code{which_alternative}, which is
1484 the ordinal number of the alternative that was actually satisfied (0 for
1485 the first, 1 for the second alternative, etc.).  @xref{Output Statement}.
1486 @end ifset
1487
1488 @ifset INTERNALS
1489 @node Class Preferences
1490 @subsection Register Class Preferences
1491 @cindex class preference constraints
1492 @cindex register class preference constraints
1493
1494 @cindex voting between constraint alternatives
1495 The operand constraints have another function: they enable the compiler
1496 to decide which kind of hardware register a pseudo register is best
1497 allocated to.  The compiler examines the constraints that apply to the
1498 insns that use the pseudo register, looking for the machine-dependent
1499 letters such as @samp{d} and @samp{a} that specify classes of registers.
1500 The pseudo register is put in whichever class gets the most ``votes''.
1501 The constraint letters @samp{g} and @samp{r} also vote: they vote in
1502 favor of a general register.  The machine description says which registers
1503 are considered general.
1504
1505 Of course, on some machines all registers are equivalent, and no register
1506 classes are defined.  Then none of this complexity is relevant.
1507 @end ifset
1508
1509 @node Modifiers
1510 @subsection Constraint Modifier Characters
1511 @cindex modifiers in constraints
1512 @cindex constraint modifier characters
1513
1514 @c prevent bad page break with this line
1515 Here are constraint modifier characters.
1516
1517 @table @samp
1518 @cindex @samp{=} in constraint
1519 @item =
1520 Means that this operand is write-only for this instruction: the previous
1521 value is discarded and replaced by output data.
1522
1523 @cindex @samp{+} in constraint
1524 @item +
1525 Means that this operand is both read and written by the instruction.
1526
1527 When the compiler fixes up the operands to satisfy the constraints,
1528 it needs to know which operands are inputs to the instruction and
1529 which are outputs from it.  @samp{=} identifies an output; @samp{+}
1530 identifies an operand that is both input and output; all other operands
1531 are assumed to be input only.
1532
1533 If you specify @samp{=} or @samp{+} in a constraint, you put it in the
1534 first character of the constraint string.
1535
1536 @cindex @samp{&} in constraint
1537 @cindex earlyclobber operand
1538 @item &
1539 Means (in a particular alternative) that this operand is an
1540 @dfn{earlyclobber} operand, which is modified before the instruction is
1541 finished using the input operands.  Therefore, this operand may not lie
1542 in a register that is used as an input operand or as part of any memory
1543 address.
1544
1545 @samp{&} applies only to the alternative in which it is written.  In
1546 constraints with multiple alternatives, sometimes one alternative
1547 requires @samp{&} while others do not.  See, for example, the
1548 @samp{movdf} insn of the 68000.
1549
1550 An input operand can be tied to an earlyclobber operand if its only
1551 use as an input occurs before the early result is written.  Adding
1552 alternatives of this form often allows GCC to produce better code
1553 when only some of the inputs can be affected by the earlyclobber.
1554 See, for example, the @samp{mulsi3} insn of the ARM@.
1555
1556 @samp{&} does not obviate the need to write @samp{=}.
1557
1558 @cindex @samp{%} in constraint
1559 @item %
1560 Declares the instruction to be commutative for this operand and the
1561 following operand.  This means that the compiler may interchange the
1562 two operands if that is the cheapest way to make all operands fit the
1563 constraints.
1564 @ifset INTERNALS
1565 This is often used in patterns for addition instructions
1566 that really have only two operands: the result must go in one of the
1567 arguments.  Here for example, is how the 68000 halfword-add
1568 instruction is defined:
1569
1570 @smallexample
1571 (define_insn "addhi3"
1572   [(set (match_operand:HI 0 "general_operand" "=m,r")
1573      (plus:HI (match_operand:HI 1 "general_operand" "%0,0")
1574               (match_operand:HI 2 "general_operand" "di,g")))]
1575   @dots{})
1576 @end smallexample
1577 @end ifset
1578 GCC can only handle one commutative pair in an asm; if you use more,
1579 the compiler may fail.  Note that you need not use the modifier if
1580 the two alternatives are strictly identical; this would only waste
1581 time in the reload pass.  The modifier is not operational after
1582 register allocation, so the result of @code{define_peephole2}
1583 and @code{define_split}s performed after reload cannot rely on
1584 @samp{%} to make the intended insn match.
1585
1586 @cindex @samp{#} in constraint
1587 @item #
1588 Says that all following characters, up to the next comma, are to be
1589 ignored as a constraint.  They are significant only for choosing
1590 register preferences.
1591
1592 @cindex @samp{*} in constraint
1593 @item *
1594 Says that the following character should be ignored when choosing
1595 register preferences.  @samp{*} has no effect on the meaning of the
1596 constraint as a constraint, and no effect on reloading.
1597
1598 @ifset INTERNALS
1599 Here is an example: the 68000 has an instruction to sign-extend a
1600 halfword in a data register, and can also sign-extend a value by
1601 copying it into an address register.  While either kind of register is
1602 acceptable, the constraints on an address-register destination are
1603 less strict, so it is best if register allocation makes an address
1604 register its goal.  Therefore, @samp{*} is used so that the @samp{d}
1605 constraint letter (for data register) is ignored when computing
1606 register preferences.
1607
1608 @smallexample
1609 (define_insn "extendhisi2"
1610   [(set (match_operand:SI 0 "general_operand" "=*d,a")
1611         (sign_extend:SI
1612          (match_operand:HI 1 "general_operand" "0,g")))]
1613   @dots{})
1614 @end smallexample
1615 @end ifset
1616 @end table
1617
1618 @node Machine Constraints
1619 @subsection Constraints for Particular Machines
1620 @cindex machine specific constraints
1621 @cindex constraints, machine specific
1622
1623 Whenever possible, you should use the general-purpose constraint letters
1624 in @code{asm} arguments, since they will convey meaning more readily to
1625 people reading your code.  Failing that, use the constraint letters
1626 that usually have very similar meanings across architectures.  The most
1627 commonly used constraints are @samp{m} and @samp{r} (for memory and
1628 general-purpose registers respectively; @pxref{Simple Constraints}), and
1629 @samp{I}, usually the letter indicating the most common
1630 immediate-constant format.
1631
1632 Each architecture defines additional constraints.  These constraints
1633 are used by the compiler itself for instruction generation, as well as
1634 for @code{asm} statements; therefore, some of the constraints are not
1635 particularly useful for @code{asm}.  Here is a summary of some of the
1636 machine-dependent constraints available on some particular machines;
1637 it includes both constraints that are useful for @code{asm} and
1638 constraints that aren't.  The compiler source file mentioned in the
1639 table heading for each architecture is the definitive reference for
1640 the meanings of that architecture's constraints.
1641
1642 @table @emph
1643 @item ARM family---@file{config/arm/arm.h}
1644 @table @code
1645 @item f
1646 Floating-point register
1647
1648 @item w
1649 VFP floating-point register
1650
1651 @item F
1652 One of the floating-point constants 0.0, 0.5, 1.0, 2.0, 3.0, 4.0, 5.0
1653 or 10.0
1654
1655 @item G
1656 Floating-point constant that would satisfy the constraint @samp{F} if it
1657 were negated
1658
1659 @item I
1660 Integer that is valid as an immediate operand in a data processing
1661 instruction.  That is, an integer in the range 0 to 255 rotated by a
1662 multiple of 2
1663
1664 @item J
1665 Integer in the range @minus{}4095 to 4095
1666
1667 @item K
1668 Integer that satisfies constraint @samp{I} when inverted (ones complement)
1669
1670 @item L
1671 Integer that satisfies constraint @samp{I} when negated (twos complement)
1672
1673 @item M
1674 Integer in the range 0 to 32
1675
1676 @item Q
1677 A memory reference where the exact address is in a single register
1678 (`@samp{m}' is preferable for @code{asm} statements)
1679
1680 @item R
1681 An item in the constant pool
1682
1683 @item S
1684 A symbol in the text segment of the current file
1685
1686 @item Uv
1687 A memory reference suitable for VFP load/store insns (reg+constant offset)
1688
1689 @item Uy
1690 A memory reference suitable for iWMMXt load/store instructions.
1691
1692 @item Uq
1693 A memory reference suitable for the ARMv4 ldrsb instruction.
1694 @end table
1695
1696 @item AVR family---@file{config/avr/constraints.md}
1697 @table @code
1698 @item l
1699 Registers from r0 to r15
1700
1701 @item a
1702 Registers from r16 to r23
1703
1704 @item d
1705 Registers from r16 to r31
1706
1707 @item w
1708 Registers from r24 to r31.  These registers can be used in @samp{adiw} command
1709
1710 @item e
1711 Pointer register (r26--r31)
1712
1713 @item b
1714 Base pointer register (r28--r31)
1715
1716 @item q
1717 Stack pointer register (SPH:SPL)
1718
1719 @item t
1720 Temporary register r0
1721
1722 @item x
1723 Register pair X (r27:r26)
1724
1725 @item y
1726 Register pair Y (r29:r28)
1727
1728 @item z
1729 Register pair Z (r31:r30)
1730
1731 @item I
1732 Constant greater than @minus{}1, less than 64
1733
1734 @item J
1735 Constant greater than @minus{}64, less than 1
1736
1737 @item K
1738 Constant integer 2
1739
1740 @item L
1741 Constant integer 0
1742
1743 @item M
1744 Constant that fits in 8 bits
1745
1746 @item N
1747 Constant integer @minus{}1
1748
1749 @item O
1750 Constant integer 8, 16, or 24
1751
1752 @item P
1753 Constant integer 1
1754
1755 @item G
1756 A floating point constant 0.0
1757
1758 @item R
1759 Integer constant in the range @minus{}6 @dots{} 5.
1760
1761 @item Q
1762 A memory address based on Y or Z pointer with displacement.
1763 @end table
1764
1765 @item CRX Architecture---@file{config/crx/crx.h}
1766 @table @code
1767
1768 @item b
1769 Registers from r0 to r14 (registers without stack pointer)
1770
1771 @item l
1772 Register r16 (64-bit accumulator lo register)
1773
1774 @item h
1775 Register r17 (64-bit accumulator hi register)
1776
1777 @item k
1778 Register pair r16-r17. (64-bit accumulator lo-hi pair)
1779
1780 @item I
1781 Constant that fits in 3 bits
1782
1783 @item J
1784 Constant that fits in 4 bits
1785
1786 @item K
1787 Constant that fits in 5 bits
1788
1789 @item L
1790 Constant that is one of @minus{}1, 4, @minus{}4, 7, 8, 12, 16, 20, 32, 48
1791
1792 @item G
1793 Floating point constant that is legal for store immediate
1794 @end table
1795
1796 @item Hewlett-Packard PA-RISC---@file{config/pa/pa.h}
1797 @table @code
1798 @item a
1799 General register 1
1800
1801 @item f
1802 Floating point register
1803
1804 @item q
1805 Shift amount register
1806
1807 @item x
1808 Floating point register (deprecated)
1809
1810 @item y
1811 Upper floating point register (32-bit), floating point register (64-bit)
1812
1813 @item Z
1814 Any register
1815
1816 @item I
1817 Signed 11-bit integer constant
1818
1819 @item J
1820 Signed 14-bit integer constant
1821
1822 @item K
1823 Integer constant that can be deposited with a @code{zdepi} instruction
1824
1825 @item L
1826 Signed 5-bit integer constant
1827
1828 @item M
1829 Integer constant 0
1830
1831 @item N
1832 Integer constant that can be loaded with a @code{ldil} instruction
1833
1834 @item O
1835 Integer constant whose value plus one is a power of 2
1836
1837 @item P
1838 Integer constant that can be used for @code{and} operations in @code{depi}
1839 and @code{extru} instructions
1840
1841 @item S
1842 Integer constant 31
1843
1844 @item U
1845 Integer constant 63
1846
1847 @item G
1848 Floating-point constant 0.0
1849
1850 @item A
1851 A @code{lo_sum} data-linkage-table memory operand
1852
1853 @item Q
1854 A memory operand that can be used as the destination operand of an
1855 integer store instruction
1856
1857 @item R
1858 A scaled or unscaled indexed memory operand
1859
1860 @item T
1861 A memory operand for floating-point loads and stores
1862
1863 @item W
1864 A register indirect memory operand
1865 @end table
1866
1867 @item picoChip family---@file{picochip.h}
1868 @table @code
1869 @item k
1870 Stack register.
1871
1872 @item f
1873 Pointer register.  A register which can be used to access memory without
1874 supplying an offset.  Any other register can be used to access memory,
1875 but will need a constant offset.  In the case of the offset being zero,
1876 it is more efficient to use a pointer register, since this reduces code
1877 size.
1878
1879 @item t
1880 A twin register.  A register which may be paired with an adjacent
1881 register to create a 32-bit register.
1882
1883 @item a
1884 Any absolute memory address (e.g., symbolic constant, symbolic
1885 constant + offset).
1886
1887 @item I
1888 4-bit signed integer.
1889
1890 @item J
1891 4-bit unsigned integer.
1892
1893 @item K
1894 8-bit signed integer.
1895
1896 @item M
1897 Any constant whose absolute value is no greater than 4-bits.
1898
1899 @item N
1900 10-bit signed integer
1901
1902 @item O
1903 16-bit signed integer.
1904
1905 @end table
1906
1907 @item PowerPC and IBM RS6000---@file{config/rs6000/rs6000.h}
1908 @table @code
1909 @item b
1910 Address base register
1911
1912 @item d
1913 Floating point register (containing 64-bit value)
1914
1915 @item f
1916 Floating point register (containing 32-bit value)
1917
1918 @item v
1919 Altivec vector register
1920
1921 @item wd
1922 VSX vector register to hold vector double data
1923
1924 @item wf
1925 VSX vector register to hold vector float data
1926
1927 @item ws
1928 VSX vector register to hold scalar float data
1929
1930 @item wa
1931 Any VSX register
1932
1933 @item h
1934 @samp{MQ}, @samp{CTR}, or @samp{LINK} register
1935
1936 @item q
1937 @samp{MQ} register
1938
1939 @item c
1940 @samp{CTR} register
1941
1942 @item l
1943 @samp{LINK} register
1944
1945 @item x
1946 @samp{CR} register (condition register) number 0
1947
1948 @item y
1949 @samp{CR} register (condition register)
1950
1951 @item z
1952 @samp{FPMEM} stack memory for FPR-GPR transfers
1953
1954 @item I
1955 Signed 16-bit constant
1956
1957 @item J
1958 Unsigned 16-bit constant shifted left 16 bits (use @samp{L} instead for
1959 @code{SImode} constants)
1960
1961 @item K
1962 Unsigned 16-bit constant
1963
1964 @item L
1965 Signed 16-bit constant shifted left 16 bits
1966
1967 @item M
1968 Constant larger than 31
1969
1970 @item N
1971 Exact power of 2
1972
1973 @item O
1974 Zero
1975
1976 @item P
1977 Constant whose negation is a signed 16-bit constant
1978
1979 @item G
1980 Floating point constant that can be loaded into a register with one
1981 instruction per word
1982
1983 @item H
1984 Integer/Floating point constant that can be loaded into a register using
1985 three instructions
1986
1987 @item m
1988 Memory operand.  Note that on PowerPC targets, @code{m} can include
1989 addresses that update the base register.  It is therefore only safe
1990 to use @samp{m} in an @code{asm} statement if that @code{asm} statement
1991 accesses the operand exactly once.  The @code{asm} statement must also
1992 use @samp{%U@var{<opno>}} as a placeholder for the ``update'' flag in the
1993 corresponding load or store instruction.  For example:
1994
1995 @smallexample
1996 asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
1997 @end smallexample
1998
1999 is correct but:
2000
2001 @smallexample
2002 asm ("st %1,%0" : "=m" (mem) : "r" (val));
2003 @end smallexample
2004
2005 is not.  Use @code{es} rather than @code{m} if you don't want the
2006 base register to be updated.
2007
2008 @item es
2009 A ``stable'' memory operand; that is, one which does not include any
2010 automodification of the base register.  Unlike @samp{m}, this constraint
2011 can be used in @code{asm} statements that might access the operand
2012 several times, or that might not access it at all.
2013
2014 @item Q
2015 Memory operand that is an offset from a register (it is usually better
2016 to use @samp{m} or @samp{es} in @code{asm} statements)
2017
2018 @item Z
2019 Memory operand that is an indexed or indirect from a register (it is
2020 usually better to use @samp{m} or @samp{es} in @code{asm} statements)
2021
2022 @item R
2023 AIX TOC entry
2024
2025 @item a
2026 Address operand that is an indexed or indirect from a register (@samp{p} is
2027 preferable for @code{asm} statements)
2028
2029 @item S
2030 Constant suitable as a 64-bit mask operand
2031
2032 @item T
2033 Constant suitable as a 32-bit mask operand
2034
2035 @item U
2036 System V Release 4 small data area reference
2037
2038 @item t
2039 AND masks that can be performed by two rldic@{l, r@} instructions
2040
2041 @item W
2042 Vector constant that does not require memory
2043
2044 @item j
2045 Vector constant that is all zeros.
2046
2047 @end table
2048
2049 @item Intel 386---@file{config/i386/constraints.md}
2050 @table @code
2051 @item R
2052 Legacy register---the eight integer registers available on all
2053 i386 processors (@code{a}, @code{b}, @code{c}, @code{d},
2054 @code{si}, @code{di}, @code{bp}, @code{sp}).
2055
2056 @item q
2057 Any register accessible as @code{@var{r}l}.  In 32-bit mode, @code{a},
2058 @code{b}, @code{c}, and @code{d}; in 64-bit mode, any integer register.
2059
2060 @item Q
2061 Any register accessible as @code{@var{r}h}: @code{a}, @code{b},
2062 @code{c}, and @code{d}.
2063
2064 @ifset INTERNALS
2065 @item l
2066 Any register that can be used as the index in a base+index memory
2067 access: that is, any general register except the stack pointer.
2068 @end ifset
2069
2070 @item a
2071 The @code{a} register.
2072
2073 @item b
2074 The @code{b} register.
2075
2076 @item c
2077 The @code{c} register.
2078
2079 @item d
2080 The @code{d} register.
2081
2082 @item S
2083 The @code{si} register.
2084
2085 @item D
2086 The @code{di} register.
2087
2088 @item A
2089 The @code{a} and @code{d} registers, as a pair (for instructions that
2090 return half the result in one and half in the other).
2091
2092 @item f
2093 Any 80387 floating-point (stack) register.
2094
2095 @item t
2096 Top of 80387 floating-point stack (@code{%st(0)}).
2097
2098 @item u
2099 Second from top of 80387 floating-point stack (@code{%st(1)}).
2100
2101 @item y
2102 Any MMX register.
2103
2104 @item x
2105 Any SSE register.
2106
2107 @item Yz
2108 First SSE register (@code{%xmm0}).
2109
2110 @ifset INTERNALS
2111 @item Y2
2112 Any SSE register, when SSE2 is enabled.
2113
2114 @item Yi
2115 Any SSE register, when SSE2 and inter-unit moves are enabled.
2116
2117 @item Ym
2118 Any MMX register, when inter-unit moves are enabled.
2119 @end ifset
2120
2121 @item I
2122 Integer constant in the range 0 @dots{} 31, for 32-bit shifts.
2123
2124 @item J
2125 Integer constant in the range 0 @dots{} 63, for 64-bit shifts.
2126
2127 @item K
2128 Signed 8-bit integer constant.
2129
2130 @item L
2131 @code{0xFF} or @code{0xFFFF}, for andsi as a zero-extending move.
2132
2133 @item M
2134 0, 1, 2, or 3 (shifts for the @code{lea} instruction).
2135
2136 @item N
2137 Unsigned 8-bit integer constant (for @code{in} and @code{out} 
2138 instructions).
2139
2140 @ifset INTERNALS
2141 @item O
2142 Integer constant in the range 0 @dots{} 127, for 128-bit shifts.
2143 @end ifset
2144
2145 @item G
2146 Standard 80387 floating point constant.
2147
2148 @item C
2149 Standard SSE floating point constant.
2150
2151 @item e
2152 32-bit signed integer constant, or a symbolic reference known
2153 to fit that range (for immediate operands in sign-extending x86-64
2154 instructions).
2155
2156 @item Z
2157 32-bit unsigned integer constant, or a symbolic reference known
2158 to fit that range (for immediate operands in zero-extending x86-64
2159 instructions).
2160
2161 @end table
2162
2163 @item Intel IA-64---@file{config/ia64/ia64.h}
2164 @table @code
2165 @item a
2166 General register @code{r0} to @code{r3} for @code{addl} instruction
2167
2168 @item b
2169 Branch register
2170
2171 @item c
2172 Predicate register (@samp{c} as in ``conditional'')
2173
2174 @item d
2175 Application register residing in M-unit
2176
2177 @item e
2178 Application register residing in I-unit
2179
2180 @item f
2181 Floating-point register
2182
2183 @item m
2184 Memory operand.
2185 Remember that @samp{m} allows postincrement and postdecrement which
2186 require printing with @samp{%Pn} on IA-64.
2187 Use @samp{S} to disallow postincrement and postdecrement.
2188
2189 @item G
2190 Floating-point constant 0.0 or 1.0
2191
2192 @item I
2193 14-bit signed integer constant
2194
2195 @item J
2196 22-bit signed integer constant
2197
2198 @item K
2199 8-bit signed integer constant for logical instructions
2200
2201 @item L
2202 8-bit adjusted signed integer constant for compare pseudo-ops
2203
2204 @item M
2205 6-bit unsigned integer constant for shift counts
2206
2207 @item N
2208 9-bit signed integer constant for load and store postincrements
2209
2210 @item O
2211 The constant zero
2212
2213 @item P
2214 0 or @minus{}1 for @code{dep} instruction
2215
2216 @item Q
2217 Non-volatile memory for floating-point loads and stores
2218
2219 @item R
2220 Integer constant in the range 1 to 4 for @code{shladd} instruction
2221
2222 @item S
2223 Memory operand except postincrement and postdecrement
2224 @end table
2225
2226 @item FRV---@file{config/frv/frv.h}
2227 @table @code
2228 @item a
2229 Register in the class @code{ACC_REGS} (@code{acc0} to @code{acc7}).
2230
2231 @item b
2232 Register in the class @code{EVEN_ACC_REGS} (@code{acc0} to @code{acc7}).
2233
2234 @item c
2235 Register in the class @code{CC_REGS} (@code{fcc0} to @code{fcc3} and
2236 @code{icc0} to @code{icc3}).
2237
2238 @item d
2239 Register in the class @code{GPR_REGS} (@code{gr0} to @code{gr63}).
2240
2241 @item e
2242 Register in the class @code{EVEN_REGS} (@code{gr0} to @code{gr63}).
2243 Odd registers are excluded not in the class but through the use of a machine
2244 mode larger than 4 bytes.
2245
2246 @item f
2247 Register in the class @code{FPR_REGS} (@code{fr0} to @code{fr63}).
2248
2249 @item h
2250 Register in the class @code{FEVEN_REGS} (@code{fr0} to @code{fr63}).
2251 Odd registers are excluded not in the class but through the use of a machine
2252 mode larger than 4 bytes.
2253
2254 @item l
2255 Register in the class @code{LR_REG} (the @code{lr} register).
2256
2257 @item q
2258 Register in the class @code{QUAD_REGS} (@code{gr2} to @code{gr63}).
2259 Register numbers not divisible by 4 are excluded not in the class but through
2260 the use of a machine mode larger than 8 bytes.
2261
2262 @item t
2263 Register in the class @code{ICC_REGS} (@code{icc0} to @code{icc3}).
2264
2265 @item u
2266 Register in the class @code{FCC_REGS} (@code{fcc0} to @code{fcc3}).
2267
2268 @item v
2269 Register in the class @code{ICR_REGS} (@code{cc4} to @code{cc7}).
2270
2271 @item w
2272 Register in the class @code{FCR_REGS} (@code{cc0} to @code{cc3}).
2273
2274 @item x
2275 Register in the class @code{QUAD_FPR_REGS} (@code{fr0} to @code{fr63}).
2276 Register numbers not divisible by 4 are excluded not in the class but through
2277 the use of a machine mode larger than 8 bytes.
2278
2279 @item z
2280 Register in the class @code{SPR_REGS} (@code{lcr} and @code{lr}).
2281
2282 @item A
2283 Register in the class @code{QUAD_ACC_REGS} (@code{acc0} to @code{acc7}).
2284
2285 @item B
2286 Register in the class @code{ACCG_REGS} (@code{accg0} to @code{accg7}).
2287
2288 @item C
2289 Register in the class @code{CR_REGS} (@code{cc0} to @code{cc7}).
2290
2291 @item G
2292 Floating point constant zero
2293
2294 @item I
2295 6-bit signed integer constant
2296
2297 @item J
2298 10-bit signed integer constant
2299
2300 @item L
2301 16-bit signed integer constant
2302
2303 @item M
2304 16-bit unsigned integer constant
2305
2306 @item N
2307 12-bit signed integer constant that is negative---i.e.@: in the
2308 range of @minus{}2048 to @minus{}1
2309
2310 @item O
2311 Constant zero
2312
2313 @item P
2314 12-bit signed integer constant that is greater than zero---i.e.@: in the
2315 range of 1 to 2047.
2316
2317 @end table
2318
2319 @item Blackfin family---@file{config/bfin/constraints.md}
2320 @table @code
2321 @item a
2322 P register
2323
2324 @item d
2325 D register
2326
2327 @item z
2328 A call clobbered P register.
2329
2330 @item q@var{n}
2331 A single register.  If @var{n} is in the range 0 to 7, the corresponding D
2332 register.  If it is @code{A}, then the register P0.
2333
2334 @item D
2335 Even-numbered D register
2336
2337 @item W
2338 Odd-numbered D register
2339
2340 @item e
2341 Accumulator register.
2342
2343 @item A
2344 Even-numbered accumulator register.
2345
2346 @item B
2347 Odd-numbered accumulator register.
2348
2349 @item b
2350 I register
2351
2352 @item v
2353 B register
2354
2355 @item f
2356 M register
2357
2358 @item c
2359 Registers used for circular buffering, i.e. I, B, or L registers.
2360
2361 @item C
2362 The CC register.
2363
2364 @item t
2365 LT0 or LT1.
2366
2367 @item k
2368 LC0 or LC1.
2369
2370 @item u
2371 LB0 or LB1.
2372
2373 @item x
2374 Any D, P, B, M, I or L register.
2375
2376 @item y
2377 Additional registers typically used only in prologues and epilogues: RETS,
2378 RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and USP.
2379
2380 @item w
2381 Any register except accumulators or CC.
2382
2383 @item Ksh
2384 Signed 16 bit integer (in the range @minus{}32768 to 32767)
2385
2386 @item Kuh
2387 Unsigned 16 bit integer (in the range 0 to 65535)
2388
2389 @item Ks7
2390 Signed 7 bit integer (in the range @minus{}64 to 63)
2391
2392 @item Ku7
2393 Unsigned 7 bit integer (in the range 0 to 127)
2394
2395 @item Ku5
2396 Unsigned 5 bit integer (in the range 0 to 31)
2397
2398 @item Ks4
2399 Signed 4 bit integer (in the range @minus{}8 to 7)
2400
2401 @item Ks3
2402 Signed 3 bit integer (in the range @minus{}3 to 4)
2403
2404 @item Ku3
2405 Unsigned 3 bit integer (in the range 0 to 7)
2406
2407 @item P@var{n}
2408 Constant @var{n}, where @var{n} is a single-digit constant in the range 0 to 4.
2409
2410 @item PA
2411 An integer equal to one of the MACFLAG_XXX constants that is suitable for
2412 use with either accumulator.
2413
2414 @item PB
2415 An integer equal to one of the MACFLAG_XXX constants that is suitable for
2416 use only with accumulator A1.
2417
2418 @item M1
2419 Constant 255.
2420
2421 @item M2
2422 Constant 65535.
2423
2424 @item J
2425 An integer constant with exactly a single bit set.
2426
2427 @item L
2428 An integer constant with all bits set except exactly one.
2429
2430 @item H
2431
2432 @item Q
2433 Any SYMBOL_REF.
2434 @end table
2435
2436 @item M32C---@file{config/m32c/m32c.c}
2437 @table @code
2438 @item Rsp
2439 @itemx Rfb
2440 @itemx Rsb
2441 @samp{$sp}, @samp{$fb}, @samp{$sb}.
2442
2443 @item Rcr
2444 Any control register, when they're 16 bits wide (nothing if control
2445 registers are 24 bits wide)
2446
2447 @item Rcl
2448 Any control register, when they're 24 bits wide.
2449
2450 @item R0w
2451 @itemx R1w
2452 @itemx R2w
2453 @itemx R3w
2454 $r0, $r1, $r2, $r3.
2455
2456 @item R02
2457 $r0 or $r2, or $r2r0 for 32 bit values.
2458
2459 @item R13
2460 $r1 or $r3, or $r3r1 for 32 bit values.
2461
2462 @item Rdi
2463 A register that can hold a 64 bit value.
2464
2465 @item Rhl
2466 $r0 or $r1 (registers with addressable high/low bytes)
2467
2468 @item R23
2469 $r2 or $r3
2470
2471 @item Raa
2472 Address registers
2473
2474 @item Raw
2475 Address registers when they're 16 bits wide.
2476
2477 @item Ral
2478 Address registers when they're 24 bits wide.
2479
2480 @item Rqi
2481 Registers that can hold QI values.
2482
2483 @item Rad
2484 Registers that can be used with displacements ($a0, $a1, $sb).
2485
2486 @item Rsi
2487 Registers that can hold 32 bit values.
2488
2489 @item Rhi
2490 Registers that can hold 16 bit values.
2491
2492 @item Rhc
2493 Registers chat can hold 16 bit values, including all control
2494 registers.
2495
2496 @item Rra
2497 $r0 through R1, plus $a0 and $a1.
2498
2499 @item Rfl
2500 The flags register.
2501
2502 @item Rmm
2503 The memory-based pseudo-registers $mem0 through $mem15.
2504
2505 @item Rpi
2506 Registers that can hold pointers (16 bit registers for r8c, m16c; 24
2507 bit registers for m32cm, m32c).
2508
2509 @item Rpa
2510 Matches multiple registers in a PARALLEL to form a larger register.
2511 Used to match function return values.
2512
2513 @item Is3
2514 @minus{}8 @dots{} 7
2515
2516 @item IS1
2517 @minus{}128 @dots{} 127
2518
2519 @item IS2
2520 @minus{}32768 @dots{} 32767
2521
2522 @item IU2
2523 0 @dots{} 65535
2524
2525 @item In4
2526 @minus{}8 @dots{} @minus{}1 or 1 @dots{} 8
2527
2528 @item In5
2529 @minus{}16 @dots{} @minus{}1 or 1 @dots{} 16
2530
2531 @item In6
2532 @minus{}32 @dots{} @minus{}1 or 1 @dots{} 32
2533
2534 @item IM2
2535 @minus{}65536 @dots{} @minus{}1
2536
2537 @item Ilb
2538 An 8 bit value with exactly one bit set.
2539
2540 @item Ilw
2541 A 16 bit value with exactly one bit set.
2542
2543 @item Sd
2544 The common src/dest memory addressing modes.
2545
2546 @item Sa
2547 Memory addressed using $a0 or $a1.
2548
2549 @item Si
2550 Memory addressed with immediate addresses.
2551
2552 @item Ss
2553 Memory addressed using the stack pointer ($sp).
2554
2555 @item Sf
2556 Memory addressed using the frame base register ($fb).
2557
2558 @item Ss
2559 Memory addressed using the small base register ($sb).
2560
2561 @item S1
2562 $r1h
2563 @end table
2564
2565 @item MeP---@file{config/mep/constraints.md}
2566 @table @code
2567
2568 @item a
2569 The $sp register.
2570
2571 @item b
2572 The $tp register.
2573
2574 @item c
2575 Any control register.
2576
2577 @item d
2578 Either the $hi or the $lo register.
2579
2580 @item em
2581 Coprocessor registers that can be directly loaded ($c0-$c15).
2582
2583 @item ex
2584 Coprocessor registers that can be moved to each other.
2585
2586 @item er
2587 Coprocessor registers that can be moved to core registers.
2588
2589 @item h
2590 The $hi register.
2591
2592 @item j
2593 The $rpc register.
2594
2595 @item l
2596 The $lo register.
2597
2598 @item t
2599 Registers which can be used in $tp-relative addressing.
2600
2601 @item v
2602 The $gp register.
2603
2604 @item x
2605 The coprocessor registers.
2606
2607 @item y
2608 The coprocessor control registers.
2609
2610 @item z
2611 The $0 register.
2612
2613 @item A
2614 User-defined register set A.
2615
2616 @item B
2617 User-defined register set B.
2618
2619 @item C
2620 User-defined register set C.
2621
2622 @item D
2623 User-defined register set D.
2624
2625 @item I
2626 Offsets for $gp-rel addressing.
2627
2628 @item J
2629 Constants that can be used directly with boolean insns.
2630
2631 @item K
2632 Constants that can be moved directly to registers.
2633
2634 @item L
2635 Small constants that can be added to registers.
2636
2637 @item M
2638 Long shift counts.
2639
2640 @item N
2641 Small constants that can be compared to registers.
2642
2643 @item O
2644 Constants that can be loaded into the top half of registers.
2645
2646 @item S
2647 Signed 8-bit immediates.
2648
2649 @item T
2650 Symbols encoded for $tp-rel or $gp-rel addressing.
2651
2652 @item U
2653 Non-constant addresses for loading/saving coprocessor registers.
2654
2655 @item W
2656 The top half of a symbol's value.
2657
2658 @item Y
2659 A register indirect address without offset.
2660
2661 @item Z
2662 Symbolic references to the control bus.
2663
2664
2665
2666 @end table
2667
2668 @item MIPS---@file{config/mips/constraints.md}
2669 @table @code
2670 @item d
2671 An address register.  This is equivalent to @code{r} unless
2672 generating MIPS16 code.
2673
2674 @item f
2675 A floating-point register (if available).
2676
2677 @item h
2678 Formerly the @code{hi} register.  This constraint is no longer supported.
2679
2680 @item l
2681 The @code{lo} register.  Use this register to store values that are
2682 no bigger than a word.
2683
2684 @item x
2685 The concatenated @code{hi} and @code{lo} registers.  Use this register
2686 to store doubleword values.
2687
2688 @item c
2689 A register suitable for use in an indirect jump.  This will always be
2690 @code{$25} for @option{-mabicalls}.
2691
2692 @item v
2693 Register @code{$3}.  Do not use this constraint in new code;
2694 it is retained only for compatibility with glibc.
2695
2696 @item y
2697 Equivalent to @code{r}; retained for backwards compatibility.
2698
2699 @item z
2700 A floating-point condition code register.
2701
2702 @item I
2703 A signed 16-bit constant (for arithmetic instructions).
2704
2705 @item J
2706 Integer zero.
2707
2708 @item K
2709 An unsigned 16-bit constant (for logic instructions).
2710
2711 @item L
2712 A signed 32-bit constant in which the lower 16 bits are zero.
2713 Such constants can be loaded using @code{lui}.
2714
2715 @item M
2716 A constant that cannot be loaded using @code{lui}, @code{addiu}
2717 or @code{ori}.
2718
2719 @item N
2720 A constant in the range @minus{}65535 to @minus{}1 (inclusive).
2721
2722 @item O
2723 A signed 15-bit constant.
2724
2725 @item P
2726 A constant in the range 1 to 65535 (inclusive).
2727
2728 @item G
2729 Floating-point zero.
2730
2731 @item R
2732 An address that can be used in a non-macro load or store.
2733 @end table
2734
2735 @item Motorola 680x0---@file{config/m68k/constraints.md}
2736 @table @code
2737 @item a
2738 Address register
2739
2740 @item d
2741 Data register
2742
2743 @item f
2744 68881 floating-point register, if available
2745
2746 @item I
2747 Integer in the range 1 to 8
2748
2749 @item J
2750 16-bit signed number
2751
2752 @item K
2753 Signed number whose magnitude is greater than 0x80
2754
2755 @item L
2756 Integer in the range @minus{}8 to @minus{}1
2757
2758 @item M
2759 Signed number whose magnitude is greater than 0x100
2760
2761 @item N
2762 Range 24 to 31, rotatert:SI 8 to 1 expressed as rotate
2763
2764 @item O
2765 16 (for rotate using swap)
2766
2767 @item P
2768 Range 8 to 15, rotatert:HI 8 to 1 expressed as rotate
2769
2770 @item R
2771 Numbers that mov3q can handle
2772
2773 @item G
2774 Floating point constant that is not a 68881 constant
2775
2776 @item S
2777 Operands that satisfy 'm' when -mpcrel is in effect
2778
2779 @item T
2780 Operands that satisfy 's' when -mpcrel is not in effect
2781
2782 @item Q
2783 Address register indirect addressing mode
2784
2785 @item U
2786 Register offset addressing
2787
2788 @item W
2789 const_call_operand
2790
2791 @item Cs
2792 symbol_ref or const
2793
2794 @item Ci
2795 const_int
2796
2797 @item C0
2798 const_int 0
2799
2800 @item Cj
2801 Range of signed numbers that don't fit in 16 bits
2802
2803 @item Cmvq
2804 Integers valid for mvq
2805
2806 @item Capsw
2807 Integers valid for a moveq followed by a swap
2808
2809 @item Cmvz
2810 Integers valid for mvz
2811
2812 @item Cmvs
2813 Integers valid for mvs
2814
2815 @item Ap
2816 push_operand
2817
2818 @item Ac
2819 Non-register operands allowed in clr
2820
2821 @end table
2822
2823 @item Motorola 68HC11 & 68HC12 families---@file{config/m68hc11/m68hc11.h}
2824 @table @code
2825 @item a
2826 Register `a'
2827
2828 @item b
2829 Register `b'
2830
2831 @item d
2832 Register `d'
2833
2834 @item q
2835 An 8-bit register
2836
2837 @item t
2838 Temporary soft register _.tmp
2839
2840 @item u
2841 A soft register _.d1 to _.d31
2842
2843 @item w
2844 Stack pointer register
2845
2846 @item x
2847 Register `x'
2848
2849 @item y
2850 Register `y'
2851
2852 @item z
2853 Pseudo register `z' (replaced by `x' or `y' at the end)
2854
2855 @item A
2856 An address register: x, y or z
2857
2858 @item B
2859 An address register: x or y
2860
2861 @item D
2862 Register pair (x:d) to form a 32-bit value
2863
2864 @item L
2865 Constants in the range @minus{}65536 to 65535
2866
2867 @item M
2868 Constants whose 16-bit low part is zero
2869
2870 @item N
2871 Constant integer 1 or @minus{}1
2872
2873 @item O
2874 Constant integer 16
2875
2876 @item P
2877 Constants in the range @minus{}8 to 2
2878
2879 @end table
2880
2881 @item Moxie---@file{config/moxie/constraints.md}
2882 @table @code
2883 @item A
2884 An absolute address
2885
2886 @item B
2887 An offset address
2888
2889 @item W
2890 A register indirect memory operand
2891
2892 @item I
2893 A constant in the range of 0 to 255.
2894
2895 @item N
2896 A constant in the range of 0 to @minus{}255.
2897
2898 @end table
2899
2900 @item RX---@file{config/rx/constraints.md}
2901 @table @code
2902 @item Q
2903 An address which does not involve register indirect addressing or
2904 pre/post increment/decrement addressing.
2905
2906 @item Symbol
2907 A symbol reference.
2908
2909 @item Int08
2910 A constant in the range @minus{}256 to 255, inclusive.
2911
2912 @item Sint08
2913 A constant in the range @minus{}128 to 127, inclusive.
2914
2915 @item Sint16
2916 A constant in the range @minus{}32768 to 32767, inclusive.
2917
2918 @item Sint24
2919 A constant in the range @minus{}8388608 to 8388607, inclusive.
2920
2921 @item Uint04
2922 A constant in the range 0 to 15, inclusive.
2923
2924 @end table
2925
2926 @need 1000
2927 @item SPARC---@file{config/sparc/sparc.h}
2928 @table @code
2929 @item f
2930 Floating-point register on the SPARC-V8 architecture and
2931 lower floating-point register on the SPARC-V9 architecture.
2932
2933 @item e
2934 Floating-point register.  It is equivalent to @samp{f} on the
2935 SPARC-V8 architecture and contains both lower and upper
2936 floating-point registers on the SPARC-V9 architecture.
2937
2938 @item c
2939 Floating-point condition code register.
2940
2941 @item d
2942 Lower floating-point register.  It is only valid on the SPARC-V9
2943 architecture when the Visual Instruction Set is available.
2944
2945 @item b
2946 Floating-point register.  It is only valid on the SPARC-V9 architecture
2947 when the Visual Instruction Set is available.
2948
2949 @item h
2950 64-bit global or out register for the SPARC-V8+ architecture.
2951
2952 @item D
2953 A vector constant
2954
2955 @item I
2956 Signed 13-bit constant
2957
2958 @item J
2959 Zero
2960
2961 @item K
2962 32-bit constant with the low 12 bits clear (a constant that can be
2963 loaded with the @code{sethi} instruction)
2964
2965 @item L
2966 A constant in the range supported by @code{movcc} instructions
2967
2968 @item M
2969 A constant in the range supported by @code{movrcc} instructions
2970
2971 @item N
2972 Same as @samp{K}, except that it verifies that bits that are not in the
2973 lower 32-bit range are all zero.  Must be used instead of @samp{K} for
2974 modes wider than @code{SImode}
2975
2976 @item O
2977 The constant 4096
2978
2979 @item G
2980 Floating-point zero
2981
2982 @item H
2983 Signed 13-bit constant, sign-extended to 32 or 64 bits
2984
2985 @item Q
2986 Floating-point constant whose integral representation can
2987 be moved into an integer register using a single sethi
2988 instruction
2989
2990 @item R
2991 Floating-point constant whose integral representation can
2992 be moved into an integer register using a single mov
2993 instruction
2994
2995 @item S
2996 Floating-point constant whose integral representation can
2997 be moved into an integer register using a high/lo_sum
2998 instruction sequence
2999
3000 @item T
3001 Memory address aligned to an 8-byte boundary
3002
3003 @item U
3004 Even register
3005
3006 @item W
3007 Memory address for @samp{e} constraint registers
3008
3009 @item Y
3010 Vector zero
3011
3012 @end table
3013
3014 @item SPU---@file{config/spu/spu.h}
3015 @table @code
3016 @item a
3017 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is treated as a 64 bit value.  
3018
3019 @item c
3020 An immediate for and/xor/or instructions.  const_int is treated as a 64 bit value.  
3021
3022 @item d
3023 An immediate for the @code{iohl} instruction.  const_int is treated as a 64 bit value.  
3024
3025 @item f
3026 An immediate which can be loaded with @code{fsmbi}.  
3027
3028 @item A
3029 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is treated as a 32 bit value.  
3030
3031 @item B
3032 An immediate for most arithmetic instructions.  const_int is treated as a 32 bit value.  
3033
3034 @item C
3035 An immediate for and/xor/or instructions.  const_int is treated as a 32 bit value.  
3036
3037 @item D
3038 An immediate for the @code{iohl} instruction.  const_int is treated as a 32 bit value.  
3039
3040 @item I
3041 A constant in the range [@minus{}64, 63] for shift/rotate instructions.  
3042
3043 @item J
3044 An unsigned 7-bit constant for conversion/nop/channel instructions.  
3045
3046 @item K
3047 A signed 10-bit constant for most arithmetic instructions.  
3048
3049 @item M
3050 A signed 16 bit immediate for @code{stop}.  
3051
3052 @item N
3053 An unsigned 16-bit constant for @code{iohl} and @code{fsmbi}.  
3054
3055 @item O
3056 An unsigned 7-bit constant whose 3 least significant bits are 0.  
3057
3058 @item P
3059 An unsigned 3-bit constant for 16-byte rotates and shifts 
3060
3061 @item R
3062 Call operand, reg, for indirect calls 
3063
3064 @item S
3065 Call operand, symbol, for relative calls.  
3066
3067 @item T
3068 Call operand, const_int, for absolute calls.  
3069
3070 @item U
3071 An immediate which can be loaded with the il/ila/ilh/ilhu instructions.  const_int is sign extended to 128 bit.  
3072
3073 @item W
3074 An immediate for shift and rotate instructions.  const_int is treated as a 32 bit value.  
3075
3076 @item Y
3077 An immediate for and/xor/or instructions.  const_int is sign extended as a 128 bit.  
3078
3079 @item Z
3080 An immediate for the @code{iohl} instruction.  const_int is sign extended to 128 bit.  
3081
3082 @end table
3083
3084 @item S/390 and zSeries---@file{config/s390/s390.h}
3085 @table @code
3086 @item a
3087 Address register (general purpose register except r0)
3088
3089 @item c
3090 Condition code register
3091
3092 @item d
3093 Data register (arbitrary general purpose register)
3094
3095 @item f
3096 Floating-point register
3097
3098 @item I
3099 Unsigned 8-bit constant (0--255)
3100
3101 @item J
3102 Unsigned 12-bit constant (0--4095)
3103
3104 @item K
3105 Signed 16-bit constant (@minus{}32768--32767)
3106
3107 @item L
3108 Value appropriate as displacement.
3109 @table @code
3110 @item (0..4095)
3111 for short displacement
3112 @item (@minus{}524288..524287)
3113 for long displacement
3114 @end table
3115
3116 @item M
3117 Constant integer with a value of 0x7fffffff.
3118
3119 @item N
3120 Multiple letter constraint followed by 4 parameter letters.
3121 @table @code
3122 @item 0..9:
3123 number of the part counting from most to least significant
3124 @item H,Q:
3125 mode of the part
3126 @item D,S,H:
3127 mode of the containing operand
3128 @item 0,F:
3129 value of the other parts (F---all bits set)
3130 @end table
3131 The constraint matches if the specified part of a constant
3132 has a value different from its other parts.
3133
3134 @item Q
3135 Memory reference without index register and with short displacement.
3136
3137 @item R
3138 Memory reference with index register and short displacement.
3139
3140 @item S
3141 Memory reference without index register but with long displacement.
3142
3143 @item T
3144 Memory reference with index register and long displacement.
3145
3146 @item U
3147 Pointer with short displacement.
3148
3149 @item W
3150 Pointer with long displacement.
3151
3152 @item Y
3153 Shift count operand.
3154
3155 @end table
3156
3157 @item Score family---@file{config/score/score.h}
3158 @table @code
3159 @item d
3160 Registers from r0 to r32.
3161
3162 @item e
3163 Registers from r0 to r16.
3164
3165 @item t
3166 r8---r11 or r22---r27 registers.
3167
3168 @item h
3169 hi register.
3170
3171 @item l
3172 lo register.
3173
3174 @item x
3175 hi + lo register.
3176
3177 @item q
3178 cnt register.
3179
3180 @item y
3181 lcb register.
3182
3183 @item z
3184 scb register.
3185
3186 @item a
3187 cnt + lcb + scb register.
3188
3189 @item c
3190 cr0---cr15 register.
3191
3192 @item b
3193 cp1 registers.
3194
3195 @item f
3196 cp2 registers.
3197
3198 @item i
3199 cp3 registers.
3200
3201 @item j
3202 cp1 + cp2 + cp3 registers.
3203
3204 @item I
3205 High 16-bit constant (32-bit constant with 16 LSBs zero).
3206
3207 @item J
3208 Unsigned 5 bit integer (in the range 0 to 31).
3209
3210 @item K
3211 Unsigned 16 bit integer (in the range 0 to 65535).
3212
3213 @item L
3214 Signed 16 bit integer (in the range @minus{}32768 to 32767).
3215
3216 @item M
3217 Unsigned 14 bit integer (in the range 0 to 16383).
3218
3219 @item N
3220 Signed 14 bit integer (in the range @minus{}8192 to 8191).
3221
3222 @item Z
3223 Any SYMBOL_REF.
3224 @end table
3225
3226 @item Xstormy16---@file{config/stormy16/stormy16.h}
3227 @table @code
3228 @item a
3229 Register r0.
3230
3231 @item b
3232 Register r1.
3233
3234 @item c
3235 Register r2.
3236
3237 @item d
3238 Register r8.
3239
3240 @item e
3241 Registers r0 through r7.
3242
3243 @item t
3244 Registers r0 and r1.
3245
3246 @item y
3247 The carry register.
3248
3249 @item z
3250 Registers r8 and r9.
3251
3252 @item I
3253 A constant between 0 and 3 inclusive.
3254
3255 @item J
3256 A constant that has exactly one bit set.
3257
3258 @item K
3259 A constant that has exactly one bit clear.
3260
3261 @item L
3262 A constant between 0 and 255 inclusive.
3263
3264 @item M
3265 A constant between @minus{}255 and 0 inclusive.
3266
3267 @item N
3268 A constant between @minus{}3 and 0 inclusive.
3269
3270 @item O
3271 A constant between 1 and 4 inclusive.
3272
3273 @item P
3274 A constant between @minus{}4 and @minus{}1 inclusive.
3275
3276 @item Q
3277 A memory reference that is a stack push.
3278
3279 @item R
3280 A memory reference that is a stack pop.
3281
3282 @item S
3283 A memory reference that refers to a constant address of known value.
3284
3285 @item T
3286 The register indicated by Rx (not implemented yet).
3287
3288 @item U
3289 A constant that is not between 2 and 15 inclusive.
3290
3291 @item Z
3292 The constant 0.
3293
3294 @end table
3295
3296 @item Xtensa---@file{config/xtensa/constraints.md}
3297 @table @code
3298 @item a
3299 General-purpose 32-bit register
3300
3301 @item b
3302 One-bit boolean register
3303
3304 @item A
3305 MAC16 40-bit accumulator register
3306
3307 @item I
3308 Signed 12-bit integer constant, for use in MOVI instructions
3309
3310 @item J
3311 Signed 8-bit integer constant, for use in ADDI instructions
3312
3313 @item K
3314 Integer constant valid for BccI instructions
3315
3316 @item L
3317 Unsigned constant valid for BccUI instructions
3318
3319 @end table
3320
3321 @end table
3322
3323 @ifset INTERNALS
3324 @node Disable Insn Alternatives
3325 @subsection Disable insn alternatives using the @code{enabled} attribute
3326 @cindex enabled
3327
3328 The @code{enabled} insn attribute may be used to disable certain insn
3329 alternatives for machine-specific reasons.  This is useful when adding
3330 new instructions to an existing pattern which are only available for
3331 certain cpu architecture levels as specified with the @code{-march=}
3332 option.
3333
3334 If an insn alternative is disabled, then it will never be used.  The
3335 compiler treats the constraints for the disabled alternative as
3336 unsatisfiable.
3337
3338 In order to make use of the @code{enabled} attribute a back end has to add
3339 in the machine description files:
3340
3341 @enumerate
3342 @item
3343 A definition of the @code{enabled} insn attribute.  The attribute is
3344 defined as usual using the @code{define_attr} command.  This
3345 definition should be based on other insn attributes and/or target flags.
3346 The @code{enabled} attribute is a numeric attribute and should evaluate to
3347 @code{(const_int 1)} for an enabled alternative and to
3348 @code{(const_int 0)} otherwise.
3349 @item
3350 A definition of another insn attribute used to describe for what
3351 reason an insn alternative might be available or
3352 not.  E.g. @code{cpu_facility} as in the example below.
3353 @item
3354 An assignment for the second attribute to each insn definition
3355 combining instructions which are not all available under the same
3356 circumstances.  (Note: It obviously only makes sense for definitions
3357 with more than one alternative.  Otherwise the insn pattern should be
3358 disabled or enabled using the insn condition.)
3359 @end enumerate
3360
3361 E.g. the following two patterns could easily be merged using the @code{enabled}
3362 attribute:
3363
3364 @smallexample
3365
3366 (define_insn "*movdi_old"
3367   [(set (match_operand:DI 0 "register_operand" "=d")
3368         (match_operand:DI 1 "register_operand" " d"))]
3369   "!TARGET_NEW"
3370   "lgr %0,%1")
3371
3372 (define_insn "*movdi_new"
3373   [(set (match_operand:DI 0 "register_operand" "=d,f,d")
3374         (match_operand:DI 1 "register_operand" " d,d,f"))]
3375   "TARGET_NEW"
3376   "@@
3377    lgr  %0,%1
3378    ldgr %0,%1
3379    lgdr %0,%1")
3380
3381 @end smallexample
3382
3383 to:
3384
3385 @smallexample
3386
3387 (define_insn "*movdi_combined"
3388   [(set (match_operand:DI 0 "register_operand" "=d,f,d")
3389         (match_operand:DI 1 "register_operand" " d,d,f"))]
3390   ""
3391   "@@
3392    lgr  %0,%1
3393    ldgr %0,%1
3394    lgdr %0,%1"
3395   [(set_attr "cpu_facility" "*,new,new")])
3396
3397 @end smallexample
3398
3399 with the @code{enabled} attribute defined like this:
3400
3401 @smallexample
3402
3403 (define_attr "cpu_facility" "standard,new" (const_string "standard"))
3404
3405 (define_attr "enabled" ""
3406   (cond [(eq_attr "cpu_facility" "standard") (const_int 1)
3407          (and (eq_attr "cpu_facility" "new")
3408               (ne (symbol_ref "TARGET_NEW") (const_int 0)))
3409          (const_int 1)]
3410         (const_int 0)))
3411
3412 @end smallexample
3413
3414 @end ifset
3415
3416 @ifset INTERNALS
3417 @node Define Constraints
3418 @subsection Defining Machine-Specific Constraints
3419 @cindex defining constraints
3420 @cindex constraints, defining
3421
3422 Machine-specific constraints fall into two categories: register and
3423 non-register constraints.  Within the latter category, constraints
3424 which allow subsets of all possible memory or address operands should
3425 be specially marked, to give @code{reload} more information.
3426
3427 Machine-specific constraints can be given names of arbitrary length,
3428 but they must be entirely composed of letters, digits, underscores
3429 (@samp{_}), and angle brackets (@samp{< >}).  Like C identifiers, they
3430 must begin with a letter or underscore. 
3431
3432 In order to avoid ambiguity in operand constraint strings, no
3433 constraint can have a name that begins with any other constraint's
3434 name.  For example, if @code{x} is defined as a constraint name,
3435 @code{xy} may not be, and vice versa.  As a consequence of this rule,
3436 no constraint may begin with one of the generic constraint letters:
3437 @samp{E F V X g i m n o p r s}.
3438
3439 Register constraints correspond directly to register classes.
3440 @xref{Register Classes}.  There is thus not much flexibility in their
3441 definitions.
3442
3443 @deffn {MD Expression} define_register_constraint name regclass docstring
3444 All three arguments are string constants.
3445 @var{name} is the name of the constraint, as it will appear in
3446 @code{match_operand} expressions.  If @var{name} is a multi-letter
3447 constraint its length shall be the same for all constraints starting
3448 with the same letter.  @var{regclass} can be either the
3449 name of the corresponding register class (@pxref{Register Classes}),
3450 or a C expression which evaluates to the appropriate register class.
3451 If it is an expression, it must have no side effects, and it cannot
3452 look at the operand.  The usual use of expressions is to map some
3453 register constraints to @code{NO_REGS} when the register class
3454 is not available on a given subarchitecture.
3455
3456 @var{docstring} is a sentence documenting the meaning of the
3457 constraint.  Docstrings are explained further below.
3458 @end deffn
3459
3460 Non-register constraints are more like predicates: the constraint
3461 definition gives a Boolean expression which indicates whether the
3462 constraint matches.
3463
3464 @deffn {MD Expression} define_constraint name docstring exp
3465 The @var{name} and @var{docstring} arguments are the same as for
3466 @code{define_register_constraint}, but note that the docstring comes
3467 immediately after the name for these expressions.  @var{exp} is an RTL
3468 expression, obeying the same rules as the RTL expressions in predicate
3469 definitions.  @xref{Defining Predicates}, for details.  If it
3470 evaluates true, the constraint matches; if it evaluates false, it
3471 doesn't. Constraint expressions should indicate which RTL codes they
3472 might match, just like predicate expressions.
3473
3474 @code{match_test} C expressions have access to the
3475 following variables:
3476
3477 @table @var
3478 @item op
3479 The RTL object defining the operand.
3480 @item mode
3481 The machine mode of @var{op}.
3482 @item ival
3483 @samp{INTVAL (@var{op})}, if @var{op} is a @code{const_int}.
3484 @item hval
3485 @samp{CONST_DOUBLE_HIGH (@var{op})}, if @var{op} is an integer
3486 @code{const_double}.
3487 @item lval
3488 @samp{CONST_DOUBLE_LOW (@var{op})}, if @var{op} is an integer
3489 @code{const_double}.
3490 @item rval
3491 @samp{CONST_DOUBLE_REAL_VALUE (@var{op})}, if @var{op} is a floating-point
3492 @code{const_double}.
3493 @end table
3494
3495 The @var{*val} variables should only be used once another piece of the
3496 expression has verified that @var{op} is the appropriate kind of RTL
3497 object.
3498 @end deffn
3499
3500 Most non-register constraints should be defined with
3501 @code{define_constraint}.  The remaining two definition expressions
3502 are only appropriate for constraints that should be handled specially
3503 by @code{reload} if they fail to match.
3504
3505 @deffn {MD Expression} define_memory_constraint name docstring exp
3506 Use this expression for constraints that match a subset of all memory
3507 operands: that is, @code{reload} can make them match by converting the
3508 operand to the form @samp{@w{(mem (reg @var{X}))}}, where @var{X} is a
3509 base register (from the register class specified by
3510 @code{BASE_REG_CLASS}, @pxref{Register Classes}).
3511
3512 For example, on the S/390, some instructions do not accept arbitrary
3513 memory references, but only those that do not make use of an index
3514 register.  The constraint letter @samp{Q} is defined to represent a
3515 memory address of this type.  If @samp{Q} is defined with
3516 @code{define_memory_constraint}, a @samp{Q} constraint can handle any
3517 memory operand, because @code{reload} knows it can simply copy the
3518 memory address into a base register if required.  This is analogous to
3519 the way an @samp{o} constraint can handle any memory operand.
3520
3521 The syntax and semantics are otherwise identical to
3522 @code{define_constraint}.
3523 @end deffn
3524
3525 @deffn {MD Expression} define_address_constraint name docstring exp
3526 Use this expression for constraints that match a subset of all address
3527 operands: that is, @code{reload} can make the constraint match by
3528 converting the operand to the form @samp{@w{(reg @var{X})}}, again
3529 with @var{X} a base register.
3530
3531 Constraints defined with @code{define_address_constraint} can only be
3532 used with the @code{address_operand} predicate, or machine-specific
3533 predicates that work the same way.  They are treated analogously to
3534 the generic @samp{p} constraint.
3535
3536 The syntax and semantics are otherwise identical to
3537 @code{define_constraint}.
3538 @end deffn
3539
3540 For historical reasons, names beginning with the letters @samp{G H}
3541 are reserved for constraints that match only @code{const_double}s, and
3542 names beginning with the letters @samp{I J K L M N O P} are reserved
3543 for constraints that match only @code{const_int}s.  This may change in
3544 the future.  For the time being, constraints with these names must be
3545 written in a stylized form, so that @code{genpreds} can tell you did
3546 it correctly:
3547
3548 @smallexample
3549 @group
3550 (define_constraint "[@var{GHIJKLMNOP}]@dots{}"
3551   "@var{doc}@dots{}"
3552   (and (match_code "const_int")  ; @r{@code{const_double} for G/H}
3553        @var{condition}@dots{}))            ; @r{usually a @code{match_test}}
3554 @end group
3555 @end smallexample
3556 @c the semicolons line up in the formatted manual
3557
3558 It is fine to use names beginning with other letters for constraints
3559 that match @code{const_double}s or @code{const_int}s.
3560
3561 Each docstring in a constraint definition should be one or more complete
3562 sentences, marked up in Texinfo format.  @emph{They are currently unused.}
3563 In the future they will be copied into the GCC manual, in @ref{Machine
3564 Constraints}, replacing the hand-maintained tables currently found in
3565 that section.  Also, in the future the compiler may use this to give
3566 more helpful diagnostics when poor choice of @code{asm} constraints
3567 causes a reload failure.
3568
3569 If you put the pseudo-Texinfo directive @samp{@@internal} at the
3570 beginning of a docstring, then (in the future) it will appear only in
3571 the internals manual's version of the machine-specific constraint tables.
3572 Use this for constraints that should not appear in @code{asm} statements.
3573
3574 @node C Constraint Interface
3575 @subsection Testing constraints from C
3576 @cindex testing constraints
3577 @cindex constraints, testing
3578
3579 It is occasionally useful to test a constraint from C code rather than
3580 implicitly via the constraint string in a @code{match_operand}.  The
3581 generated file @file{tm_p.h} declares a few interfaces for working
3582 with machine-specific constraints.  None of these interfaces work with
3583 the generic constraints described in @ref{Simple Constraints}.  This
3584 may change in the future.
3585
3586 @strong{Warning:} @file{tm_p.h} may declare other functions that
3587 operate on constraints, besides the ones documented here.  Do not use
3588 those functions from machine-dependent code.  They exist to implement
3589 the old constraint interface that machine-independent components of
3590 the compiler still expect.  They will change or disappear in the
3591 future.
3592
3593 Some valid constraint names are not valid C identifiers, so there is a
3594 mangling scheme for referring to them from C@.  Constraint names that
3595 do not contain angle brackets or underscores are left unchanged.
3596 Underscores are doubled, each @samp{<} is replaced with @samp{_l}, and
3597 each @samp{>} with @samp{_g}.  Here are some examples:
3598
3599 @c the @c's prevent double blank lines in the printed manual.
3600 @example
3601 @multitable {Original} {Mangled}
3602 @item @strong{Original} @tab @strong{Mangled}  @c
3603 @item @code{x}     @tab @code{x}       @c
3604 @item @code{P42x}  @tab @code{P42x}    @c
3605 @item @code{P4_x}  @tab @code{P4__x}   @c
3606 @item @code{P4>x}  @tab @code{P4_gx}   @c
3607 @item @code{P4>>}  @tab @code{P4_g_g}  @c
3608 @item @code{P4_g>} @tab @code{P4__g_g} @c
3609 @end multitable
3610 @end example
3611
3612 Throughout this section, the variable @var{c} is either a constraint
3613 in the abstract sense, or a constant from @code{enum constraint_num};
3614 the variable @var{m} is a mangled constraint name (usually as part of
3615 a larger identifier).
3616
3617 @deftp Enum constraint_num
3618 For each machine-specific constraint, there is a corresponding
3619 enumeration constant: @samp{CONSTRAINT_} plus the mangled name of the
3620 constraint.  Functions that take an @code{enum constraint_num} as an
3621 argument expect one of these constants.
3622
3623 Machine-independent constraints do not have associated constants.
3624 This may change in the future.
3625 @end deftp
3626
3627 @deftypefun {inline bool} satisfies_constraint_@var{m} (rtx @var{exp})
3628 For each machine-specific, non-register constraint @var{m}, there is
3629 one of these functions; it returns @code{true} if @var{exp} satisfies the
3630 constraint.  These functions are only visible if @file{rtl.h} was included
3631 before @file{tm_p.h}.
3632 @end deftypefun
3633
3634 @deftypefun bool constraint_satisfied_p (rtx @var{exp}, enum constraint_num @var{c})
3635 Like the @code{satisfies_constraint_@var{m}} functions, but the
3636 constraint to test is given as an argument, @var{c}.  If @var{c}
3637 specifies a register constraint, this function will always return
3638 @code{false}.
3639 @end deftypefun
3640
3641 @deftypefun {enum reg_class} regclass_for_constraint (enum constraint_num @var{c})
3642 Returns the register class associated with @var{c}.  If @var{c} is not
3643 a register constraint, or those registers are not available for the
3644 currently selected subtarget, returns @code{NO_REGS}.
3645 @end deftypefun
3646
3647 Here is an example use of @code{satisfies_constraint_@var{m}}.  In
3648 peephole optimizations (@pxref{Peephole Definitions}), operand
3649 constraint strings are ignored, so if there are relevant constraints,
3650 they must be tested in the C condition.  In the example, the
3651 optimization is applied if operand 2 does @emph{not} satisfy the
3652 @samp{K} constraint.  (This is a simplified version of a peephole
3653 definition from the i386 machine description.)
3654
3655 @smallexample
3656 (define_peephole2
3657   [(match_scratch:SI 3 "r")
3658    (set (match_operand:SI 0 "register_operand" "")
3659         (mult:SI (match_operand:SI 1 "memory_operand" "")
3660                  (match_operand:SI 2 "immediate_operand" "")))]
3661
3662   "!satisfies_constraint_K (operands[2])"
3663
3664   [(set (match_dup 3) (match_dup 1))
3665    (set (match_dup 0) (mult:SI (match_dup 3) (match_dup 2)))]
3666
3667   "")
3668 @end smallexample
3669
3670 @node Standard Names
3671 @section Standard Pattern Names For Generation
3672 @cindex standard pattern names
3673 @cindex pattern names
3674 @cindex names, pattern
3675
3676 Here is a table of the instruction names that are meaningful in the RTL
3677 generation pass of the compiler.  Giving one of these names to an
3678 instruction pattern tells the RTL generation pass that it can use the
3679 pattern to accomplish a certain task.
3680
3681 @table @asis
3682 @cindex @code{mov@var{m}} instruction pattern
3683 @item @samp{mov@var{m}}
3684 Here @var{m} stands for a two-letter machine mode name, in lowercase.
3685 This instruction pattern moves data with that machine mode from operand
3686 1 to operand 0.  For example, @samp{movsi} moves full-word data.
3687
3688 If operand 0 is a @code{subreg} with mode @var{m} of a register whose
3689 own mode is wider than @var{m}, the effect of this instruction is
3690 to store the specified value in the part of the register that corresponds
3691 to mode @var{m}.  Bits outside of @var{m}, but which are within the
3692 same target word as the @code{subreg} are undefined.  Bits which are
3693 outside the target word are left unchanged.
3694
3695 This class of patterns is special in several ways.  First of all, each
3696 of these names up to and including full word size @emph{must} be defined,
3697 because there is no other way to copy a datum from one place to another.
3698 If there are patterns accepting operands in larger modes,
3699 @samp{mov@var{m}} must be defined for integer modes of those sizes.
3700
3701 Second, these patterns are not used solely in the RTL generation pass.
3702 Even the reload pass can generate move insns to copy values from stack
3703 slots into temporary registers.  When it does so, one of the operands is
3704 a hard register and the other is an operand that can need to be reloaded
3705 into a register.
3706
3707 @findex force_reg
3708 Therefore, when given such a pair of operands, the pattern must generate
3709 RTL which needs no reloading and needs no temporary registers---no
3710 registers other than the operands.  For example, if you support the
3711 pattern with a @code{define_expand}, then in such a case the
3712 @code{define_expand} mustn't call @code{force_reg} or any other such
3713 function which might generate new pseudo registers.
3714
3715 This requirement exists even for subword modes on a RISC machine where
3716 fetching those modes from memory normally requires several insns and
3717 some temporary registers.
3718
3719 @findex change_address
3720 During reload a memory reference with an invalid address may be passed
3721 as an operand.  Such an address will be replaced with a valid address
3722 later in the reload pass.  In this case, nothing may be done with the
3723 address except to use it as it stands.  If it is copied, it will not be
3724 replaced with a valid address.  No attempt should be made to make such
3725 an address into a valid address and no routine (such as
3726 @code{change_address}) that will do so may be called.  Note that
3727 @code{general_operand} will fail when applied to such an address.
3728
3729 @findex reload_in_progress
3730 The global variable @code{reload_in_progress} (which must be explicitly
3731 declared if required) can be used to determine whether such special
3732 handling is required.
3733
3734 The variety of operands that have reloads depends on the rest of the
3735 machine description, but typically on a RISC machine these can only be
3736 pseudo registers that did not get hard registers, while on other
3737 machines explicit memory references will get optional reloads.
3738
3739 If a scratch register is required to move an object to or from memory,
3740 it can be allocated using @code{gen_reg_rtx} prior to life analysis.
3741
3742 If there are cases which need scratch registers during or after reload,
3743 you must provide an appropriate secondary_reload target hook.
3744
3745 @findex can_create_pseudo_p
3746 The macro @code{can_create_pseudo_p} can be used to determine if it
3747 is unsafe to create new pseudo registers.  If this variable is nonzero, then
3748 it is unsafe to call @code{gen_reg_rtx} to allocate a new pseudo.
3749
3750 The constraints on a @samp{mov@var{m}} must permit moving any hard
3751 register to any other hard register provided that
3752 @code{HARD_REGNO_MODE_OK} permits mode @var{m} in both registers and
3753 @code{REGISTER_MOVE_COST} applied to their classes returns a value of 2.
3754
3755 It is obligatory to support floating point @samp{mov@var{m}}
3756 instructions into and out of any registers that can hold fixed point
3757 values, because unions and structures (which have modes @code{SImode} or
3758 @code{DImode}) can be in those registers and they may have floating
3759 point members.
3760
3761 There may also be a need to support fixed point @samp{mov@var{m}}
3762 instructions in and out of floating point registers.  Unfortunately, I
3763 have forgotten why this was so, and I don't know whether it is still
3764 true.  If @code{HARD_REGNO_MODE_OK} rejects fixed point values in
3765 floating point registers, then the constraints of the fixed point
3766 @samp{mov@var{m}} instructions must be designed to avoid ever trying to
3767 reload into a floating point register.
3768
3769 @cindex @code{reload_in} instruction pattern
3770 @cindex @code{reload_out} instruction pattern
3771 @item @samp{reload_in@var{m}}
3772 @itemx @samp{reload_out@var{m}}
3773 These named patterns have been obsoleted by the target hook
3774 @code{secondary_reload}.
3775
3776 Like @samp{mov@var{m}}, but used when a scratch register is required to
3777 move between operand 0 and operand 1.  Operand 2 describes the scratch
3778 register.  See the discussion of the @code{SECONDARY_RELOAD_CLASS}
3779 macro in @pxref{Register Classes}.
3780
3781 There are special restrictions on the form of the @code{match_operand}s
3782 used in these patterns.  First, only the predicate for the reload
3783 operand is examined, i.e., @code{reload_in} examines operand 1, but not
3784 the predicates for operand 0 or 2.  Second, there may be only one
3785 alternative in the constraints.  Third, only a single register class
3786 letter may be used for the constraint; subsequent constraint letters
3787 are ignored.  As a special exception, an empty constraint string
3788 matches the @code{ALL_REGS} register class.  This may relieve ports
3789 of the burden of defining an @code{ALL_REGS} constraint letter just
3790 for these patterns.
3791
3792 @cindex @code{movstrict@var{m}} instruction pattern
3793 @item @samp{movstrict@var{m}}
3794 Like @samp{mov@var{m}} except that if operand 0 is a @code{subreg}
3795 with mode @var{m} of a register whose natural mode is wider,
3796 the @samp{movstrict@var{m}} instruction is guaranteed not to alter
3797 any of the register except the part which belongs to mode @var{m}.
3798
3799 @cindex @code{movmisalign@var{m}} instruction pattern
3800 @item @samp{movmisalign@var{m}}
3801 This variant of a move pattern is designed to load or store a value
3802 from a memory address that is not naturally aligned for its mode.
3803 For a store, the memory will be in operand 0; for a load, the memory
3804 will be in operand 1.  The other operand is guaranteed not to be a
3805 memory, so that it's easy to tell whether this is a load or store.
3806
3807 This pattern is used by the autovectorizer, and when expanding a
3808 @code{MISALIGNED_INDIRECT_REF} expression.
3809
3810 @cindex @code{load_multiple} instruction pattern
3811 @item @samp{load_multiple}
3812 Load several consecutive memory locations into consecutive registers.
3813 Operand 0 is the first of the consecutive registers, operand 1
3814 is the first memory location, and operand 2 is a constant: the
3815 number of consecutive registers.
3816
3817 Define this only if the target machine really has such an instruction;
3818 do not define this if the most efficient way of loading consecutive
3819 registers from memory is to do them one at a time.
3820
3821 On some machines, there are restrictions as to which consecutive
3822 registers can be stored into memory, such as particular starting or
3823 ending register numbers or only a range of valid counts.  For those
3824 machines, use a @code{define_expand} (@pxref{Expander Definitions})
3825 and make the pattern fail if the restrictions are not met.
3826