OSDN Git Service

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