<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>