OSDN Git Service

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