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.
1460 lines
86 KiB
HTML
1460 lines
86 KiB
HTML
<html lang="en">
|
|
<head>
|
|
<title>Misc - GNU Compiler Collection (GCC) Internals</title>
|
|
<meta http-equiv="Content-Type" content="text/html">
|
|
<meta name="description" content="GNU Compiler Collection (GCC) Internals">
|
|
<meta name="generator" content="makeinfo 4.13">
|
|
<link title="Top" rel="start" href="index.html#Top">
|
|
<link rel="up" href="Target-Macros.html#Target-Macros" title="Target Macros">
|
|
<link rel="prev" href="Named-Address-Spaces.html#Named-Address-Spaces" title="Named Address Spaces">
|
|
<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="Misc"></a>
|
|
<p>
|
|
Previous: <a rel="previous" accesskey="p" href="Named-Address-Spaces.html#Named-Address-Spaces">Named Address Spaces</a>,
|
|
Up: <a rel="up" accesskey="u" href="Target-Macros.html#Target-Macros">Target Macros</a>
|
|
<hr>
|
|
</div>
|
|
|
|
<h3 class="section">17.30 Miscellaneous Parameters</h3>
|
|
|
|
<p><a name="index-parameters_002c-miscellaneous-4891"></a>
|
|
<!-- prevent bad page break with this line -->
|
|
Here are several miscellaneous parameters.
|
|
|
|
<div class="defun">
|
|
— Macro: <b>HAS_LONG_COND_BRANCH</b><var><a name="index-HAS_005fLONG_005fCOND_005fBRANCH-4892"></a></var><br>
|
|
<blockquote><p>Define this boolean macro to indicate whether or not your architecture
|
|
has conditional branches that can span all of memory. It is used in
|
|
conjunction with an optimization that partitions hot and cold basic
|
|
blocks into separate sections of the executable. If this macro is
|
|
set to false, gcc will convert any conditional branches that attempt
|
|
to cross between sections into unconditional branches or indirect jumps.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>HAS_LONG_UNCOND_BRANCH</b><var><a name="index-HAS_005fLONG_005fUNCOND_005fBRANCH-4893"></a></var><br>
|
|
<blockquote><p>Define this boolean macro to indicate whether or not your architecture
|
|
has unconditional branches that can span all of memory. It is used in
|
|
conjunction with an optimization that partitions hot and cold basic
|
|
blocks into separate sections of the executable. If this macro is
|
|
set to false, gcc will convert any unconditional branches that attempt
|
|
to cross between sections into indirect jumps.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>CASE_VECTOR_MODE</b><var><a name="index-CASE_005fVECTOR_005fMODE-4894"></a></var><br>
|
|
<blockquote><p>An alias for a machine mode name. This is the machine mode that
|
|
elements of a jump-table should have.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>CASE_VECTOR_SHORTEN_MODE</b> (<var>min_offset, max_offset, body</var>)<var><a name="index-CASE_005fVECTOR_005fSHORTEN_005fMODE-4895"></a></var><br>
|
|
<blockquote><p>Optional: return the preferred mode for an <code>addr_diff_vec</code>
|
|
when the minimum and maximum offset are known. If you define this,
|
|
it enables extra code in branch shortening to deal with <code>addr_diff_vec</code>.
|
|
To make this work, you also have to define <code>INSN_ALIGN</code> and
|
|
make the alignment for <code>addr_diff_vec</code> explicit.
|
|
The <var>body</var> argument is provided so that the offset_unsigned and scale
|
|
flags can be updated.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>CASE_VECTOR_PC_RELATIVE</b><var><a name="index-CASE_005fVECTOR_005fPC_005fRELATIVE-4896"></a></var><br>
|
|
<blockquote><p>Define this macro to be a C expression to indicate when jump-tables
|
|
should contain relative addresses. You need not define this macro if
|
|
jump-tables never contain relative addresses, or jump-tables should
|
|
contain relative addresses only when <samp><span class="option">-fPIC</span></samp> or <samp><span class="option">-fPIC</span></samp>
|
|
is in effect.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned int <b>TARGET_CASE_VALUES_THRESHOLD</b> (<var>void</var>)<var><a name="index-TARGET_005fCASE_005fVALUES_005fTHRESHOLD-4897"></a></var><br>
|
|
<blockquote><p>This function return the smallest number of different values for which it
|
|
is best to use a jump-table instead of a tree of conditional branches.
|
|
The default is four for machines with a <code>casesi</code> instruction and
|
|
five otherwise. This is best for most machines.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>WORD_REGISTER_OPERATIONS</b><var><a name="index-WORD_005fREGISTER_005fOPERATIONS-4898"></a></var><br>
|
|
<blockquote><p>Define this macro if operations between registers with integral mode
|
|
smaller than a word are always performed on the entire register.
|
|
Most RISC machines have this property and most CISC machines do not.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>LOAD_EXTEND_OP</b> (<var>mem_mode</var>)<var><a name="index-LOAD_005fEXTEND_005fOP-4899"></a></var><br>
|
|
<blockquote><p>Define this macro to be a C expression indicating when insns that read
|
|
memory in <var>mem_mode</var>, an integral mode narrower than a word, set the
|
|
bits outside of <var>mem_mode</var> to be either the sign-extension or the
|
|
zero-extension of the data read. Return <code>SIGN_EXTEND</code> for values
|
|
of <var>mem_mode</var> for which the
|
|
insn sign-extends, <code>ZERO_EXTEND</code> for which it zero-extends, and
|
|
<code>UNKNOWN</code> for other modes.
|
|
|
|
<p>This macro is not called with <var>mem_mode</var> non-integral or with a width
|
|
greater than or equal to <code>BITS_PER_WORD</code>, so you may return any
|
|
value in this case. Do not define this macro if it would always return
|
|
<code>UNKNOWN</code>. On machines where this macro is defined, you will normally
|
|
define it as the constant <code>SIGN_EXTEND</code> or <code>ZERO_EXTEND</code>.
|
|
|
|
<p>You may return a non-<code>UNKNOWN</code> value even if for some hard registers
|
|
the sign extension is not performed, if for the <code>REGNO_REG_CLASS</code>
|
|
of these hard registers <code>CANNOT_CHANGE_MODE_CLASS</code> returns nonzero
|
|
when the <var>from</var> mode is <var>mem_mode</var> and the <var>to</var> mode is any
|
|
integral mode larger than this but not larger than <code>word_mode</code>.
|
|
|
|
<p>You must return <code>UNKNOWN</code> if for some hard registers that allow this
|
|
mode, <code>CANNOT_CHANGE_MODE_CLASS</code> says that they cannot change to
|
|
<code>word_mode</code>, but that they can change to another integral mode that
|
|
is larger then <var>mem_mode</var> but still smaller than <code>word_mode</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>SHORT_IMMEDIATES_SIGN_EXTEND</b><var><a name="index-SHORT_005fIMMEDIATES_005fSIGN_005fEXTEND-4900"></a></var><br>
|
|
<blockquote><p>Define this macro if loading short immediate values into registers sign
|
|
extends.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned int <b>TARGET_MIN_DIVISIONS_FOR_RECIP_MUL</b> (<var>machine_mode mode</var>)<var><a name="index-TARGET_005fMIN_005fDIVISIONS_005fFOR_005fRECIP_005fMUL-4901"></a></var><br>
|
|
<blockquote><p>When <samp><span class="option">-ffast-math</span></samp> is in effect, GCC tries to optimize
|
|
divisions by the same divisor, by turning them into multiplications by
|
|
the reciprocal. This target hook specifies the minimum number of divisions
|
|
that should be there for GCC to perform the optimization for a variable
|
|
of mode <var>mode</var>. The default implementation returns 3 if the machine
|
|
has an instruction for the division, and 2 if it does not.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MOVE_MAX</b><var><a name="index-MOVE_005fMAX-4902"></a></var><br>
|
|
<blockquote><p>The maximum number of bytes that a single instruction can move quickly
|
|
between memory and registers or between two memory locations.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MAX_MOVE_MAX</b><var><a name="index-MAX_005fMOVE_005fMAX-4903"></a></var><br>
|
|
<blockquote><p>The maximum number of bytes that a single instruction can move quickly
|
|
between memory and registers or between two memory locations. If this
|
|
is undefined, the default is <code>MOVE_MAX</code>. Otherwise, it is the
|
|
constant value that is the largest value that <code>MOVE_MAX</code> can have
|
|
at run-time.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>SHIFT_COUNT_TRUNCATED</b><var><a name="index-SHIFT_005fCOUNT_005fTRUNCATED-4904"></a></var><br>
|
|
<blockquote><p>A C expression that is nonzero if on this machine the number of bits
|
|
actually used for the count of a shift operation is equal to the number
|
|
of bits needed to represent the size of the object being shifted. When
|
|
this macro is nonzero, the compiler will assume that it is safe to omit
|
|
a sign-extend, zero-extend, and certain bitwise `and' instructions that
|
|
truncates the count of a shift operation. On machines that have
|
|
instructions that act on bit-fields at variable positions, which may
|
|
include `bit test' instructions, a nonzero <code>SHIFT_COUNT_TRUNCATED</code>
|
|
also enables deletion of truncations of the values that serve as
|
|
arguments to bit-field instructions.
|
|
|
|
<p>If both types of instructions truncate the count (for shifts) and
|
|
position (for bit-field operations), or if no variable-position bit-field
|
|
instructions exist, you should define this macro.
|
|
|
|
<p>However, on some machines, such as the 80386 and the 680x0, truncation
|
|
only applies to shift operations and not the (real or pretended)
|
|
bit-field operations. Define <code>SHIFT_COUNT_TRUNCATED</code> to be zero on
|
|
such machines. Instead, add patterns to the <samp><span class="file">md</span></samp> file that include
|
|
the implied truncation of the shift instructions.
|
|
|
|
<p>You need not define this macro if it would always have the value of zero.
|
|
</p></blockquote></div>
|
|
|
|
<p><a name="TARGET_005fSHIFT_005fTRUNCATION_005fMASK"></a>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned HOST_WIDE_INT <b>TARGET_SHIFT_TRUNCATION_MASK</b> (<var>machine_mode mode</var>)<var><a name="index-TARGET_005fSHIFT_005fTRUNCATION_005fMASK-4905"></a></var><br>
|
|
<blockquote><p>This function describes how the standard shift patterns for <var>mode</var>
|
|
deal with shifts by negative amounts or by more than the width of the mode.
|
|
See <a href="shift-patterns.html#shift-patterns">shift patterns</a>.
|
|
|
|
<p>On many machines, the shift patterns will apply a mask <var>m</var> to the
|
|
shift count, meaning that a fixed-width shift of <var>x</var> by <var>y</var> is
|
|
equivalent to an arbitrary-width shift of <var>x</var> by <var>y & m</var>. If
|
|
this is true for mode <var>mode</var>, the function should return <var>m</var>,
|
|
otherwise it should return 0. A return value of 0 indicates that no
|
|
particular behavior is guaranteed.
|
|
|
|
<p>Note that, unlike <code>SHIFT_COUNT_TRUNCATED</code>, this function does
|
|
<em>not</em> apply to general shift rtxes; it applies only to instructions
|
|
that are generated by the named shift patterns.
|
|
|
|
<p>The default implementation of this function returns
|
|
<code>GET_MODE_BITSIZE (</code><var>mode</var><code>) - 1</code> if <code>SHIFT_COUNT_TRUNCATED</code>
|
|
and 0 otherwise. This definition is always safe, but if
|
|
<code>SHIFT_COUNT_TRUNCATED</code> is false, and some shift patterns
|
|
nevertheless truncate the shift count, you may get better code
|
|
by overriding it.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TRULY_NOOP_TRUNCATION</b> (<var>outprec, inprec</var>)<var><a name="index-TRULY_005fNOOP_005fTRUNCATION-4906"></a></var><br>
|
|
<blockquote><p>A C expression which is nonzero if on this machine it is safe to
|
|
“convert” an integer of <var>inprec</var> bits to one of <var>outprec</var>
|
|
bits (where <var>outprec</var> is smaller than <var>inprec</var>) by merely
|
|
operating on it as if it had only <var>outprec</var> bits.
|
|
|
|
<p>On many machines, this expression can be 1.
|
|
|
|
<!-- rearranged this, removed the phrase "it is reported that". this was -->
|
|
<!-- to fix an overfull hbox. -mew 10feb93 -->
|
|
<p>When <code>TRULY_NOOP_TRUNCATION</code> returns 1 for a pair of sizes for
|
|
modes for which <code>MODES_TIEABLE_P</code> is 0, suboptimal code can result.
|
|
If this is the case, making <code>TRULY_NOOP_TRUNCATION</code> return 0 in
|
|
such cases may improve things.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: int <b>TARGET_MODE_REP_EXTENDED</b> (<var>machine_mode mode, machine_mode rep_mode</var>)<var><a name="index-TARGET_005fMODE_005fREP_005fEXTENDED-4907"></a></var><br>
|
|
<blockquote><p>The representation of an integral mode can be such that the values
|
|
are always extended to a wider integral mode. Return
|
|
<code>SIGN_EXTEND</code> if values of <var>mode</var> are represented in
|
|
sign-extended form to <var>rep_mode</var>. Return <code>UNKNOWN</code>
|
|
otherwise. (Currently, none of the targets use zero-extended
|
|
representation this way so unlike <code>LOAD_EXTEND_OP</code>,
|
|
<code>TARGET_MODE_REP_EXTENDED</code> is expected to return either
|
|
<code>SIGN_EXTEND</code> or <code>UNKNOWN</code>. Also no target extends
|
|
<var>mode</var> to <var>rep_mode</var> so that <var>rep_mode</var> is not the next
|
|
widest integral mode and currently we take advantage of this fact.)
|
|
|
|
<p>Similarly to <code>LOAD_EXTEND_OP</code> you may return a non-<code>UNKNOWN</code>
|
|
value even if the extension is not performed on certain hard registers
|
|
as long as for the <code>REGNO_REG_CLASS</code> of these hard registers
|
|
<code>CANNOT_CHANGE_MODE_CLASS</code> returns nonzero.
|
|
|
|
<p>Note that <code>TARGET_MODE_REP_EXTENDED</code> and <code>LOAD_EXTEND_OP</code>
|
|
describe two related properties. If you define
|
|
<code>TARGET_MODE_REP_EXTENDED (mode, word_mode)</code> you probably also want
|
|
to define <code>LOAD_EXTEND_OP (mode)</code> to return the same type of
|
|
extension.
|
|
|
|
<p>In order to enforce the representation of <code>mode</code>,
|
|
<code>TRULY_NOOP_TRUNCATION</code> should return false when truncating to
|
|
<code>mode</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>STORE_FLAG_VALUE</b><var><a name="index-STORE_005fFLAG_005fVALUE-4908"></a></var><br>
|
|
<blockquote><p>A C expression describing the value returned by a comparison operator
|
|
with an integral mode and stored by a store-flag instruction
|
|
(‘<samp><span class="samp">cstore</span><var>mode</var><span class="samp">4</span></samp>’) when the condition is true. This description must
|
|
apply to <em>all</em> the ‘<samp><span class="samp">cstore</span><var>mode</var><span class="samp">4</span></samp>’ patterns and all the
|
|
comparison operators whose results have a <code>MODE_INT</code> mode.
|
|
|
|
<p>A value of 1 or −1 means that the instruction implementing the
|
|
comparison operator returns exactly 1 or −1 when the comparison is true
|
|
and 0 when the comparison is false. Otherwise, the value indicates
|
|
which bits of the result are guaranteed to be 1 when the comparison is
|
|
true. This value is interpreted in the mode of the comparison
|
|
operation, which is given by the mode of the first operand in the
|
|
‘<samp><span class="samp">cstore</span><var>mode</var><span class="samp">4</span></samp>’ pattern. Either the low bit or the sign bit of
|
|
<code>STORE_FLAG_VALUE</code> be on. Presently, only those bits are used by
|
|
the compiler.
|
|
|
|
<p>If <code>STORE_FLAG_VALUE</code> is neither 1 or −1, the compiler will
|
|
generate code that depends only on the specified bits. It can also
|
|
replace comparison operators with equivalent operations if they cause
|
|
the required bits to be set, even if the remaining bits are undefined.
|
|
For example, on a machine whose comparison operators return an
|
|
<code>SImode</code> value and where <code>STORE_FLAG_VALUE</code> is defined as
|
|
‘<samp><span class="samp">0x80000000</span></samp>’, saying that just the sign bit is relevant, the
|
|
expression
|
|
|
|
<pre class="smallexample"> (ne:SI (and:SI <var>x</var> (const_int <var>power-of-2</var>)) (const_int 0))
|
|
</pre>
|
|
<p class="noindent">can be converted to
|
|
|
|
<pre class="smallexample"> (ashift:SI <var>x</var> (const_int <var>n</var>))
|
|
</pre>
|
|
<p class="noindent">where <var>n</var> is the appropriate shift count to move the bit being
|
|
tested into the sign bit.
|
|
|
|
<p>There is no way to describe a machine that always sets the low-order bit
|
|
for a true value, but does not guarantee the value of any other bits,
|
|
but we do not know of any machine that has such an instruction. If you
|
|
are trying to port GCC to such a machine, include an instruction to
|
|
perform a logical-and of the result with 1 in the pattern for the
|
|
comparison operators and let us know at <a href="mailto:gcc@gcc.gnu.org">gcc@gcc.gnu.org</a>.
|
|
|
|
<p>Often, a machine will have multiple instructions that obtain a value
|
|
from a comparison (or the condition codes). Here are rules to guide the
|
|
choice of value for <code>STORE_FLAG_VALUE</code>, and hence the instructions
|
|
to be used:
|
|
|
|
<ul>
|
|
<li>Use the shortest sequence that yields a valid definition for
|
|
<code>STORE_FLAG_VALUE</code>. It is more efficient for the compiler to
|
|
“normalize” the value (convert it to, e.g., 1 or 0) than for the
|
|
comparison operators to do so because there may be opportunities to
|
|
combine the normalization with other operations.
|
|
|
|
<li>For equal-length sequences, use a value of 1 or −1, with −1 being
|
|
slightly preferred on machines with expensive jumps and 1 preferred on
|
|
other machines.
|
|
|
|
<li>As a second choice, choose a value of ‘<samp><span class="samp">0x80000001</span></samp>’ if instructions
|
|
exist that set both the sign and low-order bits but do not define the
|
|
others.
|
|
|
|
<li>Otherwise, use a value of ‘<samp><span class="samp">0x80000000</span></samp>’.
|
|
</ul>
|
|
|
|
<p>Many machines can produce both the value chosen for
|
|
<code>STORE_FLAG_VALUE</code> and its negation in the same number of
|
|
instructions. On those machines, you should also define a pattern for
|
|
those cases, e.g., one matching
|
|
|
|
<pre class="smallexample"> (set <var>A</var> (neg:<var>m</var> (ne:<var>m</var> <var>B</var> <var>C</var>)))
|
|
</pre>
|
|
<p>Some machines can also perform <code>and</code> or <code>plus</code> operations on
|
|
condition code values with less instructions than the corresponding
|
|
‘<samp><span class="samp">cstore</span><var>mode</var><span class="samp">4</span></samp>’ insn followed by <code>and</code> or <code>plus</code>. On those
|
|
machines, define the appropriate patterns. Use the names <code>incscc</code>
|
|
and <code>decscc</code>, respectively, for the patterns which perform
|
|
<code>plus</code> or <code>minus</code> operations on condition code values. See
|
|
<samp><span class="file">rs6000.md</span></samp> for some examples. The GNU Superoptimizer can be used to
|
|
find such instruction sequences on other machines.
|
|
|
|
<p>If this macro is not defined, the default value, 1, is used. You need
|
|
not define <code>STORE_FLAG_VALUE</code> if the machine has no store-flag
|
|
instructions, or if the value generated by these instructions is 1.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>FLOAT_STORE_FLAG_VALUE</b> (<var>mode</var>)<var><a name="index-FLOAT_005fSTORE_005fFLAG_005fVALUE-4909"></a></var><br>
|
|
<blockquote><p>A C expression that gives a nonzero <code>REAL_VALUE_TYPE</code> value that is
|
|
returned when comparison operators with floating-point results are true.
|
|
Define this macro on machines that have comparison operations that return
|
|
floating-point values. If there are no such operations, do not define
|
|
this macro.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>VECTOR_STORE_FLAG_VALUE</b> (<var>mode</var>)<var><a name="index-VECTOR_005fSTORE_005fFLAG_005fVALUE-4910"></a></var><br>
|
|
<blockquote><p>A C expression that gives a rtx representing the nonzero true element
|
|
for vector comparisons. The returned rtx should be valid for the inner
|
|
mode of <var>mode</var> which is guaranteed to be a vector mode. Define
|
|
this macro on machines that have vector comparison operations that
|
|
return a vector result. If there are no such operations, do not define
|
|
this macro. Typically, this macro is defined as <code>const1_rtx</code> or
|
|
<code>constm1_rtx</code>. This macro may return <code>NULL_RTX</code> to prevent
|
|
the compiler optimizing such vector comparison operations for the
|
|
given mode.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>CLZ_DEFINED_VALUE_AT_ZERO</b> (<var>mode, value</var>)<var><a name="index-CLZ_005fDEFINED_005fVALUE_005fAT_005fZERO-4911"></a></var><br>
|
|
— Macro: <b>CTZ_DEFINED_VALUE_AT_ZERO</b> (<var>mode, value</var>)<var><a name="index-CTZ_005fDEFINED_005fVALUE_005fAT_005fZERO-4912"></a></var><br>
|
|
<blockquote><p>A C expression that indicates whether the architecture defines a value
|
|
for <code>clz</code> or <code>ctz</code> with a zero operand.
|
|
A result of <code>0</code> indicates the value is undefined.
|
|
If the value is defined for only the RTL expression, the macro should
|
|
evaluate to <code>1</code>; if the value applies also to the corresponding optab
|
|
entry (which is normally the case if it expands directly into
|
|
the corresponding RTL), then the macro should evaluate to <code>2</code>.
|
|
In the cases where the value is defined, <var>value</var> should be set to
|
|
this value.
|
|
|
|
<p>If this macro is not defined, the value of <code>clz</code> or
|
|
<code>ctz</code> at zero is assumed to be undefined.
|
|
|
|
<p>This macro must be defined if the target's expansion for <code>ffs</code>
|
|
relies on a particular value to get correct results. Otherwise it
|
|
is not necessary, though it may be used to optimize some corner cases, and
|
|
to provide a default expansion for the <code>ffs</code> optab.
|
|
|
|
<p>Note that regardless of this macro the “definedness” of <code>clz</code>
|
|
and <code>ctz</code> at zero do <em>not</em> extend to the builtin functions
|
|
visible to the user. Thus one may be free to adjust the value at will
|
|
to match the target expansion of these operations without fear of
|
|
breaking the API.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>Pmode</b><var><a name="index-Pmode-4913"></a></var><br>
|
|
<blockquote><p>An alias for the machine mode for pointers. On most machines, define
|
|
this to be the integer mode corresponding to the width of a hardware
|
|
pointer; <code>SImode</code> on 32-bit machine or <code>DImode</code> on 64-bit machines.
|
|
On some machines you must define this to be one of the partial integer
|
|
modes, such as <code>PSImode</code>.
|
|
|
|
<p>The width of <code>Pmode</code> must be at least as large as the value of
|
|
<code>POINTER_SIZE</code>. If it is not equal, you must define the macro
|
|
<code>POINTERS_EXTEND_UNSIGNED</code> to specify how pointers are extended
|
|
to <code>Pmode</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>FUNCTION_MODE</b><var><a name="index-FUNCTION_005fMODE-4914"></a></var><br>
|
|
<blockquote><p>An alias for the machine mode used for memory references to functions
|
|
being called, in <code>call</code> RTL expressions. On most CISC machines,
|
|
where an instruction can begin at any byte address, this should be
|
|
<code>QImode</code>. On most RISC machines, where all instructions have fixed
|
|
size and alignment, this should be a mode with the same size and alignment
|
|
as the machine instruction words - typically <code>SImode</code> or <code>HImode</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>STDC_0_IN_SYSTEM_HEADERS</b><var><a name="index-STDC_005f0_005fIN_005fSYSTEM_005fHEADERS-4915"></a></var><br>
|
|
<blockquote><p>In normal operation, the preprocessor expands <code>__STDC__</code> to the
|
|
constant 1, to signify that GCC conforms to ISO Standard C. On some
|
|
hosts, like Solaris, the system compiler uses a different convention,
|
|
where <code>__STDC__</code> is normally 0, but is 1 if the user specifies
|
|
strict conformance to the C Standard.
|
|
|
|
<p>Defining <code>STDC_0_IN_SYSTEM_HEADERS</code> makes GNU CPP follows the host
|
|
convention when processing system header files, but when processing user
|
|
files <code>__STDC__</code> will always expand to 1.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— C Target Hook: const char * <b>TARGET_C_PREINCLUDE</b> (<var>void</var>)<var><a name="index-TARGET_005fC_005fPREINCLUDE-4916"></a></var><br>
|
|
<blockquote><p>Define this hook to return the name of a header file to be included at the start of all compilations, as if it had been included with <code>#include <</code><var>file</var><code>></code>. If this hook returns <code>NULL</code>, or is not defined, or the header is not found, or if the user specifies <samp><span class="option">-ffreestanding</span></samp> or <samp><span class="option">-nostdinc</span></samp>, no header is included.
|
|
|
|
<p>This hook can be used together with a header provided by the system C library to implement ISO C requirements for certain macros to be predefined that describe properties of the whole implementation rather than just the compiler.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— C Target Hook: bool <b>TARGET_CXX_IMPLICIT_EXTERN_C</b> (<var>const char*</var>)<var><a name="index-TARGET_005fCXX_005fIMPLICIT_005fEXTERN_005fC-4917"></a></var><br>
|
|
<blockquote><p>Define this hook to add target-specific C++ implicit extern C functions. If this function returns true for the name of a file-scope function, that function implicitly gets extern "C" linkage rather than whatever language linkage the declaration would normally have. An example of such function is WinMain on Win32 targets.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>NO_IMPLICIT_EXTERN_C</b><var><a name="index-NO_005fIMPLICIT_005fEXTERN_005fC-4918"></a></var><br>
|
|
<blockquote><p>Define this macro if the system header files support C++ as well as C.
|
|
This macro inhibits the usual method of using system header files in
|
|
C++, which is to pretend that the file's contents are enclosed in
|
|
‘<samp><span class="samp">extern "C" {...}</span></samp>’.
|
|
</p></blockquote></div>
|
|
|
|
<p><a name="index-g_t_0023pragma-4919"></a><a name="index-pragma-4920"></a>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>REGISTER_TARGET_PRAGMAS</b> ()<var><a name="index-REGISTER_005fTARGET_005fPRAGMAS-4921"></a></var><br>
|
|
<blockquote><p>Define this macro if you want to implement any target-specific pragmas.
|
|
If defined, it is a C expression which makes a series of calls to
|
|
<code>c_register_pragma</code> or <code>c_register_pragma_with_expansion</code>
|
|
for each pragma. The macro may also do any
|
|
setup required for the pragmas.
|
|
|
|
<p>The primary reason to define this macro is to provide compatibility with
|
|
other compilers for the same target. In general, we discourage
|
|
definition of target-specific pragmas for GCC.
|
|
|
|
<p>If the pragma can be implemented by attributes then you should consider
|
|
defining the target hook ‘<samp><span class="samp">TARGET_INSERT_ATTRIBUTES</span></samp>’ as well.
|
|
|
|
<p>Preprocessor macros that appear on pragma lines are not expanded. All
|
|
‘<samp><span class="samp">#pragma</span></samp>’ directives that do not match any registered pragma are
|
|
silently ignored, unless the user specifies <samp><span class="option">-Wunknown-pragmas</span></samp>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Function: void <b>c_register_pragma</b> (<var>const char *space, const char *name, void </var>(<var>*callback</var>) (<var>struct cpp_reader *</var>))<var><a name="index-c_005fregister_005fpragma-4922"></a></var><br>
|
|
— Function: void <b>c_register_pragma_with_expansion</b> (<var>const char *space, const char *name, void </var>(<var>*callback</var>) (<var>struct cpp_reader *</var>))<var><a name="index-c_005fregister_005fpragma_005fwith_005fexpansion-4923"></a></var><br>
|
|
<blockquote>
|
|
<p>Each call to <code>c_register_pragma</code> or
|
|
<code>c_register_pragma_with_expansion</code> establishes one pragma. The
|
|
<var>callback</var> routine will be called when the preprocessor encounters a
|
|
pragma of the form
|
|
|
|
<pre class="smallexample"> #pragma [<var>space</var>] <var>name</var> ...
|
|
</pre>
|
|
<p><var>space</var> is the case-sensitive namespace of the pragma, or
|
|
<code>NULL</code> to put the pragma in the global namespace. The callback
|
|
routine receives <var>pfile</var> as its first argument, which can be passed
|
|
on to cpplib's functions if necessary. You can lex tokens after the
|
|
<var>name</var> by calling <code>pragma_lex</code>. Tokens that are not read by the
|
|
callback will be silently ignored. The end of the line is indicated by
|
|
a token of type <code>CPP_EOF</code>. Macro expansion occurs on the
|
|
arguments of pragmas registered with
|
|
<code>c_register_pragma_with_expansion</code> but not on the arguments of
|
|
pragmas registered with <code>c_register_pragma</code>.
|
|
|
|
<p>Note that the use of <code>pragma_lex</code> is specific to the C and C++
|
|
compilers. It will not work in the Java or Fortran compilers, or any
|
|
other language compilers for that matter. Thus if <code>pragma_lex</code> is going
|
|
to be called from target-specific code, it must only be done so when
|
|
building the C and C++ compilers. This can be done by defining the
|
|
variables <code>c_target_objs</code> and <code>cxx_target_objs</code> in the
|
|
target entry in the <samp><span class="file">config.gcc</span></samp> file. These variables should name
|
|
the target-specific, language-specific object file which contains the
|
|
code that uses <code>pragma_lex</code>. Note it will also be necessary to add a
|
|
rule to the makefile fragment pointed to by <code>tmake_file</code> that shows
|
|
how to build this object file.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>HANDLE_PRAGMA_PACK_WITH_EXPANSION</b><var><a name="index-HANDLE_005fPRAGMA_005fPACK_005fWITH_005fEXPANSION-4924"></a></var><br>
|
|
<blockquote><p>Define this macro if macros should be expanded in the
|
|
arguments of ‘<samp><span class="samp">#pragma pack</span></samp>’.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_DEFAULT_PACK_STRUCT</b><var><a name="index-TARGET_005fDEFAULT_005fPACK_005fSTRUCT-4925"></a></var><br>
|
|
<blockquote><p>If your target requires a structure packing default other than 0 (meaning
|
|
the machine default), define this macro to the necessary value (in bytes).
|
|
This must be a value that would also be valid to use with
|
|
‘<samp><span class="samp">#pragma pack()</span></samp>’ (that is, a small power of two).
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>DOLLARS_IN_IDENTIFIERS</b><var><a name="index-DOLLARS_005fIN_005fIDENTIFIERS-4926"></a></var><br>
|
|
<blockquote><p>Define this macro to control use of the character ‘<samp><span class="samp">$</span></samp>’ in
|
|
identifier names for the C family of languages. 0 means ‘<samp><span class="samp">$</span></samp>’ is
|
|
not allowed by default; 1 means it is allowed. 1 is the default;
|
|
there is no need to define this macro in that case.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>INSN_SETS_ARE_DELAYED</b> (<var>insn</var>)<var><a name="index-INSN_005fSETS_005fARE_005fDELAYED-4927"></a></var><br>
|
|
<blockquote><p>Define this macro as a C expression that is nonzero if it is safe for the
|
|
delay slot scheduler to place instructions in the delay slot of <var>insn</var>,
|
|
even if they appear to use a resource set or clobbered in <var>insn</var>.
|
|
<var>insn</var> is always a <code>jump_insn</code> or an <code>insn</code>; GCC knows that
|
|
every <code>call_insn</code> has this behavior. On machines where some <code>insn</code>
|
|
or <code>jump_insn</code> is really a function call and hence has this behavior,
|
|
you should define this macro.
|
|
|
|
<p>You need not define this macro if it would always return zero.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>INSN_REFERENCES_ARE_DELAYED</b> (<var>insn</var>)<var><a name="index-INSN_005fREFERENCES_005fARE_005fDELAYED-4928"></a></var><br>
|
|
<blockquote><p>Define this macro as a C expression that is nonzero if it is safe for the
|
|
delay slot scheduler to place instructions in the delay slot of <var>insn</var>,
|
|
even if they appear to set or clobber a resource referenced in <var>insn</var>.
|
|
<var>insn</var> is always a <code>jump_insn</code> or an <code>insn</code>. On machines where
|
|
some <code>insn</code> or <code>jump_insn</code> is really a function call and its operands
|
|
are registers whose use is actually in the subroutine it calls, you should
|
|
define this macro. Doing so allows the delay slot scheduler to move
|
|
instructions which copy arguments into the argument registers into the delay
|
|
slot of <var>insn</var>.
|
|
|
|
<p>You need not define this macro if it would always return zero.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MULTIPLE_SYMBOL_SPACES</b><var><a name="index-MULTIPLE_005fSYMBOL_005fSPACES-4929"></a></var><br>
|
|
<blockquote><p>Define this macro as a C expression that is nonzero if, in some cases,
|
|
global symbols from one translation unit may not be bound to undefined
|
|
symbols in another translation unit without user intervention. For
|
|
instance, under Microsoft Windows symbols must be explicitly imported
|
|
from shared libraries (DLLs).
|
|
|
|
<p>You need not define this macro if it would always evaluate to zero.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_MD_ASM_CLOBBERS</b> (<var>tree outputs, tree inputs, tree clobbers</var>)<var><a name="index-TARGET_005fMD_005fASM_005fCLOBBERS-4930"></a></var><br>
|
|
<blockquote><p>This target hook should add to <var>clobbers</var> <code>STRING_CST</code> trees for
|
|
any hard regs the port wishes to automatically clobber for an asm.
|
|
It should return the result of the last <code>tree_cons</code> used to add a
|
|
clobber. The <var>outputs</var>, <var>inputs</var> and <var>clobber</var> lists are the
|
|
corresponding parameters to the asm and may be inspected to avoid
|
|
clobbering a register that is an input or output of the asm. You can use
|
|
<code>tree_overlaps_hard_reg_set</code>, declared in <samp><span class="file">tree.h</span></samp>, to test
|
|
for overlap with regards to asm-declared registers.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MATH_LIBRARY</b><var><a name="index-MATH_005fLIBRARY-4931"></a></var><br>
|
|
<blockquote><p>Define this macro as a C string constant for the linker argument to link
|
|
in the system math library, minus the initial ‘<samp><span class="samp">"-l"</span></samp>’, or
|
|
‘<samp><span class="samp">""</span></samp>’ if the target does not have a
|
|
separate math library.
|
|
|
|
<p>You need only define this macro if the default of ‘<samp><span class="samp">"m"</span></samp>’ is wrong.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>LIBRARY_PATH_ENV</b><var><a name="index-LIBRARY_005fPATH_005fENV-4932"></a></var><br>
|
|
<blockquote><p>Define this macro as a C string constant for the environment variable that
|
|
specifies where the linker should look for libraries.
|
|
|
|
<p>You need only define this macro if the default of ‘<samp><span class="samp">"LIBRARY_PATH"</span></samp>’
|
|
is wrong.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_POSIX_IO</b><var><a name="index-TARGET_005fPOSIX_005fIO-4933"></a></var><br>
|
|
<blockquote><p>Define this macro if the target supports the following POSIX file
|
|
functions, access, mkdir and file locking with fcntl / F_SETLKW.
|
|
Defining <code>TARGET_POSIX_IO</code> will enable the test coverage code
|
|
to use file locking when exiting a program, which avoids race conditions
|
|
if the program has forked. It will also create directories at run-time
|
|
for cross-profiling.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MAX_CONDITIONAL_EXECUTE</b><var><a name="index-MAX_005fCONDITIONAL_005fEXECUTE-4934"></a></var><br>
|
|
<blockquote>
|
|
<p>A C expression for the maximum number of instructions to execute via
|
|
conditional execution instructions instead of a branch. A value of
|
|
<code>BRANCH_COST</code>+1 is the default if the machine does not use cc0, and
|
|
1 if it does use cc0.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MODIFY_TESTS</b> (<var>ce_info, true_expr, false_expr</var>)<var><a name="index-IFCVT_005fMODIFY_005fTESTS-4935"></a></var><br>
|
|
<blockquote><p>Used if the target needs to perform machine-dependent modifications on the
|
|
conditionals used for turning basic blocks into conditionally executed code.
|
|
<var>ce_info</var> points to a data structure, <code>struct ce_if_block</code>, which
|
|
contains information about the currently processed blocks. <var>true_expr</var>
|
|
and <var>false_expr</var> are the tests that are used for converting the
|
|
then-block and the else-block, respectively. Set either <var>true_expr</var> or
|
|
<var>false_expr</var> to a null pointer if the tests cannot be converted.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MODIFY_MULTIPLE_TESTS</b> (<var>ce_info, bb, true_expr, false_expr</var>)<var><a name="index-IFCVT_005fMODIFY_005fMULTIPLE_005fTESTS-4936"></a></var><br>
|
|
<blockquote><p>Like <code>IFCVT_MODIFY_TESTS</code>, but used when converting more complicated
|
|
if-statements into conditions combined by <code>and</code> and <code>or</code> operations.
|
|
<var>bb</var> contains the basic block that contains the test that is currently
|
|
being processed and about to be turned into a condition.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MODIFY_INSN</b> (<var>ce_info, pattern, insn</var>)<var><a name="index-IFCVT_005fMODIFY_005fINSN-4937"></a></var><br>
|
|
<blockquote><p>A C expression to modify the <var>PATTERN</var> of an <var>INSN</var> that is to
|
|
be converted to conditional execution format. <var>ce_info</var> points to
|
|
a data structure, <code>struct ce_if_block</code>, which contains information
|
|
about the currently processed blocks.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MODIFY_FINAL</b> (<var>ce_info</var>)<var><a name="index-IFCVT_005fMODIFY_005fFINAL-4938"></a></var><br>
|
|
<blockquote><p>A C expression to perform any final machine dependent modifications in
|
|
converting code to conditional execution. The involved basic blocks
|
|
can be found in the <code>struct ce_if_block</code> structure that is pointed
|
|
to by <var>ce_info</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MODIFY_CANCEL</b> (<var>ce_info</var>)<var><a name="index-IFCVT_005fMODIFY_005fCANCEL-4939"></a></var><br>
|
|
<blockquote><p>A C expression to cancel any machine dependent modifications in
|
|
converting code to conditional execution. The involved basic blocks
|
|
can be found in the <code>struct ce_if_block</code> structure that is pointed
|
|
to by <var>ce_info</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>IFCVT_MACHDEP_INIT</b> (<var>ce_info</var>)<var><a name="index-IFCVT_005fMACHDEP_005fINIT-4940"></a></var><br>
|
|
<blockquote><p>A C expression to initialize any machine specific data for if-conversion
|
|
of the if-block in the <code>struct ce_if_block</code> structure that is pointed
|
|
to by <var>ce_info</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_MACHINE_DEPENDENT_REORG</b> (<var>void</var>)<var><a name="index-TARGET_005fMACHINE_005fDEPENDENT_005fREORG-4941"></a></var><br>
|
|
<blockquote><p>If non-null, this hook performs a target-specific pass over the
|
|
instruction stream. The compiler will run it at all optimization levels,
|
|
just before the point at which it normally does delayed-branch scheduling.
|
|
|
|
<p>The exact purpose of the hook varies from target to target. Some use
|
|
it to do transformations that are necessary for correctness, such as
|
|
laying out in-function constant pools or avoiding hardware hazards.
|
|
Others use it as an opportunity to do some machine-dependent optimizations.
|
|
|
|
<p>You need not implement the hook if it has nothing to do. The default
|
|
definition is null.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_INIT_BUILTINS</b> (<var>void</var>)<var><a name="index-TARGET_005fINIT_005fBUILTINS-4942"></a></var><br>
|
|
<blockquote><p>Define this hook if you have any machine-specific built-in functions
|
|
that need to be defined. It should be a function that performs the
|
|
necessary setup.
|
|
|
|
<p>Machine specific built-in functions can be useful to expand special machine
|
|
instructions that would otherwise not normally be generated because
|
|
they have no equivalent in the source language (for example, SIMD vector
|
|
instructions or prefetch instructions).
|
|
|
|
<p>To create a built-in function, call the function
|
|
<code>lang_hooks.builtin_function</code>
|
|
which is defined by the language front end. You can use any type nodes set
|
|
up by <code>build_common_tree_nodes</code>;
|
|
only language front ends that use those two functions will call
|
|
‘<samp><span class="samp">TARGET_INIT_BUILTINS</span></samp>’.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_BUILTIN_DECL</b> (<var>unsigned code, bool initialize_p</var>)<var><a name="index-TARGET_005fBUILTIN_005fDECL-4943"></a></var><br>
|
|
<blockquote><p>Define this hook if you have any machine-specific built-in functions
|
|
that need to be defined. It should be a function that returns the
|
|
builtin function declaration for the builtin function code <var>code</var>.
|
|
If there is no such builtin and it cannot be initialized at this time
|
|
if <var>initialize_p</var> is true the function should return <code>NULL_TREE</code>.
|
|
If <var>code</var> is out of range the function should return
|
|
<code>error_mark_node</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: rtx <b>TARGET_EXPAND_BUILTIN</b> (<var>tree exp, rtx target, rtx subtarget, machine_mode mode, int ignore</var>)<var><a name="index-TARGET_005fEXPAND_005fBUILTIN-4944"></a></var><br>
|
|
<blockquote>
|
|
<p>Expand a call to a machine specific built-in function that was set up by
|
|
‘<samp><span class="samp">TARGET_INIT_BUILTINS</span></samp>’. <var>exp</var> is the expression for the
|
|
function call; the result should go to <var>target</var> if that is
|
|
convenient, and have mode <var>mode</var> if that is convenient.
|
|
<var>subtarget</var> may be used as the target for computing one of
|
|
<var>exp</var>'s operands. <var>ignore</var> is nonzero if the value is to be
|
|
ignored. This function should return the result of the call to the
|
|
built-in function.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_BUILTIN_CHKP_FUNCTION</b> (<var>unsigned fcode</var>)<var><a name="index-TARGET_005fBUILTIN_005fCHKP_005fFUNCTION-4945"></a></var><br>
|
|
<blockquote><p>This hook allows target to redefine built-in functions used by
|
|
Pointer Bounds Checker for code instrumentation. Hook should return
|
|
fndecl of function implementing generic builtin whose code is
|
|
passed in <var>fcode</var>. Currently following built-in functions are
|
|
obtained using this hook:
|
|
|
|
<div class="defun">
|
|
— Built-in Function: __bounds_type <b>__chkp_bndmk</b> (<var>const void *lb, size_t size</var>)<var><a name="index-g_t_005f_005fchkp_005fbndmk-4946"></a></var><br>
|
|
<blockquote><p>Function code - BUILT_IN_CHKP_BNDMK. This built-in function is used
|
|
by Pointer Bounds Checker to create bound values. <var>lb</var> holds low
|
|
bound of the resulting bounds. <var>size</var> holds size of created bounds.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: void <b>__chkp_bndstx</b> (<var>const void *ptr, __bounds_type b, const void **loc</var>)<var><a name="index-g_t_005f_005fchkp_005fbndstx-4947"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_BNDSTX</code>. This built-in function is used
|
|
by Pointer Bounds Checker to store bounds <var>b</var> for pointer <var>ptr</var>
|
|
when <var>ptr</var> is stored by address <var>loc</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: __bounds_type <b>__chkp_bndldx</b> (<var>const void **loc, const void *ptr</var>)<var><a name="index-g_t_005f_005fchkp_005fbndldx-4948"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_BNDLDX</code>. This built-in function is used
|
|
by Pointer Bounds Checker to get bounds of pointer <var>ptr</var> loaded by
|
|
address <var>loc</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: void <b>__chkp_bndcl</b> (<var>const void *ptr, __bounds_type b</var>)<var><a name="index-g_t_005f_005fchkp_005fbndcl-4949"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_BNDCL</code>. This built-in function is used
|
|
by Pointer Bounds Checker to perform check for pointer <var>ptr</var> against
|
|
lower bound of bounds <var>b</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: void <b>__chkp_bndcu</b> (<var>const void *ptr, __bounds_type b</var>)<var><a name="index-g_t_005f_005fchkp_005fbndcu-4950"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_BNDCU</code>. This built-in function is used
|
|
by Pointer Bounds Checker to perform check for pointer <var>ptr</var> against
|
|
upper bound of bounds <var>b</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: __bounds_type <b>__chkp_bndret</b> (<var>void *ptr</var>)<var><a name="index-g_t_005f_005fchkp_005fbndret-4951"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_BNDRET</code>. This built-in function is used
|
|
by Pointer Bounds Checker to obtain bounds returned by a call statement.
|
|
<var>ptr</var> passed to built-in is <code>SSA_NAME</code> returned by the call.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: __bounds_type <b>__chkp_intersect</b> (<var>__bounds_type b1, __bounds_type b2</var>)<var><a name="index-g_t_005f_005fchkp_005fintersect-4952"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_INTERSECT</code>. This built-in function
|
|
returns intersection of bounds <var>b1</var> and <var>b2</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: __bounds_type <b>__chkp_narrow</b> (<var>const void *ptr, __bounds_type b, size_t s</var>)<var><a name="index-g_t_005f_005fchkp_005fnarrow-4953"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_NARROW</code>. This built-in function
|
|
returns intersection of bounds <var>b</var> and
|
|
[<var>ptr</var>, <var>ptr</var> + <var>s</var> - <code>1</code>].
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: size_t <b>__chkp_sizeof</b> (<var>const void *ptr</var>)<var><a name="index-g_t_005f_005fchkp_005fsizeof-4954"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_SIZEOF</code>. This built-in function
|
|
returns size of object referenced by <var>ptr</var>. <var>ptr</var> is always
|
|
<code>ADDR_EXPR</code> of <code>VAR_DECL</code>. This built-in is used by
|
|
Pointer Bounds Checker when bounds of object cannot be computed statically
|
|
(e.g. object has incomplete type).
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: const <b>void</b><var> *__chkp_extract_lower </var>(<var>__bounds_type b</var>)<var><a name="index-void-4955"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_EXTRACT_LOWER</code>. This built-in function
|
|
returns lower bound of bounds <var>b</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Built-in Function: const <b>void</b><var> *__chkp_extract_upper </var>(<var>__bounds_type b</var>)<var><a name="index-void-4956"></a></var><br>
|
|
<blockquote><p>Function code - <code>BUILT_IN_CHKP_EXTRACT_UPPER</code>. This built-in function
|
|
returns upper bound of bounds <var>b</var>.
|
|
</p></blockquote></div>
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_CHKP_BOUND_TYPE</b> (<var>void</var>)<var><a name="index-TARGET_005fCHKP_005fBOUND_005fTYPE-4957"></a></var><br>
|
|
<blockquote><p>Return type to be used for bounds
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: enum machine_mode <b>TARGET_CHKP_BOUND_MODE</b> (<var>void</var>)<var><a name="index-TARGET_005fCHKP_005fBOUND_005fMODE-4958"></a></var><br>
|
|
<blockquote><p>Return mode to be used for bounds.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_CHKP_MAKE_BOUNDS_CONSTANT</b> (<var>HOST_WIDE_INT lb, HOST_WIDE_INT ub</var>)<var><a name="index-TARGET_005fCHKP_005fMAKE_005fBOUNDS_005fCONSTANT-4959"></a></var><br>
|
|
<blockquote><p>Return constant used to statically initialize constant bounds
|
|
with specified lower bound <var>lb</var> and upper bounds <var>ub</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: int <b>TARGET_CHKP_INITIALIZE_BOUNDS</b> (<var>tree var, tree lb, tree ub, tree *stmts</var>)<var><a name="index-TARGET_005fCHKP_005fINITIALIZE_005fBOUNDS-4960"></a></var><br>
|
|
<blockquote><p>Generate a list of statements <var>stmts</var> to initialize pointer
|
|
bounds variable <var>var</var> with bounds <var>lb</var> and <var>ub</var>. Return
|
|
the number of generated statements.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_RESOLVE_OVERLOADED_BUILTIN</b> (<var>unsigned int loc, tree fndecl, void *arglist</var>)<var><a name="index-TARGET_005fRESOLVE_005fOVERLOADED_005fBUILTIN-4961"></a></var><br>
|
|
<blockquote><p>Select a replacement for a machine specific built-in function that
|
|
was set up by ‘<samp><span class="samp">TARGET_INIT_BUILTINS</span></samp>’. This is done
|
|
<em>before</em> regular type checking, and so allows the target to
|
|
implement a crude form of function overloading. <var>fndecl</var> is the
|
|
declaration of the built-in function. <var>arglist</var> is the list of
|
|
arguments passed to the built-in function. The result is a
|
|
complete expression that implements the operation, usually
|
|
another <code>CALL_EXPR</code>.
|
|
<var>arglist</var> really has type ‘<samp><span class="samp">VEC(tree,gc)*</span></samp>’
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_FOLD_BUILTIN</b> (<var>tree fndecl, int n_args, tree *argp, bool ignore</var>)<var><a name="index-TARGET_005fFOLD_005fBUILTIN-4962"></a></var><br>
|
|
<blockquote><p>Fold a call to a machine specific built-in function that was set up by
|
|
‘<samp><span class="samp">TARGET_INIT_BUILTINS</span></samp>’. <var>fndecl</var> is the declaration of the
|
|
built-in function. <var>n_args</var> is the number of arguments passed to
|
|
the function; the arguments themselves are pointed to by <var>argp</var>.
|
|
The result is another tree, valid for both GIMPLE and GENERIC,
|
|
containing a simplified expression for the call's result. If
|
|
<var>ignore</var> is true the value will be ignored.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_GIMPLE_FOLD_BUILTIN</b> (<var>gimple_stmt_iterator *gsi</var>)<var><a name="index-TARGET_005fGIMPLE_005fFOLD_005fBUILTIN-4963"></a></var><br>
|
|
<blockquote><p>Fold a call to a machine specific built-in function that was set up
|
|
by ‘<samp><span class="samp">TARGET_INIT_BUILTINS</span></samp>’. <var>gsi</var> points to the gimple
|
|
statement holding the function call. Returns true if any change
|
|
was made to the GIMPLE stream.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: int <b>TARGET_COMPARE_VERSION_PRIORITY</b> (<var>tree decl1, tree decl2</var>)<var><a name="index-TARGET_005fCOMPARE_005fVERSION_005fPRIORITY-4964"></a></var><br>
|
|
<blockquote><p>This hook is used to compare the target attributes in two functions to
|
|
determine which function's features get higher priority. This is used
|
|
during function multi-versioning to figure out the order in which two
|
|
versions must be dispatched. A function version with a higher priority
|
|
is checked for dispatching earlier. <var>decl1</var> and <var>decl2</var> are
|
|
the two function decls that will be compared.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_GET_FUNCTION_VERSIONS_DISPATCHER</b> (<var>void *decl</var>)<var><a name="index-TARGET_005fGET_005fFUNCTION_005fVERSIONS_005fDISPATCHER-4965"></a></var><br>
|
|
<blockquote><p>This hook is used to get the dispatcher function for a set of function
|
|
versions. The dispatcher function is called to invoke the right function
|
|
version at run-time. <var>decl</var> is one version from a set of semantically
|
|
identical versions.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_GENERATE_VERSION_DISPATCHER_BODY</b> (<var>void *arg</var>)<var><a name="index-TARGET_005fGENERATE_005fVERSION_005fDISPATCHER_005fBODY-4966"></a></var><br>
|
|
<blockquote><p>This hook is used to generate the dispatcher logic to invoke the right
|
|
function version at run-time for a given set of function versions.
|
|
<var>arg</var> points to the callgraph node of the dispatcher function whose
|
|
body must be generated.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_CAN_USE_DOLOOP_P</b> (<var>const widest_int &iterations, const widest_int &iterations_max, unsigned int loop_depth, bool entered_at_top</var>)<var><a name="index-TARGET_005fCAN_005fUSE_005fDOLOOP_005fP-4967"></a></var><br>
|
|
<blockquote><p>Return true if it is possible to use low-overhead loops (<code>doloop_end</code>
|
|
and <code>doloop_begin</code>) for a particular loop. <var>iterations</var> gives the
|
|
exact number of iterations, or 0 if not known. <var>iterations_max</var> gives
|
|
the maximum number of iterations, or 0 if not known. <var>loop_depth</var> is
|
|
the nesting depth of the loop, with 1 for innermost loops, 2 for loops that
|
|
contain innermost loops, and so on. <var>entered_at_top</var> is true if the
|
|
loop is only entered from the top.
|
|
|
|
<p>This hook is only used if <code>doloop_end</code> is available. The default
|
|
implementation returns true. You can use <code>can_use_doloop_if_innermost</code>
|
|
if the loop must be the innermost, and if there are no other restrictions.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_WITHIN_DOLOOP</b> (<var>const rtx_insn *insn</var>)<var><a name="index-TARGET_005fINVALID_005fWITHIN_005fDOLOOP-4968"></a></var><br>
|
|
<blockquote>
|
|
<p>Take an instruction in <var>insn</var> and return NULL if it is valid within a
|
|
low-overhead loop, otherwise return a string explaining why doloop
|
|
could not be applied.
|
|
|
|
<p>Many targets use special registers for low-overhead looping. For any
|
|
instruction that clobbers these this function should return a string indicating
|
|
the reason why the doloop could not be applied.
|
|
By default, the RTL loop optimizer does not use a present doloop pattern for
|
|
loops containing function calls or branch on table instructions.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_LEGITIMATE_COMBINED_INSN</b> (<var>rtx_insn *insn</var>)<var><a name="index-TARGET_005fLEGITIMATE_005fCOMBINED_005fINSN-4969"></a></var><br>
|
|
<blockquote><p>Take an instruction in <var>insn</var> and return <code>false</code> if the instruction is not appropriate as a combination of two or more instructions. The default is to accept all instructions.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_CAN_FOLLOW_JUMP</b> (<var>const rtx_insn *follower, const rtx_insn *followee</var>)<var><a name="index-TARGET_005fCAN_005fFOLLOW_005fJUMP-4970"></a></var><br>
|
|
<blockquote><p>FOLLOWER and FOLLOWEE are JUMP_INSN instructions; return true if FOLLOWER may be modified to follow FOLLOWEE; false, if it can't. For example, on some targets, certain kinds of branches can't be made to follow through a hot/cold partitioning.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_COMMUTATIVE_P</b> (<var>const_rtx x, int outer_code</var>)<var><a name="index-TARGET_005fCOMMUTATIVE_005fP-4971"></a></var><br>
|
|
<blockquote><p>This target hook returns <code>true</code> if <var>x</var> is considered to be commutative.
|
|
Usually, this is just COMMUTATIVE_P (<var>x</var>), but the HP PA doesn't consider
|
|
PLUS to be commutative inside a MEM. <var>outer_code</var> is the rtx code
|
|
of the enclosing rtl, if known, otherwise it is UNKNOWN.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: rtx <b>TARGET_ALLOCATE_INITIAL_VALUE</b> (<var>rtx hard_reg</var>)<var><a name="index-TARGET_005fALLOCATE_005fINITIAL_005fVALUE-4972"></a></var><br>
|
|
<blockquote>
|
|
<p>When the initial value of a hard register has been copied in a pseudo
|
|
register, it is often not necessary to actually allocate another register
|
|
to this pseudo register, because the original hard register or a stack slot
|
|
it has been saved into can be used. <code>TARGET_ALLOCATE_INITIAL_VALUE</code>
|
|
is called at the start of register allocation once for each hard register
|
|
that had its initial value copied by using
|
|
<code>get_func_hard_reg_initial_val</code> or <code>get_hard_reg_initial_val</code>.
|
|
Possible values are <code>NULL_RTX</code>, if you don't want
|
|
to do any special allocation, a <code>REG</code> rtx—that would typically be
|
|
the hard register itself, if it is known not to be clobbered—or a
|
|
<code>MEM</code>.
|
|
If you are returning a <code>MEM</code>, this is only a hint for the allocator;
|
|
it might decide to use another register anyways.
|
|
You may use <code>current_function_is_leaf</code> or
|
|
<code>REG_N_SETS</code> in the hook to determine if the hard
|
|
register in question will not be clobbered.
|
|
The default value of this hook is <code>NULL</code>, which disables any special
|
|
allocation.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: int <b>TARGET_UNSPEC_MAY_TRAP_P</b> (<var>const_rtx x, unsigned flags</var>)<var><a name="index-TARGET_005fUNSPEC_005fMAY_005fTRAP_005fP-4973"></a></var><br>
|
|
<blockquote><p>This target hook returns nonzero if <var>x</var>, an <code>unspec</code> or
|
|
<code>unspec_volatile</code> operation, might cause a trap. Targets can use
|
|
this hook to enhance precision of analysis for <code>unspec</code> and
|
|
<code>unspec_volatile</code> operations. You may call <code>may_trap_p_1</code>
|
|
to analyze inner elements of <var>x</var> in which case <var>flags</var> should be
|
|
passed along.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_SET_CURRENT_FUNCTION</b> (<var>tree decl</var>)<var><a name="index-TARGET_005fSET_005fCURRENT_005fFUNCTION-4974"></a></var><br>
|
|
<blockquote><p>The compiler invokes this hook whenever it changes its current function
|
|
context (<code>cfun</code>). You can define this function if
|
|
the back end needs to perform any initialization or reset actions on a
|
|
per-function basis. For example, it may be used to implement function
|
|
attributes that affect register usage or code generation patterns.
|
|
The argument <var>decl</var> is the declaration for the new function context,
|
|
and may be null to indicate that the compiler has left a function context
|
|
and is returning to processing at the top level.
|
|
The default hook function does nothing.
|
|
|
|
<p>GCC sets <code>cfun</code> to a dummy function context during initialization of
|
|
some parts of the back end. The hook function is not invoked in this
|
|
situation; you need not worry about the hook being invoked recursively,
|
|
or when the back end is in a partially-initialized state.
|
|
<code>cfun</code> might be <code>NULL</code> to indicate processing at top level,
|
|
outside of any function scope.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_OBJECT_SUFFIX</b><var><a name="index-TARGET_005fOBJECT_005fSUFFIX-4975"></a></var><br>
|
|
<blockquote><p>Define this macro to be a C string representing the suffix for object
|
|
files on your target machine. If you do not define this macro, GCC will
|
|
use ‘<samp><span class="samp">.o</span></samp>’ as the suffix for object files.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_EXECUTABLE_SUFFIX</b><var><a name="index-TARGET_005fEXECUTABLE_005fSUFFIX-4976"></a></var><br>
|
|
<blockquote><p>Define this macro to be a C string representing the suffix to be
|
|
automatically added to executable files on your target machine. If you
|
|
do not define this macro, GCC will use the null string as the suffix for
|
|
executable files.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>COLLECT_EXPORT_LIST</b><var><a name="index-COLLECT_005fEXPORT_005fLIST-4977"></a></var><br>
|
|
<blockquote><p>If defined, <code>collect2</code> will scan the individual object files
|
|
specified on its command line and create an export list for the linker.
|
|
Define this macro for systems like AIX, where the linker discards
|
|
object files that are not referenced from <code>main</code> and uses export
|
|
lists.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>MODIFY_JNI_METHOD_CALL</b> (<var>mdecl</var>)<var><a name="index-MODIFY_005fJNI_005fMETHOD_005fCALL-4978"></a></var><br>
|
|
<blockquote><p>Define this macro to a C expression representing a variant of the
|
|
method call <var>mdecl</var>, if Java Native Interface (JNI) methods
|
|
must be invoked differently from other methods on your target.
|
|
For example, on 32-bit Microsoft Windows, JNI methods must be invoked using
|
|
the <code>stdcall</code> calling convention and this macro is then
|
|
defined as this expression:
|
|
|
|
<pre class="smallexample"> build_type_attribute_variant (<var>mdecl</var>,
|
|
build_tree_list
|
|
(get_identifier ("stdcall"),
|
|
NULL))
|
|
</pre>
|
|
</blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_CANNOT_MODIFY_JUMPS_P</b> (<var>void</var>)<var><a name="index-TARGET_005fCANNOT_005fMODIFY_005fJUMPS_005fP-4979"></a></var><br>
|
|
<blockquote><p>This target hook returns <code>true</code> past the point in which new jump
|
|
instructions could be created. On machines that require a register for
|
|
every jump such as the SHmedia ISA of SH5, this point would typically be
|
|
reload, so this target hook should be defined to a function such as:
|
|
|
|
<pre class="smallexample"> static bool
|
|
cannot_modify_jumps_past_reload_p ()
|
|
{
|
|
return (reload_completed || reload_in_progress);
|
|
}
|
|
</pre>
|
|
</blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: reg_class_t <b>TARGET_BRANCH_TARGET_REGISTER_CLASS</b> (<var>void</var>)<var><a name="index-TARGET_005fBRANCH_005fTARGET_005fREGISTER_005fCLASS-4980"></a></var><br>
|
|
<blockquote><p>This target hook returns a register class for which branch target register
|
|
optimizations should be applied. All registers in this class should be
|
|
usable interchangeably. After reload, registers in this class will be
|
|
re-allocated and loads will be hoisted out of loops and be subjected
|
|
to inter-block scheduling.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED</b> (<var>bool after_prologue_epilogue_gen</var>)<var><a name="index-TARGET_005fBRANCH_005fTARGET_005fREGISTER_005fCALLEE_005fSAVED-4981"></a></var><br>
|
|
<blockquote><p>Branch target register optimization will by default exclude callee-saved
|
|
registers
|
|
that are not already live during the current function; if this target hook
|
|
returns true, they will be included. The target code must than make sure
|
|
that all target registers in the class returned by
|
|
‘<samp><span class="samp">TARGET_BRANCH_TARGET_REGISTER_CLASS</span></samp>’ that might need saving are
|
|
saved. <var>after_prologue_epilogue_gen</var> indicates if prologues and
|
|
epilogues have already been generated. Note, even if you only return
|
|
true when <var>after_prologue_epilogue_gen</var> is false, you still are likely
|
|
to have to make special provisions in <code>INITIAL_ELIMINATION_OFFSET</code>
|
|
to reserve space for caller-saved target registers.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_HAVE_CONDITIONAL_EXECUTION</b> (<var>void</var>)<var><a name="index-TARGET_005fHAVE_005fCONDITIONAL_005fEXECUTION-4982"></a></var><br>
|
|
<blockquote><p>This target hook returns true if the target supports conditional execution.
|
|
This target hook is required only when the target has several different
|
|
modes and they have different conditional execution capability, such as ARM.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: rtx <b>TARGET_GEN_CCMP_FIRST</b> (<var>rtx *prep_seq, rtx *gen_seq, int code, tree op0, tree op1</var>)<var><a name="index-TARGET_005fGEN_005fCCMP_005fFIRST-4983"></a></var><br>
|
|
<blockquote><p>This function prepares to emit a comparison insn for the first compare in a
|
|
sequence of conditional comparisions. It returns a appropriate <code>CC</code>
|
|
for passing to <code>gen_ccmp_next</code> or <code>cbranch_optab</code>. The insns to
|
|
prepare the compare are saved in <var>prep_seq</var> and the compare insns are
|
|
saved in <var>gen_seq</var>. They will be emitted when all the compares in the
|
|
the conditional comparision are generated without error. <var>code</var> is
|
|
the <code>rtx_code</code> of the compare for <var>op0</var> and <var>op1</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: rtx <b>TARGET_GEN_CCMP_NEXT</b> (<var>rtx *prep_seq, rtx *gen_seq, rtx prev, int cmp_code, tree op0, tree op1, int bit_code</var>)<var><a name="index-TARGET_005fGEN_005fCCMP_005fNEXT-4984"></a></var><br>
|
|
<blockquote><p>This function prepare to emit a conditional comparison within a sequence of
|
|
conditional comparisons. It returns a appropriate <code>CC</code> for passing to
|
|
<code>gen_ccmp_next</code> or <code>cbranch_optab</code>. The insns to prepare the
|
|
compare are saved in <var>prep_seq</var> and the compare insns are saved in
|
|
<var>gen_seq</var>. They will be emitted when all the compares in the conditional
|
|
comparision are generated without error. The <var>prev</var> expression is the
|
|
result of a prior call to <code>gen_ccmp_first</code> or <code>gen_ccmp_next</code>. It
|
|
may return <code>NULL</code> if the combination of <var>prev</var> and this comparison is
|
|
not supported, otherwise the result must be appropriate for passing to
|
|
<code>gen_ccmp_next</code> or <code>cbranch_optab</code>. <var>code</var> is the
|
|
<code>rtx_code</code> of the compare for <var>op0</var> and <var>op1</var>. <var>bit_code</var>
|
|
is <code>AND</code> or <code>IOR</code>, which is the op on the two compares.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned <b>TARGET_LOOP_UNROLL_ADJUST</b> (<var>unsigned nunroll, struct loop *loop</var>)<var><a name="index-TARGET_005fLOOP_005fUNROLL_005fADJUST-4985"></a></var><br>
|
|
<blockquote><p>This target hook returns a new value for the number of times <var>loop</var>
|
|
should be unrolled. The parameter <var>nunroll</var> is the number of times
|
|
the loop is to be unrolled. The parameter <var>loop</var> is a pointer to
|
|
the loop, which is going to be checked for unrolling. This target hook
|
|
is required only when the target has special constraints like maximum
|
|
number of memory accesses.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>POWI_MAX_MULTS</b><var><a name="index-POWI_005fMAX_005fMULTS-4986"></a></var><br>
|
|
<blockquote><p>If defined, this macro is interpreted as a signed integer C expression
|
|
that specifies the maximum number of floating point multiplications
|
|
that should be emitted when expanding exponentiation by an integer
|
|
constant inline. When this value is defined, exponentiation requiring
|
|
more than this number of multiplications is implemented by calling the
|
|
system library's <code>pow</code>, <code>powf</code> or <code>powl</code> routines.
|
|
The default value places no upper bound on the multiplication count.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: void <b>TARGET_EXTRA_INCLUDES</b> (<var>const char *sysroot, const char *iprefix, int stdinc</var>)<var><a name="index-TARGET_005fEXTRA_005fINCLUDES-4987"></a></var><br>
|
|
<blockquote><p>This target hook should register any extra include files for the
|
|
target. The parameter <var>stdinc</var> indicates if normal include files
|
|
are present. The parameter <var>sysroot</var> is the system root directory.
|
|
The parameter <var>iprefix</var> is the prefix for the gcc directory.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: void <b>TARGET_EXTRA_PRE_INCLUDES</b> (<var>const char *sysroot, const char *iprefix, int stdinc</var>)<var><a name="index-TARGET_005fEXTRA_005fPRE_005fINCLUDES-4988"></a></var><br>
|
|
<blockquote><p>This target hook should register any extra include files for the
|
|
target before any standard headers. The parameter <var>stdinc</var>
|
|
indicates if normal include files are present. The parameter
|
|
<var>sysroot</var> is the system root directory. The parameter
|
|
<var>iprefix</var> is the prefix for the gcc directory.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: void <b>TARGET_OPTF</b> (<var>char *path</var>)<var><a name="index-TARGET_005fOPTF-4989"></a></var><br>
|
|
<blockquote><p>This target hook should register special include paths for the target.
|
|
The parameter <var>path</var> is the include to register. On Darwin
|
|
systems, this is used for Framework includes, which have semantics
|
|
that are different from <samp><span class="option">-I</span></samp>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>bool</b><var> TARGET_USE_LOCAL_THUNK_ALIAS_P </var>(<var>tree fndecl</var>)<var><a name="index-bool-4990"></a></var><br>
|
|
<blockquote><p>This target macro returns <code>true</code> if it is safe to use a local alias
|
|
for a virtual function <var>fndecl</var> when constructing thunks,
|
|
<code>false</code> otherwise. By default, the macro returns <code>true</code> for all
|
|
functions, if a target supports aliases (i.e. defines
|
|
<code>ASM_OUTPUT_DEF</code>), <code>false</code> otherwise,
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_FORMAT_TYPES</b><var><a name="index-TARGET_005fFORMAT_005fTYPES-4991"></a></var><br>
|
|
<blockquote><p>If defined, this macro is the name of a global variable containing
|
|
target-specific format checking information for the <samp><span class="option">-Wformat</span></samp>
|
|
option. The default is to have no target-specific format checks.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_N_FORMAT_TYPES</b><var><a name="index-TARGET_005fN_005fFORMAT_005fTYPES-4992"></a></var><br>
|
|
<blockquote><p>If defined, this macro is the number of entries in
|
|
<code>TARGET_FORMAT_TYPES</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_OVERRIDES_FORMAT_ATTRIBUTES</b><var><a name="index-TARGET_005fOVERRIDES_005fFORMAT_005fATTRIBUTES-4993"></a></var><br>
|
|
<blockquote><p>If defined, this macro is the name of a global variable containing
|
|
target-specific format overrides for the <samp><span class="option">-Wformat</span></samp> option. The
|
|
default is to have no target-specific format overrides. If defined,
|
|
<code>TARGET_FORMAT_TYPES</code> must be defined, too.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_OVERRIDES_FORMAT_ATTRIBUTES_COUNT</b><var><a name="index-TARGET_005fOVERRIDES_005fFORMAT_005fATTRIBUTES_005fCOUNT-4994"></a></var><br>
|
|
<blockquote><p>If defined, this macro specifies the number of entries in
|
|
<code>TARGET_OVERRIDES_FORMAT_ATTRIBUTES</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_OVERRIDES_FORMAT_INIT</b><var><a name="index-TARGET_005fOVERRIDES_005fFORMAT_005fINIT-4995"></a></var><br>
|
|
<blockquote><p>If defined, this macro specifies the optional initialization
|
|
routine for target specific customizations of the system printf
|
|
and scanf formatter settings.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_RELAXED_ORDERING</b><var><a name="index-TARGET_005fRELAXED_005fORDERING-4996"></a></var><br>
|
|
<blockquote><p>If set to <code>true</code>, means that the target's memory model does not
|
|
guarantee that loads which do not depend on one another will access
|
|
main memory in the order of the instruction stream; if ordering is
|
|
important, an explicit memory barrier must be used. This is true of
|
|
many recent processors which implement a policy of “relaxed,”
|
|
“weak,” or “release” memory consistency, such as Alpha, PowerPC,
|
|
and ia64. The default is <code>false</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN</b> (<var>const_tree typelist, const_tree funcdecl, const_tree val</var>)<var><a name="index-TARGET_005fINVALID_005fARG_005fFOR_005fUNPROTOTYPED_005fFN-4997"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
illegal to pass argument <var>val</var> to function <var>funcdecl</var>
|
|
with prototype <var>typelist</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_CONVERSION</b> (<var>const_tree fromtype, const_tree totype</var>)<var><a name="index-TARGET_005fINVALID_005fCONVERSION-4998"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
invalid to convert from <var>fromtype</var> to <var>totype</var>, or <code>NULL</code>
|
|
if validity should be determined by the front end.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_UNARY_OP</b> (<var>int op, const_tree type</var>)<var><a name="index-TARGET_005fINVALID_005fUNARY_005fOP-4999"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
invalid to apply operation <var>op</var> (where unary plus is denoted by
|
|
<code>CONVERT_EXPR</code>) to an operand of type <var>type</var>, or <code>NULL</code>
|
|
if validity should be determined by the front end.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_BINARY_OP</b> (<var>int op, const_tree type1, const_tree type2</var>)<var><a name="index-TARGET_005fINVALID_005fBINARY_005fOP-5000"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
invalid to apply operation <var>op</var> to operands of types <var>type1</var>
|
|
and <var>type2</var>, or <code>NULL</code> if validity should be determined by
|
|
the front end.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_PARAMETER_TYPE</b> (<var>const_tree type</var>)<var><a name="index-TARGET_005fINVALID_005fPARAMETER_005fTYPE-5001"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
invalid for functions to include parameters of type <var>type</var>,
|
|
or <code>NULL</code> if validity should be determined by
|
|
the front end. This is currently used only by the C and C++ front ends.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: const char * <b>TARGET_INVALID_RETURN_TYPE</b> (<var>const_tree type</var>)<var><a name="index-TARGET_005fINVALID_005fRETURN_005fTYPE-5002"></a></var><br>
|
|
<blockquote><p>If defined, this macro returns the diagnostic message when it is
|
|
invalid for functions to have return type <var>type</var>,
|
|
or <code>NULL</code> if validity should be determined by
|
|
the front end. This is currently used only by the C and C++ front ends.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_PROMOTED_TYPE</b> (<var>const_tree type</var>)<var><a name="index-TARGET_005fPROMOTED_005fTYPE-5003"></a></var><br>
|
|
<blockquote><p>If defined, this target hook returns the type to which values of
|
|
<var>type</var> should be promoted when they appear in expressions,
|
|
analogous to the integer promotions, or <code>NULL_TREE</code> to use the
|
|
front end's normal promotion rules. This hook is useful when there are
|
|
target-specific types with special promotion rules.
|
|
This is currently used only by the C and C++ front ends.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: tree <b>TARGET_CONVERT_TO_TYPE</b> (<var>tree type, tree expr</var>)<var><a name="index-TARGET_005fCONVERT_005fTO_005fTYPE-5004"></a></var><br>
|
|
<blockquote><p>If defined, this hook returns the result of converting <var>expr</var> to
|
|
<var>type</var>. It should return the converted expression,
|
|
or <code>NULL_TREE</code> to apply the front end's normal conversion rules.
|
|
This hook is useful when there are target-specific types with special
|
|
conversion rules.
|
|
This is currently used only by the C and C++ front ends.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_USE_JCR_SECTION</b><var><a name="index-TARGET_005fUSE_005fJCR_005fSECTION-5005"></a></var><br>
|
|
<blockquote><p>This macro determines whether to use the JCR section to register Java
|
|
classes. By default, TARGET_USE_JCR_SECTION is defined to 1 if both
|
|
SUPPORTS_WEAK and TARGET_HAVE_NAMED_SECTIONS are true, else 0.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>OBJC_JBLEN</b><var><a name="index-OBJC_005fJBLEN-5006"></a></var><br>
|
|
<blockquote><p>This macro determines the size of the objective C jump buffer for the
|
|
NeXT runtime. By default, OBJC_JBLEN is defined to an innocuous value.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>LIBGCC2_UNWIND_ATTRIBUTE</b><var><a name="index-LIBGCC2_005fUNWIND_005fATTRIBUTE-5007"></a></var><br>
|
|
<blockquote><p>Define this macro if any target-specific attributes need to be attached
|
|
to the functions in <samp><span class="file">libgcc</span></samp> that provide low-level support for
|
|
call stack unwinding. It is used in declarations in <samp><span class="file">unwind-generic.h</span></samp>
|
|
and the associated definitions of those functions.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_UPDATE_STACK_BOUNDARY</b> (<var>void</var>)<var><a name="index-TARGET_005fUPDATE_005fSTACK_005fBOUNDARY-5008"></a></var><br>
|
|
<blockquote><p>Define this macro to update the current function stack boundary if
|
|
necessary.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: rtx <b>TARGET_GET_DRAP_RTX</b> (<var>void</var>)<var><a name="index-TARGET_005fGET_005fDRAP_005fRTX-5009"></a></var><br>
|
|
<blockquote><p>This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a
|
|
different argument pointer register is needed to access the function's
|
|
argument list due to stack realignment. Return <code>NULL</code> if no DRAP
|
|
is needed.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS</b> (<var>void</var>)<var><a name="index-TARGET_005fALLOCATE_005fSTACK_005fSLOTS_005fFOR_005fARGS-5010"></a></var><br>
|
|
<blockquote><p>When optimization is disabled, this hook indicates whether or not
|
|
arguments should be allocated to stack slots. Normally, GCC allocates
|
|
stacks slots for arguments when not optimizing in order to make
|
|
debugging easier. However, when a function is declared with
|
|
<code>__attribute__((naked))</code>, there is no stack frame, and the compiler
|
|
cannot safely move arguments from the registers in which they are passed
|
|
to the stack. Therefore, this hook should return true in general, but
|
|
false for naked functions. The default implementation always returns true.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned HOST_WIDE_INT <b>TARGET_CONST_ANCHOR</b><var><a name="index-TARGET_005fCONST_005fANCHOR-5011"></a></var><br>
|
|
<blockquote><p>On some architectures it can take multiple instructions to synthesize
|
|
a constant. If there is another constant already in a register that
|
|
is close enough in value then it is preferable that the new constant
|
|
is computed from this register using immediate addition or
|
|
subtraction. We accomplish this through CSE. Besides the value of
|
|
the constant we also add a lower and an upper constant anchor to the
|
|
available expressions. These are then queried when encountering new
|
|
constants. The anchors are computed by rounding the constant up and
|
|
down to a multiple of the value of <code>TARGET_CONST_ANCHOR</code>.
|
|
<code>TARGET_CONST_ANCHOR</code> should be the maximum positive value
|
|
accepted by immediate-add plus one. We currently assume that the
|
|
value of <code>TARGET_CONST_ANCHOR</code> is a power of 2. For example, on
|
|
MIPS, where add-immediate takes a 16-bit signed value,
|
|
<code>TARGET_CONST_ANCHOR</code> is set to ‘<samp><span class="samp">0x8000</span></samp>’. The default value
|
|
is zero, which disables this optimization.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned HOST_WIDE_INT <b>TARGET_ASAN_SHADOW_OFFSET</b> (<var>void</var>)<var><a name="index-TARGET_005fASAN_005fSHADOW_005fOFFSET-5012"></a></var><br>
|
|
<blockquote><p>Return the offset bitwise ored into shifted address to get corresponding
|
|
Address Sanitizer shadow memory address. NULL if Address Sanitizer is not
|
|
supported by the target.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned HOST_WIDE_INT <b>TARGET_MEMMODEL_CHECK</b> (<var>unsigned HOST_WIDE_INT val</var>)<var><a name="index-TARGET_005fMEMMODEL_005fCHECK-5013"></a></var><br>
|
|
<blockquote><p>Validate target specific memory model mask bits. When NULL no target specific
|
|
memory model bits are allowed.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned char <b>TARGET_ATOMIC_TEST_AND_SET_TRUEVAL</b><var><a name="index-TARGET_005fATOMIC_005fTEST_005fAND_005fSET_005fTRUEVAL-5014"></a></var><br>
|
|
<blockquote><p>This value should be set if the result written by <code>atomic_test_and_set</code> is not exactly 1, i.e. the <code>bool</code> <code>true</code>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: bool <b>TARGET_HAS_IFUNC_P</b> (<var>void</var>)<var><a name="index-TARGET_005fHAS_005fIFUNC_005fP-5015"></a></var><br>
|
|
<blockquote><p>It returns true if the target supports GNU indirect functions.
|
|
The support includes the assembler, linker and dynamic linker.
|
|
The default value of this hook is based on target's libc.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: unsigned int <b>TARGET_ATOMIC_ALIGN_FOR_MODE</b> (<var>machine_mode mode</var>)<var><a name="index-TARGET_005fATOMIC_005fALIGN_005fFOR_005fMODE-5016"></a></var><br>
|
|
<blockquote><p>If defined, this function returns an appropriate alignment in bits for an atomic object of machine_mode <var>mode</var>. If 0 is returned then the default alignment for the specified mode is used.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_ATOMIC_ASSIGN_EXPAND_FENV</b> (<var>tree *hold, tree *clear, tree *update</var>)<var><a name="index-TARGET_005fATOMIC_005fASSIGN_005fEXPAND_005fFENV-5017"></a></var><br>
|
|
<blockquote><p>ISO C11 requires atomic compound assignments that may raise floating-point exceptions to raise exceptions corresponding to the arithmetic operation whose result was successfully stored in a compare-and-exchange sequence. This requires code equivalent to calls to <code>feholdexcept</code>, <code>feclearexcept</code> and <code>feupdateenv</code> to be generated at appropriate points in the compare-and-exchange sequence. This hook should set <code>*</code><var>hold</var> to an expression equivalent to the call to <code>feholdexcept</code>, <code>*</code><var>clear</var> to an expression equivalent to the call to <code>feclearexcept</code> and <code>*</code><var>update</var> to an expression equivalent to the call to <code>feupdateenv</code>. The three expressions are <code>NULL_TREE</code> on entry to the hook and may be left as <code>NULL_TREE</code> if no code is required in a particular place. The default implementation leaves all three expressions as <code>NULL_TREE</code>. The <code>__atomic_feraiseexcept</code> function from <code>libatomic</code> may be of use as part of the code generated in <code>*</code><var>update</var>.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: void <b>TARGET_RECORD_OFFLOAD_SYMBOL</b> (<var>tree</var>)<var><a name="index-TARGET_005fRECORD_005fOFFLOAD_005fSYMBOL-5018"></a></var><br>
|
|
<blockquote><p>Used when offloaded functions are seen in the compilation unit and no named
|
|
sections are available. It is called once for each symbol that must be
|
|
recorded in the offload function and variable table.
|
|
</p></blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Target Hook: char * <b>TARGET_OFFLOAD_OPTIONS</b> (<var>void</var>)<var><a name="index-TARGET_005fOFFLOAD_005fOPTIONS-5019"></a></var><br>
|
|
<blockquote><p>Used when writing out the list of options into an LTO file. It should
|
|
translate any relevant target-specific options (such as the ABI in use)
|
|
into one of the <samp><span class="option">-foffload</span></samp> options that exist as a common interface
|
|
to express such options. It should return a string containing these options,
|
|
separated by spaces, which the caller will free.
|
|
|
|
</blockquote></div>
|
|
|
|
<div class="defun">
|
|
— Macro: <b>TARGET_SUPPORTS_WIDE_INT</b><var><a name="index-TARGET_005fSUPPORTS_005fWIDE_005fINT-5020"></a></var><br>
|
|
<blockquote>
|
|
<p>On older ports, large integers are stored in <code>CONST_DOUBLE</code> rtl
|
|
objects. Newer ports define <code>TARGET_SUPPORTS_WIDE_INT</code> to be nonzero
|
|
to indicate that large integers are stored in
|
|
<code>CONST_WIDE_INT</code> rtl objects. The <code>CONST_WIDE_INT</code> allows
|
|
very large integer constants to be represented. <code>CONST_DOUBLE</code>
|
|
is limited to twice the size of the host's <code>HOST_WIDE_INT</code>
|
|
representation.
|
|
|
|
<p>Converting a port mostly requires looking for the places where
|
|
<code>CONST_DOUBLE</code>s are used with <code>VOIDmode</code> and replacing that
|
|
code with code that accesses <code>CONST_WIDE_INT</code>s. ‘<samp><span class="samp">"grep -i
|
|
const_double"</span></samp>’ at the port level gets you to 95% of the changes that
|
|
need to be made. There are a few places that require a deeper look.
|
|
|
|
<ul>
|
|
<li>There is no equivalent to <code>hval</code> and <code>lval</code> for
|
|
<code>CONST_WIDE_INT</code>s. This would be difficult to express in the md
|
|
language since there are a variable number of elements.
|
|
|
|
<p>Most ports only check that <code>hval</code> is either 0 or -1 to see if the
|
|
value is small. As mentioned above, this will no longer be necessary
|
|
since small constants are always <code>CONST_INT</code>. Of course there
|
|
are still a few exceptions, the alpha's constraint used by the zap
|
|
instruction certainly requires careful examination by C code.
|
|
However, all the current code does is pass the hval and lval to C
|
|
code, so evolving the c code to look at the <code>CONST_WIDE_INT</code> is
|
|
not really a large change.
|
|
|
|
<li>Because there is no standard template that ports use to materialize
|
|
constants, there is likely to be some futzing that is unique to each
|
|
port in this code.
|
|
|
|
<li>The rtx costs may have to be adjusted to properly account for larger
|
|
constants that are represented as <code>CONST_WIDE_INT</code>.
|
|
</ul>
|
|
|
|
<p>All and all it does not take long to convert ports that the
|
|
maintainer is familiar with.
|
|
|
|
</blockquote></div>
|
|
|
|
<!-- Copyright (C) 1988-2015 Free Software Foundation, Inc. -->
|
|
<!-- This is part of the GCC manual. -->
|
|
<!-- For copying conditions, see the file gccint.texi. -->
|
|
</body></html>
|
|
|