1 | This is Info file gcc.info, produced by Makeinfo version 1.67 from the |
---|
2 | input file gcc.texi. |
---|
3 | |
---|
4 | This file documents the use and the internals of the GNU compiler. |
---|
5 | |
---|
6 | Published by the Free Software Foundation 59 Temple Place - Suite 330 |
---|
7 | Boston, MA 02111-1307 USA |
---|
8 | |
---|
9 | Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998 |
---|
10 | Free Software Foundation, Inc. |
---|
11 | |
---|
12 | Permission is granted to make and distribute verbatim copies of this |
---|
13 | manual provided the copyright notice and this permission notice are |
---|
14 | preserved on all copies. |
---|
15 | |
---|
16 | Permission is granted to copy and distribute modified versions of |
---|
17 | this manual under the conditions for verbatim copying, provided also |
---|
18 | that the sections entitled "GNU General Public License," "Funding for |
---|
19 | Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are |
---|
20 | included exactly as in the original, and provided that the entire |
---|
21 | resulting derived work is distributed under the terms of a permission |
---|
22 | notice identical to this one. |
---|
23 | |
---|
24 | Permission is granted to copy and distribute translations of this |
---|
25 | manual into another language, under the above conditions for modified |
---|
26 | versions, except that the sections entitled "GNU General Public |
---|
27 | License," "Funding for Free Software," and "Protect Your Freedom--Fight |
---|
28 | `Look And Feel'", and this permission notice, may be included in |
---|
29 | translations approved by the Free Software Foundation instead of in the |
---|
30 | original English. |
---|
31 | |
---|
32 | |
---|
33 | File: gcc.info, Node: Function Units, Prev: Delay Slots, Up: Insn Attributes |
---|
34 | |
---|
35 | Specifying Function Units |
---|
36 | ------------------------- |
---|
37 | |
---|
38 | On most RISC machines, there are instructions whose results are not |
---|
39 | available for a specific number of cycles. Common cases are |
---|
40 | instructions that load data from memory. On many machines, a pipeline |
---|
41 | stall will result if the data is referenced too soon after the load |
---|
42 | instruction. |
---|
43 | |
---|
44 | In addition, many newer microprocessors have multiple function |
---|
45 | units, usually one for integer and one for floating point, and often |
---|
46 | will incur pipeline stalls when a result that is needed is not yet |
---|
47 | ready. |
---|
48 | |
---|
49 | The descriptions in this section allow the specification of how much |
---|
50 | time must elapse between the execution of an instruction and the time |
---|
51 | when its result is used. It also allows specification of when the |
---|
52 | execution of an instruction will delay execution of similar instructions |
---|
53 | due to function unit conflicts. |
---|
54 | |
---|
55 | For the purposes of the specifications in this section, a machine is |
---|
56 | divided into "function units", each of which execute a specific class |
---|
57 | of instructions in first-in-first-out order. Function units that |
---|
58 | accept one instruction each cycle and allow a result to be used in the |
---|
59 | succeeding instruction (usually via forwarding) need not be specified. |
---|
60 | Classic RISC microprocessors will normally have a single function unit, |
---|
61 | which we can call `memory'. The newer "superscalar" processors will |
---|
62 | often have function units for floating point operations, usually at |
---|
63 | least a floating point adder and multiplier. |
---|
64 | |
---|
65 | Each usage of a function units by a class of insns is specified with |
---|
66 | a `define_function_unit' expression, which looks like this: |
---|
67 | |
---|
68 | (define_function_unit NAME MULTIPLICITY SIMULTANEITY |
---|
69 | TEST READY-DELAY ISSUE-DELAY |
---|
70 | [CONFLICT-LIST]) |
---|
71 | |
---|
72 | NAME is a string giving the name of the function unit. |
---|
73 | |
---|
74 | MULTIPLICITY is an integer specifying the number of identical units |
---|
75 | in the processor. If more than one unit is specified, they will be |
---|
76 | scheduled independently. Only truly independent units should be |
---|
77 | counted; a pipelined unit should be specified as a single unit. (The |
---|
78 | only common example of a machine that has multiple function units for a |
---|
79 | single instruction class that are truly independent and not pipelined |
---|
80 | are the two multiply and two increment units of the CDC 6600.) |
---|
81 | |
---|
82 | SIMULTANEITY specifies the maximum number of insns that can be |
---|
83 | executing in each instance of the function unit simultaneously or zero |
---|
84 | if the unit is pipelined and has no limit. |
---|
85 | |
---|
86 | All `define_function_unit' definitions referring to function unit |
---|
87 | NAME must have the same name and values for MULTIPLICITY and |
---|
88 | SIMULTANEITY. |
---|
89 | |
---|
90 | TEST is an attribute test that selects the insns we are describing |
---|
91 | in this definition. Note that an insn may use more than one function |
---|
92 | unit and a function unit may be specified in more than one |
---|
93 | `define_function_unit'. |
---|
94 | |
---|
95 | READY-DELAY is an integer that specifies the number of cycles after |
---|
96 | which the result of the instruction can be used without introducing any |
---|
97 | stalls. |
---|
98 | |
---|
99 | ISSUE-DELAY is an integer that specifies the number of cycles after |
---|
100 | the instruction matching the TEST expression begins using this unit |
---|
101 | until a subsequent instruction can begin. A cost of N indicates an N-1 |
---|
102 | cycle delay. A subsequent instruction may also be delayed if an |
---|
103 | earlier instruction has a longer READY-DELAY value. This blocking |
---|
104 | effect is computed using the SIMULTANEITY, READY-DELAY, ISSUE-DELAY, |
---|
105 | and CONFLICT-LIST terms. For a normal non-pipelined function unit, |
---|
106 | SIMULTANEITY is one, the unit is taken to block for the READY-DELAY |
---|
107 | cycles of the executing insn, and smaller values of ISSUE-DELAY are |
---|
108 | ignored. |
---|
109 | |
---|
110 | CONFLICT-LIST is an optional list giving detailed conflict costs for |
---|
111 | this unit. If specified, it is a list of condition test expressions to |
---|
112 | be applied to insns chosen to execute in NAME following the particular |
---|
113 | insn matching TEST that is already executing in NAME. For each insn in |
---|
114 | the list, ISSUE-DELAY specifies the conflict cost; for insns not in the |
---|
115 | list, the cost is zero. If not specified, CONFLICT-LIST defaults to |
---|
116 | all instructions that use the function unit. |
---|
117 | |
---|
118 | Typical uses of this vector are where a floating point function unit |
---|
119 | can pipeline either single- or double-precision operations, but not |
---|
120 | both, or where a memory unit can pipeline loads, but not stores, etc. |
---|
121 | |
---|
122 | As an example, consider a classic RISC machine where the result of a |
---|
123 | load instruction is not available for two cycles (a single "delay" |
---|
124 | instruction is required) and where only one load instruction can be |
---|
125 | executed simultaneously. This would be specified as: |
---|
126 | |
---|
127 | (define_function_unit "memory" 1 1 (eq_attr "type" "load") 2 0) |
---|
128 | |
---|
129 | For the case of a floating point function unit that can pipeline |
---|
130 | either single or double precision, but not both, the following could be |
---|
131 | specified: |
---|
132 | |
---|
133 | (define_function_unit |
---|
134 | "fp" 1 0 (eq_attr "type" "sp_fp") 4 4 [(eq_attr "type" "dp_fp")]) |
---|
135 | (define_function_unit |
---|
136 | "fp" 1 0 (eq_attr "type" "dp_fp") 4 4 [(eq_attr "type" "sp_fp")]) |
---|
137 | |
---|
138 | *Note:* The scheduler attempts to avoid function unit conflicts and |
---|
139 | uses all the specifications in the `define_function_unit' expression. |
---|
140 | It has recently come to our attention that these specifications may not |
---|
141 | allow modeling of some of the newer "superscalar" processors that have |
---|
142 | insns using multiple pipelined units. These insns will cause a |
---|
143 | potential conflict for the second unit used during their execution and |
---|
144 | there is no way of representing that conflict. We welcome any examples |
---|
145 | of how function unit conflicts work in such processors and suggestions |
---|
146 | for their representation. |
---|
147 | |
---|
148 | |
---|
149 | File: gcc.info, Node: Target Macros, Next: Config, Prev: Machine Desc, Up: Top |
---|
150 | |
---|
151 | Target Description Macros |
---|
152 | ************************* |
---|
153 | |
---|
154 | In addition to the file `MACHINE.md', a machine description includes |
---|
155 | a C header file conventionally given the name `MACHINE.h'. This header |
---|
156 | file defines numerous macros that convey the information about the |
---|
157 | target machine that does not fit into the scheme of the `.md' file. |
---|
158 | The file `tm.h' should be a link to `MACHINE.h'. The header file |
---|
159 | `config.h' includes `tm.h' and most compiler source files include |
---|
160 | `config.h'. |
---|
161 | |
---|
162 | * Menu: |
---|
163 | |
---|
164 | * Driver:: Controlling how the driver runs the compilation passes. |
---|
165 | * Run-time Target:: Defining `-m' options like `-m68000' and `-m68020'. |
---|
166 | * Storage Layout:: Defining sizes and alignments of data. |
---|
167 | * Type Layout:: Defining sizes and properties of basic user data types. |
---|
168 | * Registers:: Naming and describing the hardware registers. |
---|
169 | * Register Classes:: Defining the classes of hardware registers. |
---|
170 | * Stack and Calling:: Defining which way the stack grows and by how much. |
---|
171 | * Varargs:: Defining the varargs macros. |
---|
172 | * Trampolines:: Code set up at run time to enter a nested function. |
---|
173 | * Library Calls:: Controlling how library routines are implicitly called. |
---|
174 | * Addressing Modes:: Defining addressing modes valid for memory operands. |
---|
175 | * Condition Code:: Defining how insns update the condition code. |
---|
176 | * Costs:: Defining relative costs of different operations. |
---|
177 | * Sections:: Dividing storage into text, data, and other sections. |
---|
178 | * PIC:: Macros for position independent code. |
---|
179 | * Assembler Format:: Defining how to write insns and pseudo-ops to output. |
---|
180 | * Debugging Info:: Defining the format of debugging output. |
---|
181 | * Cross-compilation:: Handling floating point for cross-compilers. |
---|
182 | * Misc:: Everything else. |
---|
183 | |
---|
184 | |
---|
185 | File: gcc.info, Node: Driver, Next: Run-time Target, Up: Target Macros |
---|
186 | |
---|
187 | Controlling the Compilation Driver, `gcc' |
---|
188 | ========================================= |
---|
189 | |
---|
190 | You can control the compilation driver. |
---|
191 | |
---|
192 | `SWITCH_TAKES_ARG (CHAR)' |
---|
193 | A C expression which determines whether the option `-CHAR' takes |
---|
194 | arguments. The value should be the number of arguments that |
---|
195 | option takes-zero, for many options. |
---|
196 | |
---|
197 | By default, this macro is defined as `DEFAULT_SWITCH_TAKES_ARG', |
---|
198 | which handles the standard options properly. You need not define |
---|
199 | `SWITCH_TAKES_ARG' unless you wish to add additional options which |
---|
200 | take arguments. Any redefinition should call |
---|
201 | `DEFAULT_SWITCH_TAKES_ARG' and then check for additional options. |
---|
202 | |
---|
203 | `WORD_SWITCH_TAKES_ARG (NAME)' |
---|
204 | A C expression which determines whether the option `-NAME' takes |
---|
205 | arguments. The value should be the number of arguments that |
---|
206 | option takes-zero, for many options. This macro rather than |
---|
207 | `SWITCH_TAKES_ARG' is used for multi-character option names. |
---|
208 | |
---|
209 | By default, this macro is defined as |
---|
210 | `DEFAULT_WORD_SWITCH_TAKES_ARG', which handles the standard options |
---|
211 | properly. You need not define `WORD_SWITCH_TAKES_ARG' unless you |
---|
212 | wish to add additional options which take arguments. Any |
---|
213 | redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and then |
---|
214 | check for additional options. |
---|
215 | |
---|
216 | `SWITCHES_NEED_SPACES' |
---|
217 | A string-valued C expression which enumerates the options for which |
---|
218 | the linker needs a space between the option and its argument. |
---|
219 | |
---|
220 | If this macro is not defined, the default value is `""'. |
---|
221 | |
---|
222 | `CPP_SPEC' |
---|
223 | A C string constant that tells the GNU CC driver program options to |
---|
224 | pass to CPP. It can also specify how to translate options you |
---|
225 | give to GNU CC into options for GNU CC to pass to the CPP. |
---|
226 | |
---|
227 | Do not define this macro if it does not need to do anything. |
---|
228 | |
---|
229 | `NO_BUILTIN_SIZE_TYPE' |
---|
230 | If this macro is defined, the preprocessor will not define the |
---|
231 | builtin macro `__SIZE_TYPE__'. The macro `__SIZE_TYPE__' must |
---|
232 | then be defined by `CPP_SPEC' instead. |
---|
233 | |
---|
234 | This should be defined if `SIZE_TYPE' depends on target dependent |
---|
235 | flags which are not accessible to the preprocessor. Otherwise, it |
---|
236 | should not be defined. |
---|
237 | |
---|
238 | `NO_BUILTIN_PTRDIFF_TYPE' |
---|
239 | If this macro is defined, the preprocessor will not define the |
---|
240 | builtin macro `__PTRDIFF_TYPE__'. The macro `__PTRDIFF_TYPE__' |
---|
241 | must then be defined by `CPP_SPEC' instead. |
---|
242 | |
---|
243 | This should be defined if `PTRDIFF_TYPE' depends on target |
---|
244 | dependent flags which are not accessible to the preprocessor. |
---|
245 | Otherwise, it should not be defined. |
---|
246 | |
---|
247 | `SIGNED_CHAR_SPEC' |
---|
248 | A C string constant that tells the GNU CC driver program options to |
---|
249 | pass to CPP. By default, this macro is defined to pass the option |
---|
250 | `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as |
---|
251 | `unsigned char' by `cc1'. |
---|
252 | |
---|
253 | Do not define this macro unless you need to override the default |
---|
254 | definition. |
---|
255 | |
---|
256 | `CC1_SPEC' |
---|
257 | A C string constant that tells the GNU CC driver program options to |
---|
258 | pass to `cc1'. It can also specify how to translate options you |
---|
259 | give to GNU CC into options for GNU CC to pass to the `cc1'. |
---|
260 | |
---|
261 | Do not define this macro if it does not need to do anything. |
---|
262 | |
---|
263 | `CC1PLUS_SPEC' |
---|
264 | A C string constant that tells the GNU CC driver program options to |
---|
265 | pass to `cc1plus'. It can also specify how to translate options |
---|
266 | you give to GNU CC into options for GNU CC to pass to the |
---|
267 | `cc1plus'. |
---|
268 | |
---|
269 | Do not define this macro if it does not need to do anything. |
---|
270 | |
---|
271 | `ASM_SPEC' |
---|
272 | A C string constant that tells the GNU CC driver program options to |
---|
273 | pass to the assembler. It can also specify how to translate |
---|
274 | options you give to GNU CC into options for GNU CC to pass to the |
---|
275 | assembler. See the file `sun3.h' for an example of this. |
---|
276 | |
---|
277 | Do not define this macro if it does not need to do anything. |
---|
278 | |
---|
279 | `ASM_FINAL_SPEC' |
---|
280 | A C string constant that tells the GNU CC driver program how to |
---|
281 | run any programs which cleanup after the normal assembler. |
---|
282 | Normally, this is not needed. See the file `mips.h' for an |
---|
283 | example of this. |
---|
284 | |
---|
285 | Do not define this macro if it does not need to do anything. |
---|
286 | |
---|
287 | `LINK_SPEC' |
---|
288 | A C string constant that tells the GNU CC driver program options to |
---|
289 | pass to the linker. It can also specify how to translate options |
---|
290 | you give to GNU CC into options for GNU CC to pass to the linker. |
---|
291 | |
---|
292 | Do not define this macro if it does not need to do anything. |
---|
293 | |
---|
294 | `LIB_SPEC' |
---|
295 | Another C string constant used much like `LINK_SPEC'. The |
---|
296 | difference between the two is that `LIB_SPEC' is used at the end |
---|
297 | of the command given to the linker. |
---|
298 | |
---|
299 | If this macro is not defined, a default is provided that loads the |
---|
300 | standard C library from the usual place. See `gcc.c'. |
---|
301 | |
---|
302 | `LIBGCC_SPEC' |
---|
303 | Another C string constant that tells the GNU CC driver program how |
---|
304 | and when to place a reference to `libgcc.a' into the linker |
---|
305 | command line. This constant is placed both before and after the |
---|
306 | value of `LIB_SPEC'. |
---|
307 | |
---|
308 | If this macro is not defined, the GNU CC driver provides a default |
---|
309 | that passes the string `-lgcc' to the linker unless the `-shared' |
---|
310 | option is specified. |
---|
311 | |
---|
312 | `STARTFILE_SPEC' |
---|
313 | Another C string constant used much like `LINK_SPEC'. The |
---|
314 | difference between the two is that `STARTFILE_SPEC' is used at the |
---|
315 | very beginning of the command given to the linker. |
---|
316 | |
---|
317 | If this macro is not defined, a default is provided that loads the |
---|
318 | standard C startup file from the usual place. See `gcc.c'. |
---|
319 | |
---|
320 | `ENDFILE_SPEC' |
---|
321 | Another C string constant used much like `LINK_SPEC'. The |
---|
322 | difference between the two is that `ENDFILE_SPEC' is used at the |
---|
323 | very end of the command given to the linker. |
---|
324 | |
---|
325 | Do not define this macro if it does not need to do anything. |
---|
326 | |
---|
327 | `EXTRA_SPECS' |
---|
328 | Define this macro to provide additional specifications to put in |
---|
329 | the `specs' file that can be used in various specifications like |
---|
330 | `CC1_SPEC'. |
---|
331 | |
---|
332 | The definition should be an initializer for an array of structures, |
---|
333 | containing a string constant, that defines the specification name, |
---|
334 | and a string constant that provides the specification. |
---|
335 | |
---|
336 | Do not define this macro if it does not need to do anything. |
---|
337 | |
---|
338 | `EXTRA_SPECS' is useful when an architecture contains several |
---|
339 | related targets, which have various `..._SPECS' which are similar |
---|
340 | to each other, and the maintainer would like one central place to |
---|
341 | keep these definitions. |
---|
342 | |
---|
343 | For example, the PowerPC System V.4 targets use `EXTRA_SPECS' to |
---|
344 | define either `_CALL_SYSV' when the System V calling sequence is |
---|
345 | used or `_CALL_AIX' when the older AIX-based calling sequence is |
---|
346 | used. |
---|
347 | |
---|
348 | The `config/rs6000/rs6000.h' target file defines: |
---|
349 | |
---|
350 | #define EXTRA_SPECS \ |
---|
351 | { "cpp_sysv_default", CPP_SYSV_DEFAULT }, |
---|
352 | |
---|
353 | #define CPP_SYS_DEFAULT "" |
---|
354 | |
---|
355 | The `config/rs6000/sysv.h' target file defines: |
---|
356 | #undef CPP_SPEC |
---|
357 | #define CPP_SPEC \ |
---|
358 | "%{posix: -D_POSIX_SOURCE } \ |
---|
359 | %{mcall-sysv: -D_CALL_SYSV } %{mcall-aix: -D_CALL_AIX } \ |
---|
360 | %{!mcall-sysv: %{!mcall-aix: %(cpp_sysv_default) }} \ |
---|
361 | %{msoft-float: -D_SOFT_FLOAT} %{mcpu=403: -D_SOFT_FLOAT}" |
---|
362 | |
---|
363 | #undef CPP_SYSV_DEFAULT |
---|
364 | #define CPP_SYSV_DEFAULT "-D_CALL_SYSV" |
---|
365 | |
---|
366 | while the `config/rs6000/eabiaix.h' target file defines |
---|
367 | `CPP_SYSV_DEFAULT' as: |
---|
368 | |
---|
369 | #undef CPP_SYSV_DEFAULT |
---|
370 | #define CPP_SYSV_DEFAULT "-D_CALL_AIX" |
---|
371 | |
---|
372 | `LINK_LIBGCC_SPECIAL' |
---|
373 | Define this macro if the driver program should find the library |
---|
374 | `libgcc.a' itself and should not pass `-L' options to the linker. |
---|
375 | If you do not define this macro, the driver program will pass the |
---|
376 | argument `-lgcc' to tell the linker to do the search and will pass |
---|
377 | `-L' options to it. |
---|
378 | |
---|
379 | `LINK_LIBGCC_SPECIAL_1' |
---|
380 | Define this macro if the driver program should find the library |
---|
381 | `libgcc.a'. If you do not define this macro, the driver program |
---|
382 | will pass the argument `-lgcc' to tell the linker to do the search. |
---|
383 | This macro is similar to `LINK_LIBGCC_SPECIAL', except that it does |
---|
384 | not affect `-L' options. |
---|
385 | |
---|
386 | `MULTILIB_DEFAULTS' |
---|
387 | Define this macro as a C expression for the initializer of an |
---|
388 | array of string to tell the driver program which options are |
---|
389 | defaults for this target and thus do not need to be handled |
---|
390 | specially when using `MULTILIB_OPTIONS'. |
---|
391 | |
---|
392 | Do not define this macro if `MULTILIB_OPTIONS' is not defined in |
---|
393 | the target makefile fragment or if none of the options listed in |
---|
394 | `MULTILIB_OPTIONS' are set by default. *Note Target Fragment::. |
---|
395 | |
---|
396 | `RELATIVE_PREFIX_NOT_LINKDIR' |
---|
397 | Define this macro to tell `gcc' that it should only translate a |
---|
398 | `-B' prefix into a `-L' linker option if the prefix indicates an |
---|
399 | absolute file name. |
---|
400 | |
---|
401 | `STANDARD_EXEC_PREFIX' |
---|
402 | Define this macro as a C string constant if you wish to override |
---|
403 | the standard choice of `/usr/local/lib/gcc-lib/' as the default |
---|
404 | prefix to try when searching for the executable files of the |
---|
405 | compiler. |
---|
406 | |
---|
407 | `MD_EXEC_PREFIX' |
---|
408 | If defined, this macro is an additional prefix to try after |
---|
409 | `STANDARD_EXEC_PREFIX'. `MD_EXEC_PREFIX' is not searched when the |
---|
410 | `-b' option is used, or the compiler is built as a cross compiler. |
---|
411 | |
---|
412 | `STANDARD_STARTFILE_PREFIX' |
---|
413 | Define this macro as a C string constant if you wish to override |
---|
414 | the standard choice of `/usr/local/lib/' as the default prefix to |
---|
415 | try when searching for startup files such as `crt0.o'. |
---|
416 | |
---|
417 | `MD_STARTFILE_PREFIX' |
---|
418 | If defined, this macro supplies an additional prefix to try after |
---|
419 | the standard prefixes. `MD_EXEC_PREFIX' is not searched when the |
---|
420 | `-b' option is used, or when the compiler is built as a cross |
---|
421 | compiler. |
---|
422 | |
---|
423 | `MD_STARTFILE_PREFIX_1' |
---|
424 | If defined, this macro supplies yet another prefix to try after the |
---|
425 | standard prefixes. It is not searched when the `-b' option is |
---|
426 | used, or when the compiler is built as a cross compiler. |
---|
427 | |
---|
428 | `INIT_ENVIRONMENT' |
---|
429 | Define this macro as a C string constant if you wish to set |
---|
430 | environment variables for programs called by the driver, such as |
---|
431 | the assembler and loader. The driver passes the value of this |
---|
432 | macro to `putenv' to initialize the necessary environment |
---|
433 | variables. |
---|
434 | |
---|
435 | `LOCAL_INCLUDE_DIR' |
---|
436 | Define this macro as a C string constant if you wish to override |
---|
437 | the standard choice of `/usr/local/include' as the default prefix |
---|
438 | to try when searching for local header files. `LOCAL_INCLUDE_DIR' |
---|
439 | comes before `SYSTEM_INCLUDE_DIR' in the search order. |
---|
440 | |
---|
441 | Cross compilers do not use this macro and do not search either |
---|
442 | `/usr/local/include' or its replacement. |
---|
443 | |
---|
444 | `SYSTEM_INCLUDE_DIR' |
---|
445 | Define this macro as a C string constant if you wish to specify a |
---|
446 | system-specific directory to search for header files before the |
---|
447 | standard directory. `SYSTEM_INCLUDE_DIR' comes before |
---|
448 | `STANDARD_INCLUDE_DIR' in the search order. |
---|
449 | |
---|
450 | Cross compilers do not use this macro and do not search the |
---|
451 | directory specified. |
---|
452 | |
---|
453 | `STANDARD_INCLUDE_DIR' |
---|
454 | Define this macro as a C string constant if you wish to override |
---|
455 | the standard choice of `/usr/include' as the default prefix to try |
---|
456 | when searching for header files. |
---|
457 | |
---|
458 | Cross compilers do not use this macro and do not search either |
---|
459 | `/usr/include' or its replacement. |
---|
460 | |
---|
461 | `STANDARD_INCLUDE_COMPONENT' |
---|
462 | The "component" corresponding to `STANDARD_INCLUDE_DIR'. See |
---|
463 | `INCLUDE_DEFAULTS', below, for the description of components. If |
---|
464 | you do not define this macro, no component is used. |
---|
465 | |
---|
466 | `INCLUDE_DEFAULTS' |
---|
467 | Define this macro if you wish to override the entire default |
---|
468 | search path for include files. For a native compiler, the default |
---|
469 | search path usually consists of `GCC_INCLUDE_DIR', |
---|
470 | `LOCAL_INCLUDE_DIR', `SYSTEM_INCLUDE_DIR', |
---|
471 | `GPLUSPLUS_INCLUDE_DIR', and `STANDARD_INCLUDE_DIR'. In addition, |
---|
472 | `GPLUSPLUS_INCLUDE_DIR' and `GCC_INCLUDE_DIR' are defined |
---|
473 | automatically by `Makefile', and specify private search areas for |
---|
474 | GCC. The directory `GPLUSPLUS_INCLUDE_DIR' is used only for C++ |
---|
475 | programs. |
---|
476 | |
---|
477 | The definition should be an initializer for an array of structures. |
---|
478 | Each array element should have four elements: the directory name (a |
---|
479 | string constant), the component name, and flag for C++-only |
---|
480 | directories, and a flag showing that the includes in the directory |
---|
481 | don't need to be wrapped in `extern `C'' when compiling C++. Mark |
---|
482 | the end of the array with a null element. |
---|
483 | |
---|
484 | The component name denotes what GNU package the include file is |
---|
485 | part of, if any, in all upper-case letters. For example, it might |
---|
486 | be `GCC' or `BINUTILS'. If the package is part of the a |
---|
487 | vendor-supplied operating system, code the component name as `0'. |
---|
488 | |
---|
489 | For example, here is the definition used for VAX/VMS: |
---|
490 | |
---|
491 | #define INCLUDE_DEFAULTS \ |
---|
492 | { \ |
---|
493 | { "GNU_GXX_INCLUDE:", "G++", 1, 1}, \ |
---|
494 | { "GNU_CC_INCLUDE:", "GCC", 0, 0}, \ |
---|
495 | { "SYS$SYSROOT:[SYSLIB.]", 0, 0, 0}, \ |
---|
496 | { ".", 0, 0, 0}, \ |
---|
497 | { 0, 0, 0, 0} \ |
---|
498 | } |
---|
499 | |
---|
500 | Here is the order of prefixes tried for exec files: |
---|
501 | |
---|
502 | 1. Any prefixes specified by the user with `-B'. |
---|
503 | |
---|
504 | 2. The environment variable `GCC_EXEC_PREFIX', if any. |
---|
505 | |
---|
506 | 3. The directories specified by the environment variable |
---|
507 | `COMPILER_PATH'. |
---|
508 | |
---|
509 | 4. The macro `STANDARD_EXEC_PREFIX'. |
---|
510 | |
---|
511 | 5. `/usr/lib/gcc/'. |
---|
512 | |
---|
513 | 6. The macro `MD_EXEC_PREFIX', if any. |
---|
514 | |
---|
515 | Here is the order of prefixes tried for startfiles: |
---|
516 | |
---|
517 | 1. Any prefixes specified by the user with `-B'. |
---|
518 | |
---|
519 | 2. The environment variable `GCC_EXEC_PREFIX', if any. |
---|
520 | |
---|
521 | 3. The directories specified by the environment variable |
---|
522 | `LIBRARY_PATH' (native only, cross compilers do not use this). |
---|
523 | |
---|
524 | 4. The macro `STANDARD_EXEC_PREFIX'. |
---|
525 | |
---|
526 | 5. `/usr/lib/gcc/'. |
---|
527 | |
---|
528 | 6. The macro `MD_EXEC_PREFIX', if any. |
---|
529 | |
---|
530 | 7. The macro `MD_STARTFILE_PREFIX', if any. |
---|
531 | |
---|
532 | 8. The macro `STANDARD_STARTFILE_PREFIX'. |
---|
533 | |
---|
534 | 9. `/lib/'. |
---|
535 | |
---|
536 | 10. `/usr/lib/'. |
---|
537 | |
---|
538 | |
---|
539 | File: gcc.info, Node: Run-time Target, Next: Storage Layout, Prev: Driver, Up: Target Macros |
---|
540 | |
---|
541 | Run-time Target Specification |
---|
542 | ============================= |
---|
543 | |
---|
544 | Here are run-time target specifications. |
---|
545 | |
---|
546 | `CPP_PREDEFINES' |
---|
547 | Define this to be a string constant containing `-D' options to |
---|
548 | define the predefined macros that identify this machine and system. |
---|
549 | These macros will be predefined unless the `-ansi' option is |
---|
550 | specified. |
---|
551 | |
---|
552 | In addition, a parallel set of macros are predefined, whose names |
---|
553 | are made by appending `__' at the beginning and at the end. These |
---|
554 | `__' macros are permitted by the ANSI standard, so they are |
---|
555 | predefined regardless of whether `-ansi' is specified. |
---|
556 | |
---|
557 | For example, on the Sun, one can use the following value: |
---|
558 | |
---|
559 | "-Dmc68000 -Dsun -Dunix" |
---|
560 | |
---|
561 | The result is to define the macros `__mc68000__', `__sun__' and |
---|
562 | `__unix__' unconditionally, and the macros `mc68000', `sun' and |
---|
563 | `unix' provided `-ansi' is not specified. |
---|
564 | |
---|
565 | `extern int target_flags;' |
---|
566 | This declaration should be present. |
---|
567 | |
---|
568 | `TARGET_...' |
---|
569 | This series of macros is to allow compiler command arguments to |
---|
570 | enable or disable the use of optional features of the target |
---|
571 | machine. For example, one machine description serves both the |
---|
572 | 68000 and the 68020; a command argument tells the compiler whether |
---|
573 | it should use 68020-only instructions or not. This command |
---|
574 | argument works by means of a macro `TARGET_68020' that tests a bit |
---|
575 | in `target_flags'. |
---|
576 | |
---|
577 | Define a macro `TARGET_FEATURENAME' for each such option. Its |
---|
578 | definition should test a bit in `target_flags'; for example: |
---|
579 | |
---|
580 | #define TARGET_68020 (target_flags & 1) |
---|
581 | |
---|
582 | One place where these macros are used is in the |
---|
583 | condition-expressions of instruction patterns. Note how |
---|
584 | `TARGET_68020' appears frequently in the 68000 machine description |
---|
585 | file, `m68k.md'. Another place they are used is in the |
---|
586 | definitions of the other macros in the `MACHINE.h' file. |
---|
587 | |
---|
588 | `TARGET_SWITCHES' |
---|
589 | This macro defines names of command options to set and clear bits |
---|
590 | in `target_flags'. Its definition is an initializer with a |
---|
591 | subgrouping for each command option. |
---|
592 | |
---|
593 | Each subgrouping contains a string constant, that defines the |
---|
594 | option name, and a number, which contains the bits to set in |
---|
595 | `target_flags'. A negative number says to clear bits instead; the |
---|
596 | negative of the number is which bits to clear. The actual option |
---|
597 | name is made by appending `-m' to the specified name. |
---|
598 | |
---|
599 | One of the subgroupings should have a null string. The number in |
---|
600 | this grouping is the default value for `target_flags'. Any target |
---|
601 | options act starting with that value. |
---|
602 | |
---|
603 | Here is an example which defines `-m68000' and `-m68020' with |
---|
604 | opposite meanings, and picks the latter as the default: |
---|
605 | |
---|
606 | #define TARGET_SWITCHES \ |
---|
607 | { { "68020", 1}, \ |
---|
608 | { "68000", -1}, \ |
---|
609 | { "", 1}} |
---|
610 | |
---|
611 | `TARGET_OPTIONS' |
---|
612 | This macro is similar to `TARGET_SWITCHES' but defines names of |
---|
613 | command options that have values. Its definition is an |
---|
614 | initializer with a subgrouping for each command option. |
---|
615 | |
---|
616 | Each subgrouping contains a string constant, that defines the |
---|
617 | fixed part of the option name, and the address of a variable. The |
---|
618 | variable, type `char *', is set to the variable part of the given |
---|
619 | option if the fixed part matches. The actual option name is made |
---|
620 | by appending `-m' to the specified name. |
---|
621 | |
---|
622 | Here is an example which defines `-mshort-data-NUMBER'. If the |
---|
623 | given option is `-mshort-data-512', the variable `m88k_short_data' |
---|
624 | will be set to the string `"512"'. |
---|
625 | |
---|
626 | extern char *m88k_short_data; |
---|
627 | #define TARGET_OPTIONS \ |
---|
628 | { { "short-data-", &m88k_short_data } } |
---|
629 | |
---|
630 | `TARGET_VERSION' |
---|
631 | This macro is a C statement to print on `stderr' a string |
---|
632 | describing the particular machine description choice. Every |
---|
633 | machine description should define `TARGET_VERSION'. For example: |
---|
634 | |
---|
635 | #ifdef MOTOROLA |
---|
636 | #define TARGET_VERSION \ |
---|
637 | fprintf (stderr, " (68k, Motorola syntax)"); |
---|
638 | #else |
---|
639 | #define TARGET_VERSION \ |
---|
640 | fprintf (stderr, " (68k, MIT syntax)"); |
---|
641 | #endif |
---|
642 | |
---|
643 | `OVERRIDE_OPTIONS' |
---|
644 | Sometimes certain combinations of command options do not make |
---|
645 | sense on a particular target machine. You can define a macro |
---|
646 | `OVERRIDE_OPTIONS' to take account of this. This macro, if |
---|
647 | defined, is executed once just after all the command options have |
---|
648 | been parsed. |
---|
649 | |
---|
650 | Don't use this macro to turn on various extra optimizations for |
---|
651 | `-O'. That is what `OPTIMIZATION_OPTIONS' is for. |
---|
652 | |
---|
653 | `OPTIMIZATION_OPTIONS (LEVEL)' |
---|
654 | Some machines may desire to change what optimizations are |
---|
655 | performed for various optimization levels. This macro, if |
---|
656 | defined, is executed once just after the optimization level is |
---|
657 | determined and before the remainder of the command options have |
---|
658 | been parsed. Values set in this macro are used as the default |
---|
659 | values for the other command line options. |
---|
660 | |
---|
661 | LEVEL is the optimization level specified; 2 if `-O2' is |
---|
662 | specified, 1 if `-O' is specified, and 0 if neither is specified. |
---|
663 | |
---|
664 | You should not use this macro to change options that are not |
---|
665 | machine-specific. These should uniformly selected by the same |
---|
666 | optimization level on all supported machines. Use this macro to |
---|
667 | enable machine-specific optimizations. |
---|
668 | |
---|
669 | *Do not examine `write_symbols' in this macro!* The debugging |
---|
670 | options are not supposed to alter the generated code. |
---|
671 | |
---|
672 | `CAN_DEBUG_WITHOUT_FP' |
---|
673 | Define this macro if debugging can be performed even without a |
---|
674 | frame pointer. If this macro is defined, GNU CC will turn on the |
---|
675 | `-fomit-frame-pointer' option whenever `-O' is specified. |
---|
676 | |
---|
677 | |
---|
678 | File: gcc.info, Node: Storage Layout, Next: Type Layout, Prev: Run-time Target, Up: Target Macros |
---|
679 | |
---|
680 | Storage Layout |
---|
681 | ============== |
---|
682 | |
---|
683 | Note that the definitions of the macros in this table which are |
---|
684 | sizes or alignments measured in bits do not need to be constant. They |
---|
685 | can be C expressions that refer to static variables, such as the |
---|
686 | `target_flags'. *Note Run-time Target::. |
---|
687 | |
---|
688 | `BITS_BIG_ENDIAN' |
---|
689 | Define this macro to have the value 1 if the most significant bit |
---|
690 | in a byte has the lowest number; otherwise define it to have the |
---|
691 | value zero. This means that bit-field instructions count from the |
---|
692 | most significant bit. If the machine has no bit-field |
---|
693 | instructions, then this must still be defined, but it doesn't |
---|
694 | matter which value it is defined to. This macro need not be a |
---|
695 | constant. |
---|
696 | |
---|
697 | This macro does not affect the way structure fields are packed into |
---|
698 | bytes or words; that is controlled by `BYTES_BIG_ENDIAN'. |
---|
699 | |
---|
700 | `BYTES_BIG_ENDIAN' |
---|
701 | Define this macro to have the value 1 if the most significant byte |
---|
702 | in a word has the lowest number. This macro need not be a |
---|
703 | constant. |
---|
704 | |
---|
705 | `WORDS_BIG_ENDIAN' |
---|
706 | Define this macro to have the value 1 if, in a multiword object, |
---|
707 | the most significant word has the lowest number. This applies to |
---|
708 | both memory locations and registers; GNU CC fundamentally assumes |
---|
709 | that the order of words in memory is the same as the order in |
---|
710 | registers. This macro need not be a constant. |
---|
711 | |
---|
712 | `LIBGCC2_WORDS_BIG_ENDIAN' |
---|
713 | Define this macro if WORDS_BIG_ENDIAN is not constant. This must |
---|
714 | be a constant value with the same meaning as WORDS_BIG_ENDIAN, |
---|
715 | which will be used only when compiling libgcc2.c. Typically the |
---|
716 | value will be set based on preprocessor defines. |
---|
717 | |
---|
718 | `FLOAT_WORDS_BIG_ENDIAN' |
---|
719 | Define this macro to have the value 1 if `DFmode', `XFmode' or |
---|
720 | `TFmode' floating point numbers are stored in memory with the word |
---|
721 | containing the sign bit at the lowest address; otherwise define it |
---|
722 | to have the value 0. This macro need not be a constant. |
---|
723 | |
---|
724 | You need not define this macro if the ordering is the same as for |
---|
725 | multi-word integers. |
---|
726 | |
---|
727 | `BITS_PER_UNIT' |
---|
728 | Define this macro to be the number of bits in an addressable |
---|
729 | storage unit (byte); normally 8. |
---|
730 | |
---|
731 | `BITS_PER_WORD' |
---|
732 | Number of bits in a word; normally 32. |
---|
733 | |
---|
734 | `MAX_BITS_PER_WORD' |
---|
735 | Maximum number of bits in a word. If this is undefined, the |
---|
736 | default is `BITS_PER_WORD'. Otherwise, it is the constant value |
---|
737 | that is the largest value that `BITS_PER_WORD' can have at |
---|
738 | run-time. |
---|
739 | |
---|
740 | `UNITS_PER_WORD' |
---|
741 | Number of storage units in a word; normally 4. |
---|
742 | |
---|
743 | `MIN_UNITS_PER_WORD' |
---|
744 | Minimum number of units in a word. If this is undefined, the |
---|
745 | default is `UNITS_PER_WORD'. Otherwise, it is the constant value |
---|
746 | that is the smallest value that `UNITS_PER_WORD' can have at |
---|
747 | run-time. |
---|
748 | |
---|
749 | `POINTER_SIZE' |
---|
750 | Width of a pointer, in bits. You must specify a value no wider |
---|
751 | than the width of `Pmode'. If it is not equal to the width of |
---|
752 | `Pmode', you must define `POINTERS_EXTEND_UNSIGNED'. |
---|
753 | |
---|
754 | `POINTERS_EXTEND_UNSIGNED' |
---|
755 | A C expression whose value is nonzero if pointers that need to be |
---|
756 | extended from being `POINTER_SIZE' bits wide to `Pmode' are |
---|
757 | sign-extended and zero if they are zero-extended. |
---|
758 | |
---|
759 | You need not define this macro if the `POINTER_SIZE' is equal to |
---|
760 | the width of `Pmode'. |
---|
761 | |
---|
762 | `PROMOTE_MODE (M, UNSIGNEDP, TYPE)' |
---|
763 | A macro to update M and UNSIGNEDP when an object whose type is |
---|
764 | TYPE and which has the specified mode and signedness is to be |
---|
765 | stored in a register. This macro is only called when TYPE is a |
---|
766 | scalar type. |
---|
767 | |
---|
768 | On most RISC machines, which only have operations that operate on |
---|
769 | a full register, define this macro to set M to `word_mode' if M is |
---|
770 | an integer mode narrower than `BITS_PER_WORD'. In most cases, |
---|
771 | only integer modes should be widened because wider-precision |
---|
772 | floating-point operations are usually more expensive than their |
---|
773 | narrower counterparts. |
---|
774 | |
---|
775 | For most machines, the macro definition does not change UNSIGNEDP. |
---|
776 | However, some machines, have instructions that preferentially |
---|
777 | handle either signed or unsigned quantities of certain modes. For |
---|
778 | example, on the DEC Alpha, 32-bit loads from memory and 32-bit add |
---|
779 | instructions sign-extend the result to 64 bits. On such machines, |
---|
780 | set UNSIGNEDP according to which kind of extension is more |
---|
781 | efficient. |
---|
782 | |
---|
783 | Do not define this macro if it would never modify M. |
---|
784 | |
---|
785 | `PROMOTE_FUNCTION_ARGS' |
---|
786 | Define this macro if the promotion described by `PROMOTE_MODE' |
---|
787 | should also be done for outgoing function arguments. |
---|
788 | |
---|
789 | `PROMOTE_FUNCTION_RETURN' |
---|
790 | Define this macro if the promotion described by `PROMOTE_MODE' |
---|
791 | should also be done for the return value of functions. |
---|
792 | |
---|
793 | If this macro is defined, `FUNCTION_VALUE' must perform the same |
---|
794 | promotions done by `PROMOTE_MODE'. |
---|
795 | |
---|
796 | `PROMOTE_FOR_CALL_ONLY' |
---|
797 | Define this macro if the promotion described by `PROMOTE_MODE' |
---|
798 | should *only* be performed for outgoing function arguments or |
---|
799 | function return values, as specified by `PROMOTE_FUNCTION_ARGS' |
---|
800 | and `PROMOTE_FUNCTION_RETURN', respectively. |
---|
801 | |
---|
802 | `PARM_BOUNDARY' |
---|
803 | Normal alignment required for function parameters on the stack, in |
---|
804 | bits. All stack parameters receive at least this much alignment |
---|
805 | regardless of data type. On most machines, this is the same as the |
---|
806 | size of an integer. |
---|
807 | |
---|
808 | `STACK_BOUNDARY' |
---|
809 | Define this macro if you wish to preserve a certain alignment for |
---|
810 | the stack pointer. The definition is a C expression for the |
---|
811 | desired alignment (measured in bits). |
---|
812 | |
---|
813 | If `PUSH_ROUNDING' is not defined, the stack will always be aligned |
---|
814 | to the specified boundary. If `PUSH_ROUNDING' is defined and |
---|
815 | specifies a less strict alignment than `STACK_BOUNDARY', the stack |
---|
816 | may be momentarily unaligned while pushing arguments. |
---|
817 | |
---|
818 | `FUNCTION_BOUNDARY' |
---|
819 | Alignment required for a function entry point, in bits. |
---|
820 | |
---|
821 | `BIGGEST_ALIGNMENT' |
---|
822 | Biggest alignment that any data type can require on this machine, |
---|
823 | in bits. |
---|
824 | |
---|
825 | `MINIMUM_ATOMIC_ALIGNMENT' |
---|
826 | If defined, the smallest alignment, in bits, that can be given to |
---|
827 | an object that can be referenced in one operation, without |
---|
828 | disturbing any nearby object. Normally, this is `BITS_PER_UNIT', |
---|
829 | but may be larger on machines that don't have byte or half-word |
---|
830 | store operations. |
---|
831 | |
---|
832 | `BIGGEST_FIELD_ALIGNMENT' |
---|
833 | Biggest alignment that any structure field can require on this |
---|
834 | machine, in bits. If defined, this overrides `BIGGEST_ALIGNMENT' |
---|
835 | for structure fields only. |
---|
836 | |
---|
837 | `ADJUST_FIELD_ALIGN (FIELD, COMPUTED)' |
---|
838 | An expression for the alignment of a structure field FIELD if the |
---|
839 | alignment computed in the usual way is COMPUTED. GNU CC uses this |
---|
840 | value instead of the value in `BIGGEST_ALIGNMENT' or |
---|
841 | `BIGGEST_FIELD_ALIGNMENT', if defined, for structure fields only. |
---|
842 | |
---|
843 | `MAX_OFILE_ALIGNMENT' |
---|
844 | Biggest alignment supported by the object file format of this |
---|
845 | machine. Use this macro to limit the alignment which can be |
---|
846 | specified using the `__attribute__ ((aligned (N)))' construct. If |
---|
847 | not defined, the default value is `BIGGEST_ALIGNMENT'. |
---|
848 | |
---|
849 | `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)' |
---|
850 | If defined, a C expression to compute the alignment for a static |
---|
851 | variable. TYPE is the data type, and BASIC-ALIGN is the alignment |
---|
852 | that the object would ordinarily have. The value of this macro is |
---|
853 | used instead of that alignment to align the object. |
---|
854 | |
---|
855 | If this macro is not defined, then BASIC-ALIGN is used. |
---|
856 | |
---|
857 | One use of this macro is to increase alignment of medium-size data |
---|
858 | to make it all fit in fewer cache lines. Another is to cause |
---|
859 | character arrays to be word-aligned so that `strcpy' calls that |
---|
860 | copy constants to character arrays can be done inline. |
---|
861 | |
---|
862 | `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)' |
---|
863 | If defined, a C expression to compute the alignment given to a |
---|
864 | constant that is being placed in memory. CONSTANT is the constant |
---|
865 | and BASIC-ALIGN is the alignment that the object would ordinarily |
---|
866 | have. The value of this macro is used instead of that alignment to |
---|
867 | align the object. |
---|
868 | |
---|
869 | If this macro is not defined, then BASIC-ALIGN is used. |
---|
870 | |
---|
871 | The typical use of this macro is to increase alignment for string |
---|
872 | constants to be word aligned so that `strcpy' calls that copy |
---|
873 | constants can be done inline. |
---|
874 | |
---|
875 | `EMPTY_FIELD_BOUNDARY' |
---|
876 | Alignment in bits to be given to a structure bit field that |
---|
877 | follows an empty field such as `int : 0;'. |
---|
878 | |
---|
879 | Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment |
---|
880 | that results from an empty field. |
---|
881 | |
---|
882 | `STRUCTURE_SIZE_BOUNDARY' |
---|
883 | Number of bits which any structure or union's size must be a |
---|
884 | multiple of. Each structure or union's size is rounded up to a |
---|
885 | multiple of this. |
---|
886 | |
---|
887 | If you do not define this macro, the default is the same as |
---|
888 | `BITS_PER_UNIT'. |
---|
889 | |
---|
890 | `STRICT_ALIGNMENT' |
---|
891 | Define this macro to be the value 1 if instructions will fail to |
---|
892 | work if given data not on the nominal alignment. If instructions |
---|
893 | will merely go slower in that case, define this macro as 0. |
---|
894 | |
---|
895 | `PCC_BITFIELD_TYPE_MATTERS' |
---|
896 | Define this if you wish to imitate the way many other C compilers |
---|
897 | handle alignment of bitfields and the structures that contain them. |
---|
898 | |
---|
899 | The behavior is that the type written for a bitfield (`int', |
---|
900 | `short', or other integer type) imposes an alignment for the |
---|
901 | entire structure, as if the structure really did contain an |
---|
902 | ordinary field of that type. In addition, the bitfield is placed |
---|
903 | within the structure so that it would fit within such a field, not |
---|
904 | crossing a boundary for it. |
---|
905 | |
---|
906 | Thus, on most machines, a bitfield whose type is written as `int' |
---|
907 | would not cross a four-byte boundary, and would force four-byte |
---|
908 | alignment for the whole structure. (The alignment used may not be |
---|
909 | four bytes; it is controlled by the other alignment parameters.) |
---|
910 | |
---|
911 | If the macro is defined, its definition should be a C expression; |
---|
912 | a nonzero value for the expression enables this behavior. |
---|
913 | |
---|
914 | Note that if this macro is not defined, or its value is zero, some |
---|
915 | bitfields may cross more than one alignment boundary. The |
---|
916 | compiler can support such references if there are `insv', `extv', |
---|
917 | and `extzv' insns that can directly reference memory. |
---|
918 | |
---|
919 | The other known way of making bitfields work is to define |
---|
920 | `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then |
---|
921 | every structure can be accessed with fullwords. |
---|
922 | |
---|
923 | Unless the machine has bitfield instructions or you define |
---|
924 | `STRUCTURE_SIZE_BOUNDARY' that way, you must define |
---|
925 | `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value. |
---|
926 | |
---|
927 | If your aim is to make GNU CC use the same conventions for laying |
---|
928 | out bitfields as are used by another compiler, here is how to |
---|
929 | investigate what the other compiler does. Compile and run this |
---|
930 | program: |
---|
931 | |
---|
932 | struct foo1 |
---|
933 | { |
---|
934 | char x; |
---|
935 | char :0; |
---|
936 | char y; |
---|
937 | }; |
---|
938 | |
---|
939 | struct foo2 |
---|
940 | { |
---|
941 | char x; |
---|
942 | int :0; |
---|
943 | char y; |
---|
944 | }; |
---|
945 | |
---|
946 | main () |
---|
947 | { |
---|
948 | printf ("Size of foo1 is %d\n", |
---|
949 | sizeof (struct foo1)); |
---|
950 | printf ("Size of foo2 is %d\n", |
---|
951 | sizeof (struct foo2)); |
---|
952 | exit (0); |
---|
953 | } |
---|
954 | |
---|
955 | If this prints 2 and 5, then the compiler's behavior is what you |
---|
956 | would get from `PCC_BITFIELD_TYPE_MATTERS'. |
---|
957 | |
---|
958 | `BITFIELD_NBYTES_LIMITED' |
---|
959 | Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to |
---|
960 | aligning a bitfield within the structure. |
---|
961 | |
---|
962 | `ROUND_TYPE_SIZE (STRUCT, SIZE, ALIGN)' |
---|
963 | Define this macro as an expression for the overall size of a |
---|
964 | structure (given by STRUCT as a tree node) when the size computed |
---|
965 | from the fields is SIZE and the alignment is ALIGN. |
---|
966 | |
---|
967 | The default is to round SIZE up to a multiple of ALIGN. |
---|
968 | |
---|
969 | `ROUND_TYPE_ALIGN (STRUCT, COMPUTED, SPECIFIED)' |
---|
970 | Define this macro as an expression for the alignment of a structure |
---|
971 | (given by STRUCT as a tree node) if the alignment computed in the |
---|
972 | usual way is COMPUTED and the alignment explicitly specified was |
---|
973 | SPECIFIED. |
---|
974 | |
---|
975 | The default is to use SPECIFIED if it is larger; otherwise, use |
---|
976 | the smaller of COMPUTED and `BIGGEST_ALIGNMENT' |
---|
977 | |
---|
978 | `MAX_FIXED_MODE_SIZE' |
---|
979 | An integer expression for the size in bits of the largest integer |
---|
980 | machine mode that should actually be used. All integer machine |
---|
981 | modes of this size or smaller can be used for structures and |
---|
982 | unions with the appropriate sizes. If this macro is undefined, |
---|
983 | `GET_MODE_BITSIZE (DImode)' is assumed. |
---|
984 | |
---|
985 | `CHECK_FLOAT_VALUE (MODE, VALUE, OVERFLOW)' |
---|
986 | A C statement to validate the value VALUE (of type `double') for |
---|
987 | mode MODE. This means that you check whether VALUE fits within |
---|
988 | the possible range of values for mode MODE on this target machine. |
---|
989 | The mode MODE is always a mode of class `MODE_FLOAT'. OVERFLOW |
---|
990 | is nonzero if the value is already known to be out of range. |
---|
991 | |
---|
992 | If VALUE is not valid or if OVERFLOW is nonzero, you should set |
---|
993 | OVERFLOW to 1 and then assign some valid value to VALUE. Allowing |
---|
994 | an invalid value to go through the compiler can produce incorrect |
---|
995 | assembler code which may even cause Unix assemblers to crash. |
---|
996 | |
---|
997 | This macro need not be defined if there is no work for it to do. |
---|
998 | |
---|
999 | `TARGET_FLOAT_FORMAT' |
---|
1000 | A code distinguishing the floating point format of the target |
---|
1001 | machine. There are three defined values: |
---|
1002 | |
---|
1003 | `IEEE_FLOAT_FORMAT' |
---|
1004 | This code indicates IEEE floating point. It is the default; |
---|
1005 | there is no need to define this macro when the format is IEEE. |
---|
1006 | |
---|
1007 | `VAX_FLOAT_FORMAT' |
---|
1008 | This code indicates the peculiar format used on the Vax. |
---|
1009 | |
---|
1010 | `UNKNOWN_FLOAT_FORMAT' |
---|
1011 | This code indicates any other format. |
---|
1012 | |
---|
1013 | The value of this macro is compared with `HOST_FLOAT_FORMAT' |
---|
1014 | (*note Config::.) to determine whether the target machine has the |
---|
1015 | same format as the host machine. If any other formats are |
---|
1016 | actually in use on supported machines, new codes should be defined |
---|
1017 | for them. |
---|
1018 | |
---|
1019 | The ordering of the component words of floating point values |
---|
1020 | stored in memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the |
---|
1021 | target machine and `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. |
---|
1022 | |
---|
1023 | `DEFAULT_VTABLE_THUNKS' |
---|
1024 | GNU CC supports two ways of implementing C++ vtables: traditional |
---|
1025 | or with so-called "thunks". The flag `-fvtable-thunk' chooses |
---|
1026 | between them. Define this macro to be a C expression for the |
---|
1027 | default value of that flag. If `DEFAULT_VTABLE_THUNKS' is 0, GNU |
---|
1028 | CC uses the traditional implementation by default. The "thunk" |
---|
1029 | implementation is more efficient (especially if you have provided |
---|
1030 | an implementation of `ASM_OUTPUT_MI_THUNK', see *Note Function |
---|
1031 | Entry::), but is not binary compatible with code compiled using |
---|
1032 | the traditional implementation. If you are writing a new ports, |
---|
1033 | define `DEFAULT_VTABLE_THUNKS' to 1. |
---|
1034 | |
---|
1035 | If you do not define this macro, the default for `-fvtable-thunk' |
---|
1036 | is 0. |
---|
1037 | |
---|
1038 | |
---|
1039 | File: gcc.info, Node: Type Layout, Next: Registers, Prev: Storage Layout, Up: Target Macros |
---|
1040 | |
---|
1041 | Layout of Source Language Data Types |
---|
1042 | ==================================== |
---|
1043 | |
---|
1044 | These macros define the sizes and other characteristics of the |
---|
1045 | standard basic data types used in programs being compiled. Unlike the |
---|
1046 | macros in the previous section, these apply to specific features of C |
---|
1047 | and related languages, rather than to fundamental aspects of storage |
---|
1048 | layout. |
---|
1049 | |
---|
1050 | `INT_TYPE_SIZE' |
---|
1051 | A C expression for the size in bits of the type `int' on the |
---|
1052 | target machine. If you don't define this, the default is one word. |
---|
1053 | |
---|
1054 | `MAX_INT_TYPE_SIZE' |
---|
1055 | Maximum number for the size in bits of the type `int' on the target |
---|
1056 | machine. If this is undefined, the default is `INT_TYPE_SIZE'. |
---|
1057 | Otherwise, it is the constant value that is the largest value that |
---|
1058 | `INT_TYPE_SIZE' can have at run-time. This is used in `cpp'. |
---|
1059 | |
---|
1060 | `SHORT_TYPE_SIZE' |
---|
1061 | A C expression for the size in bits of the type `short' on the |
---|
1062 | target machine. If you don't define this, the default is half a |
---|
1063 | word. (If this would be less than one storage unit, it is rounded |
---|
1064 | up to one unit.) |
---|
1065 | |
---|
1066 | `LONG_TYPE_SIZE' |
---|
1067 | A C expression for the size in bits of the type `long' on the |
---|
1068 | target machine. If you don't define this, the default is one word. |
---|
1069 | |
---|
1070 | `MAX_LONG_TYPE_SIZE' |
---|
1071 | Maximum number for the size in bits of the type `long' on the |
---|
1072 | target machine. If this is undefined, the default is |
---|
1073 | `LONG_TYPE_SIZE'. Otherwise, it is the constant value that is the |
---|
1074 | largest value that `LONG_TYPE_SIZE' can have at run-time. This is |
---|
1075 | used in `cpp'. |
---|
1076 | |
---|
1077 | `LONG_LONG_TYPE_SIZE' |
---|
1078 | A C expression for the size in bits of the type `long long' on the |
---|
1079 | target machine. If you don't define this, the default is two |
---|
1080 | words. If you want to support GNU Ada on your machine, the value |
---|
1081 | of macro must be at least 64. |
---|
1082 | |
---|
1083 | `CHAR_TYPE_SIZE' |
---|
1084 | A C expression for the size in bits of the type `char' on the |
---|
1085 | target machine. If you don't define this, the default is one |
---|
1086 | quarter of a word. (If this would be less than one storage unit, |
---|
1087 | it is rounded up to one unit.) |
---|
1088 | |
---|
1089 | `MAX_CHAR_TYPE_SIZE' |
---|
1090 | Maximum number for the size in bits of the type `char' on the |
---|
1091 | target machine. If this is undefined, the default is |
---|
1092 | `CHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the |
---|
1093 | largest value that `CHAR_TYPE_SIZE' can have at run-time. This is |
---|
1094 | used in `cpp'. |
---|
1095 | |
---|
1096 | `FLOAT_TYPE_SIZE' |
---|
1097 | A C expression for the size in bits of the type `float' on the |
---|
1098 | target machine. If you don't define this, the default is one word. |
---|
1099 | |
---|
1100 | `DOUBLE_TYPE_SIZE' |
---|
1101 | A C expression for the size in bits of the type `double' on the |
---|
1102 | target machine. If you don't define this, the default is two |
---|
1103 | words. |
---|
1104 | |
---|
1105 | `LONG_DOUBLE_TYPE_SIZE' |
---|
1106 | A C expression for the size in bits of the type `long double' on |
---|
1107 | the target machine. If you don't define this, the default is two |
---|
1108 | words. |
---|
1109 | |
---|
1110 | `WIDEST_HARDWARE_FP_SIZE' |
---|
1111 | A C expression for the size in bits of the widest floating-point |
---|
1112 | format supported by the hardware. If you define this macro, you |
---|
1113 | must specify a value less than or equal to the value of |
---|
1114 | `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the |
---|
1115 | value of `LONG_DOUBLE_TYPE_SIZE' is the default. |
---|
1116 | |
---|
1117 | `DEFAULT_SIGNED_CHAR' |
---|
1118 | An expression whose value is 1 or 0, according to whether the type |
---|
1119 | `char' should be signed or unsigned by default. The user can |
---|
1120 | always override this default with the options `-fsigned-char' and |
---|
1121 | `-funsigned-char'. |
---|
1122 | |
---|
1123 | `DEFAULT_SHORT_ENUMS' |
---|
1124 | A C expression to determine whether to give an `enum' type only as |
---|
1125 | many bytes as it takes to represent the range of possible values |
---|
1126 | of that type. A nonzero value means to do that; a zero value |
---|
1127 | means all `enum' types should be allocated like `int'. |
---|
1128 | |
---|
1129 | If you don't define the macro, the default is 0. |
---|
1130 | |
---|
1131 | `SIZE_TYPE' |
---|
1132 | A C expression for a string describing the name of the data type |
---|
1133 | to use for size values. The typedef name `size_t' is defined |
---|
1134 | using the contents of the string. |
---|
1135 | |
---|
1136 | The string can contain more than one keyword. If so, separate |
---|
1137 | them with spaces, and write first any length keyword, then |
---|
1138 | `unsigned' if appropriate, and finally `int'. The string must |
---|
1139 | exactly match one of the data type names defined in the function |
---|
1140 | `init_decl_processing' in the file `c-decl.c'. You may not omit |
---|
1141 | `int' or change the order--that would cause the compiler to crash |
---|
1142 | on startup. |
---|
1143 | |
---|
1144 | If you don't define this macro, the default is `"long unsigned |
---|
1145 | int"'. |
---|
1146 | |
---|
1147 | `PTRDIFF_TYPE' |
---|
1148 | A C expression for a string describing the name of the data type |
---|
1149 | to use for the result of subtracting two pointers. The typedef |
---|
1150 | name `ptrdiff_t' is defined using the contents of the string. See |
---|
1151 | `SIZE_TYPE' above for more information. |
---|
1152 | |
---|
1153 | If you don't define this macro, the default is `"long int"'. |
---|
1154 | |
---|
1155 | `WCHAR_TYPE' |
---|
1156 | A C expression for a string describing the name of the data type |
---|
1157 | to use for wide characters. The typedef name `wchar_t' is defined |
---|
1158 | using the contents of the string. See `SIZE_TYPE' above for more |
---|
1159 | information. |
---|
1160 | |
---|
1161 | If you don't define this macro, the default is `"int"'. |
---|
1162 | |
---|
1163 | `WCHAR_TYPE_SIZE' |
---|
1164 | A C expression for the size in bits of the data type for wide |
---|
1165 | characters. This is used in `cpp', which cannot make use of |
---|
1166 | `WCHAR_TYPE'. |
---|
1167 | |
---|
1168 | `MAX_WCHAR_TYPE_SIZE' |
---|
1169 | Maximum number for the size in bits of the data type for wide |
---|
1170 | characters. If this is undefined, the default is |
---|
1171 | `WCHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the |
---|
1172 | largest value that `WCHAR_TYPE_SIZE' can have at run-time. This is |
---|
1173 | used in `cpp'. |
---|
1174 | |
---|
1175 | `OBJC_INT_SELECTORS' |
---|
1176 | Define this macro if the type of Objective C selectors should be |
---|
1177 | `int'. |
---|
1178 | |
---|
1179 | If this macro is not defined, then selectors should have the type |
---|
1180 | `struct objc_selector *'. |
---|
1181 | |
---|
1182 | `OBJC_SELECTORS_WITHOUT_LABELS' |
---|
1183 | Define this macro if the compiler can group all the selectors |
---|
1184 | together into a vector and use just one label at the beginning of |
---|
1185 | the vector. Otherwise, the compiler must give each selector its |
---|
1186 | own assembler label. |
---|
1187 | |
---|
1188 | On certain machines, it is important to have a separate label for |
---|
1189 | each selector because this enables the linker to eliminate |
---|
1190 | duplicate selectors. |
---|
1191 | |
---|
1192 | `TARGET_BELL' |
---|
1193 | A C constant expression for the integer value for escape sequence |
---|
1194 | `\a'. |
---|
1195 | |
---|
1196 | `TARGET_BS' |
---|
1197 | `TARGET_TAB' |
---|
1198 | `TARGET_NEWLINE' |
---|
1199 | C constant expressions for the integer values for escape sequences |
---|
1200 | `\b', `\t' and `\n'. |
---|
1201 | |
---|
1202 | `TARGET_VT' |
---|
1203 | `TARGET_FF' |
---|
1204 | `TARGET_CR' |
---|
1205 | C constant expressions for the integer values for escape sequences |
---|
1206 | `\v', `\f' and `\r'. |
---|
1207 | |
---|