You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
201 lines
14 KiB
HTML
201 lines
14 KiB
HTML
4 years ago
|
<html lang="en">
|
||
|
|
<head>
|
||
|
|
<title>Simple Constraints - Using the GNU Compiler Collection (GCC)</title>
|
||
|
|
<meta http-equiv="Content-Type" content="text/html">
|
||
|
|
<meta name="description" content="Using the GNU Compiler Collection (GCC)">
|
||
|
|
<meta name="generator" content="makeinfo 4.13">
|
||
|
|
<link title="Top" rel="start" href="index.html#Top">
|
||
|
|
<link rel="up" href="Constraints.html#Constraints" title="Constraints">
|
||
|
|
<link rel="next" href="Multi_002dAlternative.html#Multi_002dAlternative" title="Multi-Alternative">
|
||
|
|
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
|
||
|
|
<!--
|
||
|
|
Copyright (C) 1988-2015 Free Software Foundation, Inc.
|
||
|
|
|
||
|
|
Permission is granted to copy, distribute and/or modify this document
|
||
|
|
under the terms of the GNU Free Documentation License, Version 1.3 or
|
||
|
|
any later version published by the Free Software Foundation; with the
|
||
|
|
Invariant Sections being ``Funding Free Software'', the Front-Cover
|
||
|
|
Texts being (a) (see below), and with the Back-Cover Texts being (b)
|
||
|
|
(see below). A copy of the license is included in the section entitled
|
||
|
|
``GNU Free Documentation License''.
|
||
|
|
|
||
|
|
(a) The FSF's Front-Cover Text is:
|
||
|
|
|
||
|
|
A GNU Manual
|
||
|
|
|
||
|
|
(b) The FSF's Back-Cover Text is:
|
||
|
|
|
||
|
|
You have freedom to copy and modify this GNU Manual, like GNU
|
||
|
|
software. Copies published by the Free Software Foundation raise
|
||
|
|
funds for GNU development.-->
|
||
|
|
<meta http-equiv="Content-Style-Type" content="text/css">
|
||
|
|
<style type="text/css"><!--
|
||
|
|
pre.display { font-family:inherit }
|
||
|
|
pre.format { font-family:inherit }
|
||
|
|
pre.smalldisplay { font-family:inherit; font-size:smaller }
|
||
|
|
pre.smallformat { font-family:inherit; font-size:smaller }
|
||
|
|
pre.smallexample { font-size:smaller }
|
||
|
|
pre.smalllisp { font-size:smaller }
|
||
|
|
span.sc { font-variant:small-caps }
|
||
|
|
span.roman { font-family:serif; font-weight:normal; }
|
||
|
|
span.sansserif { font-family:sans-serif; font-weight:normal; }
|
||
|
|
--></style>
|
||
|
|
</head>
|
||
|
|
<body>
|
||
|
|
<div class="node">
|
||
|
|
<a name="Simple-Constraints"></a>
|
||
|
|
<p>
|
||
|
|
Next: <a rel="next" accesskey="n" href="Multi_002dAlternative.html#Multi_002dAlternative">Multi-Alternative</a>,
|
||
|
|
Up: <a rel="up" accesskey="u" href="Constraints.html#Constraints">Constraints</a>
|
||
|
|
<hr>
|
||
|
|
</div>
|
||
|
|
|
||
|
|
<h5 class="subsubsection">6.43.3.1 Simple Constraints</h5>
|
||
|
|
|
||
|
|
<p><a name="index-simple-constraints-3436"></a>
|
||
|
|
The simplest kind of constraint is a string full of letters, each of
|
||
|
|
which describes one kind of operand that is permitted. Here are
|
||
|
|
the letters that are allowed:
|
||
|
|
|
||
|
|
<dl>
|
||
|
|
<dt>whitespace<dd>Whitespace characters are ignored and can be inserted at any position
|
||
|
|
except the first. This enables each alternative for different operands to
|
||
|
|
be visually aligned in the machine description even if they have different
|
||
|
|
number of constraints and modifiers.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bm_007d-in-constraint-3437"></a><a name="index-memory-references-in-constraints-3438"></a><br><dt>‘<samp><span class="samp">m</span></samp>’<dd>A memory operand is allowed, with any kind of address that the machine
|
||
|
|
supports in general.
|
||
|
|
Note that the letter used for the general memory constraint can be
|
||
|
|
re-defined by a back end using the <code>TARGET_MEM_CONSTRAINT</code> macro.
|
||
|
|
|
||
|
|
<p><a name="index-offsettable-address-3439"></a><a name="index-g_t_0040samp_007bo_007d-in-constraint-3440"></a><br><dt>‘<samp><span class="samp">o</span></samp>’<dd>A memory operand is allowed, but only if the address is
|
||
|
|
<dfn>offsettable</dfn>. This means that adding a small integer (actually,
|
||
|
|
the width in bytes of the operand, as determined by its machine mode)
|
||
|
|
may be added to the address and the result is also a valid memory
|
||
|
|
address.
|
||
|
|
|
||
|
|
<p><a name="index-autoincrement_002fdecrement-addressing-3441"></a>For example, an address which is constant is offsettable; so is an
|
||
|
|
address that is the sum of a register and a constant (as long as a
|
||
|
|
slightly larger constant is also within the range of address-offsets
|
||
|
|
supported by the machine); but an autoincrement or autodecrement
|
||
|
|
address is not offsettable. More complicated indirect/indexed
|
||
|
|
addresses may or may not be offsettable depending on the other
|
||
|
|
addressing modes that the machine supports.
|
||
|
|
|
||
|
|
<p>Note that in an output operand which can be matched by another
|
||
|
|
operand, the constraint letter ‘<samp><span class="samp">o</span></samp>’ is valid only when accompanied
|
||
|
|
by both ‘<samp><span class="samp"><</span></samp>’ (if the target machine has predecrement addressing)
|
||
|
|
and ‘<samp><span class="samp">></span></samp>’ (if the target machine has preincrement addressing).
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bV_007d-in-constraint-3442"></a><br><dt>‘<samp><span class="samp">V</span></samp>’<dd>A memory operand that is not offsettable. In other words, anything that
|
||
|
|
would fit the ‘<samp><span class="samp">m</span></samp>’ constraint but not the ‘<samp><span class="samp">o</span></samp>’ constraint.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007b_003c_007d-in-constraint-3443"></a><br><dt>‘<samp><span class="samp"><</span></samp>’<dd>A memory operand with autodecrement addressing (either predecrement or
|
||
|
|
postdecrement) is allowed. In inline <code>asm</code> this constraint is only
|
||
|
|
allowed if the operand is used exactly once in an instruction that can
|
||
|
|
handle the side-effects. Not using an operand with ‘<samp><span class="samp"><</span></samp>’ in constraint
|
||
|
|
string in the inline <code>asm</code> pattern at all or using it in multiple
|
||
|
|
instructions isn't valid, because the side-effects wouldn't be performed
|
||
|
|
or would be performed more than once. Furthermore, on some targets
|
||
|
|
the operand with ‘<samp><span class="samp"><</span></samp>’ in constraint string must be accompanied by
|
||
|
|
special instruction suffixes like <code>%U0</code> instruction suffix on PowerPC
|
||
|
|
or <code>%P0</code> on IA-64.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007b_003e_007d-in-constraint-3444"></a><br><dt>‘<samp><span class="samp">></span></samp>’<dd>A memory operand with autoincrement addressing (either preincrement or
|
||
|
|
postincrement) is allowed. In inline <code>asm</code> the same restrictions
|
||
|
|
as for ‘<samp><span class="samp"><</span></samp>’ apply.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007br_007d-in-constraint-3445"></a><a name="index-registers-in-constraints-3446"></a><br><dt>‘<samp><span class="samp">r</span></samp>’<dd>A register operand is allowed provided that it is in a general
|
||
|
|
register.
|
||
|
|
|
||
|
|
<p><a name="index-constants-in-constraints-3447"></a><a name="index-g_t_0040samp_007bi_007d-in-constraint-3448"></a><br><dt>‘<samp><span class="samp">i</span></samp>’<dd>An immediate integer operand (one with constant value) is allowed.
|
||
|
|
This includes symbolic constants whose values will be known only at
|
||
|
|
assembly time or later.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bn_007d-in-constraint-3449"></a><br><dt>‘<samp><span class="samp">n</span></samp>’<dd>An immediate integer operand with a known numeric value is allowed.
|
||
|
|
Many systems cannot support assembly-time constants for operands less
|
||
|
|
than a word wide. Constraints for these operands should use ‘<samp><span class="samp">n</span></samp>’
|
||
|
|
rather than ‘<samp><span class="samp">i</span></samp>’.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bI_007d-in-constraint-3450"></a><br><dt>‘<samp><span class="samp">I</span></samp>’, ‘<samp><span class="samp">J</span></samp>’, ‘<samp><span class="samp">K</span></samp>’, <small class="dots">...</small> ‘<samp><span class="samp">P</span></samp>’<dd>Other letters in the range ‘<samp><span class="samp">I</span></samp>’ through ‘<samp><span class="samp">P</span></samp>’ may be defined in
|
||
|
|
a machine-dependent fashion to permit immediate integer operands with
|
||
|
|
explicit integer values in specified ranges. For example, on the
|
||
|
|
68000, ‘<samp><span class="samp">I</span></samp>’ is defined to stand for the range of values 1 to 8.
|
||
|
|
This is the range permitted as a shift count in the shift
|
||
|
|
instructions.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bE_007d-in-constraint-3451"></a><br><dt>‘<samp><span class="samp">E</span></samp>’<dd>An immediate floating operand (expression code <code>const_double</code>) is
|
||
|
|
allowed, but only if the target floating point format is the same as
|
||
|
|
that of the host machine (on which the compiler is running).
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bF_007d-in-constraint-3452"></a><br><dt>‘<samp><span class="samp">F</span></samp>’<dd>An immediate floating operand (expression code <code>const_double</code> or
|
||
|
|
<code>const_vector</code>) is allowed.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bG_007d-in-constraint-3453"></a><a name="index-g_t_0040samp_007bH_007d-in-constraint-3454"></a><br><dt>‘<samp><span class="samp">G</span></samp>’, ‘<samp><span class="samp">H</span></samp>’<dd>‘<samp><span class="samp">G</span></samp>’ and ‘<samp><span class="samp">H</span></samp>’ may be defined in a machine-dependent fashion to
|
||
|
|
permit immediate floating operands in particular ranges of values.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bs_007d-in-constraint-3455"></a><br><dt>‘<samp><span class="samp">s</span></samp>’<dd>An immediate integer operand whose value is not an explicit integer is
|
||
|
|
allowed.
|
||
|
|
|
||
|
|
<p>This might appear strange; if an insn allows a constant operand with a
|
||
|
|
value not known at compile time, it certainly must allow any known
|
||
|
|
value. So why use ‘<samp><span class="samp">s</span></samp>’ instead of ‘<samp><span class="samp">i</span></samp>’? Sometimes it allows
|
||
|
|
better code to be generated.
|
||
|
|
|
||
|
|
<p>For example, on the 68000 in a fullword instruction it is possible to
|
||
|
|
use an immediate operand; but if the immediate value is between −128
|
||
|
|
and 127, better code results from loading the value into a register and
|
||
|
|
using the register. This is because the load into the register can be
|
||
|
|
done with a ‘<samp><span class="samp">moveq</span></samp>’ instruction. We arrange for this to happen
|
||
|
|
by defining the letter ‘<samp><span class="samp">K</span></samp>’ to mean “any integer outside the
|
||
|
|
range −128 to 127”, and then specifying ‘<samp><span class="samp">Ks</span></samp>’ in the operand
|
||
|
|
constraints.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bg_007d-in-constraint-3456"></a><br><dt>‘<samp><span class="samp">g</span></samp>’<dd>Any register, memory or immediate integer operand is allowed, except for
|
||
|
|
registers that are not general registers.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007bX_007d-in-constraint-3457"></a><br><dt>‘<samp><span class="samp">X</span></samp>’<dd>Any operand whatsoever is allowed.
|
||
|
|
|
||
|
|
<p><a name="index-g_t_0040samp_007b0_007d-in-constraint-3458"></a><a name="index-digits-in-constraint-3459"></a><br><dt>‘<samp><span class="samp">0</span></samp>’, ‘<samp><span class="samp">1</span></samp>’, ‘<samp><span class="samp">2</span></samp>’, <small class="dots">...</small> ‘<samp><span class="samp">9</span></samp>’<dd>An operand that matches the specified operand number is allowed. If a
|
||
|
|
digit is used together with letters within the same alternative, the
|
||
|
|
digit should come last.
|
||
|
|
|
||
|
|
<p>This number is allowed to be more than a single digit. If multiple
|
||
|
|
digits are encountered consecutively, they are interpreted as a single
|
||
|
|
decimal integer. There is scant chance for ambiguity, since to-date
|
||
|
|
it has never been desirable that ‘<samp><span class="samp">10</span></samp>’ be interpreted as matching
|
||
|
|
either operand 1 <em>or</em> operand 0. Should this be desired, one
|
||
|
|
can use multiple alternatives instead.
|
||
|
|
|
||
|
|
<p><a name="index-matching-constraint-3460"></a><a name="index-constraint_002c-matching-3461"></a>This is called a <dfn>matching constraint</dfn> and what it really means is
|
||
|
|
that the assembler has only a single operand that fills two roles
|
||
|
|
which <code>asm</code> distinguishes. For example, an add instruction uses
|
||
|
|
two input operands and an output operand, but on most CISC
|
||
|
|
machines an add instruction really has only two operands, one of them an
|
||
|
|
input-output operand:
|
||
|
|
|
||
|
|
<pre class="smallexample"> addl #35,r12
|
||
|
|
</pre>
|
||
|
|
<p>Matching constraints are used in these circumstances.
|
||
|
|
More precisely, the two operands that match must include one input-only
|
||
|
|
operand and one output-only operand. Moreover, the digit must be a
|
||
|
|
smaller number than the number of the operand that uses it in the
|
||
|
|
constraint.
|
||
|
|
|
||
|
|
<p><a name="index-load-address-instruction-3462"></a><a name="index-push-address-instruction-3463"></a><a name="index-address-constraints-3464"></a><a name="index-g_t_0040samp_007bp_007d-in-constraint-3465"></a><br><dt>‘<samp><span class="samp">p</span></samp>’<dd>An operand that is a valid memory address is allowed. This is
|
||
|
|
for “load address” and “push address” instructions.
|
||
|
|
|
||
|
|
<p><a name="index-address_005foperand-3466"></a>‘<samp><span class="samp">p</span></samp>’ in the constraint must be accompanied by <code>address_operand</code>
|
||
|
|
as the predicate in the <code>match_operand</code>. This predicate interprets
|
||
|
|
the mode specified in the <code>match_operand</code> as the mode of the memory
|
||
|
|
reference for which the address would be valid.
|
||
|
|
|
||
|
|
<p><a name="index-other-register-constraints-3467"></a><a name="index-extensible-constraints-3468"></a><br><dt><var>other-letters</var><dd>Other letters can be defined in machine-dependent fashion to stand for
|
||
|
|
particular classes of registers or other arbitrary operand types.
|
||
|
|
‘<samp><span class="samp">d</span></samp>’, ‘<samp><span class="samp">a</span></samp>’ and ‘<samp><span class="samp">f</span></samp>’ are defined on the 68000/68020 to stand
|
||
|
|
for data, address and floating point registers.
|
||
|
|
</dl>
|
||
|
|
|
||
|
|
</body></html>
|
||
|
|
|