Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / doc / tm.texi
1 @c Copyright (C) 1988-2015 Free Software Foundation, Inc.
2 @c This is part of the GCC manual.
3 @c For copying conditions, see the file gcc.texi.
4
5 @node Target Macros
6 @chapter Target Description Macros and Functions
7 @cindex machine description macros
8 @cindex target description macros
9 @cindex macros, target description
10 @cindex @file{tm.h} macros
11
12 In addition to the file @file{@var{machine}.md}, a machine description
13 includes a C header file conventionally given the name
14 @file{@var{machine}.h} and a C source file named @file{@var{machine}.c}.
15 The header file defines numerous macros that convey the information
16 about the target machine that does not fit into the scheme of the
17 @file{.md} file.  The file @file{tm.h} should be a link to
18 @file{@var{machine}.h}.  The header file @file{config.h} includes
19 @file{tm.h} and most compiler source files include @file{config.h}.  The
20 source file defines a variable @code{targetm}, which is a structure
21 containing pointers to functions and data relating to the target
22 machine.  @file{@var{machine}.c} should also contain their definitions,
23 if they are not defined elsewhere in GCC, and other functions called
24 through the macros defined in the @file{.h} file.
25
26 @menu
27 * Target Structure::    The @code{targetm} variable.
28 * Driver::              Controlling how the driver runs the compilation passes.
29 * Run-time Target::     Defining @samp{-m} options like @option{-m68000} and @option{-m68020}.
30 * Per-Function Data::   Defining data structures for per-function information.
31 * Storage Layout::      Defining sizes and alignments of data.
32 * Type Layout::         Defining sizes and properties of basic user data types.
33 * Registers::           Naming and describing the hardware registers.
34 * Register Classes::    Defining the classes of hardware registers.
35 * Stack and Calling::   Defining which way the stack grows and by how much.
36 * Varargs::             Defining the varargs macros.
37 * Trampolines::         Code set up at run time to enter a nested function.
38 * Library Calls::       Controlling how library routines are implicitly called.
39 * Addressing Modes::    Defining addressing modes valid for memory operands.
40 * Anchored Addresses::  Defining how @option{-fsection-anchors} should work.
41 * Condition Code::      Defining how insns update the condition code.
42 * Costs::               Defining relative costs of different operations.
43 * Scheduling::          Adjusting the behavior of the instruction scheduler.
44 * Sections::            Dividing storage into text, data, and other sections.
45 * PIC::                 Macros for position independent code.
46 * Assembler Format::    Defining how to write insns and pseudo-ops to output.
47 * Debugging Info::      Defining the format of debugging output.
48 * Floating Point::      Handling floating point for cross-compilers.
49 * Mode Switching::      Insertion of mode-switching instructions.
50 * Target Attributes::   Defining target-specific uses of @code{__attribute__}.
51 * Emulated TLS::        Emulated TLS support.
52 * MIPS Coprocessors::   MIPS coprocessor support and how to customize it.
53 * PCH Target::          Validity checking for precompiled headers.
54 * C++ ABI::             Controlling C++ ABI changes.
55 * Named Address Spaces:: Adding support for named address spaces
56 * Misc::                Everything else.
57 @end menu
58
59 @node Target Structure
60 @section The Global @code{targetm} Variable
61 @cindex target hooks
62 @cindex target functions
63
64 @deftypevar {struct gcc_target} targetm
65 The target @file{.c} file must define the global @code{targetm} variable
66 which contains pointers to functions and data relating to the target
67 machine.  The variable is declared in @file{target.h};
68 @file{target-def.h} defines the macro @code{TARGET_INITIALIZER} which is
69 used to initialize the variable, and macros for the default initializers
70 for elements of the structure.  The @file{.c} file should override those
71 macros for which the default definition is inappropriate.  For example:
72 @smallexample
73 #include "target.h"
74 #include "target-def.h"
75
76 /* @r{Initialize the GCC target structure.}  */
77
78 #undef TARGET_COMP_TYPE_ATTRIBUTES
79 #define TARGET_COMP_TYPE_ATTRIBUTES @var{machine}_comp_type_attributes
80
81 struct gcc_target targetm = TARGET_INITIALIZER;
82 @end smallexample
83 @end deftypevar
84
85 Where a macro should be defined in the @file{.c} file in this manner to
86 form part of the @code{targetm} structure, it is documented below as a
87 ``Target Hook'' with a prototype.  Many macros will change in future
88 from being defined in the @file{.h} file to being part of the
89 @code{targetm} structure.
90
91 Similarly, there is a @code{targetcm} variable for hooks that are
92 specific to front ends for C-family languages, documented as ``C
93 Target Hook''.  This is declared in @file{c-family/c-target.h}, the
94 initializer @code{TARGETCM_INITIALIZER} in
95 @file{c-family/c-target-def.h}.  If targets initialize @code{targetcm}
96 themselves, they should set @code{target_has_targetcm=yes} in
97 @file{config.gcc}; otherwise a default definition is used.
98
99 Similarly, there is a @code{targetm_common} variable for hooks that
100 are shared between the compiler driver and the compilers proper,
101 documented as ``Common Target Hook''.  This is declared in
102 @file{common/common-target.h}, the initializer
103 @code{TARGETM_COMMON_INITIALIZER} in
104 @file{common/common-target-def.h}.  If targets initialize
105 @code{targetm_common} themselves, they should set
106 @code{target_has_targetm_common=yes} in @file{config.gcc}; otherwise a
107 default definition is used.
108
109 @node Driver
110 @section Controlling the Compilation Driver, @file{gcc}
111 @cindex driver
112 @cindex controlling the compilation driver
113
114 @c prevent bad page break with this line
115 You can control the compilation driver.
116
117 @defmac DRIVER_SELF_SPECS
118 A list of specs for the driver itself.  It should be a suitable
119 initializer for an array of strings, with no surrounding braces.
120
121 The driver applies these specs to its own command line between loading
122 default @file{specs} files (but not command-line specified ones) and
123 choosing the multilib directory or running any subcommands.  It
124 applies them in the order given, so each spec can depend on the
125 options added by earlier ones.  It is also possible to remove options
126 using @samp{%<@var{option}} in the usual way.
127
128 This macro can be useful when a port has several interdependent target
129 options.  It provides a way of standardizing the command line so
130 that the other specs are easier to write.
131
132 Do not define this macro if it does not need to do anything.
133 @end defmac
134
135 @defmac OPTION_DEFAULT_SPECS
136 A list of specs used to support configure-time default options (i.e.@:
137 @option{--with} options) in the driver.  It should be a suitable initializer
138 for an array of structures, each containing two strings, without the
139 outermost pair of surrounding braces.
140
141 The first item in the pair is the name of the default.  This must match
142 the code in @file{config.gcc} for the target.  The second item is a spec
143 to apply if a default with this name was specified.  The string
144 @samp{%(VALUE)} in the spec will be replaced by the value of the default
145 everywhere it occurs.
146
147 The driver will apply these specs to its own command line between loading
148 default @file{specs} files and processing @code{DRIVER_SELF_SPECS}, using
149 the same mechanism as @code{DRIVER_SELF_SPECS}.
150
151 Do not define this macro if it does not need to do anything.
152 @end defmac
153
154 @defmac CPP_SPEC
155 A C string constant that tells the GCC driver program options to
156 pass to CPP@.  It can also specify how to translate options you
157 give to GCC into options for GCC to pass to the CPP@.
158
159 Do not define this macro if it does not need to do anything.
160 @end defmac
161
162 @defmac CPLUSPLUS_CPP_SPEC
163 This macro is just like @code{CPP_SPEC}, but is used for C++, rather
164 than C@.  If you do not define this macro, then the value of
165 @code{CPP_SPEC} (if any) will be used instead.
166 @end defmac
167
168 @defmac CC1_SPEC
169 A C string constant that tells the GCC driver program options to
170 pass to @code{cc1}, @code{cc1plus}, @code{f771}, and the other language
171 front ends.
172 It can also specify how to translate options you give to GCC into options
173 for GCC to pass to front ends.
174
175 Do not define this macro if it does not need to do anything.
176 @end defmac
177
178 @defmac CC1PLUS_SPEC
179 A C string constant that tells the GCC driver program options to
180 pass to @code{cc1plus}.  It can also specify how to translate options you
181 give to GCC into options for GCC to pass to the @code{cc1plus}.
182
183 Do not define this macro if it does not need to do anything.
184 Note that everything defined in CC1_SPEC is already passed to
185 @code{cc1plus} so there is no need to duplicate the contents of
186 CC1_SPEC in CC1PLUS_SPEC@.
187 @end defmac
188
189 @defmac ASM_SPEC
190 A C string constant that tells the GCC driver program options to
191 pass to the assembler.  It can also specify how to translate options
192 you give to GCC into options for GCC to pass to the assembler.
193 See the file @file{sun3.h} for an example of this.
194
195 Do not define this macro if it does not need to do anything.
196 @end defmac
197
198 @defmac ASM_FINAL_SPEC
199 A C string constant that tells the GCC driver program how to
200 run any programs which cleanup after the normal assembler.
201 Normally, this is not needed.  See the file @file{mips.h} for
202 an example of this.
203
204 Do not define this macro if it does not need to do anything.
205 @end defmac
206
207 @defmac AS_NEEDS_DASH_FOR_PIPED_INPUT
208 Define this macro, with no value, if the driver should give the assembler
209 an argument consisting of a single dash, @option{-}, to instruct it to
210 read from its standard input (which will be a pipe connected to the
211 output of the compiler proper).  This argument is given after any
212 @option{-o} option specifying the name of the output file.
213
214 If you do not define this macro, the assembler is assumed to read its
215 standard input if given no non-option arguments.  If your assembler
216 cannot read standard input at all, use a @samp{%@{pipe:%e@}} construct;
217 see @file{mips.h} for instance.
218 @end defmac
219
220 @defmac LINK_SPEC
221 A C string constant that tells the GCC driver program options to
222 pass to the linker.  It can also specify how to translate options you
223 give to GCC into options for GCC to pass to the linker.
224
225 Do not define this macro if it does not need to do anything.
226 @end defmac
227
228 @defmac LIB_SPEC
229 Another C string constant used much like @code{LINK_SPEC}.  The difference
230 between the two is that @code{LIB_SPEC} is used at the end of the
231 command given to the linker.
232
233 If this macro is not defined, a default is provided that
234 loads the standard C library from the usual place.  See @file{gcc.c}.
235 @end defmac
236
237 @defmac LIBGCC_SPEC
238 Another C string constant that tells the GCC driver program
239 how and when to place a reference to @file{libgcc.a} into the
240 linker command line.  This constant is placed both before and after
241 the value of @code{LIB_SPEC}.
242
243 If this macro is not defined, the GCC driver provides a default that
244 passes the string @option{-lgcc} to the linker.
245 @end defmac
246
247 @defmac REAL_LIBGCC_SPEC
248 By default, if @code{ENABLE_SHARED_LIBGCC} is defined, the
249 @code{LIBGCC_SPEC} is not directly used by the driver program but is
250 instead modified to refer to different versions of @file{libgcc.a}
251 depending on the values of the command line flags @option{-static},
252 @option{-shared}, @option{-static-libgcc}, and @option{-shared-libgcc}.  On
253 targets where these modifications are inappropriate, define
254 @code{REAL_LIBGCC_SPEC} instead.  @code{REAL_LIBGCC_SPEC} tells the
255 driver how to place a reference to @file{libgcc} on the link command
256 line, but, unlike @code{LIBGCC_SPEC}, it is used unmodified.
257 @end defmac
258
259 @defmac USE_LD_AS_NEEDED
260 A macro that controls the modifications to @code{LIBGCC_SPEC}
261 mentioned in @code{REAL_LIBGCC_SPEC}.  If nonzero, a spec will be
262 generated that uses @option{--as-needed} or equivalent options and the
263 shared @file{libgcc} in place of the
264 static exception handler library, when linking without any of
265 @code{-static}, @code{-static-libgcc}, or @code{-shared-libgcc}.
266 @end defmac
267
268 @defmac LINK_EH_SPEC
269 If defined, this C string constant is added to @code{LINK_SPEC}.
270 When @code{USE_LD_AS_NEEDED} is zero or undefined, it also affects
271 the modifications to @code{LIBGCC_SPEC} mentioned in
272 @code{REAL_LIBGCC_SPEC}.
273 @end defmac
274
275 @defmac STARTFILE_SPEC
276 Another C string constant used much like @code{LINK_SPEC}.  The
277 difference between the two is that @code{STARTFILE_SPEC} is used at
278 the very beginning of the command given to the linker.
279
280 If this macro is not defined, a default is provided that loads the
281 standard C startup file from the usual place.  See @file{gcc.c}.
282 @end defmac
283
284 @defmac ENDFILE_SPEC
285 Another C string constant used much like @code{LINK_SPEC}.  The
286 difference between the two is that @code{ENDFILE_SPEC} is used at
287 the very end of the command given to the linker.
288
289 Do not define this macro if it does not need to do anything.
290 @end defmac
291
292 @defmac THREAD_MODEL_SPEC
293 GCC @code{-v} will print the thread model GCC was configured to use.
294 However, this doesn't work on platforms that are multilibbed on thread
295 models, such as AIX 4.3.  On such platforms, define
296 @code{THREAD_MODEL_SPEC} such that it evaluates to a string without
297 blanks that names one of the recognized thread models.  @code{%*}, the
298 default value of this macro, will expand to the value of
299 @code{thread_file} set in @file{config.gcc}.
300 @end defmac
301
302 @defmac SYSROOT_SUFFIX_SPEC
303 Define this macro to add a suffix to the target sysroot when GCC is
304 configured with a sysroot.  This will cause GCC to search for usr/lib,
305 et al, within sysroot+suffix.
306 @end defmac
307
308 @defmac SYSROOT_HEADERS_SUFFIX_SPEC
309 Define this macro to add a headers_suffix to the target sysroot when
310 GCC is configured with a sysroot.  This will cause GCC to pass the
311 updated sysroot+headers_suffix to CPP, causing it to search for
312 usr/include, et al, within sysroot+headers_suffix.
313 @end defmac
314
315 @defmac EXTRA_SPECS
316 Define this macro to provide additional specifications to put in the
317 @file{specs} file that can be used in various specifications like
318 @code{CC1_SPEC}.
319
320 The definition should be an initializer for an array of structures,
321 containing a string constant, that defines the specification name, and a
322 string constant that provides the specification.
323
324 Do not define this macro if it does not need to do anything.
325
326 @code{EXTRA_SPECS} is useful when an architecture contains several
327 related targets, which have various @code{@dots{}_SPECS} which are similar
328 to each other, and the maintainer would like one central place to keep
329 these definitions.
330
331 For example, the PowerPC System V.4 targets use @code{EXTRA_SPECS} to
332 define either @code{_CALL_SYSV} when the System V calling sequence is
333 used or @code{_CALL_AIX} when the older AIX-based calling sequence is
334 used.
335
336 The @file{config/rs6000/rs6000.h} target file defines:
337
338 @smallexample
339 #define EXTRA_SPECS \
340   @{ "cpp_sysv_default", CPP_SYSV_DEFAULT @},
341
342 #define CPP_SYS_DEFAULT ""
343 @end smallexample
344
345 The @file{config/rs6000/sysv.h} target file defines:
346 @smallexample
347 #undef CPP_SPEC
348 #define CPP_SPEC \
349 "%@{posix: -D_POSIX_SOURCE @} \
350 %@{mcall-sysv: -D_CALL_SYSV @} \
351 %@{!mcall-sysv: %(cpp_sysv_default) @} \
352 %@{msoft-float: -D_SOFT_FLOAT@} %@{mcpu=403: -D_SOFT_FLOAT@}"
353
354 #undef CPP_SYSV_DEFAULT
355 #define CPP_SYSV_DEFAULT "-D_CALL_SYSV"
356 @end smallexample
357
358 while the @file{config/rs6000/eabiaix.h} target file defines
359 @code{CPP_SYSV_DEFAULT} as:
360
361 @smallexample
362 #undef CPP_SYSV_DEFAULT
363 #define CPP_SYSV_DEFAULT "-D_CALL_AIX"
364 @end smallexample
365 @end defmac
366
367 @defmac LINK_LIBGCC_SPECIAL_1
368 Define this macro if the driver program should find the library
369 @file{libgcc.a}.  If you do not define this macro, the driver program will pass
370 the argument @option{-lgcc} to tell the linker to do the search.
371 @end defmac
372
373 @defmac LINK_GCC_C_SEQUENCE_SPEC
374 The sequence in which libgcc and libc are specified to the linker.
375 By default this is @code{%G %L %G}.
376 @end defmac
377
378 @defmac LINK_COMMAND_SPEC
379 A C string constant giving the complete command line need to execute the
380 linker.  When you do this, you will need to update your port each time a
381 change is made to the link command line within @file{gcc.c}.  Therefore,
382 define this macro only if you need to completely redefine the command
383 line for invoking the linker and there is no other way to accomplish
384 the effect you need.  Overriding this macro may be avoidable by overriding
385 @code{LINK_GCC_C_SEQUENCE_SPEC} instead.
386 @end defmac
387
388 @deftypevr {Common Target Hook} bool TARGET_ALWAYS_STRIP_DOTDOT
389 True if @file{..} components should always be removed from directory names computed relative to GCC's internal directories, false (default) if such components should be preserved and directory names containing them passed to other tools such as the linker.
390 @end deftypevr
391
392 @defmac MULTILIB_DEFAULTS
393 Define this macro as a C expression for the initializer of an array of
394 string to tell the driver program which options are defaults for this
395 target and thus do not need to be handled specially when using
396 @code{MULTILIB_OPTIONS}.
397
398 Do not define this macro if @code{MULTILIB_OPTIONS} is not defined in
399 the target makefile fragment or if none of the options listed in
400 @code{MULTILIB_OPTIONS} are set by default.
401 @xref{Target Fragment}.
402 @end defmac
403
404 @defmac RELATIVE_PREFIX_NOT_LINKDIR
405 Define this macro to tell @command{gcc} that it should only translate
406 a @option{-B} prefix into a @option{-L} linker option if the prefix
407 indicates an absolute file name.
408 @end defmac
409
410 @defmac MD_EXEC_PREFIX
411 If defined, this macro is an additional prefix to try after
412 @code{STANDARD_EXEC_PREFIX}.  @code{MD_EXEC_PREFIX} is not searched
413 when the compiler is built as a cross
414 compiler.  If you define @code{MD_EXEC_PREFIX}, then be sure to add it
415 to the list of directories used to find the assembler in @file{configure.in}.
416 @end defmac
417
418 @defmac STANDARD_STARTFILE_PREFIX
419 Define this macro as a C string constant if you wish to override the
420 standard choice of @code{libdir} as the default prefix to
421 try when searching for startup files such as @file{crt0.o}.
422 @code{STANDARD_STARTFILE_PREFIX} is not searched when the compiler
423 is built as a cross compiler.
424 @end defmac
425
426 @defmac STANDARD_STARTFILE_PREFIX_1
427 Define this macro as a C string constant if you wish to override the
428 standard choice of @code{/lib} as a prefix to try after the default prefix
429 when searching for startup files such as @file{crt0.o}.
430 @code{STANDARD_STARTFILE_PREFIX_1} is not searched when the compiler
431 is built as a cross compiler.
432 @end defmac
433
434 @defmac STANDARD_STARTFILE_PREFIX_2
435 Define this macro as a C string constant if you wish to override the
436 standard choice of @code{/lib} as yet another prefix to try after the
437 default prefix when searching for startup files such as @file{crt0.o}.
438 @code{STANDARD_STARTFILE_PREFIX_2} is not searched when the compiler
439 is built as a cross compiler.
440 @end defmac
441
442 @defmac MD_STARTFILE_PREFIX
443 If defined, this macro supplies an additional prefix to try after the
444 standard prefixes.  @code{MD_EXEC_PREFIX} is not searched when the
445 compiler is built as a cross compiler.
446 @end defmac
447
448 @defmac MD_STARTFILE_PREFIX_1
449 If defined, this macro supplies yet another prefix to try after the
450 standard prefixes.  It is not searched when the compiler is built as a
451 cross compiler.
452 @end defmac
453
454 @defmac INIT_ENVIRONMENT
455 Define this macro as a C string constant if you wish to set environment
456 variables for programs called by the driver, such as the assembler and
457 loader.  The driver passes the value of this macro to @code{putenv} to
458 initialize the necessary environment variables.
459 @end defmac
460
461 @defmac LOCAL_INCLUDE_DIR
462 Define this macro as a C string constant if you wish to override the
463 standard choice of @file{/usr/local/include} as the default prefix to
464 try when searching for local header files.  @code{LOCAL_INCLUDE_DIR}
465 comes before @code{NATIVE_SYSTEM_HEADER_DIR} (set in
466 @file{config.gcc}, normally @file{/usr/include}) in the search order.
467
468 Cross compilers do not search either @file{/usr/local/include} or its
469 replacement.
470 @end defmac
471
472 @defmac NATIVE_SYSTEM_HEADER_COMPONENT
473 The ``component'' corresponding to @code{NATIVE_SYSTEM_HEADER_DIR}.
474 See @code{INCLUDE_DEFAULTS}, below, for the description of components.
475 If you do not define this macro, no component is used.
476 @end defmac
477
478 @defmac INCLUDE_DEFAULTS
479 Define this macro if you wish to override the entire default search path
480 for include files.  For a native compiler, the default search path
481 usually consists of @code{GCC_INCLUDE_DIR}, @code{LOCAL_INCLUDE_DIR},
482 @code{GPLUSPLUS_INCLUDE_DIR}, and
483 @code{NATIVE_SYSTEM_HEADER_DIR}.  In addition, @code{GPLUSPLUS_INCLUDE_DIR}
484 and @code{GCC_INCLUDE_DIR} are defined automatically by @file{Makefile},
485 and specify private search areas for GCC@.  The directory
486 @code{GPLUSPLUS_INCLUDE_DIR} is used only for C++ programs.
487
488 The definition should be an initializer for an array of structures.
489 Each array element should have four elements: the directory name (a
490 string constant), the component name (also a string constant), a flag
491 for C++-only directories,
492 and a flag showing that the includes in the directory don't need to be
493 wrapped in @code{extern @samp{C}} when compiling C++.  Mark the end of
494 the array with a null element.
495
496 The component name denotes what GNU package the include file is part of,
497 if any, in all uppercase letters.  For example, it might be @samp{GCC}
498 or @samp{BINUTILS}.  If the package is part of a vendor-supplied
499 operating system, code the component name as @samp{0}.
500
501 For example, here is the definition used for VAX/VMS:
502
503 @smallexample
504 #define INCLUDE_DEFAULTS \
505 @{                                       \
506   @{ "GNU_GXX_INCLUDE:", "G++", 1, 1@},   \
507   @{ "GNU_CC_INCLUDE:", "GCC", 0, 0@},    \
508   @{ "SYS$SYSROOT:[SYSLIB.]", 0, 0, 0@},  \
509   @{ ".", 0, 0, 0@},                      \
510   @{ 0, 0, 0, 0@}                         \
511 @}
512 @end smallexample
513 @end defmac
514
515 Here is the order of prefixes tried for exec files:
516
517 @enumerate
518 @item
519 Any prefixes specified by the user with @option{-B}.
520
521 @item
522 The environment variable @code{GCC_EXEC_PREFIX} or, if @code{GCC_EXEC_PREFIX}
523 is not set and the compiler has not been installed in the configure-time
524 @var{prefix}, the location in which the compiler has actually been installed.
525
526 @item
527 The directories specified by the environment variable @code{COMPILER_PATH}.
528
529 @item
530 The macro @code{STANDARD_EXEC_PREFIX}, if the compiler has been installed
531 in the configured-time @var{prefix}.
532
533 @item
534 The location @file{/usr/libexec/gcc/}, but only if this is a native compiler.
535
536 @item
537 The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
538
539 @item
540 The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
541 compiler.
542 @end enumerate
543
544 Here is the order of prefixes tried for startfiles:
545
546 @enumerate
547 @item
548 Any prefixes specified by the user with @option{-B}.
549
550 @item
551 The environment variable @code{GCC_EXEC_PREFIX} or its automatically determined
552 value based on the installed toolchain location.
553
554 @item
555 The directories specified by the environment variable @code{LIBRARY_PATH}
556 (or port-specific name; native only, cross compilers do not use this).
557
558 @item
559 The macro @code{STANDARD_EXEC_PREFIX}, but only if the toolchain is installed
560 in the configured @var{prefix} or this is a native compiler.
561
562 @item
563 The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
564
565 @item
566 The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
567 compiler.
568
569 @item
570 The macro @code{MD_STARTFILE_PREFIX}, if defined, but only if this is a
571 native compiler, or we have a target system root.
572
573 @item
574 The macro @code{MD_STARTFILE_PREFIX_1}, if defined, but only if this is a
575 native compiler, or we have a target system root.
576
577 @item
578 The macro @code{STANDARD_STARTFILE_PREFIX}, with any sysroot modifications.
579 If this path is relative it will be prefixed by @code{GCC_EXEC_PREFIX} and
580 the machine suffix or @code{STANDARD_EXEC_PREFIX} and the machine suffix.
581
582 @item
583 The macro @code{STANDARD_STARTFILE_PREFIX_1}, but only if this is a native
584 compiler, or we have a target system root. The default for this macro is
585 @file{/lib/}.
586
587 @item
588 The macro @code{STANDARD_STARTFILE_PREFIX_2}, but only if this is a native
589 compiler, or we have a target system root. The default for this macro is
590 @file{/usr/lib/}.
591 @end enumerate
592
593 @node Run-time Target
594 @section Run-time Target Specification
595 @cindex run-time target specification
596 @cindex predefined macros
597 @cindex target specifications
598
599 @c prevent bad page break with this line
600 Here are run-time target specifications.
601
602 @defmac TARGET_CPU_CPP_BUILTINS ()
603 This function-like macro expands to a block of code that defines
604 built-in preprocessor macros and assertions for the target CPU, using
605 the functions @code{builtin_define}, @code{builtin_define_std} and
606 @code{builtin_assert}.  When the front end
607 calls this macro it provides a trailing semicolon, and since it has
608 finished command line option processing your code can use those
609 results freely.
610
611 @code{builtin_assert} takes a string in the form you pass to the
612 command-line option @option{-A}, such as @code{cpu=mips}, and creates
613 the assertion.  @code{builtin_define} takes a string in the form
614 accepted by option @option{-D} and unconditionally defines the macro.
615
616 @code{builtin_define_std} takes a string representing the name of an
617 object-like macro.  If it doesn't lie in the user's namespace,
618 @code{builtin_define_std} defines it unconditionally.  Otherwise, it
619 defines a version with two leading underscores, and another version
620 with two leading and trailing underscores, and defines the original
621 only if an ISO standard was not requested on the command line.  For
622 example, passing @code{unix} defines @code{__unix}, @code{__unix__}
623 and possibly @code{unix}; passing @code{_mips} defines @code{__mips},
624 @code{__mips__} and possibly @code{_mips}, and passing @code{_ABI64}
625 defines only @code{_ABI64}.
626
627 You can also test for the C dialect being compiled.  The variable
628 @code{c_language} is set to one of @code{clk_c}, @code{clk_cplusplus}
629 or @code{clk_objective_c}.  Note that if we are preprocessing
630 assembler, this variable will be @code{clk_c} but the function-like
631 macro @code{preprocessing_asm_p()} will return true, so you might want
632 to check for that first.  If you need to check for strict ANSI, the
633 variable @code{flag_iso} can be used.  The function-like macro
634 @code{preprocessing_trad_p()} can be used to check for traditional
635 preprocessing.
636 @end defmac
637
638 @defmac TARGET_OS_CPP_BUILTINS ()
639 Similarly to @code{TARGET_CPU_CPP_BUILTINS} but this macro is optional
640 and is used for the target operating system instead.
641 @end defmac
642
643 @defmac TARGET_OBJFMT_CPP_BUILTINS ()
644 Similarly to @code{TARGET_CPU_CPP_BUILTINS} but this macro is optional
645 and is used for the target object format.  @file{elfos.h} uses this
646 macro to define @code{__ELF__}, so you probably do not need to define
647 it yourself.
648 @end defmac
649
650 @deftypevar {extern int} target_flags
651 This variable is declared in @file{options.h}, which is included before
652 any target-specific headers.
653 @end deftypevar
654
655 @deftypevr {Common Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
656 This variable specifies the initial value of @code{target_flags}.
657 Its default setting is 0.
658 @end deftypevr
659
660 @cindex optional hardware or system features
661 @cindex features, optional, in system conventions
662
663 @deftypefn {Common Target Hook} bool TARGET_HANDLE_OPTION (struct gcc_options *@var{opts}, struct gcc_options *@var{opts_set}, const struct cl_decoded_option *@var{decoded}, location_t @var{loc})
664 This hook is called whenever the user specifies one of the
665 target-specific options described by the @file{.opt} definition files
666 (@pxref{Options}).  It has the opportunity to do some option-specific
667 processing and should return true if the option is valid.  The default
668 definition does nothing but return true.
669
670 @var{decoded} specifies the option and its arguments.  @var{opts} and
671 @var{opts_set} are the @code{gcc_options} structures to be used for
672 storing option state, and @var{loc} is the location at which the
673 option was passed (@code{UNKNOWN_LOCATION} except for options passed
674 via attributes).
675 @end deftypefn
676
677 @deftypefn {C Target Hook} bool TARGET_HANDLE_C_OPTION (size_t @var{code}, const char *@var{arg}, int @var{value})
678 This target hook is called whenever the user specifies one of the
679 target-specific C language family options described by the @file{.opt}
680 definition files(@pxref{Options}).  It has the opportunity to do some
681 option-specific processing and should return true if the option is
682 valid.  The arguments are like for @code{TARGET_HANDLE_OPTION}.  The
683 default definition does nothing but return false.
684
685 In general, you should use @code{TARGET_HANDLE_OPTION} to handle
686 options.  However, if processing an option requires routines that are
687 only available in the C (and related language) front ends, then you
688 should use @code{TARGET_HANDLE_C_OPTION} instead.
689 @end deftypefn
690
691 @deftypefn {C Target Hook} tree TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree @var{string})
692 Targets may provide a string object type that can be used within and between C, C++ and their respective Objective-C dialects. A string object might, for example, embed encoding and length information. These objects are considered opaque to the compiler and handled as references. An ideal implementation makes the composition of the string object match that of the Objective-C @code{NSString} (@code{NXString} for GNUStep), allowing efficient interworking between C-only and Objective-C code. If a target implements string objects then this hook should return a reference to such an object constructed from the normal `C' string representation provided in @var{string}. At present, the hook is used by Objective-C only, to obtain a common-format string object when the target provides one.
693 @end deftypefn
694
695 @deftypefn {C Target Hook} void TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE (const char *@var{classname})
696 Declare that Objective C class @var{classname} is referenced  by the current TU.
697 @end deftypefn
698
699 @deftypefn {C Target Hook} void TARGET_OBJC_DECLARE_CLASS_DEFINITION (const char *@var{classname})
700 Declare that Objective C class @var{classname} is defined  by the current TU.
701 @end deftypefn
702
703 @deftypefn {C Target Hook} bool TARGET_STRING_OBJECT_REF_TYPE_P (const_tree @var{stringref})
704 If a target implements string objects then this hook should return @code{true} if @var{stringref} is a valid reference to such an object.
705 @end deftypefn
706
707 @deftypefn {C Target Hook} void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree @var{format_arg}, tree @var{args_list})
708 If a target implements string objects then this hook should should  provide a facility to check the function arguments in @var{args_list}  against the format specifiers in @var{format_arg} where the type of  @var{format_arg} is one recognized as a valid string reference type.
709 @end deftypefn
710
711 @deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
712 This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
713 but is called when the optimize level is changed via an attribute or
714 pragma or when it is reset at the end of the code affected by the
715 attribute or pragma.  It is not called at the beginning of compilation
716 when @code{TARGET_OPTION_OVERRIDE} is called so if you want to perform these
717 actions then, you should have @code{TARGET_OPTION_OVERRIDE} call
718 @code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}.
719 @end deftypefn
720
721 @defmac C_COMMON_OVERRIDE_OPTIONS
722 This is similar to the @code{TARGET_OPTION_OVERRIDE} hook
723 but is only used in the C
724 language frontends (C, Objective-C, C++, Objective-C++) and so can be
725 used to alter option flag variables which only exist in those
726 frontends.
727 @end defmac
728
729 @deftypevr {Common Target Hook} {const struct default_options *} TARGET_OPTION_OPTIMIZATION_TABLE
730 Some machines may desire to change what optimizations are performed for
731 various optimization levels.   This variable, if defined, describes
732 options to enable at particular sets of optimization levels.  These
733 options are processed once
734 just after the optimization level is determined and before the remainder
735 of the command options have been parsed, so may be overridden by other
736 options passed explicitly.
737
738 This processing is run once at program startup and when the optimization
739 options are changed via @code{#pragma GCC optimize} or by using the
740 @code{optimize} attribute.
741 @end deftypevr
742
743 @deftypefn {Common Target Hook} void TARGET_OPTION_INIT_STRUCT (struct gcc_options *@var{opts})
744 Set target-dependent initial values of fields in @var{opts}.
745 @end deftypefn
746
747 @deftypefn {Common Target Hook} void TARGET_OPTION_DEFAULT_PARAMS (void)
748 Set target-dependent default values for @option{--param} settings, using calls to @code{set_default_param_value}.
749 @end deftypefn
750
751 @defmac SWITCHABLE_TARGET
752 Some targets need to switch between substantially different subtargets
753 during compilation.  For example, the MIPS target has one subtarget for
754 the traditional MIPS architecture and another for MIPS16.  Source code
755 can switch between these two subarchitectures using the @code{mips16}
756 and @code{nomips16} attributes.
757
758 Such subtargets can differ in things like the set of available
759 registers, the set of available instructions, the costs of various
760 operations, and so on.  GCC caches a lot of this type of information
761 in global variables, and recomputing them for each subtarget takes a
762 significant amount of time.  The compiler therefore provides a facility
763 for maintaining several versions of the global variables and quickly
764 switching between them; see @file{target-globals.h} for details.
765
766 Define this macro to 1 if your target needs this facility.  The default
767 is 0.
768 @end defmac
769
770 @deftypefn {Target Hook} bool TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P (void)
771 Returns true if the target supports IEEE 754 floating-point exceptions and rounding modes, false otherwise.  This is intended to relate to the @code{float} and @code{double} types, but not necessarily @code{long double}. By default, returns true if the @code{adddf3} instruction pattern is available and false otherwise, on the assumption that hardware floating point supports exceptions and rounding modes but software floating point does not.
772 @end deftypefn
773
774 @node Per-Function Data
775 @section Defining data structures for per-function information.
776 @cindex per-function data
777 @cindex data structures
778
779 If the target needs to store information on a per-function basis, GCC
780 provides a macro and a couple of variables to allow this.  Note, just
781 using statics to store the information is a bad idea, since GCC supports
782 nested functions, so you can be halfway through encoding one function
783 when another one comes along.
784
785 GCC defines a data structure called @code{struct function} which
786 contains all of the data specific to an individual function.  This
787 structure contains a field called @code{machine} whose type is
788 @code{struct machine_function *}, which can be used by targets to point
789 to their own specific data.
790
791 If a target needs per-function specific data it should define the type
792 @code{struct machine_function} and also the macro @code{INIT_EXPANDERS}.
793 This macro should be used to initialize the function pointer
794 @code{init_machine_status}.  This pointer is explained below.
795
796 One typical use of per-function, target specific data is to create an
797 RTX to hold the register containing the function's return address.  This
798 RTX can then be used to implement the @code{__builtin_return_address}
799 function, for level 0.
800
801 Note---earlier implementations of GCC used a single data area to hold
802 all of the per-function information.  Thus when processing of a nested
803 function began the old per-function data had to be pushed onto a
804 stack, and when the processing was finished, it had to be popped off the
805 stack.  GCC used to provide function pointers called
806 @code{save_machine_status} and @code{restore_machine_status} to handle
807 the saving and restoring of the target specific information.  Since the
808 single data area approach is no longer used, these pointers are no
809 longer supported.
810
811 @defmac INIT_EXPANDERS
812 Macro called to initialize any target specific information.  This macro
813 is called once per function, before generation of any RTL has begun.
814 The intention of this macro is to allow the initialization of the
815 function pointer @code{init_machine_status}.
816 @end defmac
817
818 @deftypevar {void (*)(struct function *)} init_machine_status
819 If this function pointer is non-@code{NULL} it will be called once per
820 function, before function compilation starts, in order to allow the
821 target to perform any target specific initialization of the
822 @code{struct function} structure.  It is intended that this would be
823 used to initialize the @code{machine} of that structure.
824
825 @code{struct machine_function} structures are expected to be freed by GC@.
826 Generally, any memory that they reference must be allocated by using
827 GC allocation, including the structure itself.
828 @end deftypevar
829
830 @node Storage Layout
831 @section Storage Layout
832 @cindex storage layout
833
834 Note that the definitions of the macros in this table which are sizes or
835 alignments measured in bits do not need to be constant.  They can be C
836 expressions that refer to static variables, such as the @code{target_flags}.
837 @xref{Run-time Target}.
838
839 @defmac BITS_BIG_ENDIAN
840 Define this macro to have the value 1 if the most significant bit in a
841 byte has the lowest number; otherwise define it to have the value zero.
842 This means that bit-field instructions count from the most significant
843 bit.  If the machine has no bit-field instructions, then this must still
844 be defined, but it doesn't matter which value it is defined to.  This
845 macro need not be a constant.
846
847 This macro does not affect the way structure fields are packed into
848 bytes or words; that is controlled by @code{BYTES_BIG_ENDIAN}.
849 @end defmac
850
851 @defmac BYTES_BIG_ENDIAN
852 Define this macro to have the value 1 if the most significant byte in a
853 word has the lowest number.  This macro need not be a constant.
854 @end defmac
855
856 @defmac WORDS_BIG_ENDIAN
857 Define this macro to have the value 1 if, in a multiword object, the
858 most significant word has the lowest number.  This applies to both
859 memory locations and registers; see @code{REG_WORDS_BIG_ENDIAN} if the
860 order of words in memory is not the same as the order in registers.  This
861 macro need not be a constant.
862 @end defmac
863
864 @defmac REG_WORDS_BIG_ENDIAN
865 On some machines, the order of words in a multiword object differs between
866 registers in memory.  In such a situation, define this macro to describe
867 the order of words in a register.  The macro @code{WORDS_BIG_ENDIAN} controls
868 the order of words in memory.
869 @end defmac
870
871 @defmac FLOAT_WORDS_BIG_ENDIAN
872 Define this macro to have the value 1 if @code{DFmode}, @code{XFmode} or
873 @code{TFmode} floating point numbers are stored in memory with the word
874 containing the sign bit at the lowest address; otherwise define it to
875 have the value 0.  This macro need not be a constant.
876
877 You need not define this macro if the ordering is the same as for
878 multi-word integers.
879 @end defmac
880
881 @defmac BITS_PER_WORD
882 Number of bits in a word.  If you do not define this macro, the default
883 is @code{BITS_PER_UNIT * UNITS_PER_WORD}.
884 @end defmac
885
886 @defmac MAX_BITS_PER_WORD
887 Maximum number of bits in a word.  If this is undefined, the default is
888 @code{BITS_PER_WORD}.  Otherwise, it is the constant value that is the
889 largest value that @code{BITS_PER_WORD} can have at run-time.
890 @end defmac
891
892 @defmac UNITS_PER_WORD
893 Number of storage units in a word; normally the size of a general-purpose
894 register, a power of two from 1 or 8.
895 @end defmac
896
897 @defmac MIN_UNITS_PER_WORD
898 Minimum number of units in a word.  If this is undefined, the default is
899 @code{UNITS_PER_WORD}.  Otherwise, it is the constant value that is the
900 smallest value that @code{UNITS_PER_WORD} can have at run-time.
901 @end defmac
902
903 @defmac POINTER_SIZE
904 Width of a pointer, in bits.  You must specify a value no wider than the
905 width of @code{Pmode}.  If it is not equal to the width of @code{Pmode},
906 you must define @code{POINTERS_EXTEND_UNSIGNED}.  If you do not specify
907 a value the default is @code{BITS_PER_WORD}.
908 @end defmac
909
910 @defmac POINTERS_EXTEND_UNSIGNED
911 A C expression that determines how pointers should be extended from
912 @code{ptr_mode} to either @code{Pmode} or @code{word_mode}.  It is
913 greater than zero if pointers should be zero-extended, zero if they
914 should be sign-extended, and negative if some other sort of conversion
915 is needed.  In the last case, the extension is done by the target's
916 @code{ptr_extend} instruction.
917
918 You need not define this macro if the @code{ptr_mode}, @code{Pmode}
919 and @code{word_mode} are all the same width.
920 @end defmac
921
922 @defmac PROMOTE_MODE (@var{m}, @var{unsignedp}, @var{type})
923 A macro to update @var{m} and @var{unsignedp} when an object whose type
924 is @var{type} and which has the specified mode and signedness is to be
925 stored in a register.  This macro is only called when @var{type} is a
926 scalar type.
927
928 On most RISC machines, which only have operations that operate on a full
929 register, define this macro to set @var{m} to @code{word_mode} if
930 @var{m} is an integer mode narrower than @code{BITS_PER_WORD}.  In most
931 cases, only integer modes should be widened because wider-precision
932 floating-point operations are usually more expensive than their narrower
933 counterparts.
934
935 For most machines, the macro definition does not change @var{unsignedp}.
936 However, some machines, have instructions that preferentially handle
937 either signed or unsigned quantities of certain modes.  For example, on
938 the DEC Alpha, 32-bit loads from memory and 32-bit add instructions
939 sign-extend the result to 64 bits.  On such machines, set
940 @var{unsignedp} according to which kind of extension is more efficient.
941
942 Do not define this macro if it would never modify @var{m}.
943 @end defmac
944
945 @deftypefn {Target Hook} machine_mode TARGET_PROMOTE_FUNCTION_MODE (const_tree @var{type}, machine_mode @var{mode}, int *@var{punsignedp}, const_tree @var{funtype}, int @var{for_return})
946 Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or
947 function return values.  The target hook should return the new mode
948 and possibly change @code{*@var{punsignedp}} if the promotion should
949 change signedness.  This function is called only for scalar @emph{or
950 pointer} types.
951
952 @var{for_return} allows to distinguish the promotion of arguments and
953 return values.  If it is @code{1}, a return value is being promoted and
954 @code{TARGET_FUNCTION_VALUE} must perform the same promotions done here.
955 If it is @code{2}, the returned mode should be that of the register in
956 which an incoming parameter is copied, or the outgoing result is computed;
957 then the hook should return the same mode as @code{promote_mode}, though
958 the signedness may be different.
959
960 @var{type} can be NULL when promoting function arguments of libcalls.
961
962 The default is to not promote arguments and return values.  You can
963 also define the hook to @code{default_promote_function_mode_always_promote}
964 if you would like to apply the same rules given by @code{PROMOTE_MODE}.
965 @end deftypefn
966
967 @defmac PARM_BOUNDARY
968 Normal alignment required for function parameters on the stack, in
969 bits.  All stack parameters receive at least this much alignment
970 regardless of data type.  On most machines, this is the same as the
971 size of an integer.
972 @end defmac
973
974 @defmac STACK_BOUNDARY
975 Define this macro to the minimum alignment enforced by hardware for the
976 stack pointer on this machine.  The definition is a C expression for the
977 desired alignment (measured in bits).  This value is used as a default
978 if @code{PREFERRED_STACK_BOUNDARY} is not defined.  On most machines,
979 this should be the same as @code{PARM_BOUNDARY}.
980 @end defmac
981
982 @defmac PREFERRED_STACK_BOUNDARY
983 Define this macro if you wish to preserve a certain alignment for the
984 stack pointer, greater than what the hardware enforces.  The definition
985 is a C expression for the desired alignment (measured in bits).  This
986 macro must evaluate to a value equal to or larger than
987 @code{STACK_BOUNDARY}.
988 @end defmac
989
990 @defmac INCOMING_STACK_BOUNDARY
991 Define this macro if the incoming stack boundary may be different
992 from @code{PREFERRED_STACK_BOUNDARY}.  This macro must evaluate
993 to a value equal to or larger than @code{STACK_BOUNDARY}.
994 @end defmac
995
996 @defmac FUNCTION_BOUNDARY
997 Alignment required for a function entry point, in bits.
998 @end defmac
999
1000 @defmac BIGGEST_ALIGNMENT
1001 Biggest alignment that any data type can require on this machine, in
1002 bits.  Note that this is not the biggest alignment that is supported,
1003 just the biggest alignment that, when violated, may cause a fault.
1004 @end defmac
1005
1006 @defmac MALLOC_ABI_ALIGNMENT
1007 Alignment, in bits, a C conformant malloc implementation has to
1008 provide.  If not defined, the default value is @code{BITS_PER_WORD}.
1009 @end defmac
1010
1011 @defmac ATTRIBUTE_ALIGNED_VALUE
1012 Alignment used by the @code{__attribute__ ((aligned))} construct.  If
1013 not defined, the default value is @code{BIGGEST_ALIGNMENT}.
1014 @end defmac
1015
1016 @defmac MINIMUM_ATOMIC_ALIGNMENT
1017 If defined, the smallest alignment, in bits, that can be given to an
1018 object that can be referenced in one operation, without disturbing any
1019 nearby object.  Normally, this is @code{BITS_PER_UNIT}, but may be larger
1020 on machines that don't have byte or half-word store operations.
1021 @end defmac
1022
1023 @defmac BIGGEST_FIELD_ALIGNMENT
1024 Biggest alignment that any structure or union field can require on this
1025 machine, in bits.  If defined, this overrides @code{BIGGEST_ALIGNMENT} for
1026 structure and union fields only, unless the field alignment has been set
1027 by the @code{__attribute__ ((aligned (@var{n})))} construct.
1028 @end defmac
1029
1030 @defmac ADJUST_FIELD_ALIGN (@var{field}, @var{computed})
1031 An expression for the alignment of a structure field @var{field} if the
1032 alignment computed in the usual way (including applying of
1033 @code{BIGGEST_ALIGNMENT} and @code{BIGGEST_FIELD_ALIGNMENT} to the
1034 alignment) is @var{computed}.  It overrides alignment only if the
1035 field alignment has not been set by the
1036 @code{__attribute__ ((aligned (@var{n})))} construct.
1037 @end defmac
1038
1039 @defmac MAX_STACK_ALIGNMENT
1040 Biggest stack alignment guaranteed by the backend.  Use this macro
1041 to specify the maximum alignment of a variable on stack.
1042
1043 If not defined, the default value is @code{STACK_BOUNDARY}.
1044
1045 @c FIXME: The default should be @code{PREFERRED_STACK_BOUNDARY}.
1046 @c But the fix for PR 32893 indicates that we can only guarantee
1047 @c maximum stack alignment on stack up to @code{STACK_BOUNDARY}, not
1048 @c @code{PREFERRED_STACK_BOUNDARY}, if stack alignment isn't supported.
1049 @end defmac
1050
1051 @defmac MAX_OFILE_ALIGNMENT
1052 Biggest alignment supported by the object file format of this machine.
1053 Use this macro to limit the alignment which can be specified using the
1054 @code{__attribute__ ((aligned (@var{n})))} construct.  If not defined,
1055 the default value is @code{BIGGEST_ALIGNMENT}.
1056
1057 On systems that use ELF, the default (in @file{config/elfos.h}) is
1058 the largest supported 32-bit ELF section alignment representable on
1059 a 32-bit host e.g. @samp{(((uint64_t) 1 << 28) * 8)}.
1060 On 32-bit ELF the largest supported section alignment in bits is
1061 @samp{(0x80000000 * 8)}, but this is not representable on 32-bit hosts.
1062 @end defmac
1063
1064 @defmac DATA_ALIGNMENT (@var{type}, @var{basic-align})
1065 If defined, a C expression to compute the alignment for a variable in
1066 the static store.  @var{type} is the data type, and @var{basic-align} is
1067 the alignment that the object would ordinarily have.  The value of this
1068 macro is used instead of that alignment to align the object.
1069
1070 If this macro is not defined, then @var{basic-align} is used.
1071
1072 @findex strcpy
1073 One use of this macro is to increase alignment of medium-size data to
1074 make it all fit in fewer cache lines.  Another is to cause character
1075 arrays to be word-aligned so that @code{strcpy} calls that copy
1076 constants to character arrays can be done inline.
1077 @end defmac
1078
1079 @defmac DATA_ABI_ALIGNMENT (@var{type}, @var{basic-align})
1080 Similar to @code{DATA_ALIGNMENT}, but for the cases where the ABI mandates
1081 some alignment increase, instead of optimization only purposes.  E.g.@
1082 AMD x86-64 psABI says that variables with array type larger than 15 bytes
1083 must be aligned to 16 byte boundaries.
1084
1085 If this macro is not defined, then @var{basic-align} is used.
1086 @end defmac
1087
1088 @defmac CONSTANT_ALIGNMENT (@var{constant}, @var{basic-align})
1089 If defined, a C expression to compute the alignment given to a constant
1090 that is being placed in memory.  @var{constant} is the constant and
1091 @var{basic-align} is the alignment that the object would ordinarily
1092 have.  The value of this macro is used instead of that alignment to
1093 align the object.
1094
1095 If this macro is not defined, then @var{basic-align} is used.
1096
1097 The typical use of this macro is to increase alignment for string
1098 constants to be word aligned so that @code{strcpy} calls that copy
1099 constants can be done inline.
1100 @end defmac
1101
1102 @defmac LOCAL_ALIGNMENT (@var{type}, @var{basic-align})
1103 If defined, a C expression to compute the alignment for a variable in
1104 the local store.  @var{type} is the data type, and @var{basic-align} is
1105 the alignment that the object would ordinarily have.  The value of this
1106 macro is used instead of that alignment to align the object.
1107
1108 If this macro is not defined, then @var{basic-align} is used.
1109
1110 One use of this macro is to increase alignment of medium-size data to
1111 make it all fit in fewer cache lines.
1112
1113 If the value of this macro has a type, it should be an unsigned type.
1114 @end defmac
1115
1116 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_VECTOR_ALIGNMENT (const_tree @var{type})
1117 This hook can be used to define the alignment for a vector of type
1118 @var{type}, in order to comply with a platform ABI.  The default is to
1119 require natural alignment for vector types.  The alignment returned by
1120 this hook must be a power-of-two multiple of the default alignment of
1121 the vector element type.
1122 @end deftypefn
1123
1124 @defmac STACK_SLOT_ALIGNMENT (@var{type}, @var{mode}, @var{basic-align})
1125 If defined, a C expression to compute the alignment for stack slot.
1126 @var{type} is the data type, @var{mode} is the widest mode available,
1127 and @var{basic-align} is the alignment that the slot would ordinarily
1128 have.  The value of this macro is used instead of that alignment to
1129 align the slot.
1130
1131 If this macro is not defined, then @var{basic-align} is used when
1132 @var{type} is @code{NULL}.  Otherwise, @code{LOCAL_ALIGNMENT} will
1133 be used.
1134
1135 This macro is to set alignment of stack slot to the maximum alignment
1136 of all possible modes which the slot may have.
1137
1138 If the value of this macro has a type, it should be an unsigned type.
1139 @end defmac
1140
1141 @defmac LOCAL_DECL_ALIGNMENT (@var{decl})
1142 If defined, a C expression to compute the alignment for a local
1143 variable @var{decl}.
1144
1145 If this macro is not defined, then
1146 @code{LOCAL_ALIGNMENT (TREE_TYPE (@var{decl}), DECL_ALIGN (@var{decl}))}
1147 is used.
1148
1149 One use of this macro is to increase alignment of medium-size data to
1150 make it all fit in fewer cache lines.
1151
1152 If the value of this macro has a type, it should be an unsigned type.
1153 @end defmac
1154
1155 @defmac MINIMUM_ALIGNMENT (@var{exp}, @var{mode}, @var{align})
1156 If defined, a C expression to compute the minimum required alignment
1157 for dynamic stack realignment purposes for @var{exp} (a type or decl),
1158 @var{mode}, assuming normal alignment @var{align}.
1159
1160 If this macro is not defined, then @var{align} will be used.
1161 @end defmac
1162
1163 @defmac EMPTY_FIELD_BOUNDARY
1164 Alignment in bits to be given to a structure bit-field that follows an
1165 empty field such as @code{int : 0;}.
1166
1167 If @code{PCC_BITFIELD_TYPE_MATTERS} is true, it overrides this macro.
1168 @end defmac
1169
1170 @defmac STRUCTURE_SIZE_BOUNDARY
1171 Number of bits which any structure or union's size must be a multiple of.
1172 Each structure or union's size is rounded up to a multiple of this.
1173
1174 If you do not define this macro, the default is the same as
1175 @code{BITS_PER_UNIT}.
1176 @end defmac
1177
1178 @defmac STRICT_ALIGNMENT
1179 Define this macro to be the value 1 if instructions will fail to work
1180 if given data not on the nominal alignment.  If instructions will merely
1181 go slower in that case, define this macro as 0.
1182 @end defmac
1183
1184 @defmac PCC_BITFIELD_TYPE_MATTERS
1185 Define this if you wish to imitate the way many other C compilers handle
1186 alignment of bit-fields and the structures that contain them.
1187
1188 The behavior is that the type written for a named bit-field (@code{int},
1189 @code{short}, or other integer type) imposes an alignment for the entire
1190 structure, as if the structure really did contain an ordinary field of
1191 that type.  In addition, the bit-field is placed within the structure so
1192 that it would fit within such a field, not crossing a boundary for it.
1193
1194 Thus, on most machines, a named bit-field whose type is written as
1195 @code{int} would not cross a four-byte boundary, and would force
1196 four-byte alignment for the whole structure.  (The alignment used may
1197 not be four bytes; it is controlled by the other alignment parameters.)
1198
1199 An unnamed bit-field will not affect the alignment of the containing
1200 structure.
1201
1202 If the macro is defined, its definition should be a C expression;
1203 a nonzero value for the expression enables this behavior.
1204
1205 Note that if this macro is not defined, or its value is zero, some
1206 bit-fields may cross more than one alignment boundary.  The compiler can
1207 support such references if there are @samp{insv}, @samp{extv}, and
1208 @samp{extzv} insns that can directly reference memory.
1209
1210 The other known way of making bit-fields work is to define
1211 @code{STRUCTURE_SIZE_BOUNDARY} as large as @code{BIGGEST_ALIGNMENT}.
1212 Then every structure can be accessed with fullwords.
1213
1214 Unless the machine has bit-field instructions or you define
1215 @code{STRUCTURE_SIZE_BOUNDARY} that way, you must define
1216 @code{PCC_BITFIELD_TYPE_MATTERS} to have a nonzero value.
1217
1218 If your aim is to make GCC use the same conventions for laying out
1219 bit-fields as are used by another compiler, here is how to investigate
1220 what the other compiler does.  Compile and run this program:
1221
1222 @smallexample
1223 struct foo1
1224 @{
1225   char x;
1226   char :0;
1227   char y;
1228 @};
1229
1230 struct foo2
1231 @{
1232   char x;
1233   int :0;
1234   char y;
1235 @};
1236
1237 main ()
1238 @{
1239   printf ("Size of foo1 is %d\n",
1240           sizeof (struct foo1));
1241   printf ("Size of foo2 is %d\n",
1242           sizeof (struct foo2));
1243   exit (0);
1244 @}
1245 @end smallexample
1246
1247 If this prints 2 and 5, then the compiler's behavior is what you would
1248 get from @code{PCC_BITFIELD_TYPE_MATTERS}.
1249 @end defmac
1250
1251 @defmac BITFIELD_NBYTES_LIMITED
1252 Like @code{PCC_BITFIELD_TYPE_MATTERS} except that its effect is limited
1253 to aligning a bit-field within the structure.
1254 @end defmac
1255
1256 @deftypefn {Target Hook} bool TARGET_ALIGN_ANON_BITFIELD (void)
1257 When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine
1258 whether unnamed bitfields affect the alignment of the containing
1259 structure.  The hook should return true if the structure should inherit
1260 the alignment requirements of an unnamed bitfield's type.
1261 @end deftypefn
1262
1263 @deftypefn {Target Hook} bool TARGET_NARROW_VOLATILE_BITFIELD (void)
1264 This target hook should return @code{true} if accesses to volatile bitfields
1265 should use the narrowest mode possible.  It should return @code{false} if
1266 these accesses should use the bitfield container type.
1267
1268 The default is @code{false}.
1269 @end deftypefn
1270
1271 @deftypefn {Target Hook} bool TARGET_MEMBER_TYPE_FORCES_BLK (const_tree @var{field}, machine_mode @var{mode})
1272 Return true if a structure, union or array containing @var{field} should
1273 be accessed using @code{BLKMODE}.
1274
1275 If @var{field} is the only field in the structure, @var{mode} is its
1276 mode, otherwise @var{mode} is VOIDmode.  @var{mode} is provided in the
1277 case where structures of one field would require the structure's mode to
1278 retain the field's mode.
1279
1280 Normally, this is not needed.
1281 @end deftypefn
1282
1283 @defmac ROUND_TYPE_ALIGN (@var{type}, @var{computed}, @var{specified})
1284 Define this macro as an expression for the alignment of a type (given
1285 by @var{type} as a tree node) if the alignment computed in the usual
1286 way is @var{computed} and the alignment explicitly specified was
1287 @var{specified}.
1288
1289 The default is to use @var{specified} if it is larger; otherwise, use
1290 the smaller of @var{computed} and @code{BIGGEST_ALIGNMENT}
1291 @end defmac
1292
1293 @defmac MAX_FIXED_MODE_SIZE
1294 An integer expression for the size in bits of the largest integer
1295 machine mode that should actually be used.  All integer machine modes of
1296 this size or smaller can be used for structures and unions with the
1297 appropriate sizes.  If this macro is undefined, @code{GET_MODE_BITSIZE
1298 (DImode)} is assumed.
1299 @end defmac
1300
1301 @defmac STACK_SAVEAREA_MODE (@var{save_level})
1302 If defined, an expression of type @code{machine_mode} that
1303 specifies the mode of the save area operand of a
1304 @code{save_stack_@var{level}} named pattern (@pxref{Standard Names}).
1305 @var{save_level} is one of @code{SAVE_BLOCK}, @code{SAVE_FUNCTION}, or
1306 @code{SAVE_NONLOCAL} and selects which of the three named patterns is
1307 having its mode specified.
1308
1309 You need not define this macro if it always returns @code{Pmode}.  You
1310 would most commonly define this macro if the
1311 @code{save_stack_@var{level}} patterns need to support both a 32- and a
1312 64-bit mode.
1313 @end defmac
1314
1315 @defmac STACK_SIZE_MODE
1316 If defined, an expression of type @code{machine_mode} that
1317 specifies the mode of the size increment operand of an
1318 @code{allocate_stack} named pattern (@pxref{Standard Names}).
1319
1320 You need not define this macro if it always returns @code{word_mode}.
1321 You would most commonly define this macro if the @code{allocate_stack}
1322 pattern needs to support both a 32- and a 64-bit mode.
1323 @end defmac
1324
1325 @deftypefn {Target Hook} machine_mode TARGET_LIBGCC_CMP_RETURN_MODE (void)
1326 This target hook should return the mode to be used for the return value
1327 of compare instructions expanded to libgcc calls.  If not defined
1328 @code{word_mode} is returned which is the right choice for a majority of
1329 targets.
1330 @end deftypefn
1331
1332 @deftypefn {Target Hook} machine_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void)
1333 This target hook should return the mode to be used for the shift count operand
1334 of shift instructions expanded to libgcc calls.  If not defined
1335 @code{word_mode} is returned which is the right choice for a majority of
1336 targets.
1337 @end deftypefn
1338
1339 @deftypefn {Target Hook} machine_mode TARGET_UNWIND_WORD_MODE (void)
1340 Return machine mode to be used for @code{_Unwind_Word} type.
1341 The default is to use @code{word_mode}.
1342 @end deftypefn
1343
1344 @deftypefn {Target Hook} bool TARGET_MS_BITFIELD_LAYOUT_P (const_tree @var{record_type})
1345 This target hook returns @code{true} if bit-fields in the given
1346 @var{record_type} are to be laid out following the rules of Microsoft
1347 Visual C/C++, namely: (i) a bit-field won't share the same storage
1348 unit with the previous bit-field if their underlying types have
1349 different sizes, and the bit-field will be aligned to the highest
1350 alignment of the underlying types of itself and of the previous
1351 bit-field; (ii) a zero-sized bit-field will affect the alignment of
1352 the whole enclosing structure, even if it is unnamed; except that
1353 (iii) a zero-sized bit-field will be disregarded unless it follows
1354 another bit-field of nonzero size.  If this hook returns @code{true},
1355 other macros that control bit-field layout are ignored.
1356
1357 When a bit-field is inserted into a packed record, the whole size
1358 of the underlying type is used by one or more same-size adjacent
1359 bit-fields (that is, if its long:3, 32 bits is used in the record,
1360 and any additional adjacent long bit-fields are packed into the same
1361 chunk of 32 bits.  However, if the size changes, a new field of that
1362 size is allocated).  In an unpacked record, this is the same as using
1363 alignment, but not equivalent when packing.
1364
1365 If both MS bit-fields and @samp{__attribute__((packed))} are used,
1366 the latter will take precedence.  If @samp{__attribute__((packed))} is
1367 used on a single field when MS bit-fields are in use, it will take
1368 precedence for that field, but the alignment of the rest of the structure
1369 may affect its placement.
1370 @end deftypefn
1371
1372 @deftypefn {Target Hook} bool TARGET_DECIMAL_FLOAT_SUPPORTED_P (void)
1373 Returns true if the target supports decimal floating point.
1374 @end deftypefn
1375
1376 @deftypefn {Target Hook} bool TARGET_FIXED_POINT_SUPPORTED_P (void)
1377 Returns true if the target supports fixed-point arithmetic.
1378 @end deftypefn
1379
1380 @deftypefn {Target Hook} void TARGET_EXPAND_TO_RTL_HOOK (void)
1381 This hook is called just before expansion into rtl, allowing the target
1382 to perform additional initializations or analysis before the expansion.
1383 For example, the rs6000 port uses it to allocate a scratch stack slot
1384 for use in copying SDmode values between memory and floating point
1385 registers whenever the function being expanded has any SDmode
1386 usage.
1387 @end deftypefn
1388
1389 @deftypefn {Target Hook} void TARGET_INSTANTIATE_DECLS (void)
1390 This hook allows the backend to perform additional instantiations on rtl
1391 that are not actually in any insns yet, but will be later.
1392 @end deftypefn
1393
1394 @deftypefn {Target Hook} {const char *} TARGET_MANGLE_TYPE (const_tree @var{type})
1395 If your target defines any fundamental types, or any types your target
1396 uses should be mangled differently from the default, define this hook
1397 to return the appropriate encoding for these types as part of a C++
1398 mangled name.  The @var{type} argument is the tree structure representing
1399 the type to be mangled.  The hook may be applied to trees which are
1400 not target-specific fundamental types; it should return @code{NULL}
1401 for all such types, as well as arguments it does not recognize.  If the
1402 return value is not @code{NULL}, it must point to a statically-allocated
1403 string constant.
1404
1405 Target-specific fundamental types might be new fundamental types or
1406 qualified versions of ordinary fundamental types.  Encode new
1407 fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}
1408 is the name used for the type in source code, and @var{n} is the
1409 length of @var{name} in decimal.  Encode qualified versions of
1410 ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where
1411 @var{name} is the name used for the type qualifier in source code,
1412 @var{n} is the length of @var{name} as above, and @var{code} is the
1413 code used to represent the unqualified version of this type.  (See
1414 @code{write_builtin_type} in @file{cp/mangle.c} for the list of
1415 codes.)  In both cases the spaces are for clarity; do not include any
1416 spaces in your string.
1417
1418 This hook is applied to types prior to typedef resolution.  If the mangled
1419 name for a particular type depends only on that type's main variant, you
1420 can perform typedef resolution yourself using @code{TYPE_MAIN_VARIANT}
1421 before mangling.
1422
1423 The default version of this hook always returns @code{NULL}, which is
1424 appropriate for a target that does not define any new fundamental
1425 types.
1426 @end deftypefn
1427
1428 @node Type Layout
1429 @section Layout of Source Language Data Types
1430
1431 These macros define the sizes and other characteristics of the standard
1432 basic data types used in programs being compiled.  Unlike the macros in
1433 the previous section, these apply to specific features of C and related
1434 languages, rather than to fundamental aspects of storage layout.
1435
1436 @defmac INT_TYPE_SIZE
1437 A C expression for the size in bits of the type @code{int} on the
1438 target machine.  If you don't define this, the default is one word.
1439 @end defmac
1440
1441 @defmac SHORT_TYPE_SIZE
1442 A C expression for the size in bits of the type @code{short} on the
1443 target machine.  If you don't define this, the default is half a word.
1444 (If this would be less than one storage unit, it is rounded up to one
1445 unit.)
1446 @end defmac
1447
1448 @defmac LONG_TYPE_SIZE
1449 A C expression for the size in bits of the type @code{long} on the
1450 target machine.  If you don't define this, the default is one word.
1451 @end defmac
1452
1453 @defmac ADA_LONG_TYPE_SIZE
1454 On some machines, the size used for the Ada equivalent of the type
1455 @code{long} by a native Ada compiler differs from that used by C@.  In
1456 that situation, define this macro to be a C expression to be used for
1457 the size of that type.  If you don't define this, the default is the
1458 value of @code{LONG_TYPE_SIZE}.
1459 @end defmac
1460
1461 @defmac LONG_LONG_TYPE_SIZE
1462 A C expression for the size in bits of the type @code{long long} on the
1463 target machine.  If you don't define this, the default is two
1464 words.  If you want to support GNU Ada on your machine, the value of this
1465 macro must be at least 64.
1466 @end defmac
1467
1468 @defmac CHAR_TYPE_SIZE
1469 A C expression for the size in bits of the type @code{char} on the
1470 target machine.  If you don't define this, the default is
1471 @code{BITS_PER_UNIT}.
1472 @end defmac
1473
1474 @defmac BOOL_TYPE_SIZE
1475 A C expression for the size in bits of the C++ type @code{bool} and
1476 C99 type @code{_Bool} on the target machine.  If you don't define
1477 this, and you probably shouldn't, the default is @code{CHAR_TYPE_SIZE}.
1478 @end defmac
1479
1480 @defmac FLOAT_TYPE_SIZE
1481 A C expression for the size in bits of the type @code{float} on the
1482 target machine.  If you don't define this, the default is one word.
1483 @end defmac
1484
1485 @defmac DOUBLE_TYPE_SIZE
1486 A C expression for the size in bits of the type @code{double} on the
1487 target machine.  If you don't define this, the default is two
1488 words.
1489 @end defmac
1490
1491 @defmac LONG_DOUBLE_TYPE_SIZE
1492 A C expression for the size in bits of the type @code{long double} on
1493 the target machine.  If you don't define this, the default is two
1494 words.
1495 @end defmac
1496
1497 @defmac SHORT_FRACT_TYPE_SIZE
1498 A C expression for the size in bits of the type @code{short _Fract} on
1499 the target machine.  If you don't define this, the default is
1500 @code{BITS_PER_UNIT}.
1501 @end defmac
1502
1503 @defmac FRACT_TYPE_SIZE
1504 A C expression for the size in bits of the type @code{_Fract} on
1505 the target machine.  If you don't define this, the default is
1506 @code{BITS_PER_UNIT * 2}.
1507 @end defmac
1508
1509 @defmac LONG_FRACT_TYPE_SIZE
1510 A C expression for the size in bits of the type @code{long _Fract} on
1511 the target machine.  If you don't define this, the default is
1512 @code{BITS_PER_UNIT * 4}.
1513 @end defmac
1514
1515 @defmac LONG_LONG_FRACT_TYPE_SIZE
1516 A C expression for the size in bits of the type @code{long long _Fract} on
1517 the target machine.  If you don't define this, the default is
1518 @code{BITS_PER_UNIT * 8}.
1519 @end defmac
1520
1521 @defmac SHORT_ACCUM_TYPE_SIZE
1522 A C expression for the size in bits of the type @code{short _Accum} on
1523 the target machine.  If you don't define this, the default is
1524 @code{BITS_PER_UNIT * 2}.
1525 @end defmac
1526
1527 @defmac ACCUM_TYPE_SIZE
1528 A C expression for the size in bits of the type @code{_Accum} on
1529 the target machine.  If you don't define this, the default is
1530 @code{BITS_PER_UNIT * 4}.
1531 @end defmac
1532
1533 @defmac LONG_ACCUM_TYPE_SIZE
1534 A C expression for the size in bits of the type @code{long _Accum} on
1535 the target machine.  If you don't define this, the default is
1536 @code{BITS_PER_UNIT * 8}.
1537 @end defmac
1538
1539 @defmac LONG_LONG_ACCUM_TYPE_SIZE
1540 A C expression for the size in bits of the type @code{long long _Accum} on
1541 the target machine.  If you don't define this, the default is
1542 @code{BITS_PER_UNIT * 16}.
1543 @end defmac
1544
1545 @defmac LIBGCC2_GNU_PREFIX
1546 This macro corresponds to the @code{TARGET_LIBFUNC_GNU_PREFIX} target
1547 hook and should be defined if that hook is overriden to be true.  It
1548 causes function names in libgcc to be changed to use a @code{__gnu_}
1549 prefix for their name rather than the default @code{__}.  A port which
1550 uses this macro should also arrange to use @file{t-gnu-prefix} in
1551 the libgcc @file{config.host}.
1552 @end defmac
1553
1554 @defmac TARGET_FLT_EVAL_METHOD
1555 A C expression for the value for @code{FLT_EVAL_METHOD} in @file{float.h},
1556 assuming, if applicable, that the floating-point control word is in its
1557 default state.  If you do not define this macro the value of
1558 @code{FLT_EVAL_METHOD} will be zero.
1559 @end defmac
1560
1561 @defmac WIDEST_HARDWARE_FP_SIZE
1562 A C expression for the size in bits of the widest floating-point format
1563 supported by the hardware.  If you define this macro, you must specify a
1564 value less than or equal to the value of @code{LONG_DOUBLE_TYPE_SIZE}.
1565 If you do not define this macro, the value of @code{LONG_DOUBLE_TYPE_SIZE}
1566 is the default.
1567 @end defmac
1568
1569 @defmac DEFAULT_SIGNED_CHAR
1570 An expression whose value is 1 or 0, according to whether the type
1571 @code{char} should be signed or unsigned by default.  The user can
1572 always override this default with the options @option{-fsigned-char}
1573 and @option{-funsigned-char}.
1574 @end defmac
1575
1576 @deftypefn {Target Hook} bool TARGET_DEFAULT_SHORT_ENUMS (void)
1577 This target hook should return true if the compiler should give an
1578 @code{enum} type only as many bytes as it takes to represent the range
1579 of possible values of that type.  It should return false if all
1580 @code{enum} types should be allocated like @code{int}.
1581
1582 The default is to return false.
1583 @end deftypefn
1584
1585 @defmac SIZE_TYPE
1586 A C expression for a string describing the name of the data type to use
1587 for size values.  The typedef name @code{size_t} is defined using the
1588 contents of the string.
1589
1590 The string can contain more than one keyword.  If so, separate them with
1591 spaces, and write first any length keyword, then @code{unsigned} if
1592 appropriate, and finally @code{int}.  The string must exactly match one
1593 of the data type names defined in the function
1594 @code{c_common_nodes_and_builtins} in the file @file{c-family/c-common.c}.
1595 You may not omit @code{int} or change the order---that would cause the
1596 compiler to crash on startup.
1597
1598 If you don't define this macro, the default is @code{"long unsigned
1599 int"}.
1600 @end defmac
1601
1602 @defmac SIZETYPE
1603 GCC defines internal types (@code{sizetype}, @code{ssizetype},
1604 @code{bitsizetype} and @code{sbitsizetype}) for expressions
1605 dealing with size.  This macro is a C expression for a string describing
1606 the name of the data type from which the precision of @code{sizetype}
1607 is extracted.
1608
1609 The string has the same restrictions as @code{SIZE_TYPE} string.
1610
1611 If you don't define this macro, the default is @code{SIZE_TYPE}.
1612 @end defmac
1613
1614 @defmac PTRDIFF_TYPE
1615 A C expression for a string describing the name of the data type to use
1616 for the result of subtracting two pointers.  The typedef name
1617 @code{ptrdiff_t} is defined using the contents of the string.  See
1618 @code{SIZE_TYPE} above for more information.
1619
1620 If you don't define this macro, the default is @code{"long int"}.
1621 @end defmac
1622
1623 @defmac WCHAR_TYPE
1624 A C expression for a string describing the name of the data type to use
1625 for wide characters.  The typedef name @code{wchar_t} is defined using
1626 the contents of the string.  See @code{SIZE_TYPE} above for more
1627 information.
1628
1629 If you don't define this macro, the default is @code{"int"}.
1630 @end defmac
1631
1632 @defmac WCHAR_TYPE_SIZE
1633 A C expression for the size in bits of the data type for wide
1634 characters.  This is used in @code{cpp}, which cannot make use of
1635 @code{WCHAR_TYPE}.
1636 @end defmac
1637
1638 @defmac WINT_TYPE
1639 A C expression for a string describing the name of the data type to
1640 use for wide characters passed to @code{printf} and returned from
1641 @code{getwc}.  The typedef name @code{wint_t} is defined using the
1642 contents of the string.  See @code{SIZE_TYPE} above for more
1643 information.
1644
1645 If you don't define this macro, the default is @code{"unsigned int"}.
1646 @end defmac
1647
1648 @defmac INTMAX_TYPE
1649 A C expression for a string describing the name of the data type that
1650 can represent any value of any standard or extended signed integer type.
1651 The typedef name @code{intmax_t} is defined using the contents of the
1652 string.  See @code{SIZE_TYPE} above for more information.
1653
1654 If you don't define this macro, the default is the first of
1655 @code{"int"}, @code{"long int"}, or @code{"long long int"} that has as
1656 much precision as @code{long long int}.
1657 @end defmac
1658
1659 @defmac UINTMAX_TYPE
1660 A C expression for a string describing the name of the data type that
1661 can represent any value of any standard or extended unsigned integer
1662 type.  The typedef name @code{uintmax_t} is defined using the contents
1663 of the string.  See @code{SIZE_TYPE} above for more information.
1664
1665 If you don't define this macro, the default is the first of
1666 @code{"unsigned int"}, @code{"long unsigned int"}, or @code{"long long
1667 unsigned int"} that has as much precision as @code{long long unsigned
1668 int}.
1669 @end defmac
1670
1671 @defmac SIG_ATOMIC_TYPE
1672 @defmacx INT8_TYPE
1673 @defmacx INT16_TYPE
1674 @defmacx INT32_TYPE
1675 @defmacx INT64_TYPE
1676 @defmacx UINT8_TYPE
1677 @defmacx UINT16_TYPE
1678 @defmacx UINT32_TYPE
1679 @defmacx UINT64_TYPE
1680 @defmacx INT_LEAST8_TYPE
1681 @defmacx INT_LEAST16_TYPE
1682 @defmacx INT_LEAST32_TYPE
1683 @defmacx INT_LEAST64_TYPE
1684 @defmacx UINT_LEAST8_TYPE
1685 @defmacx UINT_LEAST16_TYPE
1686 @defmacx UINT_LEAST32_TYPE
1687 @defmacx UINT_LEAST64_TYPE
1688 @defmacx INT_FAST8_TYPE
1689 @defmacx INT_FAST16_TYPE
1690 @defmacx INT_FAST32_TYPE
1691 @defmacx INT_FAST64_TYPE
1692 @defmacx UINT_FAST8_TYPE
1693 @defmacx UINT_FAST16_TYPE
1694 @defmacx UINT_FAST32_TYPE
1695 @defmacx UINT_FAST64_TYPE
1696 @defmacx INTPTR_TYPE
1697 @defmacx UINTPTR_TYPE
1698 C expressions for the standard types @code{sig_atomic_t},
1699 @code{int8_t}, @code{int16_t}, @code{int32_t}, @code{int64_t},
1700 @code{uint8_t}, @code{uint16_t}, @code{uint32_t}, @code{uint64_t},
1701 @code{int_least8_t}, @code{int_least16_t}, @code{int_least32_t},
1702 @code{int_least64_t}, @code{uint_least8_t}, @code{uint_least16_t},
1703 @code{uint_least32_t}, @code{uint_least64_t}, @code{int_fast8_t},
1704 @code{int_fast16_t}, @code{int_fast32_t}, @code{int_fast64_t},
1705 @code{uint_fast8_t}, @code{uint_fast16_t}, @code{uint_fast32_t},
1706 @code{uint_fast64_t}, @code{intptr_t}, and @code{uintptr_t}.  See
1707 @code{SIZE_TYPE} above for more information.
1708
1709 If any of these macros evaluates to a null pointer, the corresponding
1710 type is not supported; if GCC is configured to provide
1711 @code{<stdint.h>} in such a case, the header provided may not conform
1712 to C99, depending on the type in question.  The defaults for all of
1713 these macros are null pointers.
1714 @end defmac
1715
1716 @defmac TARGET_PTRMEMFUNC_VBIT_LOCATION
1717 The C++ compiler represents a pointer-to-member-function with a struct
1718 that looks like:
1719
1720 @smallexample
1721   struct @{
1722     union @{
1723       void (*fn)();
1724       ptrdiff_t vtable_index;
1725     @};
1726     ptrdiff_t delta;
1727   @};
1728 @end smallexample
1729
1730 @noindent
1731 The C++ compiler must use one bit to indicate whether the function that
1732 will be called through a pointer-to-member-function is virtual.
1733 Normally, we assume that the low-order bit of a function pointer must
1734 always be zero.  Then, by ensuring that the vtable_index is odd, we can
1735 distinguish which variant of the union is in use.  But, on some
1736 platforms function pointers can be odd, and so this doesn't work.  In
1737 that case, we use the low-order bit of the @code{delta} field, and shift
1738 the remainder of the @code{delta} field to the left.
1739
1740 GCC will automatically make the right selection about where to store
1741 this bit using the @code{FUNCTION_BOUNDARY} setting for your platform.
1742 However, some platforms such as ARM/Thumb have @code{FUNCTION_BOUNDARY}
1743 set such that functions always start at even addresses, but the lowest
1744 bit of pointers to functions indicate whether the function at that
1745 address is in ARM or Thumb mode.  If this is the case of your
1746 architecture, you should define this macro to
1747 @code{ptrmemfunc_vbit_in_delta}.
1748
1749 In general, you should not have to define this macro.  On architectures
1750 in which function addresses are always even, according to
1751 @code{FUNCTION_BOUNDARY}, GCC will automatically define this macro to
1752 @code{ptrmemfunc_vbit_in_pfn}.
1753 @end defmac
1754
1755 @defmac TARGET_VTABLE_USES_DESCRIPTORS
1756 Normally, the C++ compiler uses function pointers in vtables.  This
1757 macro allows the target to change to use ``function descriptors''
1758 instead.  Function descriptors are found on targets for whom a
1759 function pointer is actually a small data structure.  Normally the
1760 data structure consists of the actual code address plus a data
1761 pointer to which the function's data is relative.
1762
1763 If vtables are used, the value of this macro should be the number
1764 of words that the function descriptor occupies.
1765 @end defmac
1766
1767 @defmac TARGET_VTABLE_ENTRY_ALIGN
1768 By default, the vtable entries are void pointers, the so the alignment
1769 is the same as pointer alignment.  The value of this macro specifies
1770 the alignment of the vtable entry in bits.  It should be defined only
1771 when special alignment is necessary. */
1772 @end defmac
1773
1774 @defmac TARGET_VTABLE_DATA_ENTRY_DISTANCE
1775 There are a few non-descriptor entries in the vtable at offsets below
1776 zero.  If these entries must be padded (say, to preserve the alignment
1777 specified by @code{TARGET_VTABLE_ENTRY_ALIGN}), set this to the number
1778 of words in each data entry.
1779 @end defmac
1780
1781 @node Registers
1782 @section Register Usage
1783 @cindex register usage
1784
1785 This section explains how to describe what registers the target machine
1786 has, and how (in general) they can be used.
1787
1788 The description of which registers a specific instruction can use is
1789 done with register classes; see @ref{Register Classes}.  For information
1790 on using registers to access a stack frame, see @ref{Frame Registers}.
1791 For passing values in registers, see @ref{Register Arguments}.
1792 For returning values in registers, see @ref{Scalar Return}.
1793
1794 @menu
1795 * Register Basics::             Number and kinds of registers.
1796 * Allocation Order::            Order in which registers are allocated.
1797 * Values in Registers::         What kinds of values each reg can hold.
1798 * Leaf Functions::              Renumbering registers for leaf functions.
1799 * Stack Registers::             Handling a register stack such as 80387.
1800 @end menu
1801
1802 @node Register Basics
1803 @subsection Basic Characteristics of Registers
1804
1805 @c prevent bad page break with this line
1806 Registers have various characteristics.
1807
1808 @defmac FIRST_PSEUDO_REGISTER
1809 Number of hardware registers known to the compiler.  They receive
1810 numbers 0 through @code{FIRST_PSEUDO_REGISTER-1}; thus, the first
1811 pseudo register's number really is assigned the number
1812 @code{FIRST_PSEUDO_REGISTER}.
1813 @end defmac
1814
1815 @defmac FIXED_REGISTERS
1816 @cindex fixed register
1817 An initializer that says which registers are used for fixed purposes
1818 all throughout the compiled code and are therefore not available for
1819 general allocation.  These would include the stack pointer, the frame
1820 pointer (except on machines where that can be used as a general
1821 register when no frame pointer is needed), the program counter on
1822 machines where that is considered one of the addressable registers,
1823 and any other numbered register with a standard use.
1824
1825 This information is expressed as a sequence of numbers, separated by
1826 commas and surrounded by braces.  The @var{n}th number is 1 if
1827 register @var{n} is fixed, 0 otherwise.
1828
1829 The table initialized from this macro, and the table initialized by
1830 the following one, may be overridden at run time either automatically,
1831 by the actions of the macro @code{CONDITIONAL_REGISTER_USAGE}, or by
1832 the user with the command options @option{-ffixed-@var{reg}},
1833 @option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}}.
1834 @end defmac
1835
1836 @defmac CALL_USED_REGISTERS
1837 @cindex call-used register
1838 @cindex call-clobbered register
1839 @cindex call-saved register
1840 Like @code{FIXED_REGISTERS} but has 1 for each register that is
1841 clobbered (in general) by function calls as well as for fixed
1842 registers.  This macro therefore identifies the registers that are not
1843 available for general allocation of values that must live across
1844 function calls.
1845
1846 If a register has 0 in @code{CALL_USED_REGISTERS}, the compiler
1847 automatically saves it on function entry and restores it on function
1848 exit, if the register is used within the function.
1849 @end defmac
1850
1851 @defmac CALL_REALLY_USED_REGISTERS
1852 @cindex call-used register
1853 @cindex call-clobbered register
1854 @cindex call-saved register
1855 Like @code{CALL_USED_REGISTERS} except this macro doesn't require
1856 that the entire set of @code{FIXED_REGISTERS} be included.
1857 (@code{CALL_USED_REGISTERS} must be a superset of @code{FIXED_REGISTERS}).
1858 This macro is optional.  If not specified, it defaults to the value
1859 of @code{CALL_USED_REGISTERS}.
1860 @end defmac
1861
1862 @defmac HARD_REGNO_CALL_PART_CLOBBERED (@var{regno}, @var{mode})
1863 @cindex call-used register
1864 @cindex call-clobbered register
1865 @cindex call-saved register
1866 A C expression that is nonzero if it is not permissible to store a
1867 value of mode @var{mode} in hard register number @var{regno} across a
1868 call without some part of it being clobbered.  For most machines this
1869 macro need not be defined.  It is only required for machines that do not
1870 preserve the entire contents of a register across a call.
1871 @end defmac
1872
1873 @findex fixed_regs
1874 @findex call_used_regs
1875 @findex global_regs
1876 @findex reg_names
1877 @findex reg_class_contents
1878 @deftypefn {Target Hook} void TARGET_CONDITIONAL_REGISTER_USAGE (void)
1879 This hook may conditionally modify five variables
1880 @code{fixed_regs}, @code{call_used_regs}, @code{global_regs},
1881 @code{reg_names}, and @code{reg_class_contents}, to take into account
1882 any dependence of these register sets on target flags.  The first three
1883 of these are of type @code{char []} (interpreted as Boolean vectors).
1884 @code{global_regs} is a @code{const char *[]}, and
1885 @code{reg_class_contents} is a @code{HARD_REG_SET}.  Before the macro is
1886 called, @code{fixed_regs}, @code{call_used_regs},
1887 @code{reg_class_contents}, and @code{reg_names} have been initialized
1888 from @code{FIXED_REGISTERS}, @code{CALL_USED_REGISTERS},
1889 @code{REG_CLASS_CONTENTS}, and @code{REGISTER_NAMES}, respectively.
1890 @code{global_regs} has been cleared, and any @option{-ffixed-@var{reg}},
1891 @option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}}
1892 command options have been applied.
1893
1894 @cindex disabling certain registers
1895 @cindex controlling register usage
1896 If the usage of an entire class of registers depends on the target
1897 flags, you may indicate this to GCC by using this macro to modify
1898 @code{fixed_regs} and @code{call_used_regs} to 1 for each of the
1899 registers in the classes which should not be used by GCC@.  Also make
1900 @code{define_register_constraint}s return @code{NO_REGS} for constraints
1901 that shouldn't be used.
1902
1903 (However, if this class is not included in @code{GENERAL_REGS} and all
1904 of the insn patterns whose constraints permit this class are
1905 controlled by target switches, then GCC will automatically avoid using
1906 these registers when the target switches are opposed to them.)
1907 @end deftypefn
1908
1909 @defmac INCOMING_REGNO (@var{out})
1910 Define this macro if the target machine has register windows.  This C
1911 expression returns the register number as seen by the called function
1912 corresponding to the register number @var{out} as seen by the calling
1913 function.  Return @var{out} if register number @var{out} is not an
1914 outbound register.
1915 @end defmac
1916
1917 @defmac OUTGOING_REGNO (@var{in})
1918 Define this macro if the target machine has register windows.  This C
1919 expression returns the register number as seen by the calling function
1920 corresponding to the register number @var{in} as seen by the called
1921 function.  Return @var{in} if register number @var{in} is not an inbound
1922 register.
1923 @end defmac
1924
1925 @defmac LOCAL_REGNO (@var{regno})
1926 Define this macro if the target machine has register windows.  This C
1927 expression returns true if the register is call-saved but is in the
1928 register window.  Unlike most call-saved registers, such registers
1929 need not be explicitly restored on function exit or during non-local
1930 gotos.
1931 @end defmac
1932
1933 @defmac PC_REGNUM
1934 If the program counter has a register number, define this as that
1935 register number.  Otherwise, do not define it.
1936 @end defmac
1937
1938 @node Allocation Order
1939 @subsection Order of Allocation of Registers
1940 @cindex order of register allocation
1941 @cindex register allocation order
1942
1943 @c prevent bad page break with this line
1944 Registers are allocated in order.
1945
1946 @defmac REG_ALLOC_ORDER
1947 If defined, an initializer for a vector of integers, containing the
1948 numbers of hard registers in the order in which GCC should prefer
1949 to use them (from most preferred to least).
1950
1951 If this macro is not defined, registers are used lowest numbered first
1952 (all else being equal).
1953
1954 One use of this macro is on machines where the highest numbered
1955 registers must always be saved and the save-multiple-registers
1956 instruction supports only sequences of consecutive registers.  On such
1957 machines, define @code{REG_ALLOC_ORDER} to be an initializer that lists
1958 the highest numbered allocable register first.
1959 @end defmac
1960
1961 @defmac ADJUST_REG_ALLOC_ORDER
1962 A C statement (sans semicolon) to choose the order in which to allocate
1963 hard registers for pseudo-registers local to a basic block.
1964
1965 Store the desired register order in the array @code{reg_alloc_order}.
1966 Element 0 should be the register to allocate first; element 1, the next
1967 register; and so on.
1968
1969 The macro body should not assume anything about the contents of
1970 @code{reg_alloc_order} before execution of the macro.
1971
1972 On most machines, it is not necessary to define this macro.
1973 @end defmac
1974
1975 @defmac HONOR_REG_ALLOC_ORDER
1976 Normally, IRA tries to estimate the costs for saving a register in the
1977 prologue and restoring it in the epilogue.  This discourages it from
1978 using call-saved registers.  If a machine wants to ensure that IRA
1979 allocates registers in the order given by REG_ALLOC_ORDER even if some
1980 call-saved registers appear earlier than call-used ones, then define this
1981 macro as a C expression to nonzero. Default is 0.
1982 @end defmac
1983
1984 @defmac IRA_HARD_REGNO_ADD_COST_MULTIPLIER (@var{regno})
1985 In some case register allocation order is not enough for the
1986 Integrated Register Allocator (@acronym{IRA}) to generate a good code.
1987 If this macro is defined, it should return a floating point value
1988 based on @var{regno}.  The cost of using @var{regno} for a pseudo will
1989 be increased by approximately the pseudo's usage frequency times the
1990 value returned by this macro.  Not defining this macro is equivalent
1991 to having it always return @code{0.0}.
1992
1993 On most machines, it is not necessary to define this macro.
1994 @end defmac
1995
1996 @node Values in Registers
1997 @subsection How Values Fit in Registers
1998
1999 This section discusses the macros that describe which kinds of values
2000 (specifically, which machine modes) each register can hold, and how many
2001 consecutive registers are needed for a given mode.
2002
2003 @defmac HARD_REGNO_NREGS (@var{regno}, @var{mode})
2004 A C expression for the number of consecutive hard registers, starting
2005 at register number @var{regno}, required to hold a value of mode
2006 @var{mode}.  This macro must never return zero, even if a register
2007 cannot hold the requested mode - indicate that with HARD_REGNO_MODE_OK
2008 and/or CANNOT_CHANGE_MODE_CLASS instead.
2009
2010 On a machine where all registers are exactly one word, a suitable
2011 definition of this macro is
2012
2013 @smallexample
2014 #define HARD_REGNO_NREGS(REGNO, MODE)            \
2015    ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)  \
2016     / UNITS_PER_WORD)
2017 @end smallexample
2018 @end defmac
2019
2020 @defmac HARD_REGNO_NREGS_HAS_PADDING (@var{regno}, @var{mode})
2021 A C expression that is nonzero if a value of mode @var{mode}, stored
2022 in memory, ends with padding that causes it to take up more space than
2023 in registers starting at register number @var{regno} (as determined by
2024 multiplying GCC's notion of the size of the register when containing
2025 this mode by the number of registers returned by
2026 @code{HARD_REGNO_NREGS}).  By default this is zero.
2027
2028 For example, if a floating-point value is stored in three 32-bit
2029 registers but takes up 128 bits in memory, then this would be
2030 nonzero.
2031
2032 This macros only needs to be defined if there are cases where
2033 @code{subreg_get_info}
2034 would otherwise wrongly determine that a @code{subreg} can be
2035 represented by an offset to the register number, when in fact such a
2036 @code{subreg} would contain some of the padding not stored in
2037 registers and so not be representable.
2038 @end defmac
2039
2040 @defmac HARD_REGNO_NREGS_WITH_PADDING (@var{regno}, @var{mode})
2041 For values of @var{regno} and @var{mode} for which
2042 @code{HARD_REGNO_NREGS_HAS_PADDING} returns nonzero, a C expression
2043 returning the greater number of registers required to hold the value
2044 including any padding.  In the example above, the value would be four.
2045 @end defmac
2046
2047 @defmac REGMODE_NATURAL_SIZE (@var{mode})
2048 Define this macro if the natural size of registers that hold values
2049 of mode @var{mode} is not the word size.  It is a C expression that
2050 should give the natural size in bytes for the specified mode.  It is
2051 used by the register allocator to try to optimize its results.  This
2052 happens for example on SPARC 64-bit where the natural size of
2053 floating-point registers is still 32-bit.
2054 @end defmac
2055
2056 @defmac HARD_REGNO_MODE_OK (@var{regno}, @var{mode})
2057 A C expression that is nonzero if it is permissible to store a value
2058 of mode @var{mode} in hard register number @var{regno} (or in several
2059 registers starting with that one).  For a machine where all registers
2060 are equivalent, a suitable definition is
2061
2062 @smallexample
2063 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
2064 @end smallexample
2065
2066 You need not include code to check for the numbers of fixed registers,
2067 because the allocation mechanism considers them to be always occupied.
2068
2069 @cindex register pairs
2070 On some machines, double-precision values must be kept in even/odd
2071 register pairs.  You can implement that by defining this macro to reject
2072 odd register numbers for such modes.
2073
2074 The minimum requirement for a mode to be OK in a register is that the
2075 @samp{mov@var{mode}} instruction pattern support moves between the
2076 register and other hard register in the same class and that moving a
2077 value into the register and back out not alter it.
2078
2079 Since the same instruction used to move @code{word_mode} will work for
2080 all narrower integer modes, it is not necessary on any machine for
2081 @code{HARD_REGNO_MODE_OK} to distinguish between these modes, provided
2082 you define patterns @samp{movhi}, etc., to take advantage of this.  This
2083 is useful because of the interaction between @code{HARD_REGNO_MODE_OK}
2084 and @code{MODES_TIEABLE_P}; it is very desirable for all integer modes
2085 to be tieable.
2086
2087 Many machines have special registers for floating point arithmetic.
2088 Often people assume that floating point machine modes are allowed only
2089 in floating point registers.  This is not true.  Any registers that
2090 can hold integers can safely @emph{hold} a floating point machine
2091 mode, whether or not floating arithmetic can be done on it in those
2092 registers.  Integer move instructions can be used to move the values.
2093
2094 On some machines, though, the converse is true: fixed-point machine
2095 modes may not go in floating registers.  This is true if the floating
2096 registers normalize any value stored in them, because storing a
2097 non-floating value there would garble it.  In this case,
2098 @code{HARD_REGNO_MODE_OK} should reject fixed-point machine modes in
2099 floating registers.  But if the floating registers do not automatically
2100 normalize, if you can store any bit pattern in one and retrieve it
2101 unchanged without a trap, then any machine mode may go in a floating
2102 register, so you can define this macro to say so.
2103
2104 The primary significance of special floating registers is rather that
2105 they are the registers acceptable in floating point arithmetic
2106 instructions.  However, this is of no concern to
2107 @code{HARD_REGNO_MODE_OK}.  You handle it by writing the proper
2108 constraints for those instructions.
2109
2110 On some machines, the floating registers are especially slow to access,
2111 so that it is better to store a value in a stack frame than in such a
2112 register if floating point arithmetic is not being done.  As long as the
2113 floating registers are not in class @code{GENERAL_REGS}, they will not
2114 be used unless some pattern's constraint asks for one.
2115 @end defmac
2116
2117 @defmac HARD_REGNO_RENAME_OK (@var{from}, @var{to})
2118 A C expression that is nonzero if it is OK to rename a hard register
2119 @var{from} to another hard register @var{to}.
2120
2121 One common use of this macro is to prevent renaming of a register to
2122 another register that is not saved by a prologue in an interrupt
2123 handler.
2124
2125 The default is always nonzero.
2126 @end defmac
2127
2128 @defmac MODES_TIEABLE_P (@var{mode1}, @var{mode2})
2129 A C expression that is nonzero if a value of mode
2130 @var{mode1} is accessible in mode @var{mode2} without copying.
2131
2132 If @code{HARD_REGNO_MODE_OK (@var{r}, @var{mode1})} and
2133 @code{HARD_REGNO_MODE_OK (@var{r}, @var{mode2})} are always the same for
2134 any @var{r}, then @code{MODES_TIEABLE_P (@var{mode1}, @var{mode2})}
2135 should be nonzero.  If they differ for any @var{r}, you should define
2136 this macro to return zero unless some other mechanism ensures the
2137 accessibility of the value in a narrower mode.
2138
2139 You should define this macro to return nonzero in as many cases as
2140 possible since doing so will allow GCC to perform better register
2141 allocation.
2142 @end defmac
2143
2144 @deftypefn {Target Hook} bool TARGET_HARD_REGNO_SCRATCH_OK (unsigned int @var{regno})
2145 This target hook should return @code{true} if it is OK to use a hard register
2146 @var{regno} as scratch reg in peephole2.
2147
2148 One common use of this macro is to prevent using of a register that
2149 is not saved by a prologue in an interrupt handler.
2150
2151 The default version of this hook always returns @code{true}.
2152 @end deftypefn
2153
2154 @defmac AVOID_CCMODE_COPIES
2155 Define this macro if the compiler should avoid copies to/from @code{CCmode}
2156 registers.  You should only define this macro if support for copying to/from
2157 @code{CCmode} is incomplete.
2158 @end defmac
2159
2160 @node Leaf Functions
2161 @subsection Handling Leaf Functions
2162
2163 @cindex leaf functions
2164 @cindex functions, leaf
2165 On some machines, a leaf function (i.e., one which makes no calls) can run
2166 more efficiently if it does not make its own register window.  Often this
2167 means it is required to receive its arguments in the registers where they
2168 are passed by the caller, instead of the registers where they would
2169 normally arrive.
2170
2171 The special treatment for leaf functions generally applies only when
2172 other conditions are met; for example, often they may use only those
2173 registers for its own variables and temporaries.  We use the term ``leaf
2174 function'' to mean a function that is suitable for this special
2175 handling, so that functions with no calls are not necessarily ``leaf
2176 functions''.
2177
2178 GCC assigns register numbers before it knows whether the function is
2179 suitable for leaf function treatment.  So it needs to renumber the
2180 registers in order to output a leaf function.  The following macros
2181 accomplish this.
2182
2183 @defmac LEAF_REGISTERS
2184 Name of a char vector, indexed by hard register number, which
2185 contains 1 for a register that is allowable in a candidate for leaf
2186 function treatment.
2187
2188 If leaf function treatment involves renumbering the registers, then the
2189 registers marked here should be the ones before renumbering---those that
2190 GCC would ordinarily allocate.  The registers which will actually be
2191 used in the assembler code, after renumbering, should not be marked with 1
2192 in this vector.
2193
2194 Define this macro only if the target machine offers a way to optimize
2195 the treatment of leaf functions.
2196 @end defmac
2197
2198 @defmac LEAF_REG_REMAP (@var{regno})
2199 A C expression whose value is the register number to which @var{regno}
2200 should be renumbered, when a function is treated as a leaf function.
2201
2202 If @var{regno} is a register number which should not appear in a leaf
2203 function before renumbering, then the expression should yield @minus{}1, which
2204 will cause the compiler to abort.
2205
2206 Define this macro only if the target machine offers a way to optimize the
2207 treatment of leaf functions, and registers need to be renumbered to do
2208 this.
2209 @end defmac
2210
2211 @findex current_function_is_leaf
2212 @findex current_function_uses_only_leaf_regs
2213 @code{TARGET_ASM_FUNCTION_PROLOGUE} and
2214 @code{TARGET_ASM_FUNCTION_EPILOGUE} must usually treat leaf functions
2215 specially.  They can test the C variable @code{current_function_is_leaf}
2216 which is nonzero for leaf functions.  @code{current_function_is_leaf} is
2217 set prior to local register allocation and is valid for the remaining
2218 compiler passes.  They can also test the C variable
2219 @code{current_function_uses_only_leaf_regs} which is nonzero for leaf
2220 functions which only use leaf registers.
2221 @code{current_function_uses_only_leaf_regs} is valid after all passes
2222 that modify the instructions have been run and is only useful if
2223 @code{LEAF_REGISTERS} is defined.
2224 @c changed this to fix overfull.  ALSO:  why the "it" at the beginning
2225 @c of the next paragraph?!  --mew 2feb93
2226
2227 @node Stack Registers
2228 @subsection Registers That Form a Stack
2229
2230 There are special features to handle computers where some of the
2231 ``registers'' form a stack.  Stack registers are normally written by
2232 pushing onto the stack, and are numbered relative to the top of the
2233 stack.
2234
2235 Currently, GCC can only handle one group of stack-like registers, and
2236 they must be consecutively numbered.  Furthermore, the existing
2237 support for stack-like registers is specific to the 80387 floating
2238 point coprocessor.  If you have a new architecture that uses
2239 stack-like registers, you will need to do substantial work on
2240 @file{reg-stack.c} and write your machine description to cooperate
2241 with it, as well as defining these macros.
2242
2243 @defmac STACK_REGS
2244 Define this if the machine has any stack-like registers.
2245 @end defmac
2246
2247 @defmac STACK_REG_COVER_CLASS
2248 This is a cover class containing the stack registers.  Define this if
2249 the machine has any stack-like registers.
2250 @end defmac
2251
2252 @defmac FIRST_STACK_REG
2253 The number of the first stack-like register.  This one is the top
2254 of the stack.
2255 @end defmac
2256
2257 @defmac LAST_STACK_REG
2258 The number of the last stack-like register.  This one is the bottom of
2259 the stack.
2260 @end defmac
2261
2262 @node Register Classes
2263 @section Register Classes
2264 @cindex register class definitions
2265 @cindex class definitions, register
2266
2267 On many machines, the numbered registers are not all equivalent.
2268 For example, certain registers may not be allowed for indexed addressing;
2269 certain registers may not be allowed in some instructions.  These machine
2270 restrictions are described to the compiler using @dfn{register classes}.
2271
2272 You define a number of register classes, giving each one a name and saying
2273 which of the registers belong to it.  Then you can specify register classes
2274 that are allowed as operands to particular instruction patterns.
2275
2276 @findex ALL_REGS
2277 @findex NO_REGS
2278 In general, each register will belong to several classes.  In fact, one
2279 class must be named @code{ALL_REGS} and contain all the registers.  Another
2280 class must be named @code{NO_REGS} and contain no registers.  Often the
2281 union of two classes will be another class; however, this is not required.
2282
2283 @findex GENERAL_REGS
2284 One of the classes must be named @code{GENERAL_REGS}.  There is nothing
2285 terribly special about the name, but the operand constraint letters
2286 @samp{r} and @samp{g} specify this class.  If @code{GENERAL_REGS} is
2287 the same as @code{ALL_REGS}, just define it as a macro which expands
2288 to @code{ALL_REGS}.
2289
2290 Order the classes so that if class @var{x} is contained in class @var{y}
2291 then @var{x} has a lower class number than @var{y}.
2292
2293 The way classes other than @code{GENERAL_REGS} are specified in operand
2294 constraints is through machine-dependent operand constraint letters.
2295 You can define such letters to correspond to various classes, then use
2296 them in operand constraints.
2297
2298 You must define the narrowest register classes for allocatable
2299 registers, so that each class either has no subclasses, or that for
2300 some mode, the move cost between registers within the class is
2301 cheaper than moving a register in the class to or from memory
2302 (@pxref{Costs}).
2303
2304 You should define a class for the union of two classes whenever some
2305 instruction allows both classes.  For example, if an instruction allows
2306 either a floating point (coprocessor) register or a general register for a
2307 certain operand, you should define a class @code{FLOAT_OR_GENERAL_REGS}
2308 which includes both of them.  Otherwise you will get suboptimal code,
2309 or even internal compiler errors when reload cannot find a register in the
2310 class computed via @code{reg_class_subunion}.
2311
2312 You must also specify certain redundant information about the register
2313 classes: for each class, which classes contain it and which ones are
2314 contained in it; for each pair of classes, the largest class contained
2315 in their union.
2316
2317 When a value occupying several consecutive registers is expected in a
2318 certain class, all the registers used must belong to that class.
2319 Therefore, register classes cannot be used to enforce a requirement for
2320 a register pair to start with an even-numbered register.  The way to
2321 specify this requirement is with @code{HARD_REGNO_MODE_OK}.
2322
2323 Register classes used for input-operands of bitwise-and or shift
2324 instructions have a special requirement: each such class must have, for
2325 each fixed-point machine mode, a subclass whose registers can transfer that
2326 mode to or from memory.  For example, on some machines, the operations for
2327 single-byte values (@code{QImode}) are limited to certain registers.  When
2328 this is so, each register class that is used in a bitwise-and or shift
2329 instruction must have a subclass consisting of registers from which
2330 single-byte values can be loaded or stored.  This is so that
2331 @code{PREFERRED_RELOAD_CLASS} can always have a possible value to return.
2332
2333 @deftp {Data type} {enum reg_class}
2334 An enumerated type that must be defined with all the register class names
2335 as enumerated values.  @code{NO_REGS} must be first.  @code{ALL_REGS}
2336 must be the last register class, followed by one more enumerated value,
2337 @code{LIM_REG_CLASSES}, which is not a register class but rather
2338 tells how many classes there are.
2339
2340 Each register class has a number, which is the value of casting
2341 the class name to type @code{int}.  The number serves as an index
2342 in many of the tables described below.
2343 @end deftp
2344
2345 @defmac N_REG_CLASSES
2346 The number of distinct register classes, defined as follows:
2347
2348 @smallexample
2349 #define N_REG_CLASSES (int) LIM_REG_CLASSES
2350 @end smallexample
2351 @end defmac
2352
2353 @defmac REG_CLASS_NAMES
2354 An initializer containing the names of the register classes as C string
2355 constants.  These names are used in writing some of the debugging dumps.
2356 @end defmac
2357
2358 @defmac REG_CLASS_CONTENTS
2359 An initializer containing the contents of the register classes, as integers
2360 which are bit masks.  The @var{n}th integer specifies the contents of class
2361 @var{n}.  The way the integer @var{mask} is interpreted is that
2362 register @var{r} is in the class if @code{@var{mask} & (1 << @var{r})} is 1.
2363
2364 When the machine has more than 32 registers, an integer does not suffice.
2365 Then the integers are replaced by sub-initializers, braced groupings containing
2366 several integers.  Each sub-initializer must be suitable as an initializer
2367 for the type @code{HARD_REG_SET} which is defined in @file{hard-reg-set.h}.
2368 In this situation, the first integer in each sub-initializer corresponds to
2369 registers 0 through 31, the second integer to registers 32 through 63, and
2370 so on.
2371 @end defmac
2372
2373 @defmac REGNO_REG_CLASS (@var{regno})
2374 A C expression whose value is a register class containing hard register
2375 @var{regno}.  In general there is more than one such class; choose a class
2376 which is @dfn{minimal}, meaning that no smaller class also contains the
2377 register.
2378 @end defmac
2379
2380 @defmac BASE_REG_CLASS
2381 A macro whose definition is the name of the class to which a valid
2382 base register must belong.  A base register is one used in an address
2383 which is the register value plus a displacement.
2384 @end defmac
2385
2386 @defmac MODE_BASE_REG_CLASS (@var{mode})
2387 This is a variation of the @code{BASE_REG_CLASS} macro which allows
2388 the selection of a base register in a mode dependent manner.  If
2389 @var{mode} is VOIDmode then it should return the same value as
2390 @code{BASE_REG_CLASS}.
2391 @end defmac
2392
2393 @defmac MODE_BASE_REG_REG_CLASS (@var{mode})
2394 A C expression whose value is the register class to which a valid
2395 base register must belong in order to be used in a base plus index
2396 register address.  You should define this macro if base plus index
2397 addresses have different requirements than other base register uses.
2398 @end defmac
2399
2400 @defmac MODE_CODE_BASE_REG_CLASS (@var{mode}, @var{address_space}, @var{outer_code}, @var{index_code})
2401 A C expression whose value is the register class to which a valid
2402 base register for a memory reference in mode @var{mode} to address
2403 space @var{address_space} must belong.  @var{outer_code} and @var{index_code}
2404 define the context in which the base register occurs.  @var{outer_code} is
2405 the code of the immediately enclosing expression (@code{MEM} for the top level
2406 of an address, @code{ADDRESS} for something that occurs in an
2407 @code{address_operand}).  @var{index_code} is the code of the corresponding
2408 index expression if @var{outer_code} is @code{PLUS}; @code{SCRATCH} otherwise.
2409 @end defmac
2410
2411 @defmac INDEX_REG_CLASS
2412 A macro whose definition is the name of the class to which a valid
2413 index register must belong.  An index register is one used in an
2414 address where its value is either multiplied by a scale factor or
2415 added to another register (as well as added to a displacement).
2416 @end defmac
2417
2418 @defmac REGNO_OK_FOR_BASE_P (@var{num})
2419 A C expression which is nonzero if register number @var{num} is
2420 suitable for use as a base register in operand addresses.
2421 @end defmac
2422
2423 @defmac REGNO_MODE_OK_FOR_BASE_P (@var{num}, @var{mode})
2424 A C expression that is just like @code{REGNO_OK_FOR_BASE_P}, except that
2425 that expression may examine the mode of the memory reference in
2426 @var{mode}.  You should define this macro if the mode of the memory
2427 reference affects whether a register may be used as a base register.  If
2428 you define this macro, the compiler will use it instead of
2429 @code{REGNO_OK_FOR_BASE_P}.  The mode may be @code{VOIDmode} for
2430 addresses that appear outside a @code{MEM}, i.e., as an
2431 @code{address_operand}.
2432 @end defmac
2433
2434 @defmac REGNO_MODE_OK_FOR_REG_BASE_P (@var{num}, @var{mode})
2435 A C expression which is nonzero if register number @var{num} is suitable for
2436 use as a base register in base plus index operand addresses, accessing
2437 memory in mode @var{mode}.  It may be either a suitable hard register or a
2438 pseudo register that has been allocated such a hard register.  You should
2439 define this macro if base plus index addresses have different requirements
2440 than other base register uses.
2441
2442 Use of this macro is deprecated; please use the more general
2443 @code{REGNO_MODE_CODE_OK_FOR_BASE_P}.
2444 @end defmac
2445
2446 @defmac REGNO_MODE_CODE_OK_FOR_BASE_P (@var{num}, @var{mode}, @var{address_space}, @var{outer_code}, @var{index_code})
2447 A C expression which is nonzero if register number @var{num} is
2448 suitable for use as a base register in operand addresses, accessing
2449 memory in mode @var{mode} in address space @var{address_space}.
2450 This is similar to @code{REGNO_MODE_OK_FOR_BASE_P}, except
2451 that that expression may examine the context in which the register
2452 appears in the memory reference.  @var{outer_code} is the code of the
2453 immediately enclosing expression (@code{MEM} if at the top level of the
2454 address, @code{ADDRESS} for something that occurs in an
2455 @code{address_operand}).  @var{index_code} is the code of the
2456 corresponding index expression if @var{outer_code} is @code{PLUS};
2457 @code{SCRATCH} otherwise.  The mode may be @code{VOIDmode} for addresses
2458 that appear outside a @code{MEM}, i.e., as an @code{address_operand}.
2459 @end defmac
2460
2461 @defmac REGNO_OK_FOR_INDEX_P (@var{num})
2462 A C expression which is nonzero if register number @var{num} is
2463 suitable for use as an index register in operand addresses.  It may be
2464 either a suitable hard register or a pseudo register that has been
2465 allocated such a hard register.
2466
2467 The difference between an index register and a base register is that
2468 the index register may be scaled.  If an address involves the sum of
2469 two registers, neither one of them scaled, then either one may be
2470 labeled the ``base'' and the other the ``index''; but whichever
2471 labeling is used must fit the machine's constraints of which registers
2472 may serve in each capacity.  The compiler will try both labelings,
2473 looking for one that is valid, and will reload one or both registers
2474 only if neither labeling works.
2475 @end defmac
2476
2477 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RENAME_CLASS (reg_class_t @var{rclass})
2478 A target hook that places additional preference on the register class to use when it is necessary to rename a register in class @var{rclass} to another class, or perhaps @var{NO_REGS}, if no preferred register class is found or hook @code{preferred_rename_class} is not implemented. Sometimes returning a more restrictive class makes better code.  For example, on ARM, thumb-2 instructions using @code{LO_REGS} may be smaller than instructions using @code{GENERIC_REGS}.  By returning @code{LO_REGS} from @code{preferred_rename_class}, code size can be reduced.
2479 @end deftypefn
2480
2481 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RELOAD_CLASS (rtx @var{x}, reg_class_t @var{rclass})
2482 A target hook that places additional restrictions on the register class
2483 to use when it is necessary to copy value @var{x} into a register in class
2484 @var{rclass}.  The value is a register class; perhaps @var{rclass}, or perhaps
2485 another, smaller class.
2486
2487 The default version of this hook always returns value of @code{rclass} argument.
2488
2489 Sometimes returning a more restrictive class makes better code.  For
2490 example, on the 68000, when @var{x} is an integer constant that is in range
2491 for a @samp{moveq} instruction, the value of this macro is always
2492 @code{DATA_REGS} as long as @var{rclass} includes the data registers.
2493 Requiring a data register guarantees that a @samp{moveq} will be used.
2494
2495 One case where @code{TARGET_PREFERRED_RELOAD_CLASS} must not return
2496 @var{rclass} is if @var{x} is a legitimate constant which cannot be
2497 loaded into some register class.  By returning @code{NO_REGS} you can
2498 force @var{x} into a memory location.  For example, rs6000 can load
2499 immediate values into general-purpose registers, but does not have an
2500 instruction for loading an immediate value into a floating-point
2501 register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
2502 @var{x} is a floating-point constant.  If the constant can't be loaded
2503 into any kind of register, code generation will be better if
2504 @code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
2505 of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
2506
2507 If an insn has pseudos in it after register allocation, reload will go
2508 through the alternatives and call repeatedly @code{TARGET_PREFERRED_RELOAD_CLASS}
2509 to find the best one.  Returning @code{NO_REGS}, in this case, makes
2510 reload add a @code{!} in front of the constraint: the x86 back-end uses
2511 this feature to discourage usage of 387 registers when math is done in
2512 the SSE registers (and vice versa).
2513 @end deftypefn
2514
2515 @defmac PREFERRED_RELOAD_CLASS (@var{x}, @var{class})
2516 A C expression that places additional restrictions on the register class
2517 to use when it is necessary to copy value @var{x} into a register in class
2518 @var{class}.  The value is a register class; perhaps @var{class}, or perhaps
2519 another, smaller class.  On many machines, the following definition is
2520 safe:
2521
2522 @smallexample
2523 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
2524 @end smallexample
2525
2526 Sometimes returning a more restrictive class makes better code.  For
2527 example, on the 68000, when @var{x} is an integer constant that is in range
2528 for a @samp{moveq} instruction, the value of this macro is always
2529 @code{DATA_REGS} as long as @var{class} includes the data registers.
2530 Requiring a data register guarantees that a @samp{moveq} will be used.
2531
2532 One case where @code{PREFERRED_RELOAD_CLASS} must not return
2533 @var{class} is if @var{x} is a legitimate constant which cannot be
2534 loaded into some register class.  By returning @code{NO_REGS} you can
2535 force @var{x} into a memory location.  For example, rs6000 can load
2536 immediate values into general-purpose registers, but does not have an
2537 instruction for loading an immediate value into a floating-point
2538 register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
2539 @var{x} is a floating-point constant.  If the constant can't be loaded
2540 into any kind of register, code generation will be better if
2541 @code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
2542 of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
2543
2544 If an insn has pseudos in it after register allocation, reload will go
2545 through the alternatives and call repeatedly @code{PREFERRED_RELOAD_CLASS}
2546 to find the best one.  Returning @code{NO_REGS}, in this case, makes
2547 reload add a @code{!} in front of the constraint: the x86 back-end uses
2548 this feature to discourage usage of 387 registers when math is done in
2549 the SSE registers (and vice versa).
2550 @end defmac
2551
2552 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_OUTPUT_RELOAD_CLASS (rtx @var{x}, reg_class_t @var{rclass})
2553 Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of
2554 input reloads.
2555
2556 The default version of this hook always returns value of @code{rclass}
2557 argument.
2558
2559 You can also use @code{TARGET_PREFERRED_OUTPUT_RELOAD_CLASS} to discourage
2560 reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}.
2561 @end deftypefn
2562
2563 @defmac LIMIT_RELOAD_CLASS (@var{mode}, @var{class})
2564 A C expression that places additional restrictions on the register class
2565 to use when it is necessary to be able to hold a value of mode
2566 @var{mode} in a reload register for which class @var{class} would
2567 ordinarily be used.
2568
2569 Unlike @code{PREFERRED_RELOAD_CLASS}, this macro should be used when
2570 there are certain modes that simply can't go in certain reload classes.
2571
2572 The value is a register class; perhaps @var{class}, or perhaps another,
2573 smaller class.
2574
2575 Don't define this macro unless the target machine has limitations which
2576 require the macro to do something nontrivial.
2577 @end defmac
2578
2579 @deftypefn {Target Hook} reg_class_t TARGET_SECONDARY_RELOAD (bool @var{in_p}, rtx @var{x}, reg_class_t @var{reload_class}, machine_mode @var{reload_mode}, secondary_reload_info *@var{sri})
2580 Many machines have some registers that cannot be copied directly to or
2581 from memory or even from other types of registers.  An example is the
2582 @samp{MQ} register, which on most machines, can only be copied to or
2583 from general registers, but not memory.  Below, we shall be using the
2584 term 'intermediate register' when a move operation cannot be performed
2585 directly, but has to be done by copying the source into the intermediate
2586 register first, and then copying the intermediate register to the
2587 destination.  An intermediate register always has the same mode as
2588 source and destination.  Since it holds the actual value being copied,
2589 reload might apply optimizations to re-use an intermediate register
2590 and eliding the copy from the source when it can determine that the
2591 intermediate register still holds the required value.
2592
2593 Another kind of secondary reload is required on some machines which
2594 allow copying all registers to and from memory, but require a scratch
2595 register for stores to some memory locations (e.g., those with symbolic
2596 address on the RT, and those with certain symbolic address on the SPARC
2597 when compiling PIC)@.  Scratch registers need not have the same mode
2598 as the value being copied, and usually hold a different value than
2599 that being copied.  Special patterns in the md file are needed to
2600 describe how the copy is performed with the help of the scratch register;
2601 these patterns also describe the number, register class(es) and mode(s)
2602 of the scratch register(s).
2603
2604 In some cases, both an intermediate and a scratch register are required.
2605
2606 For input reloads, this target hook is called with nonzero @var{in_p},
2607 and @var{x} is an rtx that needs to be copied to a register of class
2608 @var{reload_class} in @var{reload_mode}.  For output reloads, this target
2609 hook is called with zero @var{in_p}, and a register of class @var{reload_class}
2610 needs to be copied to rtx @var{x} in @var{reload_mode}.
2611
2612 If copying a register of @var{reload_class} from/to @var{x} requires
2613 an intermediate register, the hook @code{secondary_reload} should
2614 return the register class required for this intermediate register.
2615 If no intermediate register is required, it should return NO_REGS.
2616 If more than one intermediate register is required, describe the one
2617 that is closest in the copy chain to the reload register.
2618
2619 If scratch registers are needed, you also have to describe how to
2620 perform the copy from/to the reload register to/from this
2621 closest intermediate register.  Or if no intermediate register is
2622 required, but still a scratch register is needed, describe the
2623 copy  from/to the reload register to/from the reload operand @var{x}.
2624
2625 You do this by setting @code{sri->icode} to the instruction code of a pattern
2626 in the md file which performs the move.  Operands 0 and 1 are the output
2627 and input of this copy, respectively.  Operands from operand 2 onward are
2628 for scratch operands.  These scratch operands must have a mode, and a
2629 single-register-class
2630 @c [later: or memory]
2631 output constraint.
2632
2633 When an intermediate register is used, the @code{secondary_reload}
2634 hook will be called again to determine how to copy the intermediate
2635 register to/from the reload operand @var{x}, so your hook must also
2636 have code to handle the register class of the intermediate operand.
2637
2638 @c [For later: maybe we'll allow multi-alternative reload patterns -
2639 @c   the port maintainer could name a mov<mode> pattern that has clobbers -
2640 @c   and match the constraints of input and output to determine the required
2641 @c   alternative.  A restriction would be that constraints used to match
2642 @c   against reloads registers would have to be written as register class
2643 @c   constraints, or we need a new target macro / hook that tells us if an
2644 @c   arbitrary constraint can match an unknown register of a given class.
2645 @c   Such a macro / hook would also be useful in other places.]
2646
2647
2648 @var{x} might be a pseudo-register or a @code{subreg} of a
2649 pseudo-register, which could either be in a hard register or in memory.
2650 Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is
2651 in memory and the hard register number if it is in a register.
2652
2653 Scratch operands in memory (constraint @code{"=m"} / @code{"=&m"}) are
2654 currently not supported.  For the time being, you will have to continue
2655 to use @code{SECONDARY_MEMORY_NEEDED} for that purpose.
2656
2657 @code{copy_cost} also uses this target hook to find out how values are
2658 copied.  If you want it to include some extra cost for the need to allocate
2659 (a) scratch register(s), set @code{sri->extra_cost} to the additional cost.
2660 Or if two dependent moves are supposed to have a lower cost than the sum
2661 of the individual moves due to expected fortuitous scheduling and/or special
2662 forwarding logic, you can set @code{sri->extra_cost} to a negative amount.
2663 @end deftypefn
2664
2665 @defmac SECONDARY_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2666 @defmacx SECONDARY_INPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2667 @defmacx SECONDARY_OUTPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x})
2668 These macros are obsolete, new ports should use the target hook
2669 @code{TARGET_SECONDARY_RELOAD} instead.
2670
2671 These are obsolete macros, replaced by the @code{TARGET_SECONDARY_RELOAD}
2672 target hook.  Older ports still define these macros to indicate to the
2673 reload phase that it may
2674 need to allocate at least one register for a reload in addition to the
2675 register to contain the data.  Specifically, if copying @var{x} to a
2676 register @var{class} in @var{mode} requires an intermediate register,
2677 you were supposed to define @code{SECONDARY_INPUT_RELOAD_CLASS} to return the
2678 largest register class all of whose registers can be used as
2679 intermediate registers or scratch registers.
2680
2681 If copying a register @var{class} in @var{mode} to @var{x} requires an
2682 intermediate or scratch register, @code{SECONDARY_OUTPUT_RELOAD_CLASS}
2683 was supposed to be defined be defined to return the largest register
2684 class required.  If the
2685 requirements for input and output reloads were the same, the macro
2686 @code{SECONDARY_RELOAD_CLASS} should have been used instead of defining both
2687 macros identically.
2688
2689 The values returned by these macros are often @code{GENERAL_REGS}.
2690 Return @code{NO_REGS} if no spare register is needed; i.e., if @var{x}
2691 can be directly copied to or from a register of @var{class} in
2692 @var{mode} without requiring a scratch register.  Do not define this
2693 macro if it would always return @code{NO_REGS}.
2694
2695 If a scratch register is required (either with or without an
2696 intermediate register), you were supposed to define patterns for
2697 @samp{reload_in@var{m}} or @samp{reload_out@var{m}}, as required
2698 (@pxref{Standard Names}.  These patterns, which were normally
2699 implemented with a @code{define_expand}, should be similar to the
2700 @samp{mov@var{m}} patterns, except that operand 2 is the scratch
2701 register.
2702
2703 These patterns need constraints for the reload register and scratch
2704 register that
2705 contain a single register class.  If the original reload register (whose
2706 class is @var{class}) can meet the constraint given in the pattern, the
2707 value returned by these macros is used for the class of the scratch
2708 register.  Otherwise, two additional reload registers are required.
2709 Their classes are obtained from the constraints in the insn pattern.
2710
2711 @var{x} might be a pseudo-register or a @code{subreg} of a
2712 pseudo-register, which could either be in a hard register or in memory.
2713 Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is
2714 in memory and the hard register number if it is in a register.
2715
2716 These macros should not be used in the case where a particular class of
2717 registers can only be copied to memory and not to another class of
2718 registers.  In that case, secondary reload registers are not needed and
2719 would not be helpful.  Instead, a stack location must be used to perform
2720 the copy and the @code{mov@var{m}} pattern should use memory as an
2721 intermediate storage.  This case often occurs between floating-point and
2722 general registers.
2723 @end defmac
2724
2725 @defmac SECONDARY_MEMORY_NEEDED (@var{class1}, @var{class2}, @var{m})
2726 Certain machines have the property that some registers cannot be copied
2727 to some other registers without using memory.  Define this macro on
2728 those machines to be a C expression that is nonzero if objects of mode
2729 @var{m} in registers of @var{class1} can only be copied to registers of
2730 class @var{class2} by storing a register of @var{class1} into memory
2731 and loading that memory location into a register of @var{class2}.
2732
2733 Do not define this macro if its value would always be zero.
2734 @end defmac
2735
2736 @defmac SECONDARY_MEMORY_NEEDED_RTX (@var{mode})
2737 Normally when @code{SECONDARY_MEMORY_NEEDED} is defined, the compiler
2738 allocates a stack slot for a memory location needed for register copies.
2739 If this macro is defined, the compiler instead uses the memory location
2740 defined by this macro.
2741
2742 Do not define this macro if you do not define
2743 @code{SECONDARY_MEMORY_NEEDED}.
2744 @end defmac
2745
2746 @defmac SECONDARY_MEMORY_NEEDED_MODE (@var{mode})
2747 When the compiler needs a secondary memory location to copy between two
2748 registers of mode @var{mode}, it normally allocates sufficient memory to
2749 hold a quantity of @code{BITS_PER_WORD} bits and performs the store and
2750 load operations in a mode that many bits wide and whose class is the
2751 same as that of @var{mode}.
2752
2753 This is right thing to do on most machines because it ensures that all
2754 bits of the register are copied and prevents accesses to the registers
2755 in a narrower mode, which some machines prohibit for floating-point
2756 registers.
2757
2758 However, this default behavior is not correct on some machines, such as
2759 the DEC Alpha, that store short integers in floating-point registers
2760 differently than in integer registers.  On those machines, the default
2761 widening will not work correctly and you must define this macro to
2762 suppress that widening in some cases.  See the file @file{alpha.h} for
2763 details.
2764
2765 Do not define this macro if you do not define
2766 @code{SECONDARY_MEMORY_NEEDED} or if widening @var{mode} to a mode that
2767 is @code{BITS_PER_WORD} bits wide is correct for your machine.
2768 @end defmac
2769
2770 @deftypefn {Target Hook} bool TARGET_CLASS_LIKELY_SPILLED_P (reg_class_t @var{rclass})
2771 A target hook which returns @code{true} if pseudos that have been assigned
2772 to registers of class @var{rclass} would likely be spilled because
2773 registers of @var{rclass} are needed for spill registers.
2774
2775 The default version of this target hook returns @code{true} if @var{rclass}
2776 has exactly one register and @code{false} otherwise.  On most machines, this
2777 default should be used.  For generally register-starved machines, such as
2778 i386, or machines with right register constraints, such as SH, this hook
2779 can be used to avoid excessive spilling.
2780
2781 This hook is also used by some of the global intra-procedural code
2782 transformations to throtle code motion, to avoid increasing register
2783 pressure.
2784 @end deftypefn
2785
2786 @deftypefn {Target Hook} {unsigned char} TARGET_CLASS_MAX_NREGS (reg_class_t @var{rclass}, machine_mode @var{mode})
2787 A target hook returns the maximum number of consecutive registers
2788 of class @var{rclass} needed to hold a value of mode @var{mode}.
2789
2790 This is closely related to the macro @code{HARD_REGNO_NREGS}.  In fact,
2791 the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass},
2792 @var{mode})} target hook should be the maximum value of
2793 @code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}
2794 values in the class @var{rclass}.
2795
2796 This target hook helps control the handling of multiple-word values
2797 in the reload pass.
2798
2799 The default version of this target hook returns the size of @var{mode}
2800 in words.
2801 @end deftypefn
2802
2803 @defmac CLASS_MAX_NREGS (@var{class}, @var{mode})
2804 A C expression for the maximum number of consecutive registers
2805 of class @var{class} needed to hold a value of mode @var{mode}.
2806
2807 This is closely related to the macro @code{HARD_REGNO_NREGS}.  In fact,
2808 the value of the macro @code{CLASS_MAX_NREGS (@var{class}, @var{mode})}
2809 should be the maximum value of @code{HARD_REGNO_NREGS (@var{regno},
2810 @var{mode})} for all @var{regno} values in the class @var{class}.
2811
2812 This macro helps control the handling of multiple-word values
2813 in the reload pass.
2814 @end defmac
2815
2816 @defmac CANNOT_CHANGE_MODE_CLASS (@var{from}, @var{to}, @var{class})
2817 If defined, a C expression that returns nonzero for a @var{class} for which
2818 a change from mode @var{from} to mode @var{to} is invalid.
2819
2820 For the example, loading 32-bit integer or floating-point objects into
2821 floating-point registers on the Alpha extends them to 64 bits.
2822 Therefore loading a 64-bit object and then storing it as a 32-bit object
2823 does not store the low-order 32 bits, as would be the case for a normal
2824 register.  Therefore, @file{alpha.h} defines @code{CANNOT_CHANGE_MODE_CLASS}
2825 as below:
2826
2827 @smallexample
2828 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
2829   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \
2830    ? reg_classes_intersect_p (FLOAT_REGS, (CLASS)) : 0)
2831 @end smallexample
2832 @end defmac
2833
2834 @deftypefn {Target Hook} bool TARGET_LRA_P (void)
2835 A target hook which returns true if we use LRA instead of reload pass.  It means that LRA was ported to the target.    The default version of this target hook returns always false.
2836 @end deftypefn
2837
2838 @deftypefn {Target Hook} int TARGET_REGISTER_PRIORITY (int)
2839 A target hook which returns the register priority number to which the  register @var{hard_regno} belongs to.  The bigger the number, the  more preferable the hard register usage (when all other conditions are  the same).  This hook can be used to prefer some hard register over  others in LRA.  For example, some x86-64 register usage needs  additional prefix which makes instructions longer.  The hook can  return lower priority number for such registers make them less favorable  and as result making the generated code smaller.    The default version of this target hook returns always zero.
2840 @end deftypefn
2841
2842 @deftypefn {Target Hook} bool TARGET_REGISTER_USAGE_LEVELING_P (void)
2843 A target hook which returns true if we need register usage leveling.  That means if a few hard registers are equally good for the  assignment, we choose the least used hard register.  The register  usage leveling may be profitable for some targets.  Don't use the  usage leveling for targets with conditional execution or targets  with big register files as it hurts if-conversion and cross-jumping  optimizations.    The default version of this target hook returns always false.
2844 @end deftypefn
2845
2846 @deftypefn {Target Hook} bool TARGET_DIFFERENT_ADDR_DISPLACEMENT_P (void)
2847 A target hook which returns true if an address with the same structure  can have different maximal legitimate displacement.  For example, the  displacement can depend on memory mode or on operand combinations in  the insn.    The default version of this target hook returns always false.
2848 @end deftypefn
2849
2850 @deftypefn {Target Hook} bool TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P (rtx @var{subst})
2851 A target hook which returns @code{true} if @var{subst} can't
2852 substitute safely pseudos with equivalent memory values during
2853 register allocation.
2854 The default version of this target hook returns @code{false}.
2855 On most machines, this default should be used.  For generally
2856 machines with non orthogonal register usage for addressing, such
2857 as SH, this hook can be used to avoid excessive spilling.
2858 @end deftypefn
2859
2860 @deftypefn {Target Hook} bool TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT (rtx *@var{disp}, rtx *@var{offset}, machine_mode @var{mode})
2861 A target hook which returns @code{true} if *@var{disp} is
2862 legitimezed to valid address displacement with subtracting *@var{offset}
2863 at memory mode @var{mode}.
2864 The default version of this target hook returns @code{false}.
2865 This hook will benefit machines with limited base plus displacement
2866 addressing.
2867 @end deftypefn
2868
2869 @deftypefn {Target Hook} reg_class_t TARGET_SPILL_CLASS (reg_class_t, @var{machine_mode})
2870 This hook defines a class of registers which could be used for spilling  pseudos of the given mode and class, or @code{NO_REGS} if only memory  should be used.  Not defining this hook is equivalent to returning  @code{NO_REGS} for all inputs.
2871 @end deftypefn
2872
2873 @deftypefn {Target Hook} machine_mode TARGET_CSTORE_MODE (enum insn_code @var{icode})
2874 This hook defines the machine mode to use for the boolean result of  conditional store patterns.  The ICODE argument is the instruction code  for the cstore being performed.  Not definiting this hook is the same  as accepting the mode encoded into operand 0 of the cstore expander  patterns.
2875 @end deftypefn
2876
2877 @node Stack and Calling
2878 @section Stack Layout and Calling Conventions
2879 @cindex calling conventions
2880
2881 @c prevent bad page break with this line
2882 This describes the stack layout and calling conventions.
2883
2884 @menu
2885 * Frame Layout::
2886 * Exception Handling::
2887 * Stack Checking::
2888 * Frame Registers::
2889 * Elimination::
2890 * Stack Arguments::
2891 * Register Arguments::
2892 * Scalar Return::
2893 * Aggregate Return::
2894 * Caller Saves::
2895 * Function Entry::
2896 * Profiling::
2897 * Tail Calls::
2898 * Stack Smashing Protection::
2899 * Miscellaneous Register Hooks::
2900 @end menu
2901
2902 @node Frame Layout
2903 @subsection Basic Stack Layout
2904 @cindex stack frame layout
2905 @cindex frame layout
2906
2907 @c prevent bad page break with this line
2908 Here is the basic stack layout.
2909
2910 @defmac STACK_GROWS_DOWNWARD
2911 Define this macro if pushing a word onto the stack moves the stack
2912 pointer to a smaller address.
2913
2914 When we say, ``define this macro if @dots{}'', it means that the
2915 compiler checks this macro only with @code{#ifdef} so the precise
2916 definition used does not matter.
2917 @end defmac
2918
2919 @defmac STACK_PUSH_CODE
2920 This macro defines the operation used when something is pushed
2921 on the stack.  In RTL, a push operation will be
2922 @code{(set (mem (STACK_PUSH_CODE (reg sp))) @dots{})}
2923
2924 The choices are @code{PRE_DEC}, @code{POST_DEC}, @code{PRE_INC},
2925 and @code{POST_INC}.  Which of these is correct depends on
2926 the stack direction and on whether the stack pointer points
2927 to the last item on the stack or whether it points to the
2928 space for the next item on the stack.
2929
2930 The default is @code{PRE_DEC} when @code{STACK_GROWS_DOWNWARD} is
2931 defined, which is almost always right, and @code{PRE_INC} otherwise,
2932 which is often wrong.
2933 @end defmac
2934
2935 @defmac FRAME_GROWS_DOWNWARD
2936 Define this macro to nonzero value if the addresses of local variable slots
2937 are at negative offsets from the frame pointer.
2938 @end defmac
2939
2940 @defmac ARGS_GROW_DOWNWARD
2941 Define this macro if successive arguments to a function occupy decreasing
2942 addresses on the stack.
2943 @end defmac
2944
2945 @defmac STARTING_FRAME_OFFSET
2946 Offset from the frame pointer to the first local variable slot to be allocated.
2947
2948 If @code{FRAME_GROWS_DOWNWARD}, find the next slot's offset by
2949 subtracting the first slot's length from @code{STARTING_FRAME_OFFSET}.
2950 Otherwise, it is found by adding the length of the first slot to the
2951 value @code{STARTING_FRAME_OFFSET}.
2952 @c i'm not sure if the above is still correct.. had to change it to get
2953 @c rid of an overfull.  --mew 2feb93
2954 @end defmac
2955
2956 @defmac STACK_ALIGNMENT_NEEDED
2957 Define to zero to disable final alignment of the stack during reload.
2958 The nonzero default for this macro is suitable for most ports.
2959
2960 On ports where @code{STARTING_FRAME_OFFSET} is nonzero or where there
2961 is a register save block following the local block that doesn't require
2962 alignment to @code{STACK_BOUNDARY}, it may be beneficial to disable
2963 stack alignment and do it in the backend.
2964 @end defmac
2965
2966 @defmac STACK_POINTER_OFFSET
2967 Offset from the stack pointer register to the first location at which
2968 outgoing arguments are placed.  If not specified, the default value of
2969 zero is used.  This is the proper value for most machines.
2970
2971 If @code{ARGS_GROW_DOWNWARD}, this is the offset to the location above
2972 the first location at which outgoing arguments are placed.
2973 @end defmac
2974
2975 @defmac FIRST_PARM_OFFSET (@var{fundecl})
2976 Offset from the argument pointer register to the first argument's
2977 address.  On some machines it may depend on the data type of the
2978 function.
2979
2980 If @code{ARGS_GROW_DOWNWARD}, this is the offset to the location above
2981 the first argument's address.
2982 @end defmac
2983
2984 @defmac STACK_DYNAMIC_OFFSET (@var{fundecl})
2985 Offset from the stack pointer register to an item dynamically allocated
2986 on the stack, e.g., by @code{alloca}.
2987
2988 The default value for this macro is @code{STACK_POINTER_OFFSET} plus the
2989 length of the outgoing arguments.  The default is correct for most
2990 machines.  See @file{function.c} for details.
2991 @end defmac
2992
2993 @defmac INITIAL_FRAME_ADDRESS_RTX
2994 A C expression whose value is RTL representing the address of the initial
2995 stack frame. This address is passed to @code{RETURN_ADDR_RTX} and
2996 @code{DYNAMIC_CHAIN_ADDRESS}.  If you don't define this macro, a reasonable
2997 default value will be used.  Define this macro in order to make frame pointer
2998 elimination work in the presence of @code{__builtin_frame_address (count)} and
2999 @code{__builtin_return_address (count)} for @code{count} not equal to zero.
3000 @end defmac
3001
3002 @defmac DYNAMIC_CHAIN_ADDRESS (@var{frameaddr})
3003 A C expression whose value is RTL representing the address in a stack
3004 frame where the pointer to the caller's frame is stored.  Assume that
3005 @var{frameaddr} is an RTL expression for the address of the stack frame
3006 itself.
3007
3008 If you don't define this macro, the default is to return the value
3009 of @var{frameaddr}---that is, the stack frame address is also the
3010 address of the stack word that points to the previous frame.
3011 @end defmac
3012
3013 @defmac SETUP_FRAME_ADDRESSES
3014 If defined, a C expression that produces the machine-specific code to
3015 setup the stack so that arbitrary frames can be accessed.  For example,
3016 on the SPARC, we must flush all of the register windows to the stack
3017 before we can access arbitrary stack frames.  You will seldom need to
3018 define this macro.
3019 @end defmac
3020
3021 @deftypefn {Target Hook} rtx TARGET_BUILTIN_SETJMP_FRAME_VALUE (void)
3022 This target hook should return an rtx that is used to store
3023 the address of the current frame into the built in @code{setjmp} buffer.
3024 The default value, @code{virtual_stack_vars_rtx}, is correct for most
3025 machines.  One reason you may need to define this target hook is if
3026 @code{hard_frame_pointer_rtx} is the appropriate value on your machine.
3027 @end deftypefn
3028
3029 @defmac FRAME_ADDR_RTX (@var{frameaddr})
3030 A C expression whose value is RTL representing the value of the frame
3031 address for the current frame.  @var{frameaddr} is the frame pointer
3032 of the current frame.  This is used for __builtin_frame_address.
3033 You need only define this macro if the frame address is not the same
3034 as the frame pointer.  Most machines do not need to define it.
3035 @end defmac
3036
3037 @defmac RETURN_ADDR_RTX (@var{count}, @var{frameaddr})
3038 A C expression whose value is RTL representing the value of the return
3039 address for the frame @var{count} steps up from the current frame, after
3040 the prologue.  @var{frameaddr} is the frame pointer of the @var{count}
3041 frame, or the frame pointer of the @var{count} @minus{} 1 frame if
3042 @code{RETURN_ADDR_IN_PREVIOUS_FRAME} is defined.
3043
3044 The value of the expression must always be the correct address when
3045 @var{count} is zero, but may be @code{NULL_RTX} if there is no way to
3046 determine the return address of other frames.
3047 @end defmac
3048
3049 @defmac RETURN_ADDR_IN_PREVIOUS_FRAME
3050 Define this if the return address of a particular stack frame is accessed
3051 from the frame pointer of the previous stack frame.
3052 @end defmac
3053
3054 @defmac INCOMING_RETURN_ADDR_RTX
3055 A C expression whose value is RTL representing the location of the
3056 incoming return address at the beginning of any function, before the
3057 prologue.  This RTL is either a @code{REG}, indicating that the return
3058 value is saved in @samp{REG}, or a @code{MEM} representing a location in
3059 the stack.
3060
3061 You only need to define this macro if you want to support call frame
3062 debugging information like that provided by DWARF 2.
3063
3064 If this RTL is a @code{REG}, you should also define
3065 @code{DWARF_FRAME_RETURN_COLUMN} to @code{DWARF_FRAME_REGNUM (REGNO)}.
3066 @end defmac
3067
3068 @defmac DWARF_ALT_FRAME_RETURN_COLUMN
3069 A C expression whose value is an integer giving a DWARF 2 column
3070 number that may be used as an alternative return column.  The column
3071 must not correspond to any gcc hard register (that is, it must not
3072 be in the range of @code{DWARF_FRAME_REGNUM}).
3073
3074 This macro can be useful if @code{DWARF_FRAME_RETURN_COLUMN} is set to a
3075 general register, but an alternative column needs to be used for signal
3076 frames.  Some targets have also used different frame return columns
3077 over time.
3078 @end defmac
3079
3080 @defmac DWARF_ZERO_REG
3081 A C expression whose value is an integer giving a DWARF 2 register
3082 number that is considered to always have the value zero.  This should
3083 only be defined if the target has an architected zero register, and
3084 someone decided it was a good idea to use that register number to
3085 terminate the stack backtrace.  New ports should avoid this.
3086 @end defmac
3087
3088 @deftypefn {Target Hook} void TARGET_DWARF_HANDLE_FRAME_UNSPEC (const char *@var{label}, rtx @var{pattern}, int @var{index})
3089 This target hook allows the backend to emit frame-related insns that
3090 contain UNSPECs or UNSPEC_VOLATILEs.  The DWARF 2 call frame debugging
3091 info engine will invoke it on insns of the form
3092 @smallexample
3093 (set (reg) (unspec [@dots{}] UNSPEC_INDEX))
3094 @end smallexample
3095 and
3096 @smallexample
3097 (set (reg) (unspec_volatile [@dots{}] UNSPECV_INDEX)).
3098 @end smallexample
3099 to let the backend emit the call frame instructions.  @var{label} is
3100 the CFI label attached to the insn, @var{pattern} is the pattern of
3101 the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}.
3102 @end deftypefn
3103
3104 @defmac INCOMING_FRAME_SP_OFFSET
3105 A C expression whose value is an integer giving the offset, in bytes,
3106 from the value of the stack pointer register to the top of the stack
3107 frame at the beginning of any function, before the prologue.  The top of
3108 the frame is defined to be the value of the stack pointer in the
3109 previous frame, just before the call instruction.
3110
3111 You only need to define this macro if you want to support call frame
3112 debugging information like that provided by DWARF 2.
3113 @end defmac
3114
3115 @defmac ARG_POINTER_CFA_OFFSET (@var{fundecl})
3116 A C expression whose value is an integer giving the offset, in bytes,
3117 from the argument pointer to the canonical frame address (cfa).  The
3118 final value should coincide with that calculated by
3119 @code{INCOMING_FRAME_SP_OFFSET}.  Which is unfortunately not usable
3120 during virtual register instantiation.
3121
3122 The default value for this macro is
3123 @code{FIRST_PARM_OFFSET (fundecl) + crtl->args.pretend_args_size},
3124 which is correct for most machines; in general, the arguments are found
3125 immediately before the stack frame.  Note that this is not the case on
3126 some targets that save registers into the caller's frame, such as SPARC
3127 and rs6000, and so such targets need to define this macro.
3128
3129 You only need to define this macro if the default is incorrect, and you
3130 want to support call frame debugging information like that provided by
3131 DWARF 2.
3132 @end defmac
3133
3134 @defmac FRAME_POINTER_CFA_OFFSET (@var{fundecl})
3135 If defined, a C expression whose value is an integer giving the offset
3136 in bytes from the frame pointer to the canonical frame address (cfa).
3137 The final value should coincide with that calculated by
3138 @code{INCOMING_FRAME_SP_OFFSET}.
3139
3140 Normally the CFA is calculated as an offset from the argument pointer,
3141 via @code{ARG_POINTER_CFA_OFFSET}, but if the argument pointer is
3142 variable due to the ABI, this may not be possible.  If this macro is
3143 defined, it implies that the virtual register instantiation should be
3144 based on the frame pointer instead of the argument pointer.  Only one
3145 of @code{FRAME_POINTER_CFA_OFFSET} and @code{ARG_POINTER_CFA_OFFSET}
3146 should be defined.
3147 @end defmac
3148
3149 @defmac CFA_FRAME_BASE_OFFSET (@var{fundecl})
3150 If defined, a C expression whose value is an integer giving the offset
3151 in bytes from the canonical frame address (cfa) to the frame base used
3152 in DWARF 2 debug information.  The default is zero.  A different value
3153 may reduce the size of debug information on some ports.
3154 @end defmac
3155
3156 @node Exception Handling
3157 @subsection Exception Handling Support
3158 @cindex exception handling
3159
3160 @defmac EH_RETURN_DATA_REGNO (@var{N})
3161 A C expression whose value is the @var{N}th register number used for
3162 data by exception handlers, or @code{INVALID_REGNUM} if fewer than
3163 @var{N} registers are usable.
3164
3165 The exception handling library routines communicate with the exception
3166 handlers via a set of agreed upon registers.  Ideally these registers
3167 should be call-clobbered; it is possible to use call-saved registers,
3168 but may negatively impact code size.  The target must support at least
3169 2 data registers, but should define 4 if there are enough free registers.
3170
3171 You must define this macro if you want to support call frame exception
3172 handling like that provided by DWARF 2.
3173 @end defmac
3174
3175 @defmac EH_RETURN_STACKADJ_RTX
3176 A C expression whose value is RTL representing a location in which
3177 to store a stack adjustment to be applied before function return.
3178 This is used to unwind the stack to an exception handler's call frame.
3179 It will be assigned zero on code paths that return normally.
3180
3181 Typically this is a call-clobbered hard register that is otherwise
3182 untouched by the epilogue, but could also be a stack slot.
3183
3184 Do not define this macro if the stack pointer is saved and restored
3185 by the regular prolog and epilog code in the call frame itself; in
3186 this case, the exception handling library routines will update the
3187 stack location to be restored in place.  Otherwise, you must define
3188 this macro if you want to support call frame exception handling like
3189 that provided by DWARF 2.
3190 @end defmac
3191
3192 @defmac EH_RETURN_HANDLER_RTX
3193 A C expression whose value is RTL representing a location in which
3194 to store the address of an exception handler to which we should
3195 return.  It will not be assigned on code paths that return normally.
3196
3197 Typically this is the location in the call frame at which the normal
3198 return address is stored.  For targets that return by popping an
3199 address off the stack, this might be a memory address just below
3200 the @emph{target} call frame rather than inside the current call
3201 frame.  If defined, @code{EH_RETURN_STACKADJ_RTX} will have already
3202 been assigned, so it may be used to calculate the location of the
3203 target call frame.
3204
3205 Some targets have more complex requirements than storing to an
3206 address calculable during initial code generation.  In that case
3207 the @code{eh_return} instruction pattern should be used instead.
3208
3209 If you want to support call frame exception handling, you must
3210 define either this macro or the @code{eh_return} instruction pattern.
3211 @end defmac
3212
3213 @defmac RETURN_ADDR_OFFSET
3214 If defined, an integer-valued C expression for which rtl will be generated
3215 to add it to the exception handler address before it is searched in the
3216 exception handling tables, and to subtract it again from the address before
3217 using it to return to the exception handler.
3218 @end defmac
3219
3220 @defmac ASM_PREFERRED_EH_DATA_FORMAT (@var{code}, @var{global})
3221 This macro chooses the encoding of pointers embedded in the exception
3222 handling sections.  If at all possible, this should be defined such
3223 that the exception handling section will not require dynamic relocations,
3224 and so may be read-only.
3225
3226 @var{code} is 0 for data, 1 for code labels, 2 for function pointers.
3227 @var{global} is true if the symbol may be affected by dynamic relocations.
3228 The macro should return a combination of the @code{DW_EH_PE_*} defines
3229 as found in @file{dwarf2.h}.
3230
3231 If this macro is not defined, pointers will not be encoded but
3232 represented directly.
3233 @end defmac
3234
3235 @defmac ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (@var{file}, @var{encoding}, @var{size}, @var{addr}, @var{done})
3236 This macro allows the target to emit whatever special magic is required
3237 to represent the encoding chosen by @code{ASM_PREFERRED_EH_DATA_FORMAT}.
3238 Generic code takes care of pc-relative and indirect encodings; this must
3239 be defined if the target uses text-relative or data-relative encodings.
3240
3241 This is a C statement that branches to @var{done} if the format was
3242 handled.  @var{encoding} is the format chosen, @var{size} is the number
3243 of bytes that the format occupies, @var{addr} is the @code{SYMBOL_REF}
3244 to be emitted.
3245 @end defmac
3246
3247 @defmac MD_FALLBACK_FRAME_STATE_FOR (@var{context}, @var{fs})
3248 This macro allows the target to add CPU and operating system specific
3249 code to the call-frame unwinder for use when there is no unwind data
3250 available.  The most common reason to implement this macro is to unwind
3251 through signal frames.
3252
3253 This macro is called from @code{uw_frame_state_for} in
3254 @file{unwind-dw2.c}, @file{unwind-dw2-xtensa.c} and
3255 @file{unwind-ia64.c}.  @var{context} is an @code{_Unwind_Context};
3256 @var{fs} is an @code{_Unwind_FrameState}.  Examine @code{context->ra}
3257 for the address of the code being executed and @code{context->cfa} for
3258 the stack pointer value.  If the frame can be decoded, the register
3259 save addresses should be updated in @var{fs} and the macro should
3260 evaluate to @code{_URC_NO_REASON}.  If the frame cannot be decoded,
3261 the macro should evaluate to @code{_URC_END_OF_STACK}.
3262
3263 For proper signal handling in Java this macro is accompanied by
3264 @code{MAKE_THROW_FRAME}, defined in @file{libjava/include/*-signal.h} headers.
3265 @end defmac
3266
3267 @defmac MD_HANDLE_UNWABI (@var{context}, @var{fs})
3268 This macro allows the target to add operating system specific code to the
3269 call-frame unwinder to handle the IA-64 @code{.unwabi} unwinding directive,
3270 usually used for signal or interrupt frames.
3271
3272 This macro is called from @code{uw_update_context} in libgcc's
3273 @file{unwind-ia64.c}.  @var{context} is an @code{_Unwind_Context};
3274 @var{fs} is an @code{_Unwind_FrameState}.  Examine @code{fs->unwabi}
3275 for the abi and context in the @code{.unwabi} directive.  If the
3276 @code{.unwabi} directive can be handled, the register save addresses should
3277 be updated in @var{fs}.
3278 @end defmac
3279
3280 @defmac TARGET_USES_WEAK_UNWIND_INFO
3281 A C expression that evaluates to true if the target requires unwind
3282 info to be given comdat linkage.  Define it to be @code{1} if comdat
3283 linkage is necessary.  The default is @code{0}.
3284 @end defmac
3285
3286 @node Stack Checking
3287 @subsection Specifying How Stack Checking is Done
3288
3289 GCC will check that stack references are within the boundaries of the
3290 stack, if the option @option{-fstack-check} is specified, in one of
3291 three ways:
3292
3293 @enumerate
3294 @item
3295 If the value of the @code{STACK_CHECK_BUILTIN} macro is nonzero, GCC
3296 will assume that you have arranged for full stack checking to be done
3297 at appropriate places in the configuration files.  GCC will not do
3298 other special processing.
3299
3300 @item
3301 If @code{STACK_CHECK_BUILTIN} is zero and the value of the
3302 @code{STACK_CHECK_STATIC_BUILTIN} macro is nonzero, GCC will assume
3303 that you have arranged for static stack checking (checking of the
3304 static stack frame of functions) to be done at appropriate places
3305 in the configuration files.  GCC will only emit code to do dynamic
3306 stack checking (checking on dynamic stack allocations) using the third
3307 approach below.
3308
3309 @item
3310 If neither of the above are true, GCC will generate code to periodically
3311 ``probe'' the stack pointer using the values of the macros defined below.
3312 @end enumerate
3313
3314 If neither STACK_CHECK_BUILTIN nor STACK_CHECK_STATIC_BUILTIN is defined,
3315 GCC will change its allocation strategy for large objects if the option
3316 @option{-fstack-check} is specified: they will always be allocated
3317 dynamically if their size exceeds @code{STACK_CHECK_MAX_VAR_SIZE} bytes.
3318
3319 @defmac STACK_CHECK_BUILTIN
3320 A nonzero value if stack checking is done by the configuration files in a
3321 machine-dependent manner.  You should define this macro if stack checking
3322 is required by the ABI of your machine or if you would like to do stack
3323 checking in some more efficient way than the generic approach.  The default
3324 value of this macro is zero.
3325 @end defmac
3326
3327 @defmac STACK_CHECK_STATIC_BUILTIN
3328 A nonzero value if static stack checking is done by the configuration files
3329 in a machine-dependent manner.  You should define this macro if you would
3330 like to do static stack checking in some more efficient way than the generic
3331 approach.  The default value of this macro is zero.
3332 @end defmac
3333
3334 @defmac STACK_CHECK_PROBE_INTERVAL_EXP
3335 An integer specifying the interval at which GCC must generate stack probe
3336 instructions, defined as 2 raised to this integer.  You will normally
3337 define this macro so that the interval be no larger than the size of
3338 the ``guard pages'' at the end of a stack area.  The default value
3339 of 12 (4096-byte interval) is suitable for most systems.
3340 @end defmac
3341
3342 @defmac STACK_CHECK_MOVING_SP
3343 An integer which is nonzero if GCC should move the stack pointer page by page
3344 when doing probes.  This can be necessary on systems where the stack pointer
3345 contains the bottom address of the memory area accessible to the executing
3346 thread at any point in time.  In this situation an alternate signal stack
3347 is required in order to be able to recover from a stack overflow.  The
3348 default value of this macro is zero.
3349 @end defmac
3350
3351 @defmac STACK_CHECK_PROTECT
3352 The number of bytes of stack needed to recover from a stack overflow, for
3353 languages where such a recovery is supported.  The default value of 75 words
3354 with the @code{setjmp}/@code{longjmp}-based exception handling mechanism and
3355 8192 bytes with other exception handling mechanisms should be adequate for
3356 most machines.
3357 @end defmac
3358
3359 The following macros are relevant only if neither STACK_CHECK_BUILTIN
3360 nor STACK_CHECK_STATIC_BUILTIN is defined; you can omit them altogether
3361 in the opposite case.
3362
3363 @defmac STACK_CHECK_MAX_FRAME_SIZE
3364 The maximum size of a stack frame, in bytes.  GCC will generate probe
3365 instructions in non-leaf functions to ensure at least this many bytes of
3366 stack are available.  If a stack frame is larger than this size, stack
3367 checking will not be reliable and GCC will issue a warning.  The
3368 default is chosen so that GCC only generates one instruction on most
3369 systems.  You should normally not change the default value of this macro.
3370 @end defmac
3371
3372 @defmac STACK_CHECK_FIXED_FRAME_SIZE
3373 GCC uses this value to generate the above warning message.  It
3374 represents the amount of fixed frame used by a function, not including
3375 space for any callee-saved registers, temporaries and user variables.
3376 You need only specify an upper bound for this amount and will normally
3377 use the default of four words.
3378 @end defmac
3379
3380 @defmac STACK_CHECK_MAX_VAR_SIZE
3381 The maximum size, in bytes, of an object that GCC will place in the
3382 fixed area of the stack frame when the user specifies
3383 @option{-fstack-check}.
3384 GCC computed the default from the values of the above macros and you will
3385 normally not need to override that default.
3386 @end defmac
3387
3388 @need 2000
3389 @node Frame Registers
3390 @subsection Registers That Address the Stack Frame
3391
3392 @c prevent bad page break with this line
3393 This discusses registers that address the stack frame.
3394
3395 @defmac STACK_POINTER_REGNUM
3396 The register number of the stack pointer register, which must also be a
3397 fixed register according to @code{FIXED_REGISTERS}.  On most machines,
3398 the hardware determines which register this is.
3399 @end defmac
3400
3401 @defmac FRAME_POINTER_REGNUM
3402 The register number of the frame pointer register, which is used to
3403 access automatic variables in the stack frame.  On some machines, the
3404 hardware determines which register this is.  On other machines, you can
3405 choose any register you wish for this purpose.
3406 @end defmac
3407
3408 @defmac HARD_FRAME_POINTER_REGNUM
3409 On some machines the offset between the frame pointer and starting
3410 offset of the automatic variables is not known until after register
3411 allocation has been done (for example, because the saved registers are
3412 between these two locations).  On those machines, define
3413 @code{FRAME_POINTER_REGNUM} the number of a special, fixed register to
3414 be used internally until the offset is known, and define
3415 @code{HARD_FRAME_POINTER_REGNUM} to be the actual hard register number
3416 used for the frame pointer.
3417
3418 You should define this macro only in the very rare circumstances when it
3419 is not possible to calculate the offset between the frame pointer and
3420 the automatic variables until after register allocation has been
3421 completed.  When this macro is defined, you must also indicate in your
3422 definition of @code{ELIMINABLE_REGS} how to eliminate
3423 @code{FRAME_POINTER_REGNUM} into either @code{HARD_FRAME_POINTER_REGNUM}
3424 or @code{STACK_POINTER_REGNUM}.
3425
3426 Do not define this macro if it would be the same as
3427 @code{FRAME_POINTER_REGNUM}.
3428 @end defmac
3429
3430 @defmac ARG_POINTER_REGNUM
3431 The register number of the arg pointer register, which is used to access
3432 the function's argument list.  On some machines, this is the same as the
3433 frame pointer register.  On some machines, the hardware determines which
3434 register this is.  On other machines, you can choose any register you
3435 wish for this purpose.  If this is not the same register as the frame
3436 pointer register, then you must mark it as a fixed register according to
3437 @code{FIXED_REGISTERS}, or arrange to be able to eliminate it
3438 (@pxref{Elimination}).
3439 @end defmac
3440
3441 @defmac HARD_FRAME_POINTER_IS_FRAME_POINTER
3442 Define this to a preprocessor constant that is nonzero if
3443 @code{hard_frame_pointer_rtx} and @code{frame_pointer_rtx} should be
3444 the same.  The default definition is @samp{(HARD_FRAME_POINTER_REGNUM
3445 == FRAME_POINTER_REGNUM)}; you only need to define this macro if that
3446 definition is not suitable for use in preprocessor conditionals.
3447 @end defmac
3448
3449 @defmac HARD_FRAME_POINTER_IS_ARG_POINTER
3450 Define this to a preprocessor constant that is nonzero if
3451 @code{hard_frame_pointer_rtx} and @code{arg_pointer_rtx} should be the
3452 same.  The default definition is @samp{(HARD_FRAME_POINTER_REGNUM ==
3453 ARG_POINTER_REGNUM)}; you only need to define this macro if that
3454 definition is not suitable for use in preprocessor conditionals.
3455 @end defmac
3456
3457 @defmac RETURN_ADDRESS_POINTER_REGNUM
3458 The register number of the return address pointer register, which is used to
3459 access the current function's return address from the stack.  On some
3460 machines, the return address is not at a fixed offset from the frame
3461 pointer or stack pointer or argument pointer.  This register can be defined
3462 to point to the return address on the stack, and then be converted by
3463 @code{ELIMINABLE_REGS} into either the frame pointer or stack pointer.
3464
3465 Do not define this macro unless there is no other way to get the return
3466 address from the stack.
3467 @end defmac
3468
3469 @defmac STATIC_CHAIN_REGNUM
3470 @defmacx STATIC_CHAIN_INCOMING_REGNUM
3471 Register numbers used for passing a function's static chain pointer.  If
3472 register windows are used, the register number as seen by the called
3473 function is @code{STATIC_CHAIN_INCOMING_REGNUM}, while the register
3474 number as seen by the calling function is @code{STATIC_CHAIN_REGNUM}.  If
3475 these registers are the same, @code{STATIC_CHAIN_INCOMING_REGNUM} need
3476 not be defined.
3477
3478 The static chain register need not be a fixed register.
3479
3480 If the static chain is passed in memory, these macros should not be
3481 defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
3482 @end defmac
3483
3484 @deftypefn {Target Hook} rtx TARGET_STATIC_CHAIN (const_tree @var{fndecl_or_type}, bool @var{incoming_p})
3485 This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for
3486 targets that may use different static chain locations for different
3487 nested functions.  This may be required if the target has function
3488 attributes that affect the calling conventions of the function and
3489 those calling conventions use different static chain locations.
3490
3491 The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.
3492
3493 If the static chain is passed in memory, this hook should be used to
3494 provide rtx giving @code{mem} expressions that denote where they are stored.
3495 Often the @code{mem} expression as seen by the caller will be at an offset
3496 from the stack pointer and the @code{mem} expression as seen by the callee
3497 will be at an offset from the frame pointer.
3498 @findex stack_pointer_rtx
3499 @findex frame_pointer_rtx
3500 @findex arg_pointer_rtx
3501 The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and
3502 @code{arg_pointer_rtx} will have been initialized and should be used
3503 to refer to those items.
3504 @end deftypefn
3505
3506 @defmac DWARF_FRAME_REGISTERS
3507 This macro specifies the maximum number of hard registers that can be
3508 saved in a call frame.  This is used to size data structures used in
3509 DWARF2 exception handling.
3510
3511 Prior to GCC 3.0, this macro was needed in order to establish a stable
3512 exception handling ABI in the face of adding new hard registers for ISA
3513 extensions.  In GCC 3.0 and later, the EH ABI is insulated from changes
3514 in the number of hard registers.  Nevertheless, this macro can still be
3515 used to reduce the runtime memory requirements of the exception handling
3516 routines, which can be substantial if the ISA contains a lot of
3517 registers that are not call-saved.
3518
3519 If this macro is not defined, it defaults to
3520 @code{FIRST_PSEUDO_REGISTER}.
3521 @end defmac
3522
3523 @defmac PRE_GCC3_DWARF_FRAME_REGISTERS
3524
3525 This macro is similar to @code{DWARF_FRAME_REGISTERS}, but is provided
3526 for backward compatibility in pre GCC 3.0 compiled code.
3527
3528 If this macro is not defined, it defaults to
3529 @code{DWARF_FRAME_REGISTERS}.
3530 @end defmac
3531
3532 @defmac DWARF_REG_TO_UNWIND_COLUMN (@var{regno})
3533
3534 Define this macro if the target's representation for dwarf registers
3535 is different than the internal representation for unwind column.
3536 Given a dwarf register, this macro should return the internal unwind
3537 column number to use instead.
3538
3539 See the PowerPC's SPE target for an example.
3540 @end defmac
3541
3542 @defmac DWARF_FRAME_REGNUM (@var{regno})
3543
3544 Define this macro if the target's representation for dwarf registers
3545 used in .eh_frame or .debug_frame is different from that used in other
3546 debug info sections.  Given a GCC hard register number, this macro
3547 should return the .eh_frame register number.  The default is
3548 @code{DBX_REGISTER_NUMBER (@var{regno})}.
3549
3550 @end defmac
3551
3552 @defmac DWARF2_FRAME_REG_OUT (@var{regno}, @var{for_eh})
3553
3554 Define this macro to map register numbers held in the call frame info
3555 that GCC has collected using @code{DWARF_FRAME_REGNUM} to those that
3556 should be output in .debug_frame (@code{@var{for_eh}} is zero) and
3557 .eh_frame (@code{@var{for_eh}} is nonzero).  The default is to
3558 return @code{@var{regno}}.
3559
3560 @end defmac
3561
3562 @defmac REG_VALUE_IN_UNWIND_CONTEXT
3563
3564 Define this macro if the target stores register values as
3565 @code{_Unwind_Word} type in unwind context.  It should be defined if
3566 target register size is larger than the size of @code{void *}.  The
3567 default is to store register values as @code{void *} type.
3568
3569 @end defmac
3570
3571 @defmac ASSUME_EXTENDED_UNWIND_CONTEXT
3572
3573 Define this macro to be 1 if the target always uses extended unwind
3574 context with version, args_size and by_value fields.  If it is undefined,
3575 it will be defined to 1 when @code{REG_VALUE_IN_UNWIND_CONTEXT} is
3576 defined and 0 otherwise.
3577
3578 @end defmac
3579
3580 @node Elimination
3581 @subsection Eliminating Frame Pointer and Arg Pointer
3582
3583 @c prevent bad page break with this line
3584 This is about eliminating the frame pointer and arg pointer.
3585
3586 @deftypefn {Target Hook} bool TARGET_FRAME_POINTER_REQUIRED (void)
3587 This target hook should return @code{true} if a function must have and use
3588 a frame pointer.  This target hook is called in the reload pass.  If its return
3589 value is @code{true} the function will have a frame pointer.
3590
3591 This target hook can in principle examine the current function and decide
3592 according to the facts, but on most machines the constant @code{false} or the
3593 constant @code{true} suffices.  Use @code{false} when the machine allows code
3594 to be generated with no frame pointer, and doing so saves some time or space.
3595 Use @code{true} when there is no possible advantage to avoiding a frame
3596 pointer.
3597
3598 In certain cases, the compiler does not know how to produce valid code
3599 without a frame pointer.  The compiler recognizes those cases and
3600 automatically gives the function a frame pointer regardless of what
3601 @code{TARGET_FRAME_POINTER_REQUIRED} returns.  You don't need to worry about
3602 them.
3603
3604 In a function that does not require a frame pointer, the frame pointer
3605 register can be allocated for ordinary usage, unless you mark it as a
3606 fixed register.  See @code{FIXED_REGISTERS} for more information.
3607
3608 Default return value is @code{false}.
3609 @end deftypefn
3610
3611 @findex get_frame_size
3612 @defmac INITIAL_FRAME_POINTER_OFFSET (@var{depth-var})
3613 A C statement to store in the variable @var{depth-var} the difference
3614 between the frame pointer and the stack pointer values immediately after
3615 the function prologue.  The value would be computed from information
3616 such as the result of @code{get_frame_size ()} and the tables of
3617 registers @code{regs_ever_live} and @code{call_used_regs}.
3618
3619 If @code{ELIMINABLE_REGS} is defined, this macro will be not be used and
3620 need not be defined.  Otherwise, it must be defined even if
3621 @code{TARGET_FRAME_POINTER_REQUIRED} always returns true; in that
3622 case, you may set @var{depth-var} to anything.
3623 @end defmac
3624
3625 @defmac ELIMINABLE_REGS
3626 If defined, this macro specifies a table of register pairs used to
3627 eliminate unneeded registers that point into the stack frame.  If it is not
3628 defined, the only elimination attempted by the compiler is to replace
3629 references to the frame pointer with references to the stack pointer.
3630
3631 The definition of this macro is a list of structure initializations, each
3632 of which specifies an original and replacement register.
3633
3634 On some machines, the position of the argument pointer is not known until
3635 the compilation is completed.  In such a case, a separate hard register
3636 must be used for the argument pointer.  This register can be eliminated by
3637 replacing it with either the frame pointer or the argument pointer,
3638 depending on whether or not the frame pointer has been eliminated.
3639
3640 In this case, you might specify:
3641 @smallexample
3642 #define ELIMINABLE_REGS  \
3643 @{@{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM@}, \
3644  @{ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM@}, \
3645  @{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM@}@}
3646 @end smallexample
3647
3648 Note that the elimination of the argument pointer with the stack pointer is
3649 specified first since that is the preferred elimination.
3650 @end defmac
3651
3652 @deftypefn {Target Hook} bool TARGET_CAN_ELIMINATE (const int @var{from_reg}, const int @var{to_reg})
3653 This target hook should returns @code{true} if the compiler is allowed to
3654 try to replace register number @var{from_reg} with register number
3655 @var{to_reg}.  This target hook need only be defined if @code{ELIMINABLE_REGS}
3656 is defined, and will usually be @code{true}, since most of the cases
3657 preventing register elimination are things that the compiler already
3658 knows about.
3659
3660 Default return value is @code{true}.
3661 @end deftypefn
3662
3663 @defmac INITIAL_ELIMINATION_OFFSET (@var{from-reg}, @var{to-reg}, @var{offset-var})
3664 This macro is similar to @code{INITIAL_FRAME_POINTER_OFFSET}.  It
3665 specifies the initial difference between the specified pair of
3666 registers.  This macro must be defined if @code{ELIMINABLE_REGS} is
3667 defined.
3668 @end defmac
3669
3670 @node Stack Arguments
3671 @subsection Passing Function Arguments on the Stack
3672 @cindex arguments on stack
3673 @cindex stack arguments
3674
3675 The macros in this section control how arguments are passed
3676 on the stack.  See the following section for other macros that
3677 control passing certain arguments in registers.
3678
3679 @deftypefn {Target Hook} bool TARGET_PROMOTE_PROTOTYPES (const_tree @var{fntype})
3680 This target hook returns @code{true} if an argument declared in a
3681 prototype as an integral type smaller than @code{int} should actually be
3682 passed as an @code{int}.  In addition to avoiding errors in certain
3683 cases of mismatch, it also makes for better code on certain machines.
3684 The default is to not promote prototypes.
3685 @end deftypefn
3686
3687 @defmac PUSH_ARGS
3688 A C expression.  If nonzero, push insns will be used to pass
3689 outgoing arguments.
3690 If the target machine does not have a push instruction, set it to zero.
3691 That directs GCC to use an alternate strategy: to
3692 allocate the entire argument block and then store the arguments into
3693 it.  When @code{PUSH_ARGS} is nonzero, @code{PUSH_ROUNDING} must be defined too.
3694 @end defmac
3695
3696 @defmac PUSH_ARGS_REVERSED
3697 A C expression.  If nonzero, function arguments will be evaluated from
3698 last to first, rather than from first to last.  If this macro is not
3699 defined, it defaults to @code{PUSH_ARGS} on targets where the stack
3700 and args grow in opposite directions, and 0 otherwise.
3701 @end defmac
3702
3703 @defmac PUSH_ROUNDING (@var{npushed})
3704 A C expression that is the number of bytes actually pushed onto the
3705 stack when an instruction attempts to push @var{npushed} bytes.
3706
3707 On some machines, the definition
3708
3709 @smallexample
3710 #define PUSH_ROUNDING(BYTES) (BYTES)
3711 @end smallexample
3712
3713 @noindent
3714 will suffice.  But on other machines, instructions that appear
3715 to push one byte actually push two bytes in an attempt to maintain
3716 alignment.  Then the definition should be
3717
3718 @smallexample
3719 #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
3720 @end smallexample
3721
3722 If the value of this macro has a type, it should be an unsigned type.
3723 @end defmac
3724
3725 @findex outgoing_args_size
3726 @findex crtl->outgoing_args_size
3727 @defmac ACCUMULATE_OUTGOING_ARGS
3728 A C expression.  If nonzero, the maximum amount of space required for outgoing arguments
3729 will be computed and placed into
3730 @code{crtl->outgoing_args_size}.  No space will be pushed
3731 onto the stack for each call; instead, the function prologue should
3732 increase the stack frame size by this amount.
3733
3734 Setting both @code{PUSH_ARGS} and @code{ACCUMULATE_OUTGOING_ARGS}
3735 is not proper.
3736 @end defmac
3737
3738 @defmac REG_PARM_STACK_SPACE (@var{fndecl})
3739 Define this macro if functions should assume that stack space has been
3740 allocated for arguments even when their values are passed in
3741 registers.
3742
3743 The value of this macro is the size, in bytes, of the area reserved for
3744 arguments passed in registers for the function represented by @var{fndecl},
3745 which can be zero if GCC is calling a library function.
3746 The argument @var{fndecl} can be the FUNCTION_DECL, or the type itself
3747 of the function.
3748
3749 This space can be allocated by the caller, or be a part of the
3750 machine-dependent stack frame: @code{OUTGOING_REG_PARM_STACK_SPACE} says
3751 which.
3752 @end defmac
3753 @c above is overfull.  not sure what to do.  --mew 5feb93  did
3754 @c something, not sure if it looks good.  --mew 10feb93
3755
3756 @defmac INCOMING_REG_PARM_STACK_SPACE (@var{fndecl})
3757 Like @code{REG_PARM_STACK_SPACE}, but for incoming register arguments.
3758 Define this macro if space guaranteed when compiling a function body
3759 is different to space required when making a call, a situation that
3760 can arise with K&R style function definitions.
3761 @end defmac
3762
3763 @defmac OUTGOING_REG_PARM_STACK_SPACE (@var{fntype})
3764 Define this to a nonzero value if it is the responsibility of the
3765 caller to allocate the area reserved for arguments passed in registers
3766 when calling a function of @var{fntype}.  @var{fntype} may be NULL
3767 if the function called is a library function.
3768
3769 If @code{ACCUMULATE_OUTGOING_ARGS} is defined, this macro controls
3770 whether the space for these arguments counts in the value of
3771 @code{crtl->outgoing_args_size}.
3772 @end defmac
3773
3774 @defmac STACK_PARMS_IN_REG_PARM_AREA
3775 Define this macro if @code{REG_PARM_STACK_SPACE} is defined, but the
3776 stack parameters don't skip the area specified by it.
3777 @c i changed this, makes more sens and it should have taken care of the
3778 @c overfull.. not as specific, tho.  --mew 5feb93
3779
3780 Normally, when a parameter is not passed in registers, it is placed on the
3781 stack beyond the @code{REG_PARM_STACK_SPACE} area.  Defining this macro
3782 suppresses this behavior and causes the parameter to be passed on the
3783 stack in its natural location.
3784 @end defmac
3785
3786 @deftypefn {Target Hook} int TARGET_RETURN_POPS_ARGS (tree @var{fundecl}, tree @var{funtype}, int @var{size})
3787 This target hook returns the number of bytes of its own arguments that
3788 a function pops on returning, or 0 if the function pops no arguments
3789 and the caller must therefore pop them all after the function returns.
3790
3791 @var{fundecl} is a C variable whose value is a tree node that describes
3792 the function in question.  Normally it is a node of type
3793 @code{FUNCTION_DECL} that describes the declaration of the function.
3794 From this you can obtain the @code{DECL_ATTRIBUTES} of the function.
3795
3796 @var{funtype} is a C variable whose value is a tree node that
3797 describes the function in question.  Normally it is a node of type
3798 @code{FUNCTION_TYPE} that describes the data type of the function.
3799 From this it is possible to obtain the data types of the value and
3800 arguments (if known).
3801
3802 When a call to a library function is being considered, @var{fundecl}
3803 will contain an identifier node for the library function.  Thus, if
3804 you need to distinguish among various library functions, you can do so
3805 by their names.  Note that ``library function'' in this context means
3806 a function used to perform arithmetic, whose name is known specially
3807 in the compiler and was not mentioned in the C code being compiled.
3808
3809 @var{size} is the number of bytes of arguments passed on the
3810 stack.  If a variable number of bytes is passed, it is zero, and
3811 argument popping will always be the responsibility of the calling function.
3812
3813 On the VAX, all functions always pop their arguments, so the definition
3814 of this macro is @var{size}.  On the 68000, using the standard
3815 calling convention, no functions pop their arguments, so the value of
3816 the macro is always 0 in this case.  But an alternative calling
3817 convention is available in which functions that take a fixed number of
3818 arguments pop them but other functions (such as @code{printf}) pop
3819 nothing (the caller pops all).  When this convention is in use,
3820 @var{funtype} is examined to determine whether a function takes a fixed
3821 number of arguments.
3822 @end deftypefn
3823
3824 @defmac CALL_POPS_ARGS (@var{cum})
3825 A C expression that should indicate the number of bytes a call sequence
3826 pops off the stack.  It is added to the value of @code{RETURN_POPS_ARGS}
3827 when compiling a function call.
3828
3829 @var{cum} is the variable in which all arguments to the called function
3830 have been accumulated.
3831
3832 On certain architectures, such as the SH5, a call trampoline is used
3833 that pops certain registers off the stack, depending on the arguments
3834 that have been passed to the function.  Since this is a property of the
3835 call site, not of the called function, @code{RETURN_POPS_ARGS} is not
3836 appropriate.
3837 @end defmac
3838
3839 @node Register Arguments
3840 @subsection Passing Arguments in Registers
3841 @cindex arguments in registers
3842 @cindex registers arguments
3843
3844 This section describes the macros which let you control how various
3845 types of arguments are passed in registers or how they are arranged in
3846 the stack.
3847
3848 @deftypefn {Target Hook} rtx TARGET_FUNCTION_ARG (cumulative_args_t @var{ca}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
3849 Return an RTX indicating whether a function argument is passed in a
3850 register and if so, which register.
3851
3852 The arguments are @var{ca}, which summarizes all the previous
3853 arguments; @var{mode}, the machine mode of the argument; @var{type},
3854 the data type of the argument as a tree node or 0 if that is not known
3855 (which happens for C support library functions); and @var{named},
3856 which is @code{true} for an ordinary argument and @code{false} for
3857 nameless arguments that correspond to @samp{@dots{}} in the called
3858 function's prototype.  @var{type} can be an incomplete type if a
3859 syntax error has previously occurred.
3860
3861 The return value is usually either a @code{reg} RTX for the hard
3862 register in which to pass the argument, or zero to pass the argument
3863 on the stack.
3864
3865 The return value can be a @code{const_int} which means argument is
3866 passed in a target specific slot with specified number.  Target hooks
3867 should be used to store or load argument in such case.  See
3868 @code{TARGET_STORE_BOUNDS_FOR_ARG} and @code{TARGET_LOAD_BOUNDS_FOR_ARG}
3869 for more information.
3870
3871 The value of the expression can also be a @code{parallel} RTX@.  This is
3872 used when an argument is passed in multiple locations.  The mode of the
3873 @code{parallel} should be the mode of the entire argument.  The
3874 @code{parallel} holds any number of @code{expr_list} pairs; each one
3875 describes where part of the argument is passed.  In each
3876 @code{expr_list} the first operand must be a @code{reg} RTX for the hard
3877 register in which to pass this part of the argument, and the mode of the
3878 register RTX indicates how large this part of the argument is.  The
3879 second operand of the @code{expr_list} is a @code{const_int} which gives
3880 the offset in bytes into the entire argument of where this part starts.
3881 As a special exception the first @code{expr_list} in the @code{parallel}
3882 RTX may have a first operand of zero.  This indicates that the entire
3883 argument is also stored on the stack.
3884
3885 The last time this hook is called, it is called with @code{MODE ==
3886 VOIDmode}, and its result is passed to the @code{call} or @code{call_value}
3887 pattern as operands 2 and 3 respectively.
3888
3889 @cindex @file{stdarg.h} and register arguments
3890 The usual way to make the ISO library @file{stdarg.h} work on a
3891 machine where some arguments are usually passed in registers, is to
3892 cause nameless arguments to be passed on the stack instead.  This is
3893 done by making @code{TARGET_FUNCTION_ARG} return 0 whenever
3894 @var{named} is @code{false}.
3895
3896 @cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG}
3897 @cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG}
3898 You may use the hook @code{targetm.calls.must_pass_in_stack}
3899 in the definition of this macro to determine if this argument is of a
3900 type that must be passed in the stack.  If @code{REG_PARM_STACK_SPACE}
3901 is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an
3902 argument, the compiler will abort.  If @code{REG_PARM_STACK_SPACE} is
3903 defined, the argument will be computed in the stack and then loaded into
3904 a register.
3905 @end deftypefn
3906
3907 @deftypefn {Target Hook} bool TARGET_MUST_PASS_IN_STACK (machine_mode @var{mode}, const_tree @var{type})
3908 This target hook should return @code{true} if we should not pass @var{type}
3909 solely in registers.  The file @file{expr.h} defines a
3910 definition that is usually appropriate, refer to @file{expr.h} for additional
3911 documentation.
3912 @end deftypefn
3913
3914 @deftypefn {Target Hook} rtx TARGET_FUNCTION_INCOMING_ARG (cumulative_args_t @var{ca}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
3915 Define this hook if the target machine has ``register windows'', so
3916 that the register in which a function sees an arguments is not
3917 necessarily the same as the one in which the caller passed the
3918 argument.
3919
3920 For such machines, @code{TARGET_FUNCTION_ARG} computes the register in
3921 which the caller passes the value, and
3922 @code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar
3923 fashion to tell the function being called where the arguments will
3924 arrive.
3925
3926 If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,
3927 @code{TARGET_FUNCTION_ARG} serves both purposes.
3928 @end deftypefn
3929
3930 @deftypefn {Target Hook} bool TARGET_USE_PSEUDO_PIC_REG (void)
3931 This hook should return 1 in case pseudo register should be created
3932 for pic_offset_table_rtx during function expand.
3933 @end deftypefn
3934
3935 @deftypefn {Target Hook} void TARGET_INIT_PIC_REG (void)
3936 Perform a target dependent initialization of pic_offset_table_rtx.
3937 This hook is called at the start of register allocation.
3938 @end deftypefn
3939
3940 @deftypefn {Target Hook} int TARGET_ARG_PARTIAL_BYTES (cumulative_args_t @var{cum}, machine_mode @var{mode}, tree @var{type}, bool @var{named})
3941 This target hook returns the number of bytes at the beginning of an
3942 argument that must be put in registers.  The value must be zero for
3943 arguments that are passed entirely in registers or that are entirely
3944 pushed on the stack.
3945
3946 On some machines, certain arguments must be passed partially in
3947 registers and partially in memory.  On these machines, typically the
3948 first few words of arguments are passed in registers, and the rest
3949 on the stack.  If a multi-word argument (a @code{double} or a
3950 structure) crosses that boundary, its first few words must be passed
3951 in registers and the rest must be pushed.  This macro tells the
3952 compiler when this occurs, and how many bytes should go in registers.
3953
3954 @code{TARGET_FUNCTION_ARG} for these arguments should return the first
3955 register to be used by the caller for this argument; likewise
3956 @code{TARGET_FUNCTION_INCOMING_ARG}, for the called function.
3957 @end deftypefn
3958
3959 @deftypefn {Target Hook} bool TARGET_PASS_BY_REFERENCE (cumulative_args_t @var{cum}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
3960 This target hook should return @code{true} if an argument at the
3961 position indicated by @var{cum} should be passed by reference.  This
3962 predicate is queried after target independent reasons for being
3963 passed by reference, such as @code{TREE_ADDRESSABLE (type)}.
3964
3965 If the hook returns true, a copy of that argument is made in memory and a
3966 pointer to the argument is passed instead of the argument itself.
3967 The pointer is passed in whatever way is appropriate for passing a pointer
3968 to that type.
3969 @end deftypefn
3970
3971 @deftypefn {Target Hook} bool TARGET_CALLEE_COPIES (cumulative_args_t @var{cum}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
3972 The function argument described by the parameters to this hook is
3973 known to be passed by reference.  The hook should return true if the
3974 function argument should be copied by the callee instead of copied
3975 by the caller.
3976
3977 For any argument for which the hook returns true, if it can be
3978 determined that the argument is not modified, then a copy need
3979 not be generated.
3980
3981 The default version of this hook always returns false.
3982 @end deftypefn
3983
3984 @defmac CUMULATIVE_ARGS
3985 A C type for declaring a variable that is used as the first argument
3986 of @code{TARGET_FUNCTION_ARG} and other related values.  For some
3987 target machines, the type @code{int} suffices and can hold the number
3988 of bytes of argument so far.
3989
3990 There is no need to record in @code{CUMULATIVE_ARGS} anything about the
3991 arguments that have been passed on the stack.  The compiler has other
3992 variables to keep track of that.  For target machines on which all
3993 arguments are passed on the stack, there is no need to store anything in
3994 @code{CUMULATIVE_ARGS}; however, the data structure must exist and
3995 should not be empty, so use @code{int}.
3996 @end defmac
3997
3998 @defmac OVERRIDE_ABI_FORMAT (@var{fndecl})
3999 If defined, this macro is called before generating any code for a
4000 function, but after the @var{cfun} descriptor for the function has been
4001 created.  The back end may use this macro to update @var{cfun} to
4002 reflect an ABI other than that which would normally be used by default.
4003 If the compiler is generating code for a compiler-generated function,
4004 @var{fndecl} may be @code{NULL}.
4005 @end defmac
4006
4007 @defmac INIT_CUMULATIVE_ARGS (@var{cum}, @var{fntype}, @var{libname}, @var{fndecl}, @var{n_named_args})
4008 A C statement (sans semicolon) for initializing the variable
4009 @var{cum} for the state at the beginning of the argument list.  The
4010 variable has type @code{CUMULATIVE_ARGS}.  The value of @var{fntype}
4011 is the tree node for the data type of the function which will receive
4012 the args, or 0 if the args are to a compiler support library function.
4013 For direct calls that are not libcalls, @var{fndecl} contain the
4014 declaration node of the function.  @var{fndecl} is also set when
4015 @code{INIT_CUMULATIVE_ARGS} is used to find arguments for the function
4016 being compiled.  @var{n_named_args} is set to the number of named
4017 arguments, including a structure return address if it is passed as a
4018 parameter, when making a call.  When processing incoming arguments,
4019 @var{n_named_args} is set to @minus{}1.
4020
4021 When processing a call to a compiler support library function,
4022 @var{libname} identifies which one.  It is a @code{symbol_ref} rtx which
4023 contains the name of the function, as a string.  @var{libname} is 0 when
4024 an ordinary C function call is being processed.  Thus, each time this
4025 macro is called, either @var{libname} or @var{fntype} is nonzero, but
4026 never both of them at once.
4027 @end defmac
4028
4029 @defmac INIT_CUMULATIVE_LIBCALL_ARGS (@var{cum}, @var{mode}, @var{libname})
4030 Like @code{INIT_CUMULATIVE_ARGS} but only used for outgoing libcalls,
4031 it gets a @code{MODE} argument instead of @var{fntype}, that would be
4032 @code{NULL}.  @var{indirect} would always be zero, too.  If this macro
4033 is not defined, @code{INIT_CUMULATIVE_ARGS (cum, NULL_RTX, libname,
4034 0)} is used instead.
4035 @end defmac
4036
4037 @defmac INIT_CUMULATIVE_INCOMING_ARGS (@var{cum}, @var{fntype}, @var{libname})
4038 Like @code{INIT_CUMULATIVE_ARGS} but overrides it for the purposes of
4039 finding the arguments for the function being compiled.  If this macro is
4040 undefined, @code{INIT_CUMULATIVE_ARGS} is used instead.
4041
4042 The value passed for @var{libname} is always 0, since library routines
4043 with special calling conventions are never compiled with GCC@.  The
4044 argument @var{libname} exists for symmetry with
4045 @code{INIT_CUMULATIVE_ARGS}.
4046 @c could use "this macro" in place of @code{INIT_CUMULATIVE_ARGS}, maybe.
4047 @c --mew 5feb93   i switched the order of the sentences.  --mew 10feb93
4048 @end defmac
4049
4050 @deftypefn {Target Hook} void TARGET_FUNCTION_ARG_ADVANCE (cumulative_args_t @var{ca}, machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
4051 This hook updates the summarizer variable pointed to by @var{ca} to
4052 advance past an argument in the argument list.  The values @var{mode},
4053 @var{type} and @var{named} describe that argument.  Once this is done,
4054 the variable @var{cum} is suitable for analyzing the @emph{following}
4055 argument with @code{TARGET_FUNCTION_ARG}, etc.
4056
4057 This hook need not do anything if the argument in question was passed
4058 on the stack.  The compiler knows how to track the amount of stack space
4059 used for arguments without any special help.
4060 @end deftypefn
4061
4062 @defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type})
4063 If defined, a C expression that is the number of bytes to add to the
4064 offset of the argument passed in memory.  This is needed for the SPU,
4065 which passes @code{char} and @code{short} arguments in the preferred
4066 slot that is in the middle of the quad word instead of starting at the
4067 top.
4068 @end defmac
4069
4070 @defmac FUNCTION_ARG_PADDING (@var{mode}, @var{type})
4071 If defined, a C expression which determines whether, and in which direction,
4072 to pad out an argument with extra space.  The value should be of type
4073 @code{enum direction}: either @code{upward} to pad above the argument,
4074 @code{downward} to pad below, or @code{none} to inhibit padding.
4075
4076 The @emph{amount} of padding is not controlled by this macro, but by the
4077 target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}.  It is
4078 always just enough to reach the next multiple of that boundary. 
4079
4080 This macro has a default definition which is right for most systems.
4081 For little-endian machines, the default is to pad upward.  For
4082 big-endian machines, the default is to pad downward for an argument of
4083 constant size shorter than an @code{int}, and upward otherwise.
4084 @end defmac
4085
4086 @defmac PAD_VARARGS_DOWN
4087 If defined, a C expression which determines whether the default
4088 implementation of va_arg will attempt to pad down before reading the
4089 next argument, if that argument is smaller than its aligned space as
4090 controlled by @code{PARM_BOUNDARY}.  If this macro is not defined, all such
4091 arguments are padded down if @code{BYTES_BIG_ENDIAN} is true.
4092 @end defmac
4093
4094 @defmac BLOCK_REG_PADDING (@var{mode}, @var{type}, @var{first})
4095 Specify padding for the last element of a block move between registers and
4096 memory.  @var{first} is nonzero if this is the only element.  Defining this
4097 macro allows better control of register function parameters on big-endian
4098 machines, without using @code{PARALLEL} rtl.  In particular,
4099 @code{MUST_PASS_IN_STACK} need not test padding and mode of types in
4100 registers, as there is no longer a "wrong" part of a register;  For example,
4101 a three byte aggregate may be passed in the high part of a register if so
4102 required.
4103 @end defmac
4104
4105 @deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_BOUNDARY (machine_mode @var{mode}, const_tree @var{type})
4106 This hook returns the alignment boundary, in bits, of an argument
4107 with the specified mode and type.  The default hook returns
4108 @code{PARM_BOUNDARY} for all arguments.
4109 @end deftypefn
4110
4111 @deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_ROUND_BOUNDARY (machine_mode @var{mode}, const_tree @var{type})
4112 Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},
4113 which is the default value for this hook.  You can define this hook to
4114 return a different value if an argument size must be rounded to a larger
4115 value.
4116 @end deftypefn
4117
4118 @defmac FUNCTION_ARG_REGNO_P (@var{regno})
4119 A C expression that is nonzero if @var{regno} is the number of a hard
4120 register in which function arguments are sometimes passed.  This does
4121 @emph{not} include implicit arguments such as the static chain and
4122 the structure-value address.  On many machines, no registers can be
4123 used for this purpose since all function arguments are pushed on the
4124 stack.
4125 @end defmac
4126
4127 @deftypefn {Target Hook} bool TARGET_SPLIT_COMPLEX_ARG (const_tree @var{type})
4128 This hook should return true if parameter of type @var{type} are passed
4129 as two scalar parameters.  By default, GCC will attempt to pack complex
4130 arguments into the target's word size.  Some ABIs require complex arguments
4131 to be split and treated as their individual components.  For example, on
4132 AIX64, complex floats should be passed in a pair of floating point
4133 registers, even though a complex float would fit in one 64-bit floating
4134 point register.
4135
4136 The default value of this hook is @code{NULL}, which is treated as always
4137 false.
4138 @end deftypefn
4139
4140 @deftypefn {Target Hook} tree TARGET_BUILD_BUILTIN_VA_LIST (void)
4141 This hook returns a type node for @code{va_list} for the target.
4142 The default version of the hook returns @code{void*}.
4143 @end deftypefn
4144
4145 @deftypefn {Target Hook} int TARGET_ENUM_VA_LIST_P (int @var{idx}, const char **@var{pname}, tree *@var{ptree})
4146 This target hook is used in function @code{c_common_nodes_and_builtins}
4147 to iterate through the target specific builtin types for va_list. The
4148 variable @var{idx} is used as iterator. @var{pname} has to be a pointer
4149 to a @code{const char *} and @var{ptree} a pointer to a @code{tree} typed</