OSDN Git Service

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