OSDN Git Service

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