OSDN Git Service

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