OSDN Git Service

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