OSDN Git Service

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