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