OSDN Git Service

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