OSDN Git Service

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