OSDN Git Service

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