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