]>
Commit | Line | Data |
---|---|---|
c6243b4c | 1 | /* Xstormy16 cpu description. |
4b58290f GK |
2 | Copyright (C) 1997, 1998, 1999, 2000, 2001 |
3 | Free Software Foundation, Inc. | |
4 | Contributed by Red Hat, Inc. | |
5 | ||
6 | This file is part of GNU CC. | |
7 | ||
8 | GNU CC is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2, or (at your option) | |
11 | any later version. | |
12 | ||
13 | GNU CC is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GNU CC; see the file COPYING. If not, write to | |
20 | the Free Software Foundation, 59 Temple Place - Suite 330, | |
21 | Boston, MA 02111-1307, USA. */ | |
22 | ||
4b58290f GK |
23 | \f |
24 | /* Driver configuration */ | |
25 | ||
26 | /* A C expression which determines whether the option `-CHAR' takes arguments. | |
27 | The value should be the number of arguments that option takes-zero, for many | |
28 | options. | |
29 | ||
30 | By default, this macro is defined to handle the standard options properly. | |
31 | You need not define it unless you wish to add additional options which take | |
32 | arguments. | |
33 | ||
34 | Defined in svr4.h. */ | |
35 | /* #define SWITCH_TAKES_ARG(CHAR) */ | |
36 | ||
37 | /* A C expression which determines whether the option `-NAME' takes arguments. | |
38 | The value should be the number of arguments that option takes-zero, for many | |
39 | options. This macro rather than `SWITCH_TAKES_ARG' is used for | |
40 | multi-character option names. | |
41 | ||
42 | By default, this macro is defined as `DEFAULT_WORD_SWITCH_TAKES_ARG', which | |
43 | handles the standard options properly. You need not define | |
44 | `WORD_SWITCH_TAKES_ARG' unless you wish to add additional options which take | |
45 | arguments. Any redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and | |
46 | then check for additional options. | |
47 | ||
48 | Defined in svr4.h. */ | |
49 | /* #define WORD_SWITCH_TAKES_ARG(NAME) */ | |
50 | ||
51 | /* A string-valued C expression which is nonempty if the linker needs a space | |
52 | between the `-L' or `-o' option and its argument. | |
53 | ||
54 | If this macro is not defined, the default value is 0. */ | |
55 | /* #define SWITCHES_NEED_SPACES "" */ | |
56 | ||
57 | /* A C string constant that tells the GNU CC driver program options to pass to | |
58 | CPP. It can also specify how to translate options you give to GNU CC into | |
59 | options for GNU CC to pass to the CPP. | |
60 | ||
61 | Do not define this macro if it does not need to do anything. */ | |
62 | /* #define CPP_SPEC "" */ | |
63 | ||
64 | /* If this macro is defined, the preprocessor will not define the builtin macro | |
65 | `__SIZE_TYPE__'. The macro `__SIZE_TYPE__' must then be defined by | |
66 | `CPP_SPEC' instead. | |
67 | ||
68 | This should be defined if `SIZE_TYPE' depends on target dependent flags | |
69 | which are not accessible to the preprocessor. Otherwise, it should not be | |
70 | defined. */ | |
71 | /* #define NO_BUILTIN_SIZE_TYPE */ | |
72 | ||
73 | /* If this macro is defined, the preprocessor will not define the builtin macro | |
74 | `__PTRDIFF_TYPE__'. The macro `__PTRDIFF_TYPE__' must then be defined by | |
75 | `CPP_SPEC' instead. | |
76 | ||
77 | This should be defined if `PTRDIFF_TYPE' depends on target dependent flags | |
78 | which are not accessible to the preprocessor. Otherwise, it should not be | |
79 | defined. */ | |
80 | /* #define NO_BUILTIN_PTRDIFF_TYPE */ | |
81 | ||
82 | /* A C string constant that tells the GNU CC driver program options to pass to | |
83 | CPP. By default, this macro is defined to pass the option | |
84 | `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as `unsigned char' by | |
85 | `cc1'. | |
86 | ||
87 | Do not define this macro unless you need to override the default definition. */ | |
88 | /* #if DEFAULT_SIGNED_CHAR | |
89 | #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}" | |
90 | #else | |
91 | #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}" | |
92 | #endif */ | |
93 | ||
94 | /* A C string constant that tells the GNU CC driver program options to pass to | |
95 | `cc1'. It can also specify how to translate options you give to GNU CC into | |
96 | options for GNU CC to pass to the `cc1'. | |
97 | ||
98 | Do not define this macro if it does not need to do anything. */ | |
99 | /* #define CC1_SPEC "" */ | |
100 | ||
101 | /* A C string constant that tells the GNU CC driver program options to pass to | |
102 | `cc1plus'. It can also specify how to translate options you give to GNU CC | |
103 | into options for GNU CC to pass to the `cc1plus'. | |
104 | ||
105 | Do not define this macro if it does not need to do anything. */ | |
106 | /* #define CC1PLUS_SPEC "" */ | |
107 | ||
108 | /* A C string constant that tells the GNU CC driver program options to pass to | |
109 | the assembler. It can also specify how to translate options you give to GNU | |
110 | CC into options for GNU CC to pass to the assembler. See the file `sun3.h' | |
111 | for an example of this. | |
112 | ||
113 | Do not define this macro if it does not need to do anything. | |
114 | ||
115 | Defined in svr4.h. */ | |
116 | #undef ASM_SPEC | |
322fe6e1 | 117 | #define ASM_SPEC "" |
4b58290f GK |
118 | |
119 | /* A C string constant that tells the GNU CC driver program how to run any | |
120 | programs which cleanup after the normal assembler. Normally, this is not | |
121 | needed. See the file `mips.h' for an example of this. | |
122 | ||
123 | Do not define this macro if it does not need to do anything. | |
124 | ||
125 | Defined in svr4.h. */ | |
126 | /* #define ASM_FINAL_SPEC "" */ | |
127 | ||
128 | /* A C string constant that tells the GNU CC driver program options to pass to | |
129 | the linker. It can also specify how to translate options you give to GNU CC | |
130 | into options for GNU CC to pass to the linker. | |
131 | ||
132 | Do not define this macro if it does not need to do anything. | |
133 | ||
134 | Defined in svr4.h. */ | |
135 | /* #define LINK_SPEC "" */ | |
136 | ||
137 | /* Another C string constant used much like `LINK_SPEC'. The difference | |
138 | between the two is that `LIB_SPEC' is used at the end of the command given | |
139 | to the linker. | |
140 | ||
c6243b4c | 141 | For xstormy16: |
3eaaf577 GK |
142 | - If -msim is specified, everything is built and linked as for the sim. |
143 | - If -T is specified, that linker script is used, and it should provide | |
144 | appropriate libraries. | |
145 | - If neither is specified, everything is built as for the sim, but no | |
146 | I/O support is assumed. | |
147 | ||
148 | */ | |
4b58290f | 149 | #undef LIB_SPEC |
3eaaf577 | 150 | #define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:%{!T*:-lnosys}} -)" |
4b58290f GK |
151 | |
152 | /* Another C string constant that tells the GNU CC driver program how and when | |
153 | to place a reference to `libgcc.a' into the linker command line. This | |
154 | constant is placed both before and after the value of `LIB_SPEC'. | |
155 | ||
156 | If this macro is not defined, the GNU CC driver provides a default that | |
157 | passes the string `-lgcc' to the linker unless the `-shared' option is | |
158 | specified. */ | |
159 | /* #define LIBGCC_SPEC "" */ | |
160 | ||
161 | /* Another C string constant used much like `LINK_SPEC'. The difference | |
162 | between the two is that `STARTFILE_SPEC' is used at the very beginning of | |
163 | the command given to the linker. | |
164 | ||
165 | If this macro is not defined, a default is provided that loads the standard | |
166 | C startup file from the usual place. See `gcc.c'. | |
167 | ||
168 | Defined in svr4.h. */ | |
169 | #undef STARTFILE_SPEC | |
170 | #define STARTFILE_SPEC "crt0.o%s crti.o%s crtbegin.o%s" | |
171 | ||
172 | /* Another C string constant used much like `LINK_SPEC'. The difference | |
173 | between the two is that `ENDFILE_SPEC' is used at the very end of the | |
174 | command given to the linker. | |
175 | ||
176 | Do not define this macro if it does not need to do anything. | |
177 | ||
178 | Defined in svr4.h. */ | |
179 | #undef ENDFILE_SPEC | |
180 | #define ENDFILE_SPEC "crtend.o%s crtn.o%s" | |
181 | ||
182 | /* Define this macro if the driver program should find the library `libgcc.a' | |
183 | itself and should not pass `-L' options to the linker. If you do not define | |
184 | this macro, the driver program will pass the argument `-lgcc' to tell the | |
185 | linker to do the search and will pass `-L' options to it. */ | |
186 | /* #define LINK_LIBGCC_SPECIAL */ | |
187 | ||
188 | /* Define this macro if the driver program should find the library `libgcc.a'. | |
189 | If you do not define this macro, the driver program will pass the argument | |
190 | `-lgcc' to tell the linker to do the search. This macro is similar to | |
191 | `LINK_LIBGCC_SPECIAL', except that it does not affect `-L' options. */ | |
192 | /* #define LINK_LIBGCC_SPECIAL_1 */ | |
193 | ||
194 | /* Define this macro to provide additional specifications to put in the `specs' | |
195 | file that can be used in various specifications like `CC1_SPEC'. | |
196 | ||
197 | The definition should be an initializer for an array of structures, | |
198 | containing a string constant, that defines the specification name, and a | |
199 | string constant that provides the specification. | |
200 | ||
201 | Do not define this macro if it does not need to do anything. */ | |
202 | /* #define EXTRA_SPECS {{}} */ | |
203 | ||
204 | /* Define this macro as a C expression for the initializer of an array of | |
205 | string to tell the driver program which options are defaults for this target | |
206 | and thus do not need to be handled specially when using `MULTILIB_OPTIONS'. | |
207 | ||
208 | Do not define this macro if `MULTILIB_OPTIONS' is not defined in the target | |
209 | makefile fragment or if none of the options listed in `MULTILIB_OPTIONS' are | |
210 | set by default. */ | |
211 | /* #define MULTILIB_DEFAULTS {} */ | |
212 | ||
213 | /* Define this macro to tell `gcc' that it should only translate a `-B' prefix | |
214 | into a `-L' linker option if the prefix indicates an absolute file name. */ | |
215 | /* #define RELATIVE_PREFIX_NOT_LINKDIR */ | |
216 | ||
217 | /* Define this macro as a C string constant if you wish to override the | |
218 | standard choice of `/usr/local/lib/gcc-lib/' as the default prefix to try | |
219 | when searching for the executable files of the compiler. */ | |
220 | /* #define STANDARD_EXEC_PREFIX "" */ | |
221 | ||
222 | /* If defined, this macro is an additional prefix to try after | |
223 | `STANDARD_EXEC_PREFIX'. `MD_EXEC_PREFIX' is not searched when the `-b' | |
224 | option is used, or the compiler is built as a cross compiler. | |
225 | ||
226 | Defined in svr4.h for host compilers. */ | |
227 | /* #define MD_EXEC_PREFIX "" */ | |
228 | ||
229 | /* Define this macro as a C string constant if you wish to override the | |
230 | standard choice of `/usr/local/lib/' as the default prefix to try when | |
231 | searching for startup files such as `crt0.o'. */ | |
232 | /* #define STANDARD_STARTFILE_PREFIX "" */ | |
233 | ||
234 | /* If defined, this macro supplies an additional prefix to try after the | |
235 | standard prefixes. `MD_EXEC_PREFIX' is not searched when the `-b' option is | |
236 | used, or when the compiler is built as a cross compiler. | |
237 | ||
238 | Defined in svr4.h for host compilers. */ | |
239 | /* #define MD_STARTFILE_PREFIX "" */ | |
240 | ||
241 | /* If defined, this macro supplies yet another prefix to try after the standard | |
242 | prefixes. It is not searched when the `-b' option is used, or when the | |
243 | compiler is built as a cross compiler. */ | |
244 | /* #define MD_STARTFILE_PREFIX_1 "" */ | |
245 | ||
246 | /* Define this macro as a C string constant if you with to set environment | |
247 | variables for programs called by the driver, such as the assembler and | |
248 | loader. The driver passes the value of this macro to `putenv' to initialize | |
249 | the necessary environment variables. */ | |
250 | /* #define INIT_ENVIRONMENT "" */ | |
251 | ||
252 | /* Define this macro as a C string constant if you wish to override the | |
253 | standard choice of `/usr/local/include' as the default prefix to try when | |
254 | searching for local header files. `LOCAL_INCLUDE_DIR' comes before | |
255 | `SYSTEM_INCLUDE_DIR' in the search order. | |
256 | ||
257 | Cross compilers do not use this macro and do not search either | |
258 | `/usr/local/include' or its replacement. */ | |
259 | /* #define LOCAL_INCLUDE_DIR "" */ | |
260 | ||
261 | /* Define this macro as a C string constant if you wish to specify a | |
262 | system-specific directory to search for header files before the standard | |
263 | directory. `SYSTEM_INCLUDE_DIR' comes before `STANDARD_INCLUDE_DIR' in the | |
264 | search order. | |
265 | ||
266 | Cross compilers do not use this macro and do not search the directory | |
267 | specified. */ | |
268 | /* #define SYSTEM_INCLUDE_DIR "" */ | |
269 | ||
270 | /* Define this macro as a C string constant if you wish to override the | |
271 | standard choice of `/usr/include' as the default prefix to try when | |
272 | searching for header files. | |
273 | ||
274 | Cross compilers do not use this macro and do not search either | |
275 | `/usr/include' or its replacement. */ | |
276 | /* #define STANDARD_INCLUDE_DIR "" */ | |
277 | ||
278 | /* Define this macro if you wish to override the entire default search path for | |
279 | include files. The default search path includes `GCC_INCLUDE_DIR', | |
280 | `LOCAL_INCLUDE_DIR', `SYSTEM_INCLUDE_DIR', `GPLUSPLUS_INCLUDE_DIR', and | |
281 | `STANDARD_INCLUDE_DIR'. In addition, `GPLUSPLUS_INCLUDE_DIR' and | |
282 | `GCC_INCLUDE_DIR' are defined automatically by `Makefile', and specify | |
283 | private search areas for GCC. The directory `GPLUSPLUS_INCLUDE_DIR' is used | |
284 | only for C++ programs. | |
285 | ||
286 | The definition should be an initializer for an array of structures. Each | |
287 | array element should have two elements: the directory name (a string | |
288 | constant) and a flag for C++-only directories. Mark the end of the array | |
289 | with a null element. For example, here is the definition used for VMS: | |
290 | ||
291 | #define INCLUDE_DEFAULTS \ | |
292 | { \ | |
293 | { "GNU_GXX_INCLUDE:", 1}, \ | |
294 | { "GNU_CC_INCLUDE:", 0}, \ | |
295 | { "SYS$SYSROOT:[SYSLIB.]", 0}, \ | |
296 | { ".", 0}, \ | |
297 | { 0, 0} \ | |
298 | } | |
299 | ||
300 | Here is the order of prefixes tried for exec files: | |
301 | ||
302 | 1. Any prefixes specified by the user with `-B'. | |
303 | ||
304 | 2. The environment variable `GCC_EXEC_PREFIX', if any. | |
305 | ||
306 | 3. The directories specified by the environment variable | |
307 | `COMPILER_PATH'. | |
308 | ||
309 | 4. The macro `STANDARD_EXEC_PREFIX'. | |
310 | ||
311 | 5. `/usr/lib/gcc/'. | |
312 | ||
313 | 6. The macro `MD_EXEC_PREFIX', if any. | |
314 | ||
315 | Here is the order of prefixes tried for startfiles: | |
316 | ||
317 | 1. Any prefixes specified by the user with `-B'. | |
318 | ||
319 | 2. The environment variable `GCC_EXEC_PREFIX', if any. | |
320 | ||
321 | 3. The directories specified by the environment variable | |
322 | `LIBRARY_PATH' (native only, cross compilers do not use this). | |
323 | ||
324 | 4. The macro `STANDARD_EXEC_PREFIX'. | |
325 | ||
326 | 5. `/usr/lib/gcc/'. | |
327 | ||
328 | 6. The macro `MD_EXEC_PREFIX', if any. | |
329 | ||
330 | 7. The macro `MD_STARTFILE_PREFIX', if any. | |
331 | ||
332 | 8. The macro `STANDARD_STARTFILE_PREFIX'. | |
333 | ||
334 | 9. `/lib/'. | |
335 | ||
336 | 10. `/usr/lib/'. */ | |
337 | /* #define INCLUDE_DEFAULTS {{ }} */ | |
338 | ||
339 | \f | |
340 | /* Run-time target specifications */ | |
341 | ||
342 | /* Define this to be a string constant containing `-D' options to define the | |
343 | predefined macros that identify this machine and system. These macros will | |
344 | be predefined unless the `-ansi' option is specified. | |
345 | ||
346 | In addition, a parallel set of macros are predefined, whose names are made | |
347 | by appending `__' at the beginning and at the end. These `__' macros are | |
348 | permitted by the ANSI standard, so they are predefined regardless of whether | |
349 | `-ansi' is specified. | |
350 | ||
351 | For example, on the Sun, one can use the following value: | |
352 | ||
353 | "-Dmc68000 -Dsun -Dunix" | |
354 | ||
355 | The result is to define the macros `__mc68000__', `__sun__' and `__unix__' | |
356 | unconditionally, and the macros `mc68000', `sun' and `unix' provided `-ansi' | |
357 | is not specified. */ | |
c6243b4c | 358 | #define CPP_PREDEFINES "-Dxstormy16 -Amachine=xstormy16 -D__INT_MAX__=32767" |
4b58290f GK |
359 | |
360 | /* This declaration should be present. */ | |
361 | extern int target_flags; | |
362 | ||
363 | /* This series of macros is to allow compiler command arguments to enable or | |
364 | disable the use of optional features of the target machine. For example, | |
365 | one machine description serves both the 68000 and the 68020; a command | |
366 | argument tells the compiler whether it should use 68020-only instructions or | |
367 | not. This command argument works by means of a macro `TARGET_68020' that | |
368 | tests a bit in `target_flags'. | |
369 | ||
370 | Define a macro `TARGET_FEATURENAME' for each such option. Its definition | |
371 | should test a bit in `target_flags'; for example: | |
372 | ||
373 | #define TARGET_68020 (target_flags & 1) | |
374 | ||
375 | One place where these macros are used is in the condition-expressions of | |
376 | instruction patterns. Note how `TARGET_68020' appears frequently in the | |
377 | 68000 machine description file, `m68k.md'. Another place they are used is | |
378 | in the definitions of the other macros in the `MACHINE.h' file. */ | |
379 | /* #define TARGET_... */ | |
380 | ||
381 | /* This macro defines names of command options to set and clear bits in | |
382 | `target_flags'. Its definition is an initializer with a subgrouping for | |
383 | each command option. | |
384 | ||
385 | Each subgrouping contains a string constant, that defines the | |
386 | option name, a number, which contains the bits to set in | |
387 | `target_flags', and an optional second string which is the textual | |
388 | description that will be displayed when the user passes --help on | |
389 | the command line. If the number entry is negative then the | |
390 | specified bits will be cleared instead of being set. If the second | |
391 | string entry is present but empty, then no help information will be | |
392 | displayed for that option, but it will not count as an undocumented | |
393 | option. The actual option name, as seen on the command line is | |
394 | made by appending `-m' to the specified name. | |
395 | ||
396 | One of the subgroupings should have a null string. The number in this | |
397 | grouping is the default value for `target_flags'. Any target options act | |
398 | starting with that value. | |
399 | ||
400 | Here is an example which defines `-m68000' and `-m68020' with opposite | |
401 | meanings, and picks the latter as the default: | |
402 | ||
403 | #define TARGET_SWITCHES \ | |
404 | { { "68020", 1, ""}, \ | |
405 | { "68000", -1, "Compile for the m68000"}, \ | |
406 | { "", 1, }} | |
407 | ||
408 | This declaration must be present. */ | |
409 | ||
410 | #define TARGET_SWITCHES \ | |
411 | {{ "sim", 0, "Provide libraries for the simulator" }, \ | |
412 | { "", 0, "" }} | |
413 | ||
414 | /* This macro is similar to `TARGET_SWITCHES' but defines names of command | |
415 | options that have values. Its definition is an initializer with a | |
416 | subgrouping for each command option. | |
417 | ||
418 | Each subgrouping contains a string constant, that defines the fixed part of | |
419 | the option name, the address of a variable, and an optional description string. | |
420 | The variable, of type `char *', is set to the text following the fixed part of | |
421 | the option as it is specified on the command line. The actual option name is | |
422 | made by appending `-m' to the specified name. | |
423 | ||
424 | Here is an example which defines `-mshort-data-NUMBER'. If the given option | |
425 | is `-mshort-data-512', the variable `m88k_short_data' will be set to the | |
426 | string `"512"'. | |
427 | ||
428 | extern char *m88k_short_data; | |
429 | #define TARGET_OPTIONS \ | |
430 | { { "short-data-", & m88k_short_data, \ | |
431 | "Specify the size of the short data section" } } | |
432 | ||
433 | This declaration is optional. */ | |
434 | /* #define TARGET_OPTIONS */ | |
435 | ||
436 | /* This macro is a C statement to print on `stderr' a string describing the | |
437 | particular machine description choice. Every machine description should | |
438 | define `TARGET_VERSION'. For example: | |
439 | ||
440 | #ifdef MOTOROLA | |
441 | #define TARGET_VERSION \ | |
442 | fprintf (stderr, " (68k, Motorola syntax)"); | |
443 | #else | |
444 | #define TARGET_VERSION \ | |
445 | fprintf (stderr, " (68k, MIT syntax)"); | |
446 | #endif */ | |
c6243b4c | 447 | #define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)"); |
4b58290f GK |
448 | |
449 | /* Sometimes certain combinations of command options do not make sense on a | |
450 | particular target machine. You can define a macro `OVERRIDE_OPTIONS' to | |
451 | take account of this. This macro, if defined, is executed once just after | |
452 | all the command options have been parsed. | |
453 | ||
454 | Don't use this macro to turn on various extra optimizations for `-O'. That | |
455 | is what `OPTIMIZATION_OPTIONS' is for. */ | |
456 | /* #define OVERRIDE_OPTIONS */ | |
457 | ||
458 | /* Some machines may desire to change what optimizations are performed for | |
459 | various optimization levels. This macro, if defined, is executed once just | |
460 | after the optimization level is determined and before the remainder of the | |
461 | command options have been parsed. Values set in this macro are used as the | |
462 | default values for the other command line options. | |
463 | ||
464 | LEVEL is the optimization level specified; 2 if `-O2' is specified, 1 if | |
465 | `-O' is specified, and 0 if neither is specified. | |
466 | ||
467 | SIZE is non-zero if `-Os' is specified, 0 otherwise. | |
468 | ||
469 | You should not use this macro to change options that are not | |
470 | machine-specific. These should uniformly selected by the same optimization | |
471 | level on all supported machines. Use this macro to enable machbine-specific | |
472 | optimizations. | |
473 | ||
474 | *Do not examine `write_symbols' in this macro!* The debugging options are | |
475 | *not supposed to alter the generated code. */ | |
476 | /* #define OPTIMIZATION_OPTIONS(LEVEL,SIZE) */ | |
477 | ||
478 | /* Define this macro if debugging can be performed even without a frame | |
479 | pointer. If this macro is defined, GNU CC will turn on the | |
480 | `-fomit-frame-pointer' option whenever `-O' is specified. */ | |
481 | #define CAN_DEBUG_WITHOUT_FP | |
482 | ||
483 | \f | |
484 | /* Storage Layout */ | |
485 | ||
486 | /* Define this macro to have the value 1 if the most significant bit in a byte | |
487 | has the lowest number; otherwise define it to have the value zero. This | |
488 | means that bit-field instructions count from the most significant bit. If | |
489 | the machine has no bit-field instructions, then this must still be defined, | |
490 | but it doesn't matter which value it is defined to. This macro need not be | |
491 | a constant. | |
492 | ||
493 | This macro does not affect the way structure fields are packed into bytes or | |
494 | words; that is controlled by `BYTES_BIG_ENDIAN'. */ | |
495 | #define BITS_BIG_ENDIAN 1 | |
496 | ||
497 | /* Define this macro to have the value 1 if the most significant byte in a word | |
498 | has the lowest number. This macro need not be a constant. */ | |
499 | #define BYTES_BIG_ENDIAN 0 | |
500 | ||
501 | /* Define this macro to have the value 1 if, in a multiword object, the most | |
502 | significant word has the lowest number. This applies to both memory | |
503 | locations and registers; GNU CC fundamentally assumes that the order of | |
504 | words in memory is the same as the order in registers. This macro need not | |
505 | be a constant. */ | |
506 | #define WORDS_BIG_ENDIAN 0 | |
507 | ||
508 | /* Define this macro if WORDS_BIG_ENDIAN is not constant. This must be a | |
509 | constant value with the same meaning as WORDS_BIG_ENDIAN, which will be used | |
510 | only when compiling libgcc2.c. Typically the value will be set based on | |
511 | preprocessor defines. */ | |
512 | /* #define LIBGCC2_WORDS_BIG_ENDIAN */ | |
513 | ||
514 | /* Define this macro to have the value 1 if `DFmode', `XFmode' or `TFmode' | |
515 | floating point numbers are stored in memory with the word containing the | |
516 | sign bit at the lowest address; otherwise define it to have the value 0. | |
517 | This macro need not be a constant. | |
518 | ||
519 | You need not define this macro if the ordering is the same as for multi-word | |
520 | integers. */ | |
521 | /* #define FLOAT_WORDS_BIG_ENDIAN */ | |
522 | ||
523 | /* Define this macro to be the number of bits in an addressable storage unit | |
524 | (byte); normally 8. */ | |
525 | #define BITS_PER_UNIT 8 | |
526 | ||
527 | /* Number of bits in a word; normally 32. */ | |
528 | #define BITS_PER_WORD 16 | |
529 | ||
530 | /* Maximum number of bits in a word. If this is undefined, the default is | |
531 | `BITS_PER_WORD'. Otherwise, it is the constant value that is the largest | |
532 | value that `BITS_PER_WORD' can have at run-time. */ | |
533 | /* #define MAX_BITS_PER_WORD */ | |
534 | ||
535 | /* Number of storage units in a word; normally 4. */ | |
536 | #define UNITS_PER_WORD 2 | |
537 | ||
538 | /* Minimum number of units in a word. If this is undefined, the default is | |
539 | `UNITS_PER_WORD'. Otherwise, it is the constant value that is the smallest | |
540 | value that `UNITS_PER_WORD' can have at run-time. */ | |
541 | /* #define MIN_UNITS_PER_WORD */ | |
542 | ||
543 | /* Width of a pointer, in bits. You must specify a value no wider than the | |
544 | width of `Pmode'. If it is not equal to the width of `Pmode', you must | |
545 | define `POINTERS_EXTEND_UNSIGNED'. */ | |
546 | #define POINTER_SIZE 16 | |
547 | ||
548 | /* A C expression whose value is nonzero if pointers that need to be extended | |
549 | from being `POINTER_SIZE' bits wide to `Pmode' are sign-extended and zero if | |
550 | they are zero-extended. | |
551 | ||
552 | You need not define this macro if the `POINTER_SIZE' is equal to the width | |
553 | of `Pmode'. */ | |
554 | /* #define POINTERS_EXTEND_UNSIGNED */ | |
555 | ||
556 | /* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and | |
557 | which has the specified mode and signedness is to be stored in a register. | |
558 | This macro is only called when TYPE is a scalar type. | |
559 | ||
560 | On most RISC machines, which only have operations that operate on a full | |
561 | register, define this macro to set M to `word_mode' if M is an integer mode | |
562 | narrower than `BITS_PER_WORD'. In most cases, only integer modes should be | |
563 | widened because wider-precision floating-point operations are usually more | |
564 | expensive than their narrower counterparts. | |
565 | ||
566 | For most machines, the macro definition does not change UNSIGNEDP. However, | |
567 | some machines, have instructions that preferentially handle either signed or | |
568 | unsigned quantities of certain modes. For example, on the DEC Alpha, 32-bit | |
569 | loads from memory and 32-bit add instructions sign-extend the result to 64 | |
570 | bits. On such machines, set UNSIGNEDP according to which kind of extension | |
571 | is more efficient. | |
572 | ||
573 | Do not define this macro if it would never modify MODE. */ | |
574 | #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \ | |
575 | do { \ | |
576 | if (GET_MODE_CLASS (MODE) == MODE_INT \ | |
577 | && GET_MODE_SIZE (MODE) < 2) \ | |
578 | (MODE) = HImode; \ | |
579 | } while (0) | |
580 | ||
581 | /* Define this macro if the promotion described by `PROMOTE_MODE' should also | |
582 | be done for outgoing function arguments. */ | |
583 | #define PROMOTE_FUNCTION_ARGS 1 | |
584 | ||
585 | /* Define this macro if the promotion described by `PROMOTE_MODE' should also | |
586 | be done for the return value of functions. | |
587 | ||
588 | If this macro is defined, `FUNCTION_VALUE' must perform the same promotions | |
589 | done by `PROMOTE_MODE'. */ | |
590 | #define PROMOTE_FUNCTION_RETURN 1 | |
591 | ||
592 | /* Define this macro if the promotion described by `PROMOTE_MODE' should *only* | |
593 | be performed for outgoing function arguments or function return values, as | |
594 | specified by `PROMOTE_FUNCTION_ARGS' and `PROMOTE_FUNCTION_RETURN', | |
595 | respectively. */ | |
596 | /* #define PROMOTE_FOR_CALL_ONLY */ | |
597 | ||
598 | /* Normal alignment required for function parameters on the stack, in bits. | |
599 | All stack parameters receive at least this much alignment regardless of data | |
600 | type. On most machines, this is the same as the size of an integer. */ | |
601 | #define PARM_BOUNDARY 16 | |
602 | ||
603 | /* Define this macro if you wish to preserve a certain alignment for the stack | |
604 | pointer. The definition is a C expression for the desired alignment | |
605 | (measured in bits). | |
606 | ||
607 | If `PUSH_ROUNDING' is not defined, the stack will always be aligned to the | |
608 | specified boundary. If `PUSH_ROUNDING' is defined and specifies a less | |
609 | strict alignment than `STACK_BOUNDARY', the stack may be momentarily | |
610 | unaligned while pushing arguments. */ | |
611 | #define STACK_BOUNDARY 16 | |
612 | ||
613 | /* Alignment required for a function entry point, in bits. */ | |
614 | #define FUNCTION_BOUNDARY 16 | |
615 | ||
616 | /* Biggest alignment that any data type can require on this machine, | |
617 | in bits. */ | |
618 | #define BIGGEST_ALIGNMENT 16 | |
619 | ||
620 | /* Biggest alignment that any structure field can require on this machine, in | |
621 | bits. If defined, this overrides `BIGGEST_ALIGNMENT' for structure fields | |
622 | only. */ | |
623 | /* #define BIGGEST_FIELD_ALIGNMENT */ | |
624 | ||
625 | /* An expression for the alignment of a structure field FIELD if the | |
626 | alignment computed in the usual way is COMPUTED. GNU CC uses this | |
627 | value instead of the value in `BIGGEST_ALIGNMENT' or | |
628 | `BIGGEST_FIELD_ALIGNMENT', if defined, for structure fields only. */ | |
629 | /* #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) */ | |
630 | ||
631 | /* Biggest alignment supported by the object file format of this machine. Use | |
632 | this macro to limit the alignment which can be specified using the | |
633 | `__attribute__ ((aligned (N)))' construct. If not defined, the default | |
634 | value is `BIGGEST_ALIGNMENT'. | |
635 | ||
636 | Defined in svr4.h. */ | |
637 | /* #define MAX_OFILE_ALIGNMENT */ | |
638 | ||
639 | /* If defined, a C expression to compute the alignment for a static variable. | |
640 | TYPE is the data type, and ALIGN is the alignment that the object | |
641 | would ordinarily have. The value of this macro is used instead of that | |
642 | alignment to align the object. | |
643 | ||
644 | If this macro is not defined, then ALIGN is used. | |
645 | ||
646 | One use of this macro is to increase alignment of medium-size data to make | |
647 | it all fit in fewer cache lines. Another is to cause character arrays to be | |
648 | word-aligned so that `strcpy' calls that copy constants to character arrays | |
649 | can be done inline. */ | |
650 | #define DATA_ALIGNMENT(TYPE, ALIGN) \ | |
651 | (TREE_CODE (TYPE) == ARRAY_TYPE \ | |
652 | && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \ | |
653 | && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN)) | |
654 | ||
655 | /* If defined, a C expression to compute the alignment given to a constant that | |
656 | is being placed in memory. CONSTANT is the constant and ALIGN is the | |
657 | alignment that the object would ordinarily have. The value of this macro is | |
658 | used instead of that alignment to align the object. | |
659 | ||
660 | If this macro is not defined, then ALIGN is used. | |
661 | ||
662 | The typical use of this macro is to increase alignment for string constants | |
663 | to be word aligned so that `strcpy' calls that copy constants can be done | |
664 | inline. */ | |
665 | #define CONSTANT_ALIGNMENT(EXP, ALIGN) \ | |
666 | (TREE_CODE (EXP) == STRING_CST \ | |
667 | && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN)) | |
668 | ||
669 | /* Alignment in bits to be given to a structure bit field that follows an empty | |
670 | field such as `int : 0;'. | |
671 | ||
672 | Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment that | |
673 | results from an empty field. */ | |
674 | /* #define EMPTY_FIELD_BOUNDARY */ | |
675 | ||
676 | /* Number of bits which any structure or union's size must be a multiple of. | |
677 | Each structure or union's size is rounded up to a multiple of this. | |
678 | ||
679 | If you do not define this macro, the default is the same as `BITS_PER_UNIT'. */ | |
680 | /* #define STRUCTURE_SIZE_BOUNDARY */ | |
681 | ||
682 | /* Define this macro to be the value 1 if instructions will fail to work if | |
683 | given data not on the nominal alignment. If instructions will merely go | |
684 | slower in that case, define this macro as 0. */ | |
685 | #define STRICT_ALIGNMENT 1 | |
686 | ||
687 | /* Define this if you wish to imitate the way many other C compilers handle | |
688 | alignment of bitfields and the structures that contain them. | |
689 | ||
690 | The behavior is that the type written for a bitfield (`int', `short', or | |
691 | other integer type) imposes an alignment for the entire structure, as if the | |
692 | structure really did contain an ordinary field of that type. In addition, | |
693 | the bitfield is placed within the structure so that it would fit within such | |
694 | a field, not crossing a boundary for it. | |
695 | ||
696 | Thus, on most machines, a bitfield whose type is written as `int' would not | |
697 | cross a four-byte boundary, and would force four-byte alignment for the | |
698 | whole structure. (The alignment used may not be four bytes; it is | |
699 | controlled by the other alignment parameters.) | |
700 | ||
701 | If the macro is defined, its definition should be a C expression; a nonzero | |
702 | value for the expression enables this behavior. | |
703 | ||
704 | Note that if this macro is not defined, or its value is zero, some bitfields | |
705 | may cross more than one alignment boundary. The compiler can support such | |
706 | references if there are `insv', `extv', and `extzv' insns that can directly | |
707 | reference memory. | |
708 | ||
709 | The other known way of making bitfields work is to define | |
710 | `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then every | |
711 | structure can be accessed with fullwords. | |
712 | ||
713 | Unless the machine has bitfield instructions or you define | |
714 | `STRUCTURE_SIZE_BOUNDARY' that way, you must define | |
715 | `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value. | |
716 | ||
717 | If your aim is to make GNU CC use the same conventions for laying out | |
718 | bitfields as are used by another compiler, here is how to investigate what | |
719 | the other compiler does. Compile and run this program: | |
720 | ||
721 | struct foo1 | |
722 | { | |
723 | char x; | |
724 | char :0; | |
725 | char y; | |
726 | }; | |
727 | ||
728 | struct foo2 | |
729 | { | |
730 | char x; | |
731 | int :0; | |
732 | char y; | |
733 | }; | |
734 | ||
735 | main () | |
736 | { | |
737 | printf ("Size of foo1 is %d\n", | |
738 | sizeof (struct foo1)); | |
739 | printf ("Size of foo2 is %d\n", | |
740 | sizeof (struct foo2)); | |
741 | exit (0); | |
742 | } | |
743 | ||
744 | If this prints 2 and 5, then the compiler's behavior is what you would get | |
745 | from `PCC_BITFIELD_TYPE_MATTERS'. | |
746 | ||
747 | Defined in svr4.h. */ | |
748 | #define PCC_BITFIELD_TYPE_MATTERS 1 | |
749 | ||
750 | /* Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to aligning | |
751 | a bitfield within the structure. */ | |
752 | /* #define BITFIELD_NBYTES_LIMITED */ | |
753 | ||
754 | /* Define this macro as an expression for the overall size of a structure | |
755 | (given by STRUCT as a tree node) when the size computed from the fields is | |
756 | SIZE and the alignment is ALIGN. | |
757 | ||
758 | The default is to round SIZE up to a multiple of ALIGN. */ | |
759 | /* #define ROUND_TYPE_SIZE(STRUCT, SIZE, ALIGN) */ | |
760 | ||
761 | /* Define this macro as an expression for the alignment of a structure (given | |
762 | by STRUCT as a tree node) if the alignment computed in the usual way is | |
763 | COMPUTED and the alignment explicitly specified was SPECIFIED. | |
764 | ||
765 | The default is to use SPECIFIED if it is larger; otherwise, use the smaller | |
766 | of COMPUTED and `BIGGEST_ALIGNMENT' */ | |
767 | /* #define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) */ | |
768 | ||
769 | /* An integer expression for the size in bits of the largest integer machine | |
770 | mode that should actually be used. All integer machine modes of this size | |
771 | or smaller can be used for structures and unions with the appropriate sizes. | |
772 | If this macro is undefined, `GET_MODE_BITSIZE (DImode)' is assumed. */ | |
773 | /* #define MAX_FIXED_MODE_SIZE */ | |
774 | ||
775 | /* A C statement to validate the value VALUE (of type `double') for mode MODE. | |
776 | This means that you check whether VALUE fits within the possible range of | |
777 | values for mode MODE on this target machine. The mode MODE is always a mode | |
778 | of class `MODE_FLOAT'. OVERFLOW is nonzero if the value is already known to | |
779 | be out of range. | |
780 | ||
781 | If VALUE is not valid or if OVERFLOW is nonzero, you should set OVERFLOW to | |
782 | 1 and then assign some valid value to VALUE. Allowing an invalid value to | |
783 | go through the compiler can produce incorrect assembler code which may even | |
784 | cause Unix assemblers to crash. | |
785 | ||
786 | This macro need not be defined if there is no work for it to do. */ | |
787 | /* #define CHECK_FLOAT_VALUE(MODE, VALUE, OVERFLOW) */ | |
788 | ||
789 | /* A code distinguishing the floating point format of the target machine. | |
790 | There are three defined values: | |
791 | ||
792 | IEEE_FLOAT_FORMAT' | |
793 | This code indicates IEEE floating point. It is the default; | |
794 | there is no need to define this macro when the format is IEEE. | |
795 | ||
796 | VAX_FLOAT_FORMAT' | |
797 | This code indicates the peculiar format used on the Vax. | |
798 | ||
799 | UNKNOWN_FLOAT_FORMAT' | |
800 | This code indicates any other format. | |
801 | ||
802 | The value of this macro is compared with `HOST_FLOAT_FORMAT' | |
803 | to determine whether the target machine has the same format as | |
804 | the host machine. If any other formats are actually in use on supported | |
805 | machines, new codes should be defined for them. | |
806 | ||
807 | The ordering of the component words of floating point values stored in | |
808 | memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the target machine and | |
809 | `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */ | |
810 | #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT | |
811 | ||
812 | /* GNU CC supports two ways of implementing C++ vtables: traditional or with | |
813 | so-called "thunks". The flag `-fvtable-thunk' chooses between them. Define | |
814 | this macro to be a C expression for the default value of that flag. If | |
815 | `DEFAULT_VTABLE_THUNKS' is 0, GNU CC uses the traditional implementation by | |
816 | default. The "thunk" implementation is more efficient (especially if you | |
817 | have provided an implementation of `ASM_OUTPUT_MI_THUNK', but is not binary | |
818 | compatible with code compiled using the traditional implementation. If you | |
819 | are writing a new ports, define `DEFAULT_VTABLE_THUNKS' to 1. | |
820 | ||
821 | If you do not define this macro, the default for `-fvtable-thunk' is 0. */ | |
822 | #define DEFAULT_VTABLE_THUNKS 1 | |
823 | ||
824 | \f | |
825 | /* Layout of Source Language Data Types */ | |
826 | ||
827 | /* A C expression for the size in bits of the type `int' on the target machine. | |
828 | If you don't define this, the default is one word. */ | |
829 | #define INT_TYPE_SIZE 16 | |
830 | ||
831 | /* Maximum number for the size in bits of the type `int' on the target machine. | |
832 | If this is undefined, the default is `INT_TYPE_SIZE'. Otherwise, it is the | |
833 | constant value that is the largest value that `INT_TYPE_SIZE' can have at | |
834 | run-time. This is used in `cpp'. */ | |
835 | /* #define MAX_INT_TYPE_SIZE */ | |
836 | ||
837 | /* A C expression for the size in bits of the type `short' on the target | |
838 | machine. If you don't define this, the default is half a word. (If this | |
839 | would be less than one storage unit, it is rounded up to one unit.) */ | |
840 | #define SHORT_TYPE_SIZE 16 | |
841 | ||
842 | /* A C expression for the size in bits of the type `long' on the target | |
843 | machine. If you don't define this, the default is one word. */ | |
844 | #define LONG_TYPE_SIZE 32 | |
845 | ||
846 | /* Maximum number for the size in bits of the type `long' on the target | |
847 | machine. If this is undefined, the default is `LONG_TYPE_SIZE'. Otherwise, | |
848 | it is the constant value that is the largest value that `LONG_TYPE_SIZE' can | |
849 | have at run-time. This is used in `cpp'. */ | |
850 | /* #define MAX_LONG_TYPE_SIZE */ | |
851 | ||
852 | /* A C expression for the size in bits of the type `long long' on the target | |
853 | machine. If you don't define this, the default is two words. If you want | |
854 | to support GNU Ada on your machine, the value of macro must be at least 64. */ | |
855 | #define LONG_LONG_TYPE_SIZE 64 | |
856 | ||
857 | /* A C expression for the size in bits of the type `char' on the target | |
858 | machine. If you don't define this, the default is one quarter of a word. | |
859 | (If this would be less than one storage unit, it is rounded up to one unit.) */ | |
860 | #define CHAR_TYPE_SIZE 8 | |
861 | ||
862 | /* Maximum number for the size in bits of the type `char' on the target | |
863 | machine. If this is undefined, the default is `CHAR_TYPE_SIZE'. Otherwise, | |
864 | it is the constant value that is the largest value that `CHAR_TYPE_SIZE' can | |
865 | have at run-time. This is used in `cpp'. */ | |
866 | /* #define MAX_CHAR_TYPE_SIZE */ | |
867 | ||
868 | /* A C expression for the size in bits of the type `float' on the target | |
869 | machine. If you don't define this, the default is one word. */ | |
870 | #define FLOAT_TYPE_SIZE 32 | |
871 | ||
872 | /* A C expression for the size in bits of the type `double' on the target | |
873 | machine. If you don't define this, the default is two words. */ | |
874 | #define DOUBLE_TYPE_SIZE 64 | |
875 | ||
876 | /* A C expression for the size in bits of the type `long double' on the target | |
877 | machine. If you don't define this, the default is two words. */ | |
878 | #define LONG_DOUBLE_TYPE_SIZE 64 | |
879 | ||
880 | /* An expression whose value is 1 or 0, according to whether the type `char' | |
881 | should be signed or unsigned by default. The user can always override this | |
882 | default with the options `-fsigned-char' and `-funsigned-char'. */ | |
883 | #define DEFAULT_SIGNED_CHAR 0 | |
884 | ||
885 | /* A C expression to determine whether to give an `enum' type only as many | |
886 | bytes as it takes to represent the range of possible values of that type. A | |
887 | nonzero value means to do that; a zero value means all `enum' types should | |
888 | be allocated like `int'. | |
889 | ||
890 | If you don't define the macro, the default is 0. */ | |
891 | /* #define DEFAULT_SHORT_ENUMS */ | |
892 | ||
893 | /* A C expression for a string describing the name of the data type to use for | |
894 | size values. The typedef name `size_t' is defined using the contents of the | |
895 | string. | |
896 | ||
897 | The string can contain more than one keyword. If so, separate them with | |
898 | spaces, and write first any length keyword, then `unsigned' if appropriate, | |
899 | and finally `int'. The string must exactly match one of the data type names | |
900 | defined in the function `init_decl_processing' in the file `c-decl.c'. You | |
901 | may not omit `int' or change the order--that would cause the compiler to | |
902 | crash on startup. | |
903 | ||
904 | If you don't define this macro, the default is `"long unsigned int"'. | |
905 | ||
906 | Defined in svr4.h. */ | |
907 | #define SIZE_TYPE "unsigned int" | |
908 | ||
909 | /* A C expression for a string describing the name of the data type to use for | |
910 | the result of subtracting two pointers. The typedef name `ptrdiff_t' is | |
911 | defined using the contents of the string. See `SIZE_TYPE' above for more | |
912 | information. | |
913 | ||
914 | If you don't define this macro, the default is `"long int"'. | |
915 | ||
916 | Defined in svr4.h. */ | |
917 | #define PTRDIFF_TYPE "int" | |
918 | ||
919 | /* A C expression for a string describing the name of the data type to use for | |
920 | wide characters. The typedef name `wchar_t' is defined using the contents | |
921 | of the string. See `SIZE_TYPE' above for more information. | |
922 | ||
923 | If you don't define this macro, the default is `"int"'. | |
924 | ||
925 | Defined in svr4.h, to "long int". */ | |
926 | /* #define WCHAR_TYPE "long int" */ | |
927 | ||
928 | /* A C expression for the size in bits of the data type for wide characters. | |
929 | This is used in `cpp', which cannot make use of `WCHAR_TYPE'. | |
930 | ||
931 | Defined in svr4.h. */ | |
932 | #undef WCHAR_TYPE_SIZE | |
933 | #define WCHAR_TYPE_SIZE 32 | |
934 | ||
935 | /* Maximum number for the size in bits of the data type for wide characters. | |
936 | If this is undefined, the default is `WCHAR_TYPE_SIZE'. Otherwise, it is | |
937 | the constant value that is the largest value that `WCHAR_TYPE_SIZE' can have | |
938 | at run-time. This is used in `cpp'. */ | |
939 | /* #define MAX_WCHAR_TYPE_SIZE */ | |
940 | ||
941 | /* Define this macro if the type of Objective C selectors should be `int'. | |
942 | ||
943 | If this macro is not defined, then selectors should have the type `struct | |
944 | objc_selector *'. */ | |
945 | /* #define OBJC_INT_SELECTORS */ | |
946 | ||
947 | /* Define this macro if the compiler can group all the selectors together into | |
948 | a vector and use just one label at the beginning of the vector. Otherwise, | |
949 | the compiler must give each selector its own assembler label. | |
950 | ||
951 | On certain machines, it is important to have a separate label for each | |
952 | selector because this enables the linker to eliminate duplicate selectors. */ | |
953 | /* #define OBJC_SELECTORS_WITHOUT_LABELS */ | |
954 | ||
955 | \f | |
956 | /* Register Basics */ | |
957 | ||
958 | /* Number of hardware registers known to the compiler. They receive numbers 0 | |
959 | through `FIRST_PSEUDO_REGISTER-1'; thus, the first pseudo register's number | |
960 | really is assigned the number `FIRST_PSEUDO_REGISTER'. */ | |
961 | #define FIRST_PSEUDO_REGISTER 19 | |
962 | ||
963 | /* An initializer that says which registers are used for fixed purposes all | |
964 | throughout the compiled code and are therefore not available for general | |
965 | allocation. These would include the stack pointer, the frame pointer | |
966 | (except on machines where that can be used as a general register when no | |
967 | frame pointer is needed), the program counter on machines where that is | |
968 | considered one of the addressable registers, and any other numbered register | |
969 | with a standard use. | |
970 | ||
971 | This information is expressed as a sequence of numbers, separated by commas | |
972 | and surrounded by braces. The Nth number is 1 if register N is fixed, 0 | |
973 | otherwise. | |
974 | ||
975 | The table initialized from this macro, and the table initialized by the | |
976 | following one, may be overridden at run time either automatically, by the | |
977 | actions of the macro `CONDITIONAL_REGISTER_USAGE', or by the user with the | |
978 | command options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. */ | |
979 | #define FIXED_REGISTERS \ | |
980 | { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1 } | |
981 | ||
982 | /* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in | |
983 | general) by function calls as well as for fixed registers. This macro | |
984 | therefore identifies the registers that are not available for general | |
985 | allocation of values that must live across function calls. | |
986 | ||
987 | If a register has 0 in `CALL_USED_REGISTERS', the compiler automatically | |
988 | saves it on function entry and restores it on function exit, if the register | |
989 | is used within the function. */ | |
990 | #define CALL_USED_REGISTERS \ | |
991 | { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1 } | |
992 | ||
993 | /* Zero or more C statements that may conditionally modify two variables | |
994 | `fixed_regs' and `call_used_regs' (both of type `char []') after they have | |
995 | been initialized from the two preceding macros. | |
996 | ||
997 | This is necessary in case the fixed or call-clobbered registers depend on | |
998 | target flags. | |
999 | ||
1000 | You need not define this macro if it has no work to do. | |
1001 | ||
1002 | If the usage of an entire class of registers depends on the target flags, | |
1003 | you may indicate this to GCC by using this macro to modify `fixed_regs' and | |
1004 | `call_used_regs' to 1 for each of the registers in the classes which should | |
1005 | not be used by GCC. Also define the macro `REG_CLASS_FROM_LETTER' to return | |
1006 | `NO_REGS' if it is called with a letter for a class that shouldn't be used. | |
1007 | ||
1008 | (However, if this class is not included in `GENERAL_REGS' and all of the | |
1009 | insn patterns whose constraints permit this class are controlled by target | |
1010 | switches, then GCC will automatically avoid using these registers when the | |
1011 | target switches are opposed to them.) */ | |
1012 | /* #define CONDITIONAL_REGISTER_USAGE */ | |
1013 | ||
1014 | /* If this macro is defined and has a nonzero value, it means that `setjmp' and | |
1015 | related functions fail to save the registers, or that `longjmp' fails to | |
1016 | restore them. To compensate, the compiler avoids putting variables in | |
1017 | registers in functions that use `setjmp'. */ | |
1018 | /* #define NON_SAVING_SETJMP */ | |
1019 | ||
1020 | /* Define this macro if the target machine has register windows. This C | |
1021 | expression returns the register number as seen by the called function | |
1022 | corresponding to the register number OUT as seen by the calling function. | |
1023 | Return OUT if register number OUT is not an outbound register. */ | |
1024 | /* #define INCOMING_REGNO(OUT) */ | |
1025 | ||
1026 | /* Define this macro if the target machine has register windows. This C | |
1027 | expression returns the register number as seen by the calling function | |
1028 | corresponding to the register number IN as seen by the called function. | |
1029 | Return IN if register number IN is not an inbound register. */ | |
1030 | /* #define OUTGOING_REGNO(IN) */ | |
1031 | ||
1032 | \f | |
1033 | /* Order of allocation of registers */ | |
1034 | ||
1035 | /* If defined, an initializer for a vector of integers, containing the numbers | |
1036 | of hard registers in the order in which GNU CC should prefer to use them | |
1037 | (from most preferred to least). | |
1038 | ||
1039 | If this macro is not defined, registers are used lowest numbered first (all | |
1040 | else being equal). | |
1041 | ||
1042 | One use of this macro is on machines where the highest numbered registers | |
1043 | must always be saved and the save-multiple-registers instruction supports | |
1044 | only sequences of consecutive registers. On such machines, define | |
1045 | `REG_ALLOC_ORDER' to be an initializer that lists the highest numbered | |
1046 | allocatable register first. */ | |
da6e254e | 1047 | #define REG_ALLOC_ORDER { 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 10, 11, 12, 13, 14, 15, 16 } |
4b58290f GK |
1048 | |
1049 | /* A C statement (sans semicolon) to choose the order in which to allocate hard | |
1050 | registers for pseudo-registers local to a basic block. | |
1051 | ||
1052 | Store the desired register order in the array `reg_alloc_order'. Element 0 | |
1053 | should be the register to allocate first; element 1, the next register; and | |
1054 | so on. | |
1055 | ||
1056 | The macro body should not assume anything about the contents of | |
1057 | `reg_alloc_order' before execution of the macro. | |
1058 | ||
1059 | On most machines, it is not necessary to define this macro. */ | |
1060 | /* #define ORDER_REGS_FOR_LOCAL_ALLOC */ | |
1061 | ||
1062 | \f | |
1063 | /* How Values Fit in Registers */ | |
1064 | ||
1065 | /* A C expression for the number of consecutive hard registers, starting at | |
1066 | register number REGNO, required to hold a value of mode MODE. | |
1067 | ||
1068 | On a machine where all registers are exactly one word, a suitable definition | |
1069 | of this macro is | |
1070 | ||
1071 | #define HARD_REGNO_NREGS(REGNO, MODE) \ | |
1072 | ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \ | |
1073 | / UNITS_PER_WORD)) */ | |
1074 | #define HARD_REGNO_NREGS(REGNO, MODE) \ | |
1075 | ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) | |
1076 | ||
1077 | /* A C expression that is nonzero if it is permissible to store a value of mode | |
1078 | MODE in hard register number REGNO (or in several registers starting with | |
1079 | that one). For a machine where all registers are equivalent, a suitable | |
1080 | definition is | |
1081 | ||
1082 | #define HARD_REGNO_MODE_OK(REGNO, MODE) 1 | |
1083 | ||
1084 | It is not necessary for this macro to check for the numbers of fixed | |
1085 | registers, because the allocation mechanism considers them to be always | |
1086 | occupied. | |
1087 | ||
1088 | On some machines, double-precision values must be kept in even/odd register | |
1089 | pairs. The way to implement that is to define this macro to reject odd | |
1090 | register numbers for such modes. | |
1091 | ||
1092 | The minimum requirement for a mode to be OK in a register is that the | |
1093 | `movMODE' instruction pattern support moves between the register and any | |
1094 | other hard register for which the mode is OK; and that moving a value into | |
1095 | the register and back out not alter it. | |
1096 | ||
1097 | Since the same instruction used to move `SImode' will work for all narrower | |
1098 | integer modes, it is not necessary on any machine for `HARD_REGNO_MODE_OK' | |
1099 | to distinguish between these modes, provided you define patterns `movhi', | |
1100 | etc., to take advantage of this. This is useful because of the interaction | |
1101 | between `HARD_REGNO_MODE_OK' and `MODES_TIEABLE_P'; it is very desirable for | |
1102 | all integer modes to be tieable. | |
1103 | ||
1104 | Many machines have special registers for floating point arithmetic. Often | |
1105 | people assume that floating point machine modes are allowed only in floating | |
1106 | point registers. This is not true. Any registers that can hold integers | |
1107 | can safely *hold* a floating point machine mode, whether or not floating | |
1108 | arithmetic can be done on it in those registers. Integer move instructions | |
1109 | can be used to move the values. | |
1110 | ||
1111 | On some machines, though, the converse is true: fixed-point machine modes | |
1112 | may not go in floating registers. This is true if the floating registers | |
1113 | normalize any value stored in them, because storing a non-floating value | |
1114 | there would garble it. In this case, `HARD_REGNO_MODE_OK' should reject | |
1115 | fixed-point machine modes in floating registers. But if the floating | |
1116 | registers do not automatically normalize, if you can store any bit pattern | |
1117 | in one and retrieve it unchanged without a trap, then any machine mode may | |
1118 | go in a floating register, so you can define this macro to say so. | |
1119 | ||
1120 | The primary significance of special floating registers is rather that they | |
1121 | are the registers acceptable in floating point arithmetic instructions. | |
1122 | However, this is of no concern to `HARD_REGNO_MODE_OK'. You handle it by | |
1123 | writing the proper constraints for those instructions. | |
1124 | ||
1125 | On some machines, the floating registers are especially slow to access, so | |
1126 | that it is better to store a value in a stack frame than in such a register | |
1127 | if floating point arithmetic is not being done. As long as the floating | |
1128 | registers are not in class `GENERAL_REGS', they will not be used unless some | |
1129 | pattern's constraint asks for one. */ | |
1130 | #define HARD_REGNO_MODE_OK(REGNO, MODE) ((REGNO) != 16 || (MODE) == BImode) | |
1131 | ||
1132 | /* A C expression that is nonzero if it is desirable to choose register | |
1133 | allocation so as to avoid move instructions between a value of mode MODE1 | |
1134 | and a value of mode MODE2. | |
1135 | ||
1136 | If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)' are | |
1137 | ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)' must be | |
1138 | zero. */ | |
1139 | #define MODES_TIEABLE_P(MODE1, MODE2) ((MODE1) != BImode && (MODE2) != BImode) | |
1140 | ||
1141 | /* Define this macro if the compiler should avoid copies to/from CCmode | |
1142 | registers. You should only define this macro if support fo copying to/from | |
1143 | CCmode is incomplete. */ | |
1144 | /* #define AVOID_CCMODE_COPIES */ | |
1145 | ||
1146 | \f | |
1147 | /* Handling Leaf Functions */ | |
1148 | ||
1149 | /* A C initializer for a vector, indexed by hard register number, which | |
1150 | contains 1 for a register that is allowable in a candidate for leaf function | |
1151 | treatment. | |
1152 | ||
1153 | If leaf function treatment involves renumbering the registers, then the | |
1154 | registers marked here should be the ones before renumbering--those that GNU | |
1155 | CC would ordinarily allocate. The registers which will actually be used in | |
1156 | the assembler code, after renumbering, should not be marked with 1 in this | |
1157 | vector. | |
1158 | ||
1159 | Define this macro only if the target machine offers a way to optimize the | |
1160 | treatment of leaf functions. */ | |
1161 | /* #define LEAF_REGISTERS */ | |
1162 | ||
1163 | /* A C expression whose value is the register number to which REGNO should be | |
1164 | renumbered, when a function is treated as a leaf function. | |
1165 | ||
1166 | If REGNO is a register number which should not appear in a leaf function | |
1167 | before renumbering, then the expression should yield -1, which will cause | |
1168 | the compiler to abort. | |
1169 | ||
1170 | Define this macro only if the target machine offers a way to optimize the | |
1171 | treatment of leaf functions, and registers need to be renumbered to do this. */ | |
1172 | /* #define LEAF_REG_REMAP(REGNO) */ | |
1173 | ||
1174 | \f | |
1175 | /* Registers That Form a Stack. */ | |
1176 | ||
1177 | /* Define this if the machine has any stack-like registers. */ | |
1178 | /* #define STACK_REGS */ | |
1179 | ||
1180 | /* The number of the first stack-like register. This one is the top | |
1181 | of the stack. */ | |
1182 | /* #define FIRST_STACK_REG */ | |
1183 | ||
1184 | /* The number of the last stack-like register. This one is the | |
1185 | bottom of the stack. */ | |
1186 | /* #define LAST_STACK_REG */ | |
1187 | ||
1188 | \f | |
1189 | /* Register Classes */ | |
1190 | ||
1191 | /* An enumeral type that must be defined with all the register class names as | |
1192 | enumeral values. `NO_REGS' must be first. `ALL_REGS' must be the last | |
1193 | register class, followed by one more enumeral value, `LIM_REG_CLASSES', | |
1194 | which is not a register class but rather tells how many classes there are. | |
1195 | ||
1196 | Each register class has a number, which is the value of casting the class | |
1197 | name to type `int'. The number serves as an index in many of the tables | |
1198 | described below. */ | |
1199 | enum reg_class | |
1200 | { | |
1201 | NO_REGS, | |
1202 | R0_REGS, | |
1203 | R1_REGS, | |
1204 | TWO_REGS, | |
1205 | R2_REGS, | |
1206 | EIGHT_REGS, | |
1207 | R8_REGS, | |
da6e254e | 1208 | ICALL_REGS, |
4b58290f GK |
1209 | GENERAL_REGS, |
1210 | CARRY_REGS, | |
1211 | ALL_REGS, | |
1212 | LIM_REG_CLASSES | |
1213 | }; | |
1214 | ||
1215 | /* The number of distinct register classes, defined as follows: | |
1216 | ||
1217 | #define N_REG_CLASSES (int) LIM_REG_CLASSES */ | |
1218 | #define N_REG_CLASSES ((int) LIM_REG_CLASSES) | |
1219 | ||
1220 | /* An initializer containing the names of the register classes as C string | |
1221 | constants. These names are used in writing some of the debugging dumps. */ | |
1222 | #define REG_CLASS_NAMES \ | |
1223 | { \ | |
1224 | "NO_REGS", \ | |
1225 | "R0_REGS", \ | |
1226 | "R1_REGS", \ | |
1227 | "TWO_REGS", \ | |
1228 | "R2_REGS", \ | |
1229 | "EIGHT_REGS", \ | |
1230 | "R8_REGS", \ | |
da6e254e | 1231 | "ICALL_REGS", \ |
4b58290f GK |
1232 | "GENERAL_REGS", \ |
1233 | "CARRY_REGS", \ | |
1234 | "ALL_REGS" \ | |
1235 | } | |
1236 | ||
1237 | /* An initializer containing the contents of the register classes, as integers | |
1238 | which are bit masks. The Nth integer specifies the contents of class N. | |
1239 | The way the integer MASK is interpreted is that register R is in the class | |
1240 | if `MASK & (1 << R)' is 1. | |
1241 | ||
1242 | When the machine has more than 32 registers, an integer does not suffice. | |
1243 | Then the integers are replaced by sub-initializers, braced groupings | |
1244 | containing several integers. Each sub-initializer must be suitable as an | |
1245 | initializer for the type `HARD_REG_SET' which is defined in | |
1246 | `hard-reg-set.h'. */ | |
1247 | #define REG_CLASS_CONTENTS \ | |
1248 | { \ | |
1249 | 0x00000, \ | |
1250 | 0x00001, \ | |
1251 | 0x00002, \ | |
1252 | 0x00003, \ | |
1253 | 0x00004, \ | |
1254 | 0x000FF, \ | |
1255 | 0x00100, \ | |
da6e254e | 1256 | 0x00300, \ |
4b58290f GK |
1257 | 0x6FFFF, \ |
1258 | 0x10000, \ | |
1259 | (1 << FIRST_PSEUDO_REGISTER) - 1 \ | |
1260 | } | |
1261 | ||
1262 | /* A C expression whose value is a register class containing hard register | |
1263 | REGNO. In general there is more than one such class; choose a class which | |
1264 | is "minimal", meaning that no smaller class also contains the register. */ | |
1265 | #define REGNO_REG_CLASS(REGNO) \ | |
1266 | ((REGNO) == 0 ? R0_REGS \ | |
1267 | : (REGNO) == 1 ? R1_REGS \ | |
1268 | : (REGNO) == 2 ? R2_REGS \ | |
1269 | : (REGNO) < 8 ? EIGHT_REGS \ | |
1270 | : (REGNO) == 8 ? R8_REGS \ | |
1271 | : (REGNO) == 16 ? CARRY_REGS \ | |
1272 | : (REGNO) <= 18 ? GENERAL_REGS \ | |
1273 | : ALL_REGS) | |
1274 | ||
1275 | /* A macro whose definition is the name of the class to which a valid base | |
1276 | register must belong. A base register is one used in an address which is | |
1277 | the register value plus a displacement. */ | |
1278 | #define BASE_REG_CLASS GENERAL_REGS | |
1279 | ||
1280 | /* A macro whose definition is the name of the class to which a valid index | |
1281 | register must belong. An index register is one used in an address where its | |
1282 | value is either multiplied by a scale factor or added to another register | |
1283 | (as well as added to a displacement). */ | |
1284 | #define INDEX_REG_CLASS GENERAL_REGS | |
1285 | ||
1286 | /* A C expression which defines the machine-dependent operand constraint | |
1287 | letters for register classes. If CHAR is such a letter, the value should be | |
1288 | the register class corresponding to it. Otherwise, the value should be | |
1289 | `NO_REGS'. The register letter `r', corresponding to class `GENERAL_REGS', | |
1290 | will not be passed to this macro; you do not need to handle it. | |
1291 | ||
1292 | The following letters are unavailable, due to being used as | |
1293 | constraints: | |
1294 | '0'..'9' | |
1295 | '<', '>' | |
1296 | 'E', 'F', 'G', 'H' | |
1297 | 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' | |
1298 | 'Q', 'R', 'S', 'T', 'U' | |
1299 | 'V', 'X' | |
1300 | 'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */ | |
1301 | ||
1302 | #define REG_CLASS_FROM_LETTER(CHAR) \ | |
1303 | ( (CHAR) == 'a' ? R0_REGS \ | |
1304 | : (CHAR) == 'b' ? R1_REGS \ | |
1305 | : (CHAR) == 'c' ? R2_REGS \ | |
1853547e | 1306 | : (CHAR) == 'd' ? R8_REGS \ |
4b58290f | 1307 | : (CHAR) == 'e' ? EIGHT_REGS \ |
1853547e | 1308 | : (CHAR) == 't' ? TWO_REGS \ |
4b58290f | 1309 | : (CHAR) == 'y' ? CARRY_REGS \ |
da6e254e | 1310 | : (CHAR) == 'z' ? ICALL_REGS \ |
4b58290f GK |
1311 | : NO_REGS) |
1312 | ||
1313 | /* A C expression which is nonzero if register number NUM is suitable for use | |
1314 | as a base register in operand addresses. It may be either a suitable hard | |
1315 | register or a pseudo register that has been allocated such a hard register. */ | |
1316 | #define REGNO_OK_FOR_BASE_P(NUM) 1 | |
1317 | ||
1318 | /* A C expression which is nonzero if register number NUM is suitable for use | |
1319 | as an index register in operand addresses. It may be either a suitable hard | |
1320 | register or a pseudo register that has been allocated such a hard register. | |
1321 | ||
1322 | The difference between an index register and a base register is that the | |
1323 | index register may be scaled. If an address involves the sum of two | |
1324 | registers, neither one of them scaled, then either one may be labeled the | |
1325 | "base" and the other the "index"; but whichever labeling is used must fit | |
1326 | the machine's constraints of which registers may serve in each capacity. | |
1327 | The compiler will try both labelings, looking for one that is valid, and | |
1328 | will reload one or both registers only if neither labeling works. */ | |
1329 | #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM) | |
1330 | ||
1331 | /* A C expression that places additional restrictions on the register class to | |
1332 | use when it is necessary to copy value X into a register in class CLASS. | |
1333 | The value is a register class; perhaps CLASS, or perhaps another, smaller | |
1334 | class. On many machines, the following definition is safe: | |
1335 | ||
1336 | #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS | |
1337 | ||
1338 | Sometimes returning a more restrictive class makes better code. For | |
1339 | example, on the 68000, when X is an integer constant that is in range for a | |
1340 | `moveq' instruction, the value of this macro is always `DATA_REGS' as long | |
1341 | as CLASS includes the data registers. Requiring a data register guarantees | |
1342 | that a `moveq' will be used. | |
1343 | ||
1344 | If X is a `const_double', by returning `NO_REGS' you can force X into a | |
1345 | memory constant. This is useful on certain machines where immediate | |
1346 | floating values cannot be loaded into certain kinds of registers. | |
1347 | ||
1348 | This declaration must be present. */ | |
1349 | #define PREFERRED_RELOAD_CLASS(X, CLASS) \ | |
c6243b4c | 1350 | xstormy16_preferred_reload_class (X, CLASS) |
4b58290f GK |
1351 | |
1352 | /* Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of input | |
1353 | reloads. If you don't define this macro, the default is to use CLASS, | |
1354 | unchanged. */ | |
1355 | #define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \ | |
c6243b4c | 1356 | xstormy16_preferred_reload_class (X, CLASS) |
4b58290f GK |
1357 | |
1358 | /* A C expression that places additional restrictions on the register class to | |
1359 | use when it is necessary to be able to hold a value of mode MODE in a reload | |
1360 | register for which class CLASS would ordinarily be used. | |
1361 | ||
1362 | Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when there are | |
1363 | certain modes that simply can't go in certain reload classes. | |
1364 | ||
1365 | The value is a register class; perhaps CLASS, or perhaps another, smaller | |
1366 | class. | |
1367 | ||
1368 | Don't define this macro unless the target machine has limitations which | |
1369 | require the macro to do something nontrivial. */ | |
1370 | /* #define LIMIT_RELOAD_CLASS(MODE, CLASS) */ | |
1371 | ||
1372 | /* Many machines have some registers that cannot be copied directly to or from | |
1373 | memory or even from other types of registers. An example is the `MQ' | |
1374 | register, which on most machines, can only be copied to or from general | |
1375 | registers, but not memory. Some machines allow copying all registers to and | |
1376 | from memory, but require a scratch register for stores to some memory | |
1377 | locations (e.g., those with symbolic address on the RT, and those with | |
1378 | certain symbolic address on the Sparc when compiling PIC). In some cases, | |
1379 | both an intermediate and a scratch register are required. | |
1380 | ||
1381 | You should define these macros to indicate to the reload phase that it may | |
1382 | need to allocate at least one register for a reload in addition to the | |
1383 | register to contain the data. Specifically, if copying X to a register | |
1384 | CLASS in MODE requires an intermediate register, you should define | |
1385 | `SECONDARY_INPUT_RELOAD_CLASS' to return the largest register class all of | |
1386 | whose registers can be used as intermediate registers or scratch registers. | |
1387 | ||
1388 | If copying a register CLASS in MODE to X requires an intermediate or scratch | |
1389 | register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be defined to return the | |
1390 | largest register class required. If the requirements for input and output | |
1391 | reloads are the same, the macro `SECONDARY_RELOAD_CLASS' should be used | |
1392 | instead of defining both macros identically. | |
1393 | ||
1394 | The values returned by these macros are often `GENERAL_REGS'. Return | |
1395 | `NO_REGS' if no spare register is needed; i.e., if X can be directly copied | |
1396 | to or from a register of CLASS in MODE without requiring a scratch register. | |
1397 | Do not define this macro if it would always return `NO_REGS'. | |
1398 | ||
1399 | If a scratch register is required (either with or without an intermediate | |
1400 | register), you should define patterns for `reload_inM' or `reload_outM', as | |
1401 | required.. These patterns, which will normally be implemented with a | |
1402 | `define_expand', should be similar to the `movM' patterns, except that | |
1403 | operand 2 is the scratch register. | |
1404 | ||
1405 | Define constraints for the reload register and scratch register that contain | |
1406 | a single register class. If the original reload register (whose class is | |
1407 | CLASS) can meet the constraint given in the pattern, the value returned by | |
1408 | these macros is used for the class of the scratch register. Otherwise, two | |
1409 | additional reload registers are required. Their classes are obtained from | |
1410 | the constraints in the insn pattern. | |
1411 | ||
1412 | X might be a pseudo-register or a `subreg' of a pseudo-register, which could | |
1413 | either be in a hard register or in memory. Use `true_regnum' to find out; | |
1414 | it will return -1 if the pseudo is in memory and the hard register number if | |
1415 | it is in a register. | |
1416 | ||
1417 | These macros should not be used in the case where a particular class of | |
1418 | registers can only be copied to memory and not to another class of | |
1419 | registers. In that case, secondary reload registers are not needed and | |
1420 | would not be helpful. Instead, a stack location must be used to perform the | |
1421 | copy and the `movM' pattern should use memory as a intermediate storage. | |
1422 | This case often occurs between floating-point and general registers. */ | |
1423 | ||
1424 | /* This chip has the interesting property that only the first eight | |
1425 | registers can be moved to/from memory. */ | |
1426 | #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ | |
c6243b4c | 1427 | xstormy16_secondary_reload_class (CLASS, MODE, X) |
4b58290f GK |
1428 | |
1429 | /* #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) */ | |
1430 | /* #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) */ | |
1431 | ||
1432 | /* Certain machines have the property that some registers cannot be copied to | |
1433 | some other registers without using memory. Define this macro on those | |
1434 | machines to be a C expression that is non-zero if objects of mode M in | |
1435 | registers of CLASS1 can only be copied to registers of class CLASS2 by | |
1436 | storing a register of CLASS1 into memory and loading that memory location | |
1437 | into a register of CLASS2. | |
1438 | ||
1439 | Do not define this macro if its value would always be zero. */ | |
1440 | /* #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, M) */ | |
1441 | ||
1442 | /* Normally when `SECONDARY_MEMORY_NEEDED' is defined, the compiler allocates a | |
1443 | stack slot for a memory location needed for register copies. If this macro | |
1444 | is defined, the compiler instead uses the memory location defined by this | |
1445 | macro. | |
1446 | ||
1447 | Do not define this macro if you do not define | |
1448 | `SECONDARY_MEMORY_NEEDED'. */ | |
1449 | /* #define SECONDARY_MEMORY_NEEDED_RTX(MODE) */ | |
1450 | ||
1451 | /* When the compiler needs a secondary memory location to copy between two | |
1452 | registers of mode MODE, it normally allocates sufficient memory to hold a | |
1453 | quantity of `BITS_PER_WORD' bits and performs the store and load operations | |
1454 | in a mode that many bits wide and whose class is the same as that of MODE. | |
1455 | ||
1456 | This is right thing to do on most machines because it ensures that all bits | |
1457 | of the register are copied and prevents accesses to the registers in a | |
1458 | narrower mode, which some machines prohibit for floating-point registers. | |
1459 | ||
1460 | However, this default behavior is not correct on some machines, such as the | |
1461 | DEC Alpha, that store short integers in floating-point registers differently | |
1462 | than in integer registers. On those machines, the default widening will not | |
1463 | work correctly and you must define this macro to suppress that widening in | |
1464 | some cases. See the file `alpha.h' for details. | |
1465 | ||
1466 | Do not define this macro if you do not define `SECONDARY_MEMORY_NEEDED' or | |
1467 | if widening MODE to a mode that is `BITS_PER_WORD' bits wide is correct for | |
1468 | your machine. */ | |
1469 | /* #define SECONDARY_MEMORY_NEEDED_MODE(MODE) */ | |
1470 | ||
1471 | /* Normally the compiler avoids choosing registers that have been explicitly | |
1472 | mentioned in the rtl as spill registers (these registers are normally those | |
1473 | used to pass parameters and return values). However, some machines have so | |
1474 | few registers of certain classes that there would not be enough registers to | |
1475 | use as spill registers if this were done. | |
1476 | ||
1477 | Define `SMALL_REGISTER_CLASSES' to be an expression with a non-zero value on | |
1478 | these machines. When this macro has a non-zero value, the compiler allows | |
1479 | registers explicitly used in the rtl to be used as spill registers but | |
1480 | avoids extending the lifetime of these registers. | |
1481 | ||
1482 | It is always safe to define this macro with a non-zero value, but if you | |
1483 | unnecessarily define it, you will reduce the amount of optimizations that | |
1484 | can be performed in some cases. If you do not define this macro with a | |
1485 | non-zero value when it is required, the compiler will run out of spill | |
1486 | registers and print a fatal error message. For most machines, you should | |
1487 | not define this macro at all. */ | |
1488 | /* #define SMALL_REGISTER_CLASSES */ | |
1489 | ||
1490 | /* A C expression whose value is nonzero if pseudos that have been assigned to | |
1491 | registers of class CLASS would likely be spilled because registers of CLASS | |
1492 | are needed for spill registers. | |
1493 | ||
1494 | The default value of this macro returns 1 if CLASS has exactly one register | |
1495 | and zero otherwise. On most machines, this default should be used. Only | |
1496 | define this macro to some other expression if pseudo allocated by | |
1497 | `local-alloc.c' end up in memory because their hard registers were needed | |
1498 | for spill registers. If this macro returns nonzero for those classes, those | |
1499 | pseudos will only be allocated by `global.c', which knows how to reallocate | |
1500 | the pseudo to another register. If there would not be another register | |
1501 | available for reallocation, you should not change the definition of this | |
1502 | macro since the only effect of such a definition would be to slow down | |
1503 | register allocation. */ | |
1504 | /* #define CLASS_LIKELY_SPILLED_P(CLASS) */ | |
1505 | ||
1506 | /* A C expression for the maximum number of consecutive registers of | |
1507 | class CLASS needed to hold a value of mode MODE. | |
1508 | ||
1509 | This is closely related to the macro `HARD_REGNO_NREGS'. In fact, the value | |
1510 | of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be the maximum value of | |
1511 | `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO values in the class CLASS. | |
1512 | ||
1513 | This macro helps control the handling of multiple-word values in | |
1514 | the reload pass. | |
1515 | ||
1516 | This declaration is required. */ | |
1517 | #define CLASS_MAX_NREGS(CLASS, MODE) \ | |
1518 | ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) | |
1519 | ||
1520 | /* If defined, a C expression for a class that contains registers which the | |
1521 | compiler must always access in a mode that is the same size as the mode in | |
1522 | which it loaded the register. | |
1523 | ||
1524 | For the example, loading 32-bit integer or floating-point objects into | |
1525 | floating-point registers on the Alpha extends them to 64-bits. Therefore | |
1526 | loading a 64-bit object and then storing it as a 32-bit object does not | |
1527 | store the low-order 32-bits, as would be the case for a normal register. | |
1528 | Therefore, `alpha.h' defines this macro as `FLOAT_REGS'. */ | |
1529 | /* #define CLASS_CANNOT_CHANGE_SIZE */ | |
1530 | ||
1531 | /* A C expression that defines the machine-dependent operand constraint letters | |
1532 | (`I', `J', `K', .. 'P') that specify particular ranges of integer values. | |
1533 | If C is one of those letters, the expression should check that VALUE, an | |
1534 | integer, is in the appropriate range and return 1 if so, 0 otherwise. If C | |
1535 | is not one of those letters, the value should be 0 regardless of VALUE. */ | |
1536 | #define CONST_OK_FOR_LETTER_P(VALUE, C) \ | |
1537 | ( (C) == 'I' ? (VALUE) >= 0 && (VALUE) <= 3 \ | |
1538 | : (C) == 'J' ? exact_log2 (VALUE) != -1 \ | |
1539 | : (C) == 'K' ? exact_log2 (~(VALUE)) != -1 \ | |
1540 | : (C) == 'L' ? (VALUE) >= 0 && (VALUE) <= 255 \ | |
1541 | : (C) == 'M' ? (VALUE) >= -255 && (VALUE) <= 0 \ | |
1542 | : (C) == 'N' ? (VALUE) >= -3 && (VALUE) <= 0 \ | |
1543 | : (C) == 'O' ? (VALUE) >= 1 && (VALUE) <= 4 \ | |
1544 | : (C) == 'P' ? (VALUE) >= -4 && (VALUE) <= -1 \ | |
1545 | : 0 ) | |
1546 | ||
1547 | /* A C expression that defines the machine-dependent operand constraint letters | |
1548 | (`G', `H') that specify particular ranges of `const_double' values. | |
1549 | ||
1550 | If C is one of those letters, the expression should check that VALUE, an RTX | |
1551 | of code `const_double', is in the appropriate range and return 1 if so, 0 | |
1552 | otherwise. If C is not one of those letters, the value should be 0 | |
1553 | regardless of VALUE. | |
1554 | ||
1555 | `const_double' is used for all floating-point constants and for `DImode' | |
1556 | fixed-point constants. A given letter can accept either or both kinds of | |
1557 | values. It can use `GET_MODE' to distinguish between these kinds. */ | |
1558 | #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0 | |
1559 | ||
1560 | /* A C expression that defines the optional machine-dependent constraint | |
1561 | letters (`Q', `R', `S', `T', `U') that can be used to segregate specific | |
1562 | types of operands, usually memory references, for the target machine. | |
1563 | Normally this macro will not be defined. If it is required for a particular | |
1564 | target machine, it should return 1 if VALUE corresponds to the operand type | |
1565 | represented by the constraint letter C. If C is not defined as an extra | |
1566 | constraint, the value returned should be 0 regardless of VALUE. | |
1567 | ||
1568 | For example, on the ROMP, load instructions cannot have their output in r0 | |
1569 | if the memory reference contains a symbolic address. Constraint letter `Q' | |
1570 | is defined as representing a memory address that does *not* contain a | |
1571 | symbolic address. An alternative is specified with a `Q' constraint on the | |
1572 | input and `r' on the output. The next alternative specifies `m' on the | |
1573 | input and a register class that does not include r0 on the output. */ | |
1574 | #define EXTRA_CONSTRAINT(VALUE, C) \ | |
c6243b4c | 1575 | xstormy16_extra_constraint_p (VALUE, C) |
4b58290f GK |
1576 | |
1577 | \f | |
1578 | /* Basic Stack Layout */ | |
1579 | ||
1580 | /* Define this macro if pushing a word onto the stack moves the stack pointer | |
1581 | to a smaller address. | |
1582 | ||
1583 | When we say, "define this macro if ...," it means that the compiler checks | |
1584 | this macro only with `#ifdef' so the precise definition used does not | |
1585 | matter. */ | |
1586 | /* #define STACK_GROWS_DOWNWARD */ | |
1587 | ||
1588 | /* We want to use post-increment instructions to push things on the stack, | |
1589 | because we don't have any pre-increment ones. */ | |
1590 | #define STACK_PUSH_CODE POST_INC | |
1591 | ||
1592 | /* Define this macro if the addresses of local variable slots are at negative | |
1593 | offsets from the frame pointer. */ | |
1594 | /* #define FRAME_GROWS_DOWNWARD */ | |
1595 | ||
1596 | /* Define this macro if successive arguments to a function occupy decreasing | |
1597 | addresses on the stack. */ | |
1598 | #define ARGS_GROW_DOWNWARD 1 | |
1599 | ||
1600 | /* Offset from the frame pointer to the first local variable slot to be | |
1601 | allocated. | |
1602 | ||
1603 | If `FRAME_GROWS_DOWNWARD', find the next slot's offset by | |
1604 | subtracting the first slot's length from `STARTING_FRAME_OFFSET'. | |
1605 | Otherwise, it is found by adding the length of the first slot to | |
1606 | the value `STARTING_FRAME_OFFSET'. */ | |
1607 | #define STARTING_FRAME_OFFSET 0 | |
1608 | ||
1609 | /* Offset from the stack pointer register to the first location at which | |
1610 | outgoing arguments are placed. If not specified, the default value of zero | |
1611 | is used. This is the proper value for most machines. | |
1612 | ||
1613 | If `ARGS_GROW_DOWNWARD', this is the offset to the location above the first | |
1614 | location at which outgoing arguments are placed. */ | |
1615 | /* #define STACK_POINTER_OFFSET */ | |
1616 | ||
1617 | /* Offset from the argument pointer register to the first argument's address. | |
1618 | On some machines it may depend on the data type of the function. | |
1619 | ||
1620 | If `ARGS_GROW_DOWNWARD', this is the offset to the location above the first | |
1621 | argument's address. */ | |
1622 | #define FIRST_PARM_OFFSET(FUNDECL) 0 | |
1623 | ||
1624 | /* Offset from the stack pointer register to an item dynamically allocated on | |
1625 | the stack, e.g., by `alloca'. | |
1626 | ||
1627 | The default value for this macro is `STACK_POINTER_OFFSET' plus the length | |
1628 | of the outgoing arguments. The default is correct for most machines. See | |
1629 | `function.c' for details. */ | |
1630 | /* #define STACK_DYNAMIC_OFFSET(FUNDECL) */ | |
1631 | ||
1632 | /* A C expression whose value is RTL representing the address in a stack frame | |
1633 | where the pointer to the caller's frame is stored. Assume that FRAMEADDR is | |
1634 | an RTL expression for the address of the stack frame itself. | |
1635 | ||
1636 | If you don't define this macro, the default is to return the value of | |
1637 | FRAMEADDR--that is, the stack frame address is also the address of the stack | |
1638 | word that points to the previous frame. */ | |
1639 | /* #define DYNAMIC_CHAIN_ADDRESS(FRAMEADDR) */ | |
1640 | ||
1641 | /* If defined, a C expression that produces the machine-specific code to setup | |
1642 | the stack so that arbitrary frames can be accessed. For example, on the | |
1643 | Sparc, we must flush all of the register windows to the stack before we can | |
1644 | access arbitrary stack frames. This macro will seldom need to be defined. */ | |
1645 | /* #define SETUP_FRAME_ADDRESSES() */ | |
1646 | ||
1647 | /* A C expression whose value is RTL representing the value of the return | |
1648 | address for the frame COUNT steps up from the current frame, after the | |
1649 | prologue. FRAMEADDR is the frame pointer of the COUNT frame, or the frame | |
1650 | pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' is | |
1651 | defined. | |
1652 | ||
1653 | The value of the expression must always be the correct address when COUNT is | |
1654 | zero, but may be `NULL_RTX' if there is not way to determine the return | |
1655 | address of other frames. */ | |
1656 | #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \ | |
1657 | ((COUNT) == 0 \ | |
1658 | ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \ | |
1659 | : NULL_RTX) | |
1660 | ||
1661 | /* Define this if the return address of a particular stack frame is | |
1662 | accessed from the frame pointer of the previous stack frame. */ | |
1663 | /* #define RETURN_ADDR_IN_PREVIOUS_FRAME */ | |
1664 | ||
1665 | /* A C expression whose value is RTL representing the location of the incoming | |
1666 | return address at the beginning of any function, before the prologue. This | |
1667 | RTL is either a `REG', indicating that the return value is saved in `REG', | |
1668 | or a `MEM' representing a location in the stack. | |
1669 | ||
1670 | You only need to define this macro if you want to support call frame | |
1671 | debugging information like that provided by DWARF 2. */ | |
1672 | #define INCOMING_RETURN_ADDR_RTX \ | |
1673 | gen_rtx_MEM (SImode, gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (-4))) | |
1674 | ||
1675 | /* A C expression whose value is an integer giving the offset, in bytes, from | |
1676 | the value of the stack pointer register to the top of the stack frame at the | |
1677 | beginning of any function, before the prologue. The top of the frame is | |
1678 | defined to be the value of the stack pointer in the previous frame, just | |
1679 | before the call instruction. | |
1680 | ||
1681 | You only need to define this macro if you want to support call frame | |
1682 | debugging information like that provided by DWARF 2. */ | |
c6243b4c | 1683 | #define INCOMING_FRAME_SP_OFFSET (xstormy16_interrupt_function_p () ? 6 : 4) |
4b58290f GK |
1684 | |
1685 | \f | |
1686 | /* Stack Checking. */ | |
1687 | ||
1688 | /* A nonzero value if stack checking is done by the configuration files in a | |
1689 | machine-dependent manner. You should define this macro if stack checking is | |
1690 | require by the ABI of your machine or if you would like to have to stack | |
1691 | checking in some more efficient way than GNU CC's portable approach. The | |
1692 | default value of this macro is zero. */ | |
1693 | /* #define STACK_CHECK_BUILTIN */ | |
1694 | ||
1695 | /* An integer representing the interval at which GNU CC must generate stack | |
1696 | probe instructions. You will normally define this macro to be no larger | |
1697 | than the size of the "guard pages" at the end of a stack area. The default | |
1698 | value of 4096 is suitable for most systems. */ | |
1699 | /* #define STACK_CHECK_PROBE_INTERVAL */ | |
1700 | ||
1701 | /* A integer which is nonzero if GNU CC should perform the stack probe as a | |
1702 | load instruction and zero if GNU CC should use a store instruction. The | |
1703 | default is zero, which is the most efficient choice on most systems. */ | |
1704 | /* #define STACK_CHECK_PROBE_LOAD */ | |
1705 | ||
1706 | /* The number of bytes of stack needed to recover from a stack overflow, for | |
1707 | languages where such a recovery is supported. The default value of 75 words | |
1708 | should be adequate for most machines. */ | |
1709 | /* #define STACK_CHECK_PROTECT */ | |
1710 | ||
1711 | /* The maximum size of a stack frame, in bytes. GNU CC will generate probe | |
1712 | instructions in non-leaf functions to ensure at least this many bytes of | |
1713 | stack are available. If a stack frame is larger than this size, stack | |
1714 | checking will not be reliable and GNU CC will issue a warning. The default | |
1715 | is chosen so that GNU CC only generates one instruction on most systems. | |
1716 | You should normally not change the default value of this macro. */ | |
1717 | /* #define STACK_CHECK_MAX_FRAME_SIZE */ | |
1718 | ||
1719 | /* GNU CC uses this value to generate the above warning message. It represents | |
1720 | the amount of fixed frame used by a function, not including space for any | |
1721 | callee-saved registers, temporaries and user variables. You need only | |
1722 | specify an upper bound for this amount and will normally use the default of | |
1723 | four words. */ | |
1724 | /* #define STACK_CHECK_FIXED_FRAME_SIZE */ | |
1725 | ||
1726 | /* The maximum size, in bytes, of an object that GNU CC will place in the fixed | |
1727 | area of the stack frame when the user specifies `-fstack-check'. GNU CC | |
1728 | computed the default from the values of the above macros and you will | |
1729 | normally not need to override that default. */ | |
1730 | /* #define STACK_CHECK_MAX_VAR_SIZE */ | |
1731 | ||
1732 | \f | |
1733 | /* Register That Address the Stack Frame. */ | |
1734 | ||
1735 | /* The register number of the stack pointer register, which must also be a | |
1736 | fixed register according to `FIXED_REGISTERS'. On most machines, the | |
1737 | hardware determines which register this is. */ | |
1738 | #define STACK_POINTER_REGNUM 15 | |
1739 | ||
1740 | /* The register number of the frame pointer register, which is used to access | |
1741 | automatic variables in the stack frame. On some machines, the hardware | |
1742 | determines which register this is. On other machines, you can choose any | |
1743 | register you wish for this purpose. */ | |
1744 | #define FRAME_POINTER_REGNUM 17 | |
1745 | ||
1746 | /* On some machines the offset between the frame pointer and starting offset of | |
1747 | the automatic variables is not known until after register allocation has | |
1748 | been done (for example, because the saved registers are between these two | |
1749 | locations). On those machines, define `FRAME_POINTER_REGNUM' the number of | |
1750 | a special, fixed register to be used internally until the offset is known, | |
1751 | and define `HARD_FRAME_POINTER_REGNUM' to be actual the hard register number | |
1752 | used for the frame pointer. | |
1753 | ||
1754 | You should define this macro only in the very rare circumstances when it is | |
1755 | not possible to calculate the offset between the frame pointer and the | |
1756 | automatic variables until after register allocation has been completed. | |
1757 | When this macro is defined, you must also indicate in your definition of | |
1758 | `ELIMINABLE_REGS' how to eliminate `FRAME_POINTER_REGNUM' into either | |
1759 | `HARD_FRAME_POINTER_REGNUM' or `STACK_POINTER_REGNUM'. | |
1760 | ||
1761 | Do not define this macro if it would be the same as `FRAME_POINTER_REGNUM'. */ | |
1762 | #define HARD_FRAME_POINTER_REGNUM 13 | |
1763 | ||
1764 | /* The register number of the arg pointer register, which is used to access the | |
1765 | function's argument list. On some machines, this is the same as the frame | |
1766 | pointer register. On some machines, the hardware determines which register | |
1767 | this is. On other machines, you can choose any register you wish for this | |
1768 | purpose. If this is not the same register as the frame pointer register, | |
1769 | then you must mark it as a fixed register according to `FIXED_REGISTERS', or | |
1770 | arrange to be able to eliminate it. */ | |
1771 | #define ARG_POINTER_REGNUM 18 | |
1772 | ||
1773 | /* The register number of the return address pointer register, which is used to | |
1774 | access the current function's return address from the stack. On some | |
1775 | machines, the return address is not at a fixed offset from the frame pointer | |
1776 | or stack pointer or argument pointer. This register can be defined to point | |
1777 | to the return address on the stack, and then be converted by | |
1778 | `ELIMINABLE_REGS' into either the frame pointer or stack pointer. | |
1779 | ||
1780 | Do not define this macro unless there is no other way to get the return | |
1781 | address from the stack. */ | |
1782 | /* #define RETURN_ADDRESS_POINTER_REGNUM */ | |
1783 | ||
1784 | /* Register numbers used for passing a function's static chain pointer. If | |
1785 | register windows are used, the register number as seen by the called | |
1786 | function is `STATIC_CHAIN_INCOMING_REGNUM', while the register number as | |
1787 | seen by the calling function is `STATIC_CHAIN_REGNUM'. If these registers | |
1788 | are the same, `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. | |
1789 | ||
1790 | The static chain register need not be a fixed register. | |
1791 | ||
1792 | If the static chain is passed in memory, these macros should not be defined; | |
1793 | instead, the next two macros should be defined. */ | |
e2470e1b | 1794 | #define STATIC_CHAIN_REGNUM 1 |
4b58290f GK |
1795 | /* #define STATIC_CHAIN_INCOMING_REGNUM */ |
1796 | ||
1797 | /* If the static chain is passed in memory, these macros provide rtx giving | |
1798 | `mem' expressions that denote where they are stored. `STATIC_CHAIN' and | |
1799 | `STATIC_CHAIN_INCOMING' give the locations as seen by the calling and called | |
1800 | functions, respectively. Often the former will be at an offset from the | |
1801 | stack pointer and the latter at an offset from the frame pointer. | |
1802 | ||
1803 | The variables `stack_pointer_rtx', `frame_pointer_rtx', and | |
1804 | `arg_pointer_rtx' will have been initialized prior to the use of these | |
1805 | macros and should be used to refer to those items. | |
1806 | ||
1807 | If the static chain is passed in a register, the two previous | |
1808 | macros should be defined instead. */ | |
1809 | /* #define STATIC_CHAIN */ | |
1810 | /* #define STATIC_CHAIN_INCOMING */ | |
1811 | ||
1812 | \f | |
1813 | /* Eliminating the Frame Pointer and the Arg Pointer */ | |
1814 | ||
1815 | /* A C expression which is nonzero if a function must have and use a frame | |
1816 | pointer. This expression is evaluated in the reload pass. If its value is | |
1817 | nonzero the function will have a frame pointer. | |
1818 | ||
1819 | The expression can in principle examine the current function and decide | |
1820 | according to the facts, but on most machines the constant 0 or the constant | |
1821 | 1 suffices. Use 0 when the machine allows code to be generated with no | |
1822 | frame pointer, and doing so saves some time or space. Use 1 when there is | |
1823 | no possible advantage to avoiding a frame pointer. | |
1824 | ||
1825 | In certain cases, the compiler does not know how to produce valid code | |
1826 | without a frame pointer. The compiler recognizes those cases and | |
1827 | automatically gives the function a frame pointer regardless of what | |
1828 | `FRAME_POINTER_REQUIRED' says. You don't need to worry about them. | |
1829 | ||
1830 | In a function that does not require a frame pointer, the frame pointer | |
1831 | register can be allocated for ordinary usage, unless you mark it as a fixed | |
1832 | register. See `FIXED_REGISTERS' for more information. */ | |
1833 | #define FRAME_POINTER_REQUIRED 0 | |
1834 | ||
1835 | /* A C statement to store in the variable DEPTH_VAR the difference between the | |
1836 | frame pointer and the stack pointer values immediately after the function | |
1837 | prologue. The value would be computed from information such as the result | |
1838 | of `get_frame_size ()' and the tables of registers `regs_ever_live' and | |
1839 | `call_used_regs'. | |
1840 | ||
1841 | If `ELIMINABLE_REGS' is defined, this macro will be not be used and need not | |
1842 | be defined. Otherwise, it must be defined even if `FRAME_POINTER_REQUIRED' | |
1843 | is defined to always be true; in that case, you may set DEPTH_VAR to | |
1844 | anything. */ | |
1845 | /* #define INITIAL_FRAME_POINTER_OFFSET(DEPTH_VAR) */ | |
1846 | ||
1847 | /* If defined, this macro specifies a table of register pairs used to eliminate | |
1848 | unneeded registers that point into the stack frame. If it is not defined, | |
1849 | the only elimination attempted by the compiler is to replace references to | |
1850 | the frame pointer with references to the stack pointer. | |
1851 | ||
1852 | The definition of this macro is a list of structure initializations, each of | |
1853 | which specifies an original and replacement register. | |
1854 | */ | |
1855 | ||
1856 | #define ELIMINABLE_REGS \ | |
1857 | { \ | |
1858 | {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
1859 | {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ | |
1860 | {ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
1861 | {ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ | |
1862 | } | |
1863 | ||
1864 | /* A C expression that returns non-zero if the compiler is allowed to try to | |
1865 | replace register number FROM with register number TO. This macro need only | |
1866 | be defined if `ELIMINABLE_REGS' is defined, and will usually be the constant | |
1867 | 1, since most of the cases preventing register elimination are things that | |
1868 | the compiler already knows about. */ | |
1869 | ||
1870 | #define CAN_ELIMINATE(FROM, TO) \ | |
1871 | ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM \ | |
1872 | ? ! frame_pointer_needed \ | |
1873 | : 1) | |
1874 | ||
1875 | /* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It specifies the | |
1876 | initial difference between the specified pair of registers. This macro must | |
1877 | be defined if `ELIMINABLE_REGS' is defined. */ | |
1878 | #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ | |
c6243b4c | 1879 | (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO) |
4b58290f GK |
1880 | |
1881 | /* Define this macro if the `longjmp' function restores registers from the | |
1882 | stack frames, rather than from those saved specifically by `setjmp'. | |
1883 | Certain quantities must not be kept in registers across a call to `setjmp' | |
1884 | on such machines. */ | |
1885 | /* #define LONGJMP_RESTORE_FROM_STACK */ | |
1886 | ||
1887 | \f | |
1888 | /* Passing Function Arguments on the Stack */ | |
1889 | ||
1890 | /* Define this macro if an argument declared in a prototype as an integral type | |
1891 | smaller than `int' should actually be passed as an `int'. In addition to | |
1892 | avoiding errors in certain cases of mismatch, it also makes for better code | |
1893 | on certain machines. */ | |
1894 | #define PROMOTE_PROTOTYPES 1 | |
1895 | ||
1896 | /* A C expression that is the number of bytes actually pushed onto the stack | |
1897 | when an instruction attempts to push NPUSHED bytes. | |
1898 | ||
1899 | If the target machine does not have a push instruction, do not define this | |
1900 | macro. That directs GNU CC to use an alternate strategy: to allocate the | |
1901 | entire argument block and then store the arguments into it. | |
1902 | ||
1903 | On some machines, the definition | |
1904 | ||
1905 | #define PUSH_ROUNDING(BYTES) (BYTES) | |
1906 | ||
1907 | will suffice. But on other machines, instructions that appear to push one | |
1908 | byte actually push two bytes in an attempt to maintain alignment. Then the | |
1909 | definition should be | |
1910 | ||
1911 | #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) */ | |
1912 | #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) | |
1913 | ||
1914 | /* If defined, the maximum amount of space required for outgoing arguments will | |
1915 | be computed and placed into the variable | |
1916 | `current_function_outgoing_args_size'. No space will be pushed onto the | |
1917 | stack for each call; instead, the function prologue should increase the | |
1918 | stack frame size by this amount. | |
1919 | ||
1920 | Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is not | |
1921 | proper. */ | |
1922 | /* #define ACCUMULATE_OUTGOING_ARGS */ | |
1923 | ||
1924 | /* Define this macro if functions should assume that stack space has been | |
1925 | allocated for arguments even when their values are passed in registers. | |
1926 | ||
1927 | The value of this macro is the size, in bytes, of the area reserved for | |
1928 | arguments passed in registers for the function represented by FNDECL. | |
1929 | ||
1930 | This space can be allocated by the caller, or be a part of the | |
1931 | machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says | |
1932 | which. */ | |
1933 | /* #define REG_PARM_STACK_SPACE(FNDECL) */ | |
1934 | ||
1935 | /* Define these macros in addition to the one above if functions might allocate | |
1936 | stack space for arguments even when their values are passed in registers. | |
1937 | These should be used when the stack space allocated for arguments in | |
1938 | registers is not a simple constant independent of the function declaration. | |
1939 | ||
1940 | The value of the first macro is the size, in bytes, of the area that we | |
1941 | should initially assume would be reserved for arguments passed in registers. | |
1942 | ||
1943 | The value of the second macro is the actual size, in bytes, of the area that | |
1944 | will be reserved for arguments passed in registers. This takes two | |
1945 | arguments: an integer representing the number of bytes of fixed sized | |
1946 | arguments on the stack, and a tree representing the number of bytes of | |
1947 | variable sized arguments on the stack. | |
1948 | ||
1949 | When these macros are defined, `REG_PARM_STACK_SPACE' will only be called | |
1950 | for libcall functions, the current function, or for a function being called | |
1951 | when it is known that such stack space must be allocated. In each case this | |
1952 | value can be easily computed. | |
1953 | ||
1954 | When deciding whether a called function needs such stack space, and how much | |
1955 | space to reserve, GNU CC uses these two macros instead of | |
1956 | `REG_PARM_STACK_SPACE'. */ | |
1957 | /* #define MAYBE_REG_PARM_STACK_SPACE */ | |
1958 | /* #define FINAL_REG_PARM_STACK_SPACE(CONST_SIZE, VAR_SIZE) */ | |
1959 | ||
1960 | /* Define this if it is the responsibility of the caller to allocate the area | |
1961 | reserved for arguments passed in registers. | |
1962 | ||
1963 | If `ACCUMULATE_OUTGOING_ARGS' is defined, this macro controls whether the | |
1964 | space for these arguments counts in the value of | |
1965 | `current_function_outgoing_args_size'. */ | |
1966 | /* #define OUTGOING_REG_PARM_STACK_SPACE */ | |
1967 | ||
1968 | /* Define this macro if `REG_PARM_STACK_SPACE' is defined, but the stack | |
1969 | parameters don't skip the area specified by it. | |
1970 | ||
1971 | Normally, when a parameter is not passed in registers, it is placed on the | |
1972 | stack beyond the `REG_PARM_STACK_SPACE' area. Defining this macro | |
1973 | suppresses this behavior and causes the parameter to be passed on the stack | |
1974 | in its natural location. */ | |
1975 | /* #define STACK_PARMS_IN_REG_PARM_AREA */ | |
1976 | ||
1977 | /* A C expression that should indicate the number of bytes of its own arguments | |
1978 | that a function pops on returning, or 0 if the function pops no arguments | |
1979 | and the caller must therefore pop them all after the function returns. | |
1980 | ||
1981 | FUNDECL is a C variable whose value is a tree node that describes the | |
1982 | function in question. Normally it is a node of type `FUNCTION_DECL' that | |
1983 | describes the declaration of the function. From this it is possible to | |
91d231cb | 1984 | obtain the DECL_ATTRIBUTES of the function. |
4b58290f GK |
1985 | |
1986 | FUNTYPE is a C variable whose value is a tree node that describes the | |
1987 | function in question. Normally it is a node of type `FUNCTION_TYPE' that | |
1988 | describes the data type of the function. From this it is possible to obtain | |
1989 | the data types of the value and arguments (if known). | |
1990 | ||
1991 | When a call to a library function is being considered, FUNTYPE will contain | |
1992 | an identifier node for the library function. Thus, if you need to | |
1993 | distinguish among various library functions, you can do so by their names. | |
1994 | Note that "library function" in this context means a function used to | |
1995 | perform arithmetic, whose name is known specially in the compiler and was | |
1996 | not mentioned in the C code being compiled. | |
1997 | ||
1998 | STACK-SIZE is the number of bytes of arguments passed on the stack. If a | |
1999 | variable number of bytes is passed, it is zero, and argument popping will | |
2000 | always be the responsibility of the calling function. | |
2001 | ||
2002 | On the Vax, all functions always pop their arguments, so the definition of | |
2003 | this macro is STACK-SIZE. On the 68000, using the standard calling | |
2004 | convention, no functions pop their arguments, so the value of the macro is | |
2005 | always 0 in this case. But an alternative calling convention is available | |
2006 | in which functions that take a fixed number of arguments pop them but other | |
2007 | functions (such as `printf') pop nothing (the caller pops all). When this | |
2008 | convention is in use, FUNTYPE is examined to determine whether a function | |
2009 | takes a fixed number of arguments. */ | |
2010 | #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0 | |
2011 | ||
2012 | \f | |
2013 | /* Function Arguments in Registers */ | |
2014 | ||
da6e254e | 2015 | #define NUM_ARGUMENT_REGISTERS 6 |
4b58290f GK |
2016 | #define FIRST_ARGUMENT_REGISTER 2 |
2017 | ||
c6243b4c | 2018 | #define XSTORMY16_WORD_SIZE(TYPE, MODE) \ |
4b58290f GK |
2019 | ((((TYPE) ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \ |
2020 | + 1) \ | |
2021 | / 2) | |
2022 | ||
2023 | /* A C expression that controls whether a function argument is passed in a | |
2024 | register, and which register. | |
2025 | ||
2026 | The arguments are CUM, of type CUMULATIVE_ARGS, which summarizes | |
2027 | (in a way defined by INIT_CUMULATIVE_ARGS and FUNCTION_ARG_ADVANCE) | |
2028 | all of the previous arguments so far passed in registers; MODE, the | |
2029 | machine mode of the argument; TYPE, the data type of the argument | |
2030 | as a tree node or 0 if that is not known (which happens for C | |
2031 | support library functions); and NAMED, which is 1 for an ordinary | |
2032 | argument and 0 for nameless arguments that correspond to `...' in | |
2033 | the called function's prototype. | |
2034 | ||
2035 | The value of the expression should either be a `reg' RTX for the hard | |
2036 | register in which to pass the argument, or zero to pass the argument on the | |
2037 | stack. | |
2038 | ||
2039 | For machines like the Vax and 68000, where normally all arguments are | |
2040 | pushed, zero suffices as a definition. | |
2041 | ||
2042 | The usual way to make the ANSI library `stdarg.h' work on a machine where | |
2043 | some arguments are usually passed in registers, is to cause nameless | |
2044 | arguments to be passed on the stack instead. This is done by making | |
2045 | `FUNCTION_ARG' return 0 whenever NAMED is 0. | |
2046 | ||
2047 | You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the definition of | |
2048 | this macro to determine if this argument is of a type that must be passed in | |
2049 | the stack. If `REG_PARM_STACK_SPACE' is not defined and `FUNCTION_ARG' | |
2050 | returns non-zero for such an argument, the compiler will abort. If | |
2051 | `REG_PARM_STACK_SPACE' is defined, the argument will be computed in the | |
2052 | stack and then loaded into a register. */ | |
2053 | #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ | |
2054 | ((MODE) == VOIDmode ? const0_rtx \ | |
c6243b4c | 2055 | : (CUM) + XSTORMY16_WORD_SIZE (TYPE, MODE) > NUM_ARGUMENT_REGISTERS ? 0 \ |
4b58290f GK |
2056 | : gen_rtx_REG (MODE, (CUM) + 2)) |
2057 | ||
2058 | /* Define this macro if the target machine has "register windows", so that the | |
2059 | register in which a function sees an arguments is not necessarily the same | |
2060 | as the one in which the caller passed the argument. | |
2061 | ||
2062 | For such machines, `FUNCTION_ARG' computes the register in which the caller | |
2063 | passes the value, and `FUNCTION_INCOMING_ARG' should be defined in a similar | |
2064 | fashion to tell the function being called where the arguments will arrive. | |
2065 | ||
2066 | If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves both | |
2067 | purposes. */ | |
2068 | /* #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) */ | |
2069 | ||
2070 | /* A C expression for the number of words, at the beginning of an argument, | |
2071 | must be put in registers. The value must be zero for arguments that are | |
2072 | passed entirely in registers or that are entirely pushed on the stack. | |
2073 | ||
2074 | On some machines, certain arguments must be passed partially in registers | |
2075 | and partially in memory. On these machines, typically the first N words of | |
2076 | arguments are passed in registers, and the rest on the stack. If a | |
2077 | multi-word argument (a `double' or a structure) crosses that boundary, its | |
2078 | first few words must be passed in registers and the rest must be pushed. | |
2079 | This macro tells the compiler when this occurs, and how many of the words | |
2080 | should go in registers. | |
2081 | ||
2082 | `FUNCTION_ARG' for these arguments should return the first register to be | |
2083 | used by the caller for this argument; likewise `FUNCTION_INCOMING_ARG', for | |
2084 | the called function. */ | |
2085 | #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) 0 | |
2086 | ||
2087 | /* A C expression that indicates when an argument must be passed by reference. | |
2088 | If nonzero for an argument, a copy of that argument is made in memory and a | |
2089 | pointer to the argument is passed instead of the argument itself. The | |
2090 | pointer is passed in whatever way is appropriate for passing a pointer to | |
2091 | that type. | |
2092 | ||
2093 | On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable | |
2094 | definition of this macro might be | |
2095 | #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \ | |
2096 | MUST_PASS_IN_STACK (MODE, TYPE) */ | |
2097 | #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) 0 | |
2098 | ||
2099 | /* If defined, a C expression that indicates when it is more | |
2100 | desirable to keep an argument passed by invisible reference as a | |
2101 | reference, rather than copying it to a pseudo register. */ | |
2102 | /* #define FUNCTION_ARG_KEEP_AS_REFERENCE(CUM, MODE, TYPE, NAMED) */ | |
2103 | ||
2104 | /* If defined, a C expression that indicates when it is the called function's | |
2105 | responsibility to make a copy of arguments passed by invisible reference. | |
2106 | Normally, the caller makes a copy and passes the address of the copy to the | |
2107 | routine being called. When FUNCTION_ARG_CALLEE_COPIES is defined and is | |
2108 | nonzero, the caller does not make a copy. Instead, it passes a pointer to | |
2109 | the "live" value. The called function must not modify this value. If it | |
2110 | can be determined that the value won't be modified, it need not make a copy; | |
2111 | otherwise a copy must be made. */ | |
2112 | /* #define FUNCTION_ARG_CALLEE_COPIES(CUM, MODE, TYPE, NAMED) */ | |
2113 | ||
2114 | /* A C type for declaring a variable that is used as the first argument of | |
2115 | `FUNCTION_ARG' and other related values. For some target machines, the type | |
2116 | `int' suffices and can hold the number of bytes of argument so far. | |
2117 | ||
2118 | There is no need to record in `CUMULATIVE_ARGS' anything about the arguments | |
2119 | that have been passed on the stack. The compiler has other variables to | |
2120 | keep track of that. For target machines on which all arguments are passed | |
2121 | on the stack, there is no need to store anything in `CUMULATIVE_ARGS'; | |
2122 | however, the data structure must exist and should not be empty, so use | |
2123 | `int'. | |
2124 | ||
2125 | For this platform, the value of CUMULATIVE_ARGS is the number of words | |
2126 | of arguments that have been passed in registers so far. */ | |
2127 | typedef int CUMULATIVE_ARGS; | |
2128 | ||
2129 | /* A C statement (sans semicolon) for initializing the variable CUM for the | |
2130 | state at the beginning of the argument list. The variable has type | |
2131 | `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node for the data type | |
2132 | of the function which will receive the args, or 0 if the args are to a | |
2133 | compiler support library function. The value of INDIRECT is nonzero when | |
2134 | processing an indirect call, for example a call through a function pointer. | |
2135 | The value of INDIRECT is zero for a call to an explicitly named function, a | |
2136 | library function call, or when `INIT_CUMULATIVE_ARGS' is used to find | |
2137 | arguments for the function being compiled. | |
2138 | ||
2139 | When processing a call to a compiler support library function, LIBNAME | |
2140 | identifies which one. It is a `symbol_ref' rtx which contains the name of | |
2141 | the function, as a string. LIBNAME is 0 when an ordinary C function call is | |
2142 | being processed. Thus, each time this macro is called, either LIBNAME or | |
2143 | FNTYPE is nonzero, but never both of them at once. */ | |
2144 | #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT) (CUM) = 0 | |
2145 | ||
2146 | /* Like `INIT_CUMULATIVE_ARGS' but overrides it for the purposes of finding the | |
2147 | arguments for the function being compiled. If this macro is undefined, | |
2148 | `INIT_CUMULATIVE_ARGS' is used instead. | |
2149 | ||
2150 | The value passed for LIBNAME is always 0, since library routines with | |
2151 | special calling conventions are never compiled with GNU CC. The argument | |
2152 | LIBNAME exists for symmetry with `INIT_CUMULATIVE_ARGS'. */ | |
2153 | /* #define INIT_CUMULATIVE_INCOMING_ARGS(CUM, FNTYPE, LIBNAME) */ | |
2154 | ||
2155 | /* A C statement (sans semicolon) to update the summarizer variable CUM to | |
2156 | advance past an argument in the argument list. The values MODE, TYPE and | |
2157 | NAMED describe that argument. Once this is done, the variable CUM is | |
2158 | suitable for analyzing the *following* argument with `FUNCTION_ARG', etc. | |
2159 | ||
2160 | This macro need not do anything if the argument in question was passed on | |
2161 | the stack. The compiler knows how to track the amount of stack space used | |
2162 | for arguments without any special help. */ | |
2163 | #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ | |
c6243b4c | 2164 | ((CUM) = xstormy16_function_arg_advance (CUM, MODE, TYPE, NAMED)) |
4b58290f GK |
2165 | |
2166 | /* If defined, a C expression which determines whether, and in which direction, | |
2167 | to pad out an argument with extra space. The value should be of type `enum | |
2168 | direction': either `upward' to pad above the argument, `downward' to pad | |
2169 | below, or `none' to inhibit padding. | |
2170 | ||
2171 | The *amount* of padding is always just enough to reach the next multiple of | |
2172 | `FUNCTION_ARG_BOUNDARY'; this macro does not control it. | |
2173 | ||
2174 | This macro has a default definition which is right for most systems. For | |
2175 | little-endian machines, the default is to pad upward. For big-endian | |
2176 | machines, the default is to pad downward for an argument of constant size | |
2177 | shorter than an `int', and upward otherwise. */ | |
2178 | /* #define FUNCTION_ARG_PADDING(MODE, TYPE) */ | |
2179 | ||
2180 | /* If defined, a C expression that gives the alignment boundary, in bits, of an | |
2181 | argument with the specified mode and type. If it is not defined, | |
2182 | `PARM_BOUNDARY' is used for all arguments. */ | |
2183 | /* #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) */ | |
2184 | ||
2185 | /* A C expression that is nonzero if REGNO is the number of a hard register in | |
2186 | which function arguments are sometimes passed. This does *not* include | |
2187 | implicit arguments such as the static chain and the structure-value address. | |
2188 | On many machines, no registers can be used for this purpose since all | |
2189 | function arguments are pushed on the stack. */ | |
2190 | #define FUNCTION_ARG_REGNO_P(REGNO) \ | |
2191 | ((REGNO) >= FIRST_ARGUMENT_REGISTER \ | |
2192 | && (REGNO) < FIRST_ARGUMENT_REGISTER + NUM_ARGUMENT_REGISTERS) | |
2193 | ||
2194 | \f | |
2195 | /* How Scalar Function Values are Returned */ | |
2196 | ||
2197 | /* The number of the hard register that is used to return a scalar value from a | |
2198 | function call. */ | |
2199 | #define RETURN_VALUE_REGNUM FIRST_ARGUMENT_REGISTER | |
2200 | ||
2201 | /* Define this macro if `-traditional' should not cause functions declared to | |
2202 | return `float' to convert the value to `double'. */ | |
2203 | /* #define TRADITIONAL_RETURN_FLOAT */ | |
2204 | ||
2205 | /* A C expression to create an RTX representing the place where a function | |
2206 | returns a value of data type VALTYPE. VALTYPE is a tree node representing a | |
2207 | data type. Write `TYPE_MODE (VALTYPE)' to get the machine mode used to | |
2208 | represent that type. On many machines, only the mode is relevant. | |
2209 | (Actually, on most machines, scalar values are returned in the same place | |
2210 | regardless of mode). | |
2211 | ||
2212 | If `PROMOTE_FUNCTION_RETURN' is defined, you must apply the same promotion | |
2213 | rules specified in `PROMOTE_MODE' if VALTYPE is a scalar type. | |
2214 | ||
2215 | If the precise function being called is known, FUNC is a tree node | |
2216 | (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. This makes it | |
2217 | possible to use a different value-returning convention for specific | |
2218 | functions when all their calls are known. | |
2219 | ||
2220 | `FUNCTION_VALUE' is not used for return vales with aggregate data types, | |
2221 | because these are returned in another way. See `STRUCT_VALUE_REGNUM' and | |
2222 | related macros, below. */ | |
2223 | #define FUNCTION_VALUE(VALTYPE, FUNC) \ | |
c6243b4c | 2224 | xstormy16_function_value (VALTYPE, FUNC) |
4b58290f GK |
2225 | |
2226 | ||
2227 | /* Define this macro if the target machine has "register windows" so that the | |
2228 | register in which a function returns its value is not the same as the one in | |
2229 | which the caller sees the value. | |
2230 | ||
2231 | For such machines, `FUNCTION_VALUE' computes the register in which the | |
2232 | caller will see the value. `FUNCTION_OUTGOING_VALUE' should be defined in a | |
2233 | similar fashion to tell the function where to put the value. | |
2234 | ||
2235 | If `FUNCTION_OUTGOING_VALUE' is not defined, `FUNCTION_VALUE' serves both | |
2236 | purposes. | |
2237 | ||
2238 | `FUNCTION_OUTGOING_VALUE' is not used for return vales with aggregate data | |
2239 | types, because these are returned in another way. See `STRUCT_VALUE_REGNUM' | |
2240 | and related macros, below. */ | |
2241 | /* #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) */ | |
2242 | ||
2243 | /* A C expression to create an RTX representing the place where a library | |
2244 | function returns a value of mode MODE. | |
2245 | ||
2246 | Note that "library function" in this context means a compiler support | |
2247 | routine, used to perform arithmetic, whose name is known specially by the | |
2248 | compiler and was not mentioned in the C code being compiled. | |
2249 | ||
2250 | The definition of `LIBRARY_VALUE' need not be concerned aggregate data | |
2251 | types, because none of the library functions returns such types. */ | |
2252 | #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, RETURN_VALUE_REGNUM) | |
2253 | ||
2254 | /* A C expression that is nonzero if REGNO is the number of a hard register in | |
2255 | which the values of called function may come back. | |
2256 | ||
2257 | A register whose use for returning values is limited to serving as the | |
2258 | second of a pair (for a value of type `double', say) need not be recognized | |
2259 | by this macro. So for most machines, this definition suffices: | |
2260 | ||
2261 | #define FUNCTION_VALUE_REGNO_P(N) ((N) == RETURN) | |
2262 | ||
2263 | If the machine has register windows, so that the caller and the called | |
2264 | function use different registers for the return value, this macro should | |
2265 | recognize only the caller's register numbers. */ | |
2266 | #define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM) | |
2267 | ||
2268 | /* Define this macro if `untyped_call' and `untyped_return' need more space | |
2269 | than is implied by `FUNCTION_VALUE_REGNO_P' for saving and restoring an | |
2270 | arbitrary return value. */ | |
2271 | /* #define APPLY_RESULT_SIZE */ | |
2272 | ||
2273 | \f | |
2274 | /* How Large Values are Returned */ | |
2275 | ||
2276 | /* A C expression which can inhibit the returning of certain function values in | |
2277 | registers, based on the type of value. A nonzero value says to return the | |
2278 | function value in memory, just as large structures are always returned. | |
2279 | Here TYPE will be a C expression of type `tree', representing the data type | |
2280 | of the value. | |
2281 | ||
2282 | Note that values of mode `BLKmode' must be explicitly handled by this macro. | |
2283 | Also, the option `-fpcc-struct-return' takes effect regardless of this | |
2284 | macro. On most systems, it is possible to leave the macro undefined; this | |
2285 | causes a default definition to be used, whose value is the constant 1 for | |
2286 | `BLKmode' values, and 0 otherwise. | |
2287 | ||
2288 | Do not use this macro to indicate that structures and unions should always | |
2289 | be returned in memory. You should instead use `DEFAULT_PCC_STRUCT_RETURN' | |
2290 | to indicate this. */ | |
2291 | #define RETURN_IN_MEMORY(TYPE) \ | |
2292 | (int_size_in_bytes (TYPE) > UNITS_PER_WORD * NUM_ARGUMENT_REGISTERS) | |
2293 | ||
2294 | /* Define this macro to be 1 if all structure and union return values must be | |
2295 | in memory. Since this results in slower code, this should be defined only | |
2296 | if needed for compatibility with other compilers or with an ABI. If you | |
2297 | define this macro to be 0, then the conventions used for structure and union | |
2298 | return values are decided by the `RETURN_IN_MEMORY' macro. | |
2299 | ||
2300 | If not defined, this defaults to the value 1. */ | |
da6e254e | 2301 | /* #define DEFAULT_PCC_STRUCT_RETURN 0 */ |
4b58290f GK |
2302 | |
2303 | /* If the structure value address is passed in a register, then | |
2304 | `STRUCT_VALUE_REGNUM' should be the number of that register. */ | |
2305 | /* #define STRUCT_VALUE_REGNUM */ | |
2306 | ||
2307 | /* If the structure value address is not passed in a register, define | |
2308 | `STRUCT_VALUE' as an expression returning an RTX for the place where the | |
2309 | address is passed. If it returns 0, the address is passed as an "invisible" | |
2310 | first argument. */ | |
2311 | #define STRUCT_VALUE 0 | |
2312 | ||
2313 | /* On some architectures the place where the structure value address is found | |
2314 | by the called function is not the same place that the caller put it. This | |
2315 | can be due to register windows, or it could be because the function prologue | |
2316 | moves it to a different place. | |
2317 | ||
2318 | If the incoming location of the structure value address is in a register, | |
2319 | define this macro as the register number. */ | |
2320 | /* #define STRUCT_VALUE_INCOMING_REGNUM */ | |
2321 | ||
2322 | /* If the incoming location is not a register, then you should define | |
2323 | `STRUCT_VALUE_INCOMING' as an expression for an RTX for where the called | |
2324 | function should find the value. If it should find the value on the stack, | |
2325 | define this to create a `mem' which refers to the frame pointer. A | |
2326 | definition of 0 means that the address is passed as an "invisible" first | |
2327 | argument. */ | |
2328 | /* #define STRUCT_VALUE_INCOMING */ | |
2329 | ||
2330 | /* Define this macro if the usual system convention on the target machine for | |
2331 | returning structures and unions is for the called function to return the | |
2332 | address of a static variable containing the value. | |
2333 | ||
2334 | Do not define this if the usual system convention is for the caller to pass | |
2335 | an address to the subroutine. | |
2336 | ||
2337 | This macro has effect in `-fpcc-struct-return' mode, but it does nothing | |
2338 | when you use `-freg-struct-return' mode. */ | |
2339 | /* #define PCC_STATIC_STRUCT_RETURN */ | |
2340 | ||
2341 | \f | |
2342 | /* Caller-Saves Register Allocation */ | |
2343 | ||
2344 | /* Define this macro if function calls on the target machine do not preserve | |
2345 | any registers; in other words, if `CALL_USED_REGISTERS' has 1 for all | |
2346 | registers. This macro enables `-fcaller-saves' by default. Eventually that | |
2347 | option will be enabled by default on all machines and both the option and | |
2348 | this macro will be eliminated. */ | |
2349 | /* #define DEFAULT_CALLER_SAVES */ | |
2350 | ||
2351 | /* A C expression to determine whether it is worthwhile to consider placing a | |
2352 | pseudo-register in a call-clobbered hard register and saving and restoring | |
2353 | it around each function call. The expression should be 1 when this is worth | |
2354 | doing, and 0 otherwise. | |
2355 | ||
2356 | If you don't define this macro, a default is used which is good on most | |
2357 | machines: `4 * CALLS < REFS'. */ | |
2358 | /* #define CALLER_SAVE_PROFITABLE(REFS, CALLS) */ | |
2359 | ||
2360 | \f | |
2361 | /* Function Entry and Exit */ | |
2362 | ||
2363 | /* Define this macro as a C expression that is nonzero if the return | |
2364 | instruction or the function epilogue ignores the value of the stack pointer; | |
2365 | in other words, if it is safe to delete an instruction to adjust the stack | |
2366 | pointer before a return from the function. | |
2367 | ||
2368 | Note that this macro's value is relevant only for functions for which frame | |
2369 | pointers are maintained. It is never safe to delete a final stack | |
2370 | adjustment in a function that has no frame pointer, and the compiler knows | |
2371 | this regardless of `EXIT_IGNORE_STACK'. */ | |
2372 | /* #define EXIT_IGNORE_STACK */ | |
2373 | ||
2374 | /* Define this macro as a C expression that is nonzero for registers | |
2375 | are used by the epilogue or the `return' pattern. The stack and | |
2376 | frame pointer registers are already be assumed to be used as | |
2377 | needed. */ | |
2378 | #define EPILOGUE_USES(REGNO) \ | |
c6243b4c | 2379 | xstormy16_epilogue_uses (REGNO) |
4b58290f GK |
2380 | |
2381 | /* Define this macro if the function epilogue contains delay slots to which | |
2382 | instructions from the rest of the function can be "moved". The definition | |
2383 | should be a C expression whose value is an integer representing the number | |
2384 | of delay slots there. */ | |
2385 | /* #define DELAY_SLOTS_FOR_EPILOGUE */ | |
2386 | ||
2387 | /* A C expression that returns 1 if INSN can be placed in delay slot number N | |
2388 | of the epilogue. | |
2389 | ||
2390 | The argument N is an integer which identifies the delay slot now being | |
2391 | considered (since different slots may have different rules of eligibility). | |
2392 | It is never negative and is always less than the number of epilogue delay | |
2393 | slots (what `DELAY_SLOTS_FOR_EPILOGUE' returns). If you reject a particular | |
2394 | insn for a given delay slot, in principle, it may be reconsidered for a | |
2395 | subsequent delay slot. Also, other insns may (at least in principle) be | |
2396 | considered for the so far unfilled delay slot. | |
2397 | ||
2398 | The insns accepted to fill the epilogue delay slots are put in an | |
2399 | RTL list made with `insn_list' objects, stored in the variable | |
2400 | `current_function_epilogue_delay_list'. The insn for the first | |
2401 | delay slot comes first in the list. Your definition of the macro | |
2402 | `FUNCTION_EPILOGUE' should fill the delay slots by outputting the | |
2403 | insns in this list, usually by calling `final_scan_insn'. | |
2404 | ||
2405 | You need not define this macro if you did not define | |
2406 | `DELAY_SLOTS_FOR_EPILOGUE'. */ | |
2407 | /* #define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) */ | |
2408 | ||
2409 | /* A C compound statement that outputs the assembler code for a thunk function, | |
2410 | used to implement C++ virtual function calls with multiple inheritance. The | |
2411 | thunk acts as a wrapper around a virtual function, adjusting the implicit | |
2412 | object parameter before handing control off to the real function. | |
2413 | ||
2414 | First, emit code to add the integer DELTA to the location that contains the | |
2415 | incoming first argument. Assume that this argument contains a pointer, and | |
2416 | is the one used to pass the `this' pointer in C++. This is the incoming | |
2417 | argument *before* the function prologue, e.g. `%o0' on a sparc. The | |
2418 | addition must preserve the values of all other incoming arguments. | |
2419 | ||
2420 | After the addition, emit code to jump to FUNCTION, which is a | |
2421 | `FUNCTION_DECL'. This is a direct pure jump, not a call, and does not touch | |
2422 | the return address. Hence returning from FUNCTION will return to whoever | |
2423 | called the current `thunk'. | |
2424 | ||
41441dc7 NB |
2425 | The effect must be as if @var{function} had been called directly |
2426 | with the adjusted first argument. This macro is responsible for | |
2427 | emitting all of the code for a thunk function; | |
2428 | TARGET_ASM_FUNCTION_PROLOGUE and TARGET_ASM_FUNCTION_EPILOGUE are | |
2429 | not invoked. | |
4b58290f GK |
2430 | |
2431 | The THUNK_FNDECL is redundant. (DELTA and FUNCTION have already been | |
2432 | extracted from it.) It might possibly be useful on some targets, but | |
2433 | probably not. | |
2434 | ||
2435 | If you do not define this macro, the target-independent code in the C++ | |
2436 | frontend will generate a less efficient heavyweight thunk that calls | |
2437 | FUNCTION instead of jumping to it. The generic approach does not support | |
2438 | varargs. */ | |
2439 | #define ASM_OUTPUT_MI_THUNK(FILE, THUNK_FNDECL, DELTA, FUNCTION) \ | |
c6243b4c | 2440 | xstormy16_asm_output_mi_thunk (FILE, THUNK_FNDECL, DELTA, FUNCTION) |
4b58290f GK |
2441 | |
2442 | \f | |
2443 | /* Generating Code for Profiling. */ | |
2444 | ||
2445 | /* A C statement or compound statement to output to FILE some assembler code to | |
2446 | call the profiling subroutine `mcount'. Before calling, the assembler code | |
2447 | must load the address of a counter variable into a register where `mcount' | |
2448 | expects to find the address. The name of this variable is `LP' followed by | |
2449 | the number LABELNO, so you would generate the name using `LP%d' in a | |
2450 | `fprintf'. | |
2451 | ||
2452 | The details of how the address should be passed to `mcount' are determined | |
2453 | by your operating system environment, not by GNU CC. To figure them out, | |
2454 | compile a small program for profiling using the system's installed C | |
2455 | compiler and look at the assembler code that results. | |
2456 | ||
2457 | This declaration must be present, but it can be an abort if profiling is | |
2458 | not implemented. */ | |
2459 | ||
2460 | #define FUNCTION_PROFILER(FILE, LABELNO) abort () | |
2461 | ||
2462 | /* Define this macro if the code for function profiling should come before the | |
2463 | function prologue. Normally, the profiling code comes after. */ | |
2464 | /* #define PROFILE_BEFORE_PROLOGUE */ | |
2465 | ||
2466 | /* A C statement or compound statement to output to FILE some assembler code to | |
2467 | initialize basic-block profiling for the current object module. The global | |
2468 | compile flag `profile_block_flag' distingishes two profile modes. | |
2469 | ||
2470 | profile_block_flag != 2' | |
2471 | Output code to call the subroutine `__bb_init_func' once per | |
2472 | object module, passing it as its sole argument the address of | |
2473 | a block allocated in the object module. | |
2474 | ||
2475 | The name of the block is a local symbol made with this | |
2476 | statement: | |
2477 | ||
2478 | ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); | |
2479 | ||
2480 | Of course, since you are writing the definition of | |
2481 | `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, | |
2482 | you can take a short cut in the definition of this macro and | |
2483 | use the name that you know will result. | |
2484 | ||
2485 | The first word of this block is a flag which will be nonzero | |
2486 | if the object module has already been initialized. So test | |
2487 | this word first, and do not call `__bb_init_func' if the flag | |
2488 | is nonzero. BLOCK_OR_LABEL contains a unique number which | |
2489 | may be used to generate a label as a branch destination when | |
2490 | `__bb_init_func' will not be called. | |
2491 | ||
2492 | Described in assembler language, the code to be output looks | |
2493 | like: | |
2494 | ||
2495 | cmp (LPBX0),0 | |
2496 | bne local_label | |
2497 | parameter1 <- LPBX0 | |
2498 | call __bb_init_func | |
2499 | local_label: | |
2500 | ||
2501 | profile_block_flag == 2' | |
2502 | Output code to call the subroutine `__bb_init_trace_func' and | |
2503 | pass two parameters to it. The first parameter is the same as | |
2504 | for `__bb_init_func'. The second parameter is the number of | |
2505 | the first basic block of the function as given by | |
2506 | BLOCK_OR_LABEL. Note that `__bb_init_trace_func' has to be | |
2507 | called, even if the object module has been initialized | |
2508 | already. | |
2509 | ||
2510 | Described in assembler language, the code to be output looks | |
2511 | like: | |
2512 | parameter1 <- LPBX0 | |
2513 | parameter2 <- BLOCK_OR_LABEL | |
2514 | call __bb_init_trace_func */ | |
2515 | /* #define FUNCTION_BLOCK_PROFILER (FILE, LABELNO) */ | |
2516 | ||
2517 | /* A C statement or compound statement to output to FILE some assembler code to | |
2518 | increment the count associated with the basic block number BLOCKNO. The | |
2519 | global compile flag `profile_block_flag' distingishes two profile modes. | |
2520 | ||
2521 | profile_block_flag != 2' | |
2522 | Output code to increment the counter directly. Basic blocks | |
2523 | are numbered separately from zero within each compilation. | |
2524 | The count associated with block number BLOCKNO is at index | |
2525 | BLOCKNO in a vector of words; the name of this array is a | |
2526 | local symbol made with this statement: | |
2527 | ||
2528 | ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); | |
2529 | ||
2530 | Of course, since you are writing the definition of | |
2531 | `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, | |
2532 | you can take a short cut in the definition of this macro and | |
2533 | use the name that you know will result. | |
2534 | ||
2535 | Described in assembler language, the code to be output looks | |
2536 | like: | |
2537 | ||
2538 | inc (LPBX2+4*BLOCKNO) | |
2539 | ||
2540 | profile_block_flag == 2' | |
2541 | Output code to initialize the global structure `__bb' and | |
2542 | call the function `__bb_trace_func', which will increment the | |
2543 | counter. | |
2544 | ||
2545 | `__bb' consists of two words. In the first word, the current | |
2546 | basic block number, as given by BLOCKNO, has to be stored. In | |
2547 | the second word, the address of a block allocated in the | |
2548 | object module has to be stored. The address is given by the | |
2549 | label created with this statement: | |
2550 | ||
2551 | ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); | |
2552 | ||
2553 | Described in assembler language, the code to be output looks | |
2554 | like: | |
2555 | move BLOCKNO -> (__bb) | |
2556 | move LPBX0 -> (__bb+4) | |
2557 | call __bb_trace_func */ | |
2558 | /* #define BLOCK_PROFILER(FILE, BLOCKNO) */ | |
2559 | ||
2560 | /* A C statement or compound statement to output to FILE assembler | |
2561 | code to call function `__bb_trace_ret'. The assembler code should | |
2562 | only be output if the global compile flag `profile_block_flag' == | |
2563 | 2. This macro has to be used at every place where code for | |
41441dc7 NB |
2564 | returning from a function is generated |
2565 | (e.g. `TARGET_ASM_FUNCTION_EPILOGUE'). Although you have to write | |
2566 | the definition of `TARGET_ASM_FUNCTION_EPILOGUE' as well, you have | |
2567 | to define this macro to tell the compiler, that the proper call to | |
2568 | `__bb_trace_ret' is produced. */ | |
4b58290f GK |
2569 | /* #define FUNCTION_BLOCK_PROFILER_EXIT(FILE) */ |
2570 | ||
2571 | /* A C statement or compound statement to save all registers, which may be | |
2572 | clobbered by a function call, including condition codes. The `asm' | |
2573 | statement will be mostly likely needed to handle this task. Local labels in | |
2574 | the assembler code can be concatenated with the string ID, to obtain a | |
2575 | unique lable name. | |
2576 | ||
41441dc7 NB |
2577 | Registers or condition codes clobbered by |
2578 | `TARGET_ASM_FUNCTION_PROLOGUE' or `TARGET_ASM_FUNCTION_EPILOGUE' | |
2579 | must be saved in the macros `FUNCTION_BLOCK_PROFILER', | |
4b58290f | 2580 | `FUNCTION_BLOCK_PROFILER_EXIT' and `BLOCK_PROFILER' prior calling |
41441dc7 NB |
2581 | `__bb_init_trace_func', `__bb_trace_ret' and `__bb_trace_func' |
2582 | respectively. */ | |
4b58290f GK |
2583 | /* #define MACHINE_STATE_SAVE(ID) */ |
2584 | ||
2585 | /* A C statement or compound statement to restore all registers, including | |
2586 | condition codes, saved by `MACHINE_STATE_SAVE'. | |
2587 | ||
41441dc7 NB |
2588 | Registers or condition codes clobbered by `TARGET_ASM_FUNCTION_PROLOGUE' or |
2589 | `TARGET_ASM_FUNCTION_EPILOGUE' must be restored in the macros | |
4b58290f GK |
2590 | `FUNCTION_BLOCK_PROFILER', `FUNCTION_BLOCK_PROFILER_EXIT' and |
2591 | `BLOCK_PROFILER' after calling `__bb_init_trace_func', `__bb_trace_ret' and | |
2592 | `__bb_trace_func' respectively. */ | |
2593 | /* #define MACHINE_STATE_RESTORE(ID) */ | |
2594 | ||
2595 | /* A C function or functions which are needed in the library to support block | |
2596 | profiling. */ | |
2597 | /* #define BLOCK_PROFILER_CODE */ | |
2598 | ||
2599 | \f | |
2600 | /* If the target has particular reasons why a function cannot be inlined, | |
2601 | it may define the TARGET_CANNOT_INLINE_P. This macro takes one argument, | |
2602 | the DECL describing the function. The function should NULL if the function | |
2603 | *can* be inlined. Otherwise it should return a pointer to a string containing | |
2604 | a message describing why the function could not be inlined. The message will | |
2605 | displayed if the '-Winline' command line switch has been given. If the message | |
2606 | contains a '%s' sequence, this will be replaced by the name of the function. */ | |
c6243b4c | 2607 | /* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */ |
4b58290f GK |
2608 | \f |
2609 | /* Implementing the Varargs Macros. */ | |
2610 | ||
2611 | /* If defined, is a C expression that produces the machine-specific code for a | |
2612 | call to `__builtin_saveregs'. This code will be moved to the very beginning | |
2613 | of the function, before any parameter access are made. The return value of | |
2614 | this function should be an RTX that contains the value to use as the return | |
2615 | of `__builtin_saveregs'. | |
2616 | ||
2617 | If this macro is not defined, the compiler will output an ordinary call to | |
2618 | the library function `__builtin_saveregs'. */ | |
2619 | /* #define EXPAND_BUILTIN_SAVEREGS() */ | |
2620 | ||
2621 | /* This macro offers an alternative to using `__builtin_saveregs' and defining | |
2622 | the macro `EXPAND_BUILTIN_SAVEREGS'. Use it to store the anonymous register | |
2623 | arguments into the stack so that all the arguments appear to have been | |
2624 | passed consecutively on the stack. Once this is done, you can use the | |
2625 | standard implementation of varargs that works for machines that pass all | |
2626 | their arguments on the stack. | |
2627 | ||
2628 | The argument ARGS_SO_FAR is the `CUMULATIVE_ARGS' data structure, containing | |
2629 | the values that obtain after processing of the named arguments. The | |
2630 | arguments MODE and TYPE describe the last named argument--its machine mode | |
2631 | and its data type as a tree node. | |
2632 | ||
2633 | The macro implementation should do two things: first, push onto the stack | |
2634 | all the argument registers *not* used for the named arguments, and second, | |
2635 | store the size of the data thus pushed into the `int'-valued variable whose | |
2636 | name is supplied as the argument PRETEND_ARGS_SIZE. The value that you | |
2637 | store here will serve as additional offset for setting up the stack frame. | |
2638 | ||
2639 | Because you must generate code to push the anonymous arguments at compile | |
2640 | time without knowing their data types, `SETUP_INCOMING_VARARGS' is only | |
2641 | useful on machines that have just a single category of argument register and | |
2642 | use it uniformly for all data types. | |
2643 | ||
2644 | If the argument SECOND_TIME is nonzero, it means that the arguments of the | |
2645 | function are being analyzed for the second time. This happens for an inline | |
2646 | function, which is not actually compiled until the end of the source file. | |
2647 | The macro `SETUP_INCOMING_VARARGS' should not generate any instructions in | |
2648 | this case. */ | |
2649 | #define SETUP_INCOMING_VARARGS(ARGS_SO_FAR, MODE, TYPE, PRETEND_ARGS_SIZE, SECOND_TIME) \ | |
2650 | if (! SECOND_TIME) \ | |
c6243b4c | 2651 | xstormy16_setup_incoming_varargs (ARGS_SO_FAR, MODE, TYPE, & PRETEND_ARGS_SIZE) |
4b58290f GK |
2652 | |
2653 | /* Define this macro if the location where a function argument is passed | |
2654 | depends on whether or not it is a named argument. | |
2655 | ||
2656 | This macro controls how the NAMED argument to `FUNCTION_ARG' is set for | |
2657 | varargs and stdarg functions. With this macro defined, the NAMED argument | |
2658 | is always true for named arguments, and false for unnamed arguments. If | |
2659 | this is not defined, but `SETUP_INCOMING_VARARGS' is defined, then all | |
2660 | arguments are treated as named. Otherwise, all named arguments except the | |
2661 | last are treated as named. */ | |
2662 | /* #define STRICT_ARGUMENT_NAMING 1 */ | |
2663 | ||
2664 | /* Build up the stdarg/varargs va_list type tree, assinging it to NODE. If not | |
2665 | defined, it is assumed that va_list is a void * pointer. */ | |
2666 | #define BUILD_VA_LIST_TYPE(NODE) \ | |
c6243b4c | 2667 | ((NODE) = xstormy16_build_va_list ()) |
4b58290f GK |
2668 | |
2669 | /* Implement the stdarg/varargs va_start macro. STDARG_P is non-zero if this | |
2670 | is stdarg.h instead of varargs.h. VALIST is the tree of the va_list | |
2671 | variable to initialize. NEXTARG is the machine independent notion of the | |
2672 | 'next' argument after the variable arguments. If not defined, a standard | |
2673 | implementation will be defined that works for arguments passed on the stack. */ | |
2674 | #define EXPAND_BUILTIN_VA_START(STDARG_P, VALIST, NEXTARG) \ | |
c6243b4c | 2675 | xstormy16_expand_builtin_va_start (STDARG_P, VALIST, NEXTARG) |
4b58290f GK |
2676 | |
2677 | /* Implement the stdarg/varargs va_arg macro. VALIST is the variable of type | |
2678 | va_list as a tree, TYPE is the type passed to va_arg. */ | |
2679 | #define EXPAND_BUILTIN_VA_ARG(VALIST, TYPE) \ | |
c6243b4c | 2680 | xstormy16_expand_builtin_va_arg (VALIST, TYPE) |
4b58290f GK |
2681 | |
2682 | /* Implement the stdarg/varargs va_end macro. VALIST is the variable of type | |
2683 | va_list as a tree. */ | |
2684 | /* #define EXPAND_BUILTIN_VA_END(VALIST) */ | |
2685 | ||
2686 | \f | |
2687 | /* Trampolines for Nested Functions. */ | |
2688 | ||
2689 | /* A C statement to output, on the stream FILE, assembler code for a block of | |
2690 | data that contains the constant parts of a trampoline. This code should not | |
2691 | include a label--the label is taken care of automatically. */ | |
2692 | /* #define TRAMPOLINE_TEMPLATE(FILE) */ | |
2693 | ||
2694 | /* The name of a subroutine to switch to the section in which the trampoline | |
2695 | template is to be placed. The default is a value of `readonly_data_section', | |
2696 | which places the trampoline in the section containing read-only data. */ | |
2697 | /* #define TRAMPOLINE_SECTION */ | |
2698 | ||
2699 | /* A C expression for the size in bytes of the trampoline, as an integer. */ | |
2700 | #define TRAMPOLINE_SIZE 8 | |
2701 | ||
2702 | /* Alignment required for trampolines, in bits. | |
2703 | ||
2704 | If you don't define this macro, the value of `BIGGEST_ALIGNMENT' is used for | |
2705 | aligning trampolines. */ | |
2706 | #define TRAMPOLINE_ALIGNMENT 16 | |
2707 | ||
2708 | /* A C statement to initialize the variable parts of a trampoline. ADDR is an | |
2709 | RTX for the address of the trampoline; FNADDR is an RTX for the address of | |
2710 | the nested function; STATIC_CHAIN is an RTX for the static chain value that | |
2711 | should be passed to the function when it is called. */ | |
2712 | #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \ | |
c6243b4c | 2713 | xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN) |
4b58290f GK |
2714 | |
2715 | /* A C expression to allocate run-time space for a trampoline. The expression | |
2716 | value should be an RTX representing a memory reference to the space for the | |
2717 | trampoline. | |
2718 | ||
2719 | If this macro is not defined, by default the trampoline is allocated as a | |
2720 | stack slot. This default is right for most machines. The exceptions are | |
2721 | machines where it is impossible to execute instructions in the stack area. | |
2722 | On such machines, you may have to implement a separate stack, using this | |
41441dc7 NB |
2723 | macro in conjunction with `TARGET_ASM_FUNCTION_PROLOGUE' and |
2724 | `TARGET_ASM_FUNCTION_EPILOGUE'. | |
4b58290f GK |
2725 | |
2726 | FP points to a data structure, a `struct function', which describes the | |
2727 | compilation status of the immediate containing function of the function | |
2728 | which the trampoline is for. Normally (when `ALLOCATE_TRAMPOLINE' is not | |
2729 | defined), the stack slot for the trampoline is in the stack frame of this | |
2730 | containing function. Other allocation strategies probably must do something | |
2731 | analogous with this information. */ | |
2732 | /* #define ALLOCATE_TRAMPOLINE(FP) */ | |
2733 | ||
2734 | /* Implementing trampolines is difficult on many machines because they have | |
2735 | separate instruction and data caches. Writing into a stack location fails | |
2736 | to clear the memory in the instruction cache, so when the program jumps to | |
2737 | that location, it executes the old contents. | |
2738 | ||
2739 | Here are two possible solutions. One is to clear the relevant parts of the | |
2740 | instruction cache whenever a trampoline is set up. The other is to make all | |
2741 | trampolines identical, by having them jump to a standard subroutine. The | |
2742 | former technique makes trampoline execution faster; the latter makes | |
2743 | initialization faster. | |
2744 | ||
2745 | To clear the instruction cache when a trampoline is initialized, define the | |
2746 | following macros which describe the shape of the cache. */ | |
2747 | ||
2748 | /* The total size in bytes of the cache. */ | |
2749 | /* #define INSN_CACHE_SIZE */ | |
2750 | ||
2751 | /* The length in bytes of each cache line. The cache is divided into cache | |
2752 | lines which are disjoint slots, each holding a contiguous chunk of data | |
2753 | fetched from memory. Each time data is brought into the cache, an entire | |
2754 | line is read at once. The data loaded into a cache line is always aligned | |
2755 | on a boundary equal to the line size. */ | |
2756 | /* #define INSN_CACHE_LINE_WIDTH */ | |
2757 | ||
2758 | /* The number of alternative cache lines that can hold any particular memory | |
2759 | location. */ | |
2760 | /* #define INSN_CACHE_DEPTH */ | |
2761 | ||
2762 | /* Alternatively, if the machine has system calls or instructions to clear the | |
2763 | instruction cache directly, you can define the following macro. */ | |
2764 | ||
2765 | /* If defined, expands to a C expression clearing the *instruction cache* in | |
2766 | the specified interval. If it is not defined, and the macro INSN_CACHE_SIZE | |
2767 | is defined, some generic code is generated to clear the cache. The | |
2768 | definition of this macro would typically be a series of `asm' statements. | |
2769 | Both BEG and END are both pointer expressions. */ | |
2770 | /* #define CLEAR_INSN_CACHE (BEG, END) */ | |
2771 | ||
2772 | /* To use a standard subroutine, define the following macro. In addition, you | |
2773 | must make sure that the instructions in a trampoline fill an entire cache | |
2774 | line with identical instructions, or else ensure that the beginning of the | |
2775 | trampoline code is always aligned at the same point in its cache line. Look | |
2776 | in `m68k.h' as a guide. */ | |
2777 | ||
2778 | /* Define this macro if trampolines need a special subroutine to do their work. | |
2779 | The macro should expand to a series of `asm' statements which will be | |
2780 | compiled with GNU CC. They go in a library function named | |
2781 | `__transfer_from_trampoline'. | |
2782 | ||
2783 | If you need to avoid executing the ordinary prologue code of a compiled C | |
2784 | function when you jump to the subroutine, you can do so by placing a special | |
2785 | label of your own in the assembler code. Use one `asm' statement to | |
2786 | generate an assembler label, and another to make the label global. Then | |
2787 | trampolines can use that label to jump directly to your special assembler | |
2788 | code. */ | |
2789 | /* #define TRANSFER_FROM_TRAMPOLINE */ | |
2790 | ||
2791 | \f | |
2792 | /* Implicit Calls to Library Routines */ | |
2793 | ||
2794 | /* A C string constant giving the name of the function to call for | |
2795 | multiplication of one signed full-word by another. If you do not define | |
2796 | this macro, the default name is used, which is `__mulsi3', a function | |
2797 | defined in `libgcc.a'. */ | |
2798 | /* #define MULSI3_LIBCALL */ | |
2799 | ||
2800 | /* A C string constant giving the name of the function to call for division of | |
2801 | one signed full-word by another. If you do not define this macro, the | |
2802 | default name is used, which is `__divsi3', a function defined in `libgcc.a'. */ | |
2803 | /* #define DIVSI3_LIBCALL */ | |
2804 | ||
2805 | /* A C string constant giving the name of the function to call for division of | |
2806 | one unsigned full-word by another. If you do not define this macro, the | |
2807 | default name is used, which is `__udivsi3', a function defined in | |
2808 | `libgcc.a'. */ | |
2809 | /* #define UDIVSI3_LIBCALL */ | |
2810 | ||
2811 | /* A C string constant giving the name of the function to call for the | |
2812 | remainder in division of one signed full-word by another. If you do not | |
2813 | define this macro, the default name is used, which is `__modsi3', a function | |
2814 | defined in `libgcc.a'. */ | |
2815 | /* #define MODSI3_LIBCALL */ | |
2816 | ||
2817 | /* A C string constant giving the name of the function to call for the | |
2818 | remainder in division of one unsigned full-word by another. If you do not | |
2819 | define this macro, the default name is used, which is `__umodsi3', a | |
2820 | function defined in `libgcc.a'. */ | |
2821 | /* #define UMODSI3_LIBCALL */ | |
2822 | ||
2823 | /* A C string constant giving the name of the function to call for | |
2824 | multiplication of one signed double-word by another. If you do not define | |
2825 | this macro, the default name is used, which is `__muldi3', a function | |
2826 | defined in `libgcc.a'. */ | |
2827 | /* #define MULDI3_LIBCALL */ | |
2828 | ||
2829 | /* A C string constant giving the name of the function to call for division of | |
2830 | one signed double-word by another. If you do not define this macro, the | |
2831 | default name is used, which is `__divdi3', a function defined in `libgcc.a'. */ | |
2832 | /* #define DIVDI3_LIBCALL */ | |
2833 | ||
2834 | /* A C string constant giving the name of the function to call for division of | |
2835 | one unsigned full-word by another. If you do not define this macro, the | |
2836 | default name is used, which is `__udivdi3', a function defined in | |
2837 | `libgcc.a'. */ | |
2838 | /* #define UDIVDI3_LIBCALL */ | |
2839 | ||
2840 | /* A C string constant giving the name of the function to call for the | |
2841 | remainder in division of one signed double-word by another. If you do not | |
2842 | define this macro, the default name is used, which is `__moddi3', a function | |
2843 | defined in `libgcc.a'. */ | |
2844 | /* #define MODDI3_LIBCALL */ | |
2845 | ||
2846 | /* A C string constant giving the name of the function to call for the | |
2847 | remainder in division of one unsigned full-word by another. If you do not | |
2848 | define this macro, the default name is used, which is `__umoddi3', a | |
2849 | function defined in `libgcc.a'. */ | |
2850 | /* #define UMODDI3_LIBCALL */ | |
2851 | ||
2852 | /* Define this macro as a C statement that declares additional library routines | |
2853 | renames existing ones. `init_optabs' calls this macro after initializing all | |
2854 | the normal library routines. */ | |
2855 | /* #define INIT_TARGET_OPTABS */ | |
2856 | ||
2857 | /* The value of `EDOM' on the target machine, as a C integer constant | |
2858 | expression. If you don't define this macro, GNU CC does not attempt to | |
2859 | deposit the value of `EDOM' into `errno' directly. Look in | |
2860 | `/usr/include/errno.h' to find the value of `EDOM' on your system. | |
2861 | ||
2862 | If you do not define `TARGET_EDOM', then compiled code reports domain errors | |
2863 | by calling the library function and letting it report the error. If | |
2864 | mathematical functions on your system use `matherr' when there is an error, | |
2865 | then you should leave `TARGET_EDOM' undefined so that `matherr' is used | |
2866 | normally. */ | |
2867 | /* #define TARGET_EDOM */ | |
2868 | ||
2869 | /* Define this macro as a C expression to create an rtl expression that refers | |
2870 | to the global "variable" `errno'. (On certain systems, `errno' may not | |
2871 | actually be a variable.) If you don't define this macro, a reasonable | |
2872 | default is used. */ | |
2873 | /* #define GEN_ERRNO_RTX */ | |
2874 | ||
2875 | /* Define this macro if GNU CC should generate calls to the System V (and ANSI | |
2876 | C) library functions `memcpy' and `memset' rather than the BSD functions | |
2877 | `bcopy' and `bzero'. | |
2878 | ||
2879 | Defined in svr4.h. */ | |
2880 | #define TARGET_MEM_FUNCTIONS | |
2881 | ||
2882 | /* Define this macro if only `float' arguments cannot be passed to library | |
2883 | routines (so they must be converted to `double'). This macro affects both | |
2884 | how library calls are generated and how the library routines in `libgcc1.c' | |
2885 | accept their arguments. It is useful on machines where floating and fixed | |
2886 | point arguments are passed differently, such as the i860. */ | |
2887 | /* #define LIBGCC_NEEDS_DOUBLE */ | |
2888 | ||
2889 | /* Define this macro to override the type used by the library routines to pick | |
2890 | up arguments of type `float'. (By default, they use a union of `float' and | |
2891 | `int'.) | |
2892 | ||
2893 | The obvious choice would be `float'--but that won't work with traditional C | |
2894 | compilers that expect all arguments declared as `float' to arrive as | |
2895 | `double'. To avoid this conversion, the library routines ask for the value | |
2896 | as some other type and then treat it as a `float'. | |
2897 | ||
2898 | On some systems, no other type will work for this. For these systems, you | |
2899 | must use `LIBGCC_NEEDS_DOUBLE' instead, to force conversion of the values | |
2900 | `double' before they are passed. */ | |
2901 | /* #define FLOAT_ARG_TYPE */ | |
2902 | ||
2903 | /* Define this macro to override the way library routines redesignate a `float' | |
2904 | argument as a `float' instead of the type it was passed as. The default is | |
2905 | an expression which takes the `float' field of the union. */ | |
2906 | /* #define FLOATIFY(PASSED_VALUE) */ | |
2907 | ||
2908 | /* Define this macro to override the type used by the library routines to | |
2909 | return values that ought to have type `float'. (By default, they use | |
2910 | `int'.) | |
2911 | ||
2912 | The obvious choice would be `float'--but that won't work with traditional C | |
2913 | compilers gratuitously convert values declared as `float' into `double'. */ | |
2914 | /* #define FLOAT_VALUE_TYPE */ | |
2915 | ||
2916 | /* Define this macro to override the way the value of a `float'-returning | |
2917 | library routine should be packaged in order to return it. These functions | |
2918 | are actually declared to return type `FLOAT_VALUE_TYPE' (normally `int'). | |
2919 | ||
2920 | These values can't be returned as type `float' because traditional C | |
2921 | compilers would gratuitously convert the value to a `double'. | |
2922 | ||
2923 | A local variable named `intify' is always available when the macro `INTIFY' | |
2924 | is used. It is a union of a `float' field named `f' and a field named `i' | |
2925 | whose type is `FLOAT_VALUE_TYPE' or `int'. | |
2926 | ||
2927 | If you don't define this macro, the default definition works by copying the | |
2928 | value through that union. */ | |
2929 | /* #define INTIFY(FLOAT_VALUE) */ | |
2930 | ||
2931 | /* Define this macro as the name of the data type corresponding to `SImode' in | |
2932 | the system's own C compiler. | |
2933 | ||
2934 | You need not define this macro if that type is `long int', as it usually is. */ | |
2935 | /* #define nongcc_SI_type */ | |
2936 | ||
2937 | /* Define this macro as the name of the data type corresponding to the | |
2938 | word_mode in the system's own C compiler. | |
2939 | ||
2940 | You need not define this macro if that type is `long int', as it usually is. */ | |
2941 | /* #define nongcc_word_type */ | |
2942 | ||
2943 | /* Define these macros to supply explicit C statements to carry out various | |
2944 | arithmetic operations on types `float' and `double' in the library routines | |
2945 | in `libgcc1.c'. See that file for a full list of these macros and their | |
2946 | arguments. | |
2947 | ||
2948 | On most machines, you don't need to define any of these macros, because the | |
2949 | C compiler that comes with the system takes care of doing them. */ | |
2950 | /* #define perform_... */ | |
2951 | ||
2952 | /* Define this macro to generate code for Objective C message sending using the | |
2953 | calling convention of the NeXT system. This calling convention involves | |
2954 | passing the object, the selector and the method arguments all at once to the | |
2955 | method-lookup library function. | |
2956 | ||
2957 | The default calling convention passes just the object and the selector to | |
2958 | the lookup function, which returns a pointer to the method. */ | |
2959 | /* #define NEXT_OBJC_RUNTIME */ | |
2960 | ||
2961 | \f | |
2962 | /* Addressing Modes */ | |
2963 | ||
2964 | /* Define this macro if the machine supports post-increment addressing. */ | |
2965 | #define HAVE_POST_INCREMENT 1 | |
2966 | ||
2967 | /* Similar for other kinds of addressing. */ | |
2968 | /* #define HAVE_PRE_INCREMENT 1 */ | |
2969 | /* #define HAVE_POST_DECREMENT 1 */ | |
2970 | #define HAVE_PRE_DECREMENT 1 | |
2971 | ||
2972 | /* A C expression that is 1 if the RTX X is a constant which is a valid | |
2973 | address. On most machines, this can be defined as `CONSTANT_P (X)', but a | |
2974 | few machines are more restrictive in which constant addresses are supported. | |
2975 | ||
2976 | `CONSTANT_P' accepts integer-values expressions whose values are not | |
2977 | explicitly known, such as `symbol_ref', `label_ref', and `high' expressions | |
2978 | and `const' arithmetic expressions, in addition to `const_int' and | |
2979 | `const_double' expressions. */ | |
2980 | #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X) | |
2981 | ||
2982 | /* A number, the maximum number of registers that can appear in a valid memory | |
2983 | address. Note that it is up to you to specify a value equal to the maximum | |
2984 | number that `GO_IF_LEGITIMATE_ADDRESS' would ever accept. */ | |
2985 | #define MAX_REGS_PER_ADDRESS 1 | |
2986 | ||
2987 | /* A C compound statement with a conditional `goto LABEL;' executed if X (an | |
2988 | RTX) is a legitimate memory address on the target machine for a memory | |
2989 | operand of mode MODE. | |
2990 | ||
2991 | It usually pays to define several simpler macros to serve as subroutines for | |
2992 | this one. Otherwise it may be too complicated to understand. | |
2993 | ||
2994 | This macro must exist in two variants: a strict variant and a non-strict | |
2995 | one. The strict variant is used in the reload pass. It must be defined so | |
2996 | that any pseudo-register that has not been allocated a hard register is | |
2997 | considered a memory reference. In contexts where some kind of register is | |
2998 | required, a pseudo-register with no hard register must be rejected. | |
2999 | ||
3000 | The non-strict variant is used in other passes. It must be defined to | |
3001 | accept all pseudo-registers in every context where some kind of register is | |
3002 | required. | |
3003 | ||
3004 | Compiler source files that want to use the strict variant of this macro | |
3005 | define the macro `REG_OK_STRICT'. You should use an `#ifdef REG_OK_STRICT' | |
3006 | conditional to define the strict variant in that case and the non-strict | |
3007 | variant otherwise. | |
3008 | ||
3009 | Subroutines to check for acceptable registers for various purposes (one for | |
3010 | base registers, one for index registers, and so on) are typically among the | |
3011 | subroutines used to define `GO_IF_LEGITIMATE_ADDRESS'. Then only these | |
3012 | subroutine macros need have two variants; the higher levels of macros may be | |
3013 | the same whether strict or not. | |
3014 | ||
3015 | Normally, constant addresses which are the sum of a `symbol_ref' and an | |
3016 | integer are stored inside a `const' RTX to mark them as constant. | |
3017 | Therefore, there is no need to recognize such sums specifically as | |
3018 | legitimate addresses. Normally you would simply recognize any `const' as | |
3019 | legitimate. | |
3020 | ||
3021 | Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant sums that | |
3022 | are not marked with `const'. It assumes that a naked `plus' indicates | |
3023 | indexing. If so, then you *must* reject such naked constant sums as | |
3024 | illegitimate addresses, so that none of them will be given to | |
3025 | `PRINT_OPERAND_ADDRESS'. | |
3026 | ||
3027 | On some machines, whether a symbolic address is legitimate depends on the | |
3028 | section that the address refers to. On these machines, define the macro | |
3029 | `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and | |
3030 | then check for it here. When you see a `const', you will have to look | |
3031 | inside it to find the `symbol_ref' in order to determine the section. | |
3032 | ||
3033 | The best way to modify the name string is by adding text to the beginning, | |
3034 | with suitable punctuation to prevent any ambiguity. Allocate the new name | |
3035 | in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to | |
3036 | remove and decode the added text and output the name accordingly, and define | |
3037 | `STRIP_NAME_ENCODING' to access the original name string. | |
3038 | ||
3039 | You can check the information stored here into the `symbol_ref' in the | |
3040 | definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and | |
3041 | `PRINT_OPERAND_ADDRESS'. */ | |
3042 | #ifdef REG_OK_STRICT | |
3043 | #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \ | |
3044 | do { \ | |
c6243b4c | 3045 | if (xstormy16_legitimate_address_p (MODE, X, 1)) \ |
4b58290f GK |
3046 | goto LABEL; \ |
3047 | } while (0) | |
3048 | #else | |
3049 | #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \ | |
3050 | do { \ | |
c6243b4c | 3051 | if (xstormy16_legitimate_address_p (MODE, X, 0)) \ |
4b58290f GK |
3052 | goto LABEL; \ |
3053 | } while (0) | |
3054 | #endif | |
3055 | /* A C expression that is nonzero if X (assumed to be a `reg' RTX) is valid for | |
3056 | use as a base register. For hard registers, it should always accept those | |
3057 | which the hardware permits and reject the others. Whether the macro accepts | |
3058 | or rejects pseudo registers must be controlled by `REG_OK_STRICT' as | |
3059 | described above. This usually requires two variant definitions, of which | |
3060 | `REG_OK_STRICT' controls the one actually used. */ | |
3061 | #ifdef REG_OK_STRICT | |
3062 | #define REG_OK_FOR_BASE_P(X) \ | |
3063 | (REGNO_OK_FOR_BASE_P (REGNO (X)) && (REGNO (X) < FIRST_PSEUDO_REGISTER)) | |
3064 | #else | |
3065 | #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) | |
3066 | #endif | |
3067 | ||
3068 | /* A C expression that is nonzero if X (assumed to be a `reg' RTX) is valid for | |
3069 | use as an index register. | |
3070 | ||
3071 | The difference between an index register and a base register is that the | |
3072 | index register may be scaled. If an address involves the sum of two | |
3073 | registers, neither one of them scaled, then either one may be labeled the | |
3074 | "base" and the other the "index"; but whichever labeling is used must fit | |
3075 | the machine's constraints of which registers may serve in each capacity. | |
3076 | The compiler will try both labelings, looking for one that is valid, and | |
3077 | will reload one or both registers only if neither labeling works. */ | |
3078 | #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X) | |
3079 | ||
3080 | /* A C compound statement that attempts to replace X with a valid memory | |
3081 | address for an operand of mode MODE. WIN will be a C statement label | |
3082 | elsewhere in the code; the macro definition may use | |
3083 | ||
3084 | GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); | |
3085 | ||
3086 | to avoid further processing if the address has become legitimate. | |
3087 | ||
3088 | X will always be the result of a call to `break_out_memory_refs', and OLDX | |
3089 | will be the operand that was given to that function to produce X. | |
3090 | ||
3091 | The code generated by this macro should not alter the substructure of X. If | |
3092 | it transforms X into a more legitimate form, it should assign X (which will | |
3093 | always be a C variable) a new value. | |
3094 | ||
3095 | It is not necessary for this macro to come up with a legitimate address. | |
3096 | The compiler has standard ways of doing so in all cases. In fact, it is | |
3097 | safe for this macro to do nothing. But often a machine-dependent strategy | |
3098 | can generate better code. */ | |
3099 | #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) | |
3100 | ||
3101 | /* A C statement or compound statement with a conditional `goto LABEL;' | |
3102 | executed if memory address X (an RTX) can have different meanings depending | |
3103 | on the machine mode of the memory reference it is used for or if the address | |
3104 | is valid for some modes but not others. | |
3105 | ||
3106 | Autoincrement and autodecrement addresses typically have mode-dependent | |
3107 | effects because the amount of the increment or decrement is the size of the | |
3108 | operand being addressed. Some machines have other mode-dependent addresses. | |
3109 | Many RISC machines have no mode-dependent addresses. | |
3110 | ||
3111 | You may assume that ADDR is a valid address for the machine. | |
3112 | ||
3113 | On this chip, this is true if the address is valid with an offset | |
3114 | of 0 but not of 6, because in that case it cannot be used as an | |
3115 | address for DImode or DFmode, or if the address is a post-increment | |
3116 | or pre-decrement address. | |
3117 | */ | |
3118 | #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ | |
c6243b4c | 3119 | if (xstormy16_mode_dependent_address_p (ADDR)) \ |
4b58290f GK |
3120 | goto LABEL |
3121 | ||
3122 | /* A C expression that is nonzero if X is a legitimate constant for an | |
3123 | immediate operand on the target machine. You can assume that X satisfies | |
3124 | `CONSTANT_P', so you need not check this. In fact, `1' is a suitable | |
3125 | definition for this macro on machines where anything `CONSTANT_P' is valid. */ | |
3126 | #define LEGITIMATE_CONSTANT_P(X) 1 | |
3127 | ||
3128 | \f | |
3129 | /* Condition Code Status */ | |
3130 | ||
3131 | /* C code for a data type which is used for declaring the `mdep' component of | |
3132 | `cc_status'. It defaults to `int'. | |
3133 | ||
3134 | This macro is not used on machines that do not use `cc0'. */ | |
3135 | /* #define CC_STATUS_MDEP */ | |
3136 | ||
3137 | /* A C expression to initialize the `mdep' field to "empty". The default | |
3138 | definition does nothing, since most machines don't use the field anyway. If | |
3139 | you want to use the field, you should probably define this macro to | |
3140 | initialize it. | |
3141 | ||
3142 | This macro is not used on machines that do not use `cc0'. */ | |
3143 | /* #define CC_STATUS_MDEP_INIT */ | |
3144 | ||
3145 | /* A C compound statement to set the components of `cc_status' appropriately | |
3146 | for an insn INSN whose body is EXP. It is this macro's responsibility to | |
3147 | recognize insns that set the condition code as a byproduct of other activity | |
3148 | as well as those that explicitly set `(cc0)'. | |
3149 | ||
3150 | This macro is not used on machines that do not use `cc0'. | |
3151 | ||
3152 | If there are insns that do not set the condition code but do alter other | |
3153 | machine registers, this macro must check to see whether they invalidate the | |
3154 | expressions that the condition code is recorded as reflecting. For example, | |
3155 | on the 68000, insns that store in address registers do not set the condition | |
3156 | code, which means that usually `NOTICE_UPDATE_CC' can leave `cc_status' | |
3157 | unaltered for such insns. But suppose that the previous insn set the | |
3158 | condition code based on location `a4@(102)' and the current insn stores a | |
3159 | new value in `a4'. Although the condition code is not changed by this, it | |
3160 | will no longer be true that it reflects the contents of `a4@(102)'. | |
3161 | Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this case to say | |
3162 | that nothing is known about the condition code value. | |
3163 | ||
3164 | The definition of `NOTICE_UPDATE_CC' must be prepared to deal with the | |
3165 | results of peephole optimization: insns whose patterns are `parallel' RTXs | |
3166 | containing various `reg', `mem' or constants which are just the operands. | |
3167 | The RTL structure of these insns is not sufficient to indicate what the | |
3168 | insns actually do. What `NOTICE_UPDATE_CC' should do when it sees one is | |
3169 | just to run `CC_STATUS_INIT'. | |
3170 | ||
3171 | A possible definition of `NOTICE_UPDATE_CC' is to call a function that looks | |
3172 | at an attribute named, for example, `cc'. This avoids having detailed | |
3173 | information about patterns in two places, the `md' file and in | |
3174 | `NOTICE_UPDATE_CC'. */ | |
3175 | /* #define NOTICE_UPDATE_CC(EXP, INSN) */ | |
3176 | ||
3177 | /* A list of names to be used for additional modes for condition code values in | |
3178 | registers. These names are added to `enum machine_mode' and all have class | |
3179 | `MODE_CC'. By convention, they should start with `CC' and end with `mode'. | |
3180 | ||
3181 | You should only define this macro if your machine does not use `cc0' and | |
3182 | only if additional modes are required. */ | |
3183 | /* #define EXTRA_CC_MODES */ | |
3184 | ||
3185 | /* Returns a mode from class `MODE_CC' to be used when comparison operation | |
3186 | code OP is applied to rtx X and Y. For example, on the Sparc, | |
3187 | `SELECT_CC_MODE' is defined as (see *note Jump Patterns::. for a | |
3188 | description of the reason for this definition) | |
3189 | ||
3190 | #define SELECT_CC_MODE(OP,X,Y) \ | |
3191 | (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ | |
3192 | ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode) \ | |
3193 | : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS \ | |
3194 | || GET_CODE (X) == NEG) \ | |
3195 | ? CC_NOOVmode : CCmode)) | |
3196 | ||
3197 | You need not define this macro if `EXTRA_CC_MODES' is not defined. */ | |
3198 | /* #define SELECT_CC_MODE(OP, X, Y) */ | |
3199 | ||
3200 | /* One some machines not all possible comparisons are defined, but you can | |
3201 | convert an invalid comparison into a valid one. For example, the Alpha does | |
3202 | not have a `GT' comparison, but you can use an `LT' comparison instead and | |
3203 | swap the order of the operands. | |
3204 | ||
3205 | On such machines, define this macro to be a C statement to do any required | |
3206 | conversions. CODE is the initial comparison code and OP0 and OP1 are the | |
3207 | left and right operands of the comparison, respectively. You should modify | |
3208 | CODE, OP0, and OP1 as required. | |
3209 | ||
3210 | GNU CC will not assume that the comparison resulting from this macro is | |
3211 | valid but will see if the resulting insn matches a pattern in the `md' file. | |
3212 | ||
3213 | You need not define this macro if it would never change the comparison code | |
3214 | or operands. */ | |
3215 | /* #define CANONICALIZE_COMPARISON(CODE, OP0, OP1) */ | |
3216 | ||
3217 | /* A C expression whose value is one if it is always safe to reverse a | |
3218 | comparison whose mode is MODE. If `SELECT_CC_MODE' can ever return MODE for | |
3219 | a floating-point inequality comparison, then `REVERSIBLE_CC_MODE (MODE)' | |
3220 | must be zero. | |
3221 | ||
3222 | You need not define this macro if it would always returns zero or if the | |
3223 | floating-point format is anything other than `IEEE_FLOAT_FORMAT'. For | |
3224 | example, here is the definition used on the Sparc, where floating-point | |
3225 | inequality comparisons are always given `CCFPEmode': | |
3226 | ||
3227 | #define REVERSIBLE_CC_MODE(MODE) ((MODE) != CCFPEmode) */ | |
3228 | /* #define REVERSIBLE_CC_MODE(MODE) */ | |
3229 | ||
3230 | \f | |
3231 | /* Describing Relative Costs of Operations */ | |
3232 | ||
3233 | /* A part of a C `switch' statement that describes the relative costs of | |
3234 | constant RTL expressions. It must contain `case' labels for expression | |
3235 | codes `const_int', `const', `symbol_ref', `label_ref' and `const_double'. | |
3236 | Each case must ultimately reach a `return' statement to return the relative | |
3237 | cost of the use of that kind of constant value in an expression. The cost | |
3238 | may depend on the precise value of the constant, which is available for | |
3239 | examination in X, and the rtx code of the expression in which it is | |
3240 | contained, found in OUTER_CODE. | |
3241 | ||
3242 | CODE is the expression code--redundant, since it can be obtained with | |
3243 | `GET_CODE (X)'. */ | |
3fdb2f71 GK |
3244 | #define CONST_COSTS(X, CODE, OUTER_CODE) \ |
3245 | case CONST_INT: \ | |
3246 | if (INTVAL (X) < 16 && INTVAL (X) >= 0) \ | |
3247 | return COSTS_N_INSNS (1)/2; \ | |
3248 | if (INTVAL (X) < 256 && INTVAL (X) >= 0) \ | |
3249 | return COSTS_N_INSNS (1); \ | |
3250 | case CONST_DOUBLE: \ | |
3251 | case CONST: \ | |
3252 | case SYMBOL_REF: \ | |
3253 | case LABEL_REF: \ | |
3254 | return COSTS_N_INSNS(2); | |
4b58290f GK |
3255 | |
3256 | /* Like `CONST_COSTS' but applies to nonconstant RTL expressions. This can be | |
3257 | used, for example, to indicate how costly a multiply instruction is. In | |
3258 | writing this macro, you can use the construct `COSTS_N_INSNS (N)' to specify | |
3259 | a cost equal to N fast instructions. OUTER_CODE is the code of the | |
3260 | expression in which X is contained. | |
3261 | ||
3262 | This macro is optional; do not define it if the default cost assumptions are | |
3263 | adequate for the target machine. */ | |
3fdb2f71 GK |
3264 | #define RTX_COSTS(X, CODE, OUTER_CODE) \ |
3265 | case MULT: \ | |
3266 | return COSTS_N_INSNS (35 + 6); \ | |
3267 | case DIV: \ | |
3268 | return COSTS_N_INSNS (51 - 6); | |
4b58290f GK |
3269 | |
3270 | /* An expression giving the cost of an addressing mode that contains ADDRESS. | |
3271 | If not defined, the cost is computed from the ADDRESS expression and the | |
3272 | `CONST_COSTS' values. | |
3273 | ||
3274 | For most CISC machines, the default cost is a good approximation of the true | |
3275 | cost of the addressing mode. However, on RISC machines, all instructions | |
3276 | normally have the same length and execution time. Hence all addresses will | |
3277 | have equal costs. | |
3278 | ||
3279 | In cases where more than one form of an address is known, the form with the | |
3280 | lowest cost will be used. If multiple forms have the same, lowest, cost, | |
3281 | the one that is the most complex will be used. | |
3282 | ||
3283 | For example, suppose an address that is equal to the sum of a register and a | |
3284 | constant is used twice in the same basic block. When this macro is not | |
3285 | defined, the address will be computed in a register and memory references | |
3286 | will be indirect through that register. On machines where the cost of the | |
3287 | addressing mode containing the sum is no higher than that of a simple | |
3288 | indirect reference, this will produce an additional instruction and possibly | |
3289 | require an additional register. Proper specification of this macro | |
3290 | eliminates this overhead for such machines. | |
3291 | ||
3292 | Similar use of this macro is made in strength reduction of loops. | |
3293 | ||
3294 | ADDRESS need not be valid as an address. In such a case, the cost is not | |
3295 | relevant and can be any value; invalid addresses need not be assigned a | |
3296 | different cost. | |
3297 | ||
3298 | On machines where an address involving more than one register is as cheap as | |
3299 | an address computation involving only one register, defining `ADDRESS_COST' | |
3300 | to reflect this can cause two registers to be live over a region of code | |
3301 | where only one would have been if `ADDRESS_COST' were not defined in that | |
3302 | manner. This effect should be considered in the definition of this macro. | |
3303 | Equivalent costs should probably only be given to addresses with different | |
3304 | numbers of registers on machines with lots of registers. | |
3305 | ||
3fdb2f71 GK |
3306 | This macro will normally either not be defined or be defined as a |
3307 | constant. */ | |
3308 | #define ADDRESS_COST(ADDRESS) \ | |
3309 | (GET_CODE (ADDRESS) == CONST_INT ? 2 \ | |
3310 | : GET_CODE (ADDRESS) == PLUS ? 7 \ | |
3311 | : 5) | |
4b58290f GK |
3312 | |
3313 | /* A C expression for the cost of moving data of mode MODE from a | |
3314 | register in class FROM to one in class TO. The classes are | |
3315 | expressed using the enumeration values such as `GENERAL_REGS'. A | |
3316 | value of 4 is the default; other values are interpreted relative to | |
3317 | that. | |
3318 | ||
3319 | It is not required that the cost always equal 2 when FROM is the same as TO; | |
3320 | on some machines it is expensive to move between registers if they are not | |
3321 | general registers. | |
3322 | ||
3323 | If reload sees an insn consisting of a single `set' between two hard | |
3324 | registers, and if `REGISTER_MOVE_COST' applied to their classes returns a | |
3325 | value of 2, reload does not check to ensure that the constraints of the insn | |
3326 | are met. Setting a cost of other than 2 will allow reload to verify that | |
3327 | the constraints are met. You should do this if the `movM' pattern's | |
3328 | constraints do not allow such copying. */ | |
3329 | #define REGISTER_MOVE_COST(MODE, FROM, TO) 2 | |
3330 | ||
3331 | /* A C expression for the cost of moving data of mode M between a register and | |
3332 | memory. A value of 2 is the default; this cost is relative to those in | |
3333 | `REGISTER_MOVE_COST'. | |
3334 | ||
3335 | If moving between registers and memory is more expensive than between two | |
3336 | registers, you should define this macro to express the relative cost. */ | |
3fdb2f71 | 3337 | #define MEMORY_MOVE_COST(M,C,I) (5 + memory_move_secondary_cost (M, C, I)) |
4b58290f GK |
3338 | |
3339 | /* A C expression for the cost of a branch instruction. A value of 1 is the | |
3340 | default; other values are interpreted relative to that. */ | |
3341 | ||
3342 | #define BRANCH_COST 5 | |
3343 | ||
3344 | /* Here are additional macros which do not specify precise relative costs, but | |
3345 | only that certain actions are more expensive than GNU CC would ordinarily | |
3346 | expect. */ | |
3347 | ||
3348 | /* Define this macro as a C expression which is nonzero if accessing less than | |
3349 | a word of memory (i.e. a `char' or a `short') is no faster than accessing a | |
3350 | word of memory, i.e., if such access require more than one instruction or if | |
3351 | there is no difference in cost between byte and (aligned) word loads. | |
3352 | ||
3353 | When this macro is not defined, the compiler will access a field by finding | |
3354 | the smallest containing object; when it is defined, a fullword load will be | |
3355 | used if alignment permits. Unless bytes accesses are faster than word | |
3356 | accesses, using word accesses is preferable since it may eliminate | |
3357 | subsequent memory access if subsequent accesses occur to other fields in the | |
3358 | same word of the structure, but to different bytes. */ | |
3359 | #define SLOW_BYTE_ACCESS 0 | |
3360 | ||
3361 | /* Define this macro if zero-extension (of a `char' or `short' to an `int') can | |
3362 | be done faster if the destination is a register that is known to be zero. | |
3363 | ||
3364 | If you define this macro, you must have instruction patterns that recognize | |
3365 | RTL structures like this: | |
3366 | ||
3367 | (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...) | |
3368 | ||
3369 | and likewise for `HImode'. */ | |
3370 | #define SLOW_ZERO_EXTEND 0 | |
3371 | ||
3372 | /* Define this macro to be the value 1 if unaligned accesses have a cost many | |
3373 | times greater than aligned accesses, for example if they are emulated in a | |
3374 | trap handler. | |
3375 | ||
3376 | When this macro is non-zero, the compiler will act as if `STRICT_ALIGNMENT' | |
3377 | were non-zero when generating code for block moves. This can cause | |
3378 | significantly more instructions to be produced. Therefore, do not set this | |
3379 | macro non-zero if unaligned accesses only add a cycle or two to the time for | |
3380 | a memory access. | |
3381 | ||
3382 | If the value of this macro is always zero, it need not be defined. */ | |
3383 | /* #define SLOW_UNALIGNED_ACCESS */ | |
3384 | ||
3385 | /* Define this macro to inhibit strength reduction of memory addresses. (On | |
3386 | some machines, such strength reduction seems to do harm rather than good.) */ | |
3387 | /* #define DONT_REDUCE_ADDR */ | |
3388 | ||
3389 | /* The number of scalar move insns which should be generated instead of a | |
3390 | string move insn or a library call. Increasing the value will always make | |
3391 | code faster, but eventually incurs high cost in increased code size. | |
3392 | ||
3393 | If you don't define this, a reasonable default is used. */ | |
3394 | /* #define MOVE_RATIO */ | |
3395 | ||
3396 | /* Define this macro if it is as good or better to call a constant function | |
3397 | address than to call an address kept in a register. */ | |
3398 | #define NO_FUNCTION_CSE | |
3399 | ||
3400 | /* Define this macro if it is as good or better for a function to call itself | |
3401 | with an explicit address than to call an address kept in a register. */ | |
3402 | #define NO_RECURSIVE_FUNCTION_CSE | |
3403 | ||
3404 | /* A C statement (sans semicolon) to update the integer variable COST based on | |
3405 | the relationship between INSN that is dependent on DEP_INSN through the | |
3406 | dependence LINK. The default is to make no adjustment to COST. This can be | |
3407 | used for example to specify to the scheduler that an output- or | |
3408 | anti-dependence does not incur the same cost as a data-dependence. */ | |
3409 | /* #define ADJUST_COST(INSN, LINK, DEP_INSN, COST) */ | |
3410 | ||
3411 | /* A C statement (sans semicolon) to update the integer scheduling | |
3412 | priority `INSN_PRIORITY(INSN)'. Reduce the priority to execute | |
3413 | the INSN earlier, increase the priority to execute INSN later. | |
3414 | Do not define this macro if you do not need to adjust the | |
3415 | scheduling priorities of insns. */ | |
3416 | /* #define ADJUST_PRIORITY (INSN) */ | |
3417 | ||
3418 | \f | |
3419 | /* Dividing the output into sections. */ | |
3420 | ||
3421 | /* A C expression whose value is a string containing the assembler operation | |
3422 | that should precede instructions and read-only data. Normally `".text"' is | |
3423 | right. */ | |
3424 | #define TEXT_SECTION_ASM_OP ".text" | |
3425 | ||
3426 | /* A C expression whose value is a string containing the assembler operation to | |
3427 | identify the following data as writable initialized data. Normally | |
3428 | `".data"' is right. */ | |
3429 | #define DATA_SECTION_ASM_OP ".data" | |
3430 | ||
3431 | /* if defined, a C expression whose value is a string containing the assembler | |
3432 | operation to identify the following data as shared data. If not defined, | |
3433 | `DATA_SECTION_ASM_OP' will be used. */ | |
3434 | /* #define SHARED_SECTION_ASM_OP */ | |
3435 | ||
3436 | /* If defined, a C expression whose value is a string containing the | |
3437 | assembler operation to identify the following data as | |
3438 | uninitialized global data. If not defined, and neither | |
3439 | `ASM_OUTPUT_BSS' nor `ASM_OUTPUT_ALIGNED_BSS' are defined, | |
3440 | uninitialized global data will be output in the data section if | |
3441 | `-fno-common' is passed, otherwise `ASM_OUTPUT_COMMON' will be | |
3442 | used. */ | |
3443 | #define BSS_SECTION_ASM_OP ".bss" | |
3444 | ||
3445 | /* If defined, a C expression whose value is a string containing the | |
3446 | assembler operation to identify the following data as | |
3447 | uninitialized global shared data. If not defined, and | |
3448 | `BSS_SECTION_ASM_OP' is, the latter will be used. */ | |
3449 | /* #define SHARED_BSS_SECTION_ASM_OP */ | |
3450 | ||
3451 | /* Define the pseudo-ops used to switch to the .ctors and .dtors sections. | |
3452 | There are no shared libraries on this target so these sections need | |
3453 | not be writable. | |
3454 | ||
3455 | Defined in elfos.h. */ | |
3456 | ||
3457 | #undef CTORS_SECTION_ASM_OP | |
3458 | #undef DTORS_SECTION_ASM_OP | |
3459 | #define CTORS_SECTION_ASM_OP "\t.section\t.ctors,\"a\"" | |
3460 | #define DTORS_SECTION_ASM_OP "\t.section\t.dtors,\"a\"" | |
3461 | ||
3462 | /* A list of names for sections other than the standard two, which are | |
3463 | `in_text' and `in_data'. You need not define this macro on a system with no | |
3464 | other sections (that GCC needs to use). | |
3465 | ||
3466 | Defined in svr4.h. */ | |
3467 | /* #define EXTRA_SECTIONS */ | |
3468 | ||
3469 | /* One or more functions to be defined in `varasm.c'. These functions should | |
3470 | do jobs analogous to those of `text_section' and `data_section', for your | |
3471 | additional sections. Do not define this macro if you do not define | |
3472 | `EXTRA_SECTIONS'. | |
3473 | ||
3474 | Defined in svr4.h. */ | |
3475 | /* #define EXTRA_SECTION_FUNCTIONS */ | |
3476 | ||
3477 | /* On most machines, read-only variables, constants, and jump tables are placed | |
3478 | in the text section. If this is not the case on your machine, this macro | |
3479 | should be defined to be the name of a function (either `data_section' or a | |
3480 | function defined in `EXTRA_SECTIONS') that switches to the section to be | |
3481 | used for read-only items. | |
3482 | ||
3483 | If these items should be placed in the text section, this macro should not | |
3484 | be defined. */ | |
3485 | /* #define READONLY_DATA_SECTION */ | |
3486 | ||
3487 | /* A C statement or statements to switch to the appropriate section for output | |
3488 | of EXP. You can assume that EXP is either a `VAR_DECL' node or a constant | |
3489 | of some sort. RELOC indicates whether the initial value of EXP requires | |
3490 | link-time relocations. Select the section by calling `text_section' or one | |
3491 | of the alternatives for other sections. | |
3492 | ||
3493 | Do not define this macro if you put all read-only variables and constants in | |
3494 | the read-only data section (usually the text section). | |
3495 | ||
3496 | Defined in svr4.h. */ | |
201556f0 | 3497 | /* #define SELECT_SECTION(EXP, RELOC, ALIGN) */ |
4b58290f GK |
3498 | |
3499 | /* A C statement or statements to switch to the appropriate section for output | |
3500 | of RTX in mode MODE. You can assume that RTX is some kind of constant in | |
3501 | RTL. The argument MODE is redundant except in the case of a `const_int' | |
3502 | rtx. Select the section by calling `text_section' or one of the | |
3503 | alternatives for other sections. | |
3504 | ||
3505 | Do not define this macro if you put all constants in the read-only data | |
3506 | section. | |
3507 | ||
3508 | Defined in svr4.h. */ | |
201556f0 | 3509 | /* #define SELECT_RTX_SECTION(MODE, RTX, ALIGN) */ |
4b58290f GK |
3510 | |
3511 | /* Define this macro if jump tables (for `tablejump' insns) should be output in | |
3512 | the text section, along with the assembler instructions. Otherwise, the | |
3513 | readonly data section is used. | |
3514 | ||
3515 | This macro is irrelevant if there is no separate readonly data section. */ | |
3516 | #define JUMP_TABLES_IN_TEXT_SECTION 1 | |
3517 | ||
3518 | /* Define this macro if references to a symbol must be treated differently | |
3519 | depending on something about the variable or function named by the symbol | |
3520 | (such as what section it is in). | |
3521 | ||
3522 | The macro definition, if any, is executed immediately after the rtl for DECL | |
3523 | has been created and stored in `DECL_RTL (DECL)'. The value of the rtl will | |
3524 | be a `mem' whose address is a `symbol_ref'. | |
3525 | ||
3526 | The usual thing for this macro to do is to record a flag in the `symbol_ref' | |
3527 | (such as `SYMBOL_REF_FLAG') or to store a modified name string in the | |
3528 | `symbol_ref' (if one bit is not enough information). */ | |
c6243b4c | 3529 | #define ENCODE_SECTION_INFO(DECL) xstormy16_encode_section_info(DECL) |
4b58290f GK |
3530 | |
3531 | /* Decode SYM_NAME and store the real name part in VAR, sans the characters | |
3532 | that encode section info. Define this macro if `ENCODE_SECTION_INFO' alters | |
3533 | the symbol's name string. */ | |
3534 | /* #define STRIP_NAME_ENCODING(VAR, SYM_NAME) */ | |
3535 | ||
3536 | /* A C statement to build up a unique section name, expressed as a | |
3537 | STRING_CST node, and assign it to `DECL_SECTION_NAME (DECL)'. | |
3538 | RELOC indicates whether the initial value of EXP requires | |
3539 | link-time relocations. If you do not define this macro, GNU CC | |
3540 | will use the symbol name prefixed by `.' as the section name. | |
3541 | ||
3542 | Defined in svr4.h. */ | |
3543 | /* #define UNIQUE_SECTION(DECL, RELOC) */ | |
3544 | ||
3545 | \f | |
3546 | /* Position Independent Code. */ | |
3547 | ||
3548 | /* The register number of the register used to address a table of static data | |
3549 | addresses in memory. In some cases this register is defined by a | |
3550 | processor's "application binary interface" (ABI). When this macro is | |
3551 | defined, RTL is generated for this register once, as with the stack pointer | |
3552 | and frame pointer registers. If this macro is not defined, it is up to the | |
3553 | machine-dependent files to allocate such a register (if necessary). */ | |
3554 | /* #define PIC_OFFSET_TABLE_REGNUM */ | |
3555 | ||
3556 | /* Define this macro if the register defined by `PIC_OFFSET_TABLE_REGNUM' is | |
3557 | clobbered by calls. Do not define this macro if `PPIC_OFFSET_TABLE_REGNUM' | |
3558 | is not defined. */ | |
3559 | /* #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED */ | |
3560 | ||
3561 | /* By generating position-independent code, when two different programs (A and | |
3562 | B) share a common library (libC.a), the text of the library can be shared | |
3563 | whether or not the library is linked at the same address for both programs. | |
3564 | In some of these environments, position-independent code requires not only | |
3565 | the use of different addressing modes, but also special code to enable the | |
3566 | use of these addressing modes. | |
3567 | ||
3568 | The `FINALIZE_PIC' macro serves as a hook to emit these special codes once | |
3569 | the function is being compiled into assembly code, but not before. (It is | |
3570 | not done before, because in the case of compiling an inline function, it | |
3571 | would lead to multiple PIC prologues being included in functions which used | |
3572 | inline functions and were compiled to assembly language.) */ | |
3573 | /* #define FINALIZE_PIC */ | |
3574 | ||
3575 | /* A C expression that is nonzero if X is a legitimate immediate operand on the | |
3576 | target machine when generating position independent code. You can assume | |
3577 | that X satisfies `CONSTANT_P', so you need not check this. You can also | |
3578 | assume FLAG_PIC is true, so you need not check it either. You need not | |
3579 | define this macro if all constants (including `SYMBOL_REF') can be immediate | |
3580 | operands when generating position independent code. */ | |
3581 | /* #define LEGITIMATE_PIC_OPERAND_P(X) */ | |
3582 | ||
3583 | \f | |
3584 | /* The Overall Framework of an Assembler File. */ | |
3585 | ||
3586 | /* A C expression which outputs to the stdio stream STREAM some appropriate | |
3587 | text to go at the start of an assembler file. | |
3588 | ||
3589 | Normally this macro is defined to output a line containing `#NO_APP', which | |
3590 | is a comment that has no effect on most assemblers but tells the GNU | |
3591 | assembler that it can save time by not checking for certain assembler | |
3592 | constructs. | |
3593 | ||
3594 | On systems that use SDB, it is necessary to output certain commands; see | |
3595 | `attasm.h'. | |
3596 | ||
3597 | Defined in svr4.h. */ | |
3598 | /* #define ASM_FILE_START(STREAM) */ | |
3599 | ||
3600 | /* A C expression which outputs to the stdio stream STREAM some appropriate | |
3601 | text to go at the end of an assembler file. | |
3602 | ||
3603 | If this macro is not defined, the default is to output nothing special at | |
3604 | the end of the file. Most systems don't require any definition. | |
3605 | ||
3606 | On systems that use SDB, it is necessary to output certain commands; see | |
3607 | `attasm.h'. | |
3608 | ||
3609 | Defined in svr4.h. */ | |
3610 | /* #define ASM_FILE_END(STREAM) */ | |
3611 | ||
3612 | /* A C statement to output assembler commands which will identify the object | |
3613 | file as having been compiled with GNU CC (or another GNU compiler). | |
3614 | ||
3615 | If you don't define this macro, the string `gcc_compiled.:' is output. This | |
3616 | string is calculated to define a symbol which, on BSD systems, will never be | |
3617 | defined for any other reason. GDB checks for the presence of this symbol | |
3618 | when reading the symbol table of an executable. | |
3619 | ||
3620 | On non-BSD systems, you must arrange communication with GDB in some other | |
3621 | fashion. If GDB is not used on your system, you can define this macro with | |
3622 | an empty body. | |
3623 | ||
3624 | Defined in svr4.h. */ | |
3625 | /* #define ASM_IDENTIFY_GCC(FILE) */ | |
3626 | ||
3627 | /* Like ASM_IDENTIFY_GCC, but used when dbx debugging is selected to emit | |
3628 | a stab the debugger uses to identify gcc as the compiler that is emitted | |
3629 | after the stabs for the filename, which makes it easier for GDB to parse. | |
3630 | ||
3631 | Defined in svr4.h. */ | |
3632 | /* #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) */ | |
3633 | ||
3634 | /* A C string constant describing how to begin a comment in the target | |
3635 | assembler language. The compiler assumes that the comment will end at the | |
3636 | end of the line. */ | |
7c87e9f9 | 3637 | #define ASM_COMMENT_START ";" |
4b58290f GK |
3638 | |
3639 | /* A C string constant for text to be output before each `asm' statement or | |
3640 | group of consecutive ones. Normally this is `"#APP"', which is a comment | |
3641 | that has no effect on most assemblers but tells the GNU assembler that it | |
3642 | must check the lines that follow for all valid assembler constructs. */ | |
3643 | #define ASM_APP_ON "#APP\n" | |
3644 | ||
3645 | /* A C string constant for text to be output after each `asm' statement or | |
3646 | group of consecutive ones. Normally this is `"#NO_APP"', which tells the | |
3647 | GNU assembler to resume making the time-saving assumptions that are valid | |
3648 | for ordinary compiler output. */ | |
3649 | #define ASM_APP_OFF "#NO_APP\n" | |
3650 | ||
3651 | /* A C statement to output COFF information or DWARF debugging information | |
3652 | which indicates that filename NAME is the current source file to the stdio | |
3653 | stream STREAM. | |
3654 | ||
3655 | This macro need not be defined if the standard form of output for the file | |
3656 | format in use is appropriate. */ | |
3657 | /* #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME) */ | |
3658 | ||
3659 | /* A C statement to output DBX or SDB debugging information before code for | |
3660 | line number LINE of the current source file to the stdio stream STREAM. | |
3661 | ||
3662 | This macro need not be defined if the standard form of debugging information | |
3663 | for the debugger in use is appropriate. | |
3664 | ||
3665 | Defined in svr4.h. */ | |
3666 | /* #define ASM_OUTPUT_SOURCE_LINE(STREAM, LINE) */ | |
3667 | ||
3668 | /* A C statement to output something to the assembler file to handle a `#ident' | |
3669 | directive containing the text STRING. If this macro is not defined, nothing | |
3670 | is output for a `#ident' directive. | |
3671 | ||
3672 | Defined in svr4.h. */ | |
3673 | /* #define ASM_OUTPUT_IDENT(STREAM, STRING) */ | |
3674 | ||
3675 | /* A C statement to output something to the assembler file to switch to section | |
3676 | NAME for object DECL which is either a `FUNCTION_DECL', a `VAR_DECL' or | |
3677 | `NULL_TREE'. Some target formats do not support arbitrary sections. Do not | |
3678 | define this macro in such cases. | |
3679 | ||
3680 | At present this macro is only used to support section attributes. When this | |
3681 | macro is undefined, section attributes are disabled. | |
3682 | ||
3683 | Defined in svr4.h. */ | |
3684 | /* #define ASM_OUTPUT_SECTION_NAME(STREAM, DECL, NAME) */ | |
3685 | ||
3686 | /* A C statement to output any assembler statements which are required to | |
3687 | precede any Objective C object definitions or message sending. The | |
3688 | statement is executed only when compiling an Objective C program. */ | |
3689 | /* #define OBJC_PROLOGUE */ | |
3690 | ||
3691 | \f | |
3692 | /* Output of Data. */ | |
3693 | ||
3694 | /* A C statement to output to the stdio stream STREAM an assembler instruction | |
3695 | to assemble a floating-point constant of `TFmode', `DFmode', `SFmode', | |
3696 | `TQFmode', `HFmode', or `QFmode', respectively, whose value is VALUE. VALUE | |
3697 | will be a C expression of type `REAL_VALUE_TYPE'. Macros such as | |
3698 | `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these definitions. */ | |
3699 | ||
3700 | /* This is how to output an assembler line defining a `double'. */ | |
3701 | #define ASM_OUTPUT_DOUBLE(STREAM,VALUE) \ | |
3702 | do { char dstr[30]; \ | |
3703 | REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \ | |
3704 | fprintf ((STREAM), "\t.double %s\n", dstr); \ | |
3705 | } while (0) | |
3706 | ||
3707 | /* This is how to output an assembler line defining a `float' constant. */ | |
3708 | #define ASM_OUTPUT_FLOAT(STREAM,VALUE) \ | |
3709 | do { char dstr[30]; \ | |
3710 | REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \ | |
3711 | fprintf ((STREAM), "\t.float %s\n", dstr); \ | |
3712 | } while (0) | |
3713 | ||
3714 | /* #define ASM_OUTPUT_LONG_DOUBLE(STREAM, VALUE) */ | |
3715 | /* #define ASM_OUTPUT_THREE_QUARTER_FLOAT(STREAM, VALUE) */ | |
3716 | /* #define ASM_OUTPUT_SHORT_FLOAT(STREAM, VALUE) */ | |
3717 | /* #define ASM_OUTPUT_BYTE_FLOAT(STREAM, VALUE) */ | |
3718 | ||
3719 | /* A C statement to output to the stdio stream STREAM an assembler instruction | |
3720 | to assemble an integer of 16, 8, 4, 2 or 1 bytes, respectively, whose value | |
3721 | is VALUE. The argument EXP will be an RTL expression which represents a | |
3722 | constant value. Use `output_addr_const (STREAM, EXP)' to output this value | |
3723 | as an assembler expression. | |
3724 | ||
3725 | For sizes larger than `UNITS_PER_WORD', if the action of a macro would be | |
3726 | identical to repeatedly calling the macro corresponding to a size of | |
3727 | `UNITS_PER_WORD', once for each word, you need not define the macro. */ | |
3728 | /* #define ASM_OUTPUT_QUADRUPLE_INT(STREAM, EXP) */ | |
3729 | /* #define ASM_OUTPUT_DOUBLE_INT(STREAM, EXP) */ | |
3730 | ||
3731 | /* This is how to output an assembler line defining a `char' constant. */ | |
3732 | #define ASM_OUTPUT_CHAR(FILE, VALUE) \ | |
3733 | do { \ | |
3734 | fprintf (FILE, "\t.byte\t"); \ | |
3735 | output_addr_const (FILE, (VALUE)); \ | |
3736 | fprintf (FILE, "\n"); \ | |
3737 | } while (0) | |
3738 | ||
3739 | /* This is how to output an assembler line defining a `short' constant. */ | |
3740 | #define ASM_OUTPUT_SHORT(FILE, VALUE) \ | |
3741 | do { \ | |
3742 | fprintf (FILE, "\t.hword\t"); \ | |
3743 | output_addr_const (FILE, (VALUE)); \ | |
3744 | fprintf (FILE, "\n"); \ | |
3745 | } while (0) | |
3746 | ||
3747 | /* This is how to output an assembler line defining an `int' constant. | |
3748 | We also handle symbol output here. */ | |
3749 | #define ASM_OUTPUT_INT(FILE, VALUE) \ | |
3750 | do { \ | |
3751 | fprintf (FILE, "\t.word\t"); \ | |
3752 | output_addr_const (FILE, (VALUE)); \ | |
3753 | fprintf (FILE, "\n"); \ | |
3754 | } while (0) | |
3755 | ||
3756 | /* A C statement to output to the stdio stream STREAM an assembler instruction | |
3757 | to assemble a single byte containing the number VALUE. | |
3758 | ||
3759 | This declaration must be present. */ | |
3760 | #define ASM_OUTPUT_BYTE(STREAM, VALUE) \ | |
3761 | fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE)) | |
3762 | ||
3763 | /* A C string constant giving the pseudo-op to use for a sequence of | |
3764 | single-byte constants. If this macro is not defined, the default | |
3765 | is `"byte"'. | |
3766 | ||
3767 | Defined in svr4.h. */ | |
3768 | /* #define ASM_BYTE_OP */ | |
3769 | ||
3770 | /* A C statement to output to the stdio stream STREAM an assembler instruction | |
3771 | to assemble a string constant containing the LEN bytes at PTR. PTR will be | |
3772 | a C expression of type `char *' and LEN a C expression of type `int'. | |
3773 | ||
3774 | If the assembler has a `.ascii' pseudo-op as found in the Berkeley Unix | |
3775 | assembler, do not define the macro `ASM_OUTPUT_ASCII'. | |
3776 | ||
3777 | Defined in svr4.h. */ | |
3778 | /* #define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) */ | |
3779 | ||
3780 | /* You may define this macro as a C expression. You should define the | |
3781 | expression to have a non-zero value if GNU CC should output the | |
3782 | constant pool for a function before the code for the function, or | |
3783 | a zero value if GNU CC should output the constant pool after the | |
3784 | function. If you do not define this macro, the usual case, GNU CC | |
3785 | will output the constant pool before the function. */ | |
3786 | /* #define CONSTANT_POOL_BEFORE_FUNCTION */ | |
3787 | ||
3788 | /* A C statement to output assembler commands to define the start of the | |
3789 | constant pool for a function. FUNNAME is a string giving the name of the | |
3790 | function. Should the return type of the function be required, it can be | |
3791 | obtained via FUNDECL. SIZE is the size, in bytes, of the constant pool that | |
3792 | will be written immediately after this call. | |
3793 | ||
3794 | If no constant-pool prefix is required, the usual case, this macro need not | |
3795 | be defined. */ | |
3796 | /* #define ASM_OUTPUT_POOL_PROLOGUE(FILE FUNNAME FUNDECL SIZE) */ | |
3797 | ||
3798 | /* A C statement (with or without semicolon) to output a constant in the | |
3799 | constant pool, if it needs special treatment. (This macro need not do | |
3800 | anything for RTL expressions that can be output normally.) | |
3801 | ||
3802 | The argument FILE is the standard I/O stream to output the assembler code | |
3803 | on. X is the RTL expression for the constant to output, and MODE is the | |
3804 | machine mode (in case X is a `const_int'). ALIGN is the required alignment | |
3805 | for the value X; you should output an assembler directive to force this much | |
3806 | alignment. | |
3807 | ||
3808 | The argument LABELNO is a number to use in an internal label for the address | |
3809 | of this pool entry. The definition of this macro is responsible for | |
3810 | outputting the label definition at the proper place. Here is how to do | |
3811 | this: | |
3812 | ||
3813 | ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO); | |
3814 | ||
3815 | When you output a pool entry specially, you should end with a `goto' to the | |
3816 | label JUMPTO. This will prevent the same pool entry from being output a | |
3817 | second time in the usual manner. | |
3818 | ||
3819 | You need not define this macro if it would do nothing. */ | |
3820 | /* #define ASM_OUTPUT_SPECIAL_POOL_ENTRY(FILE, X, MODE, ALIGN, LABELNO, JUMPTO) */ | |
3821 | ||
3822 | /* Define this macro as a C expression which is nonzero if the constant EXP, of | |
3823 | type `tree', should be output after the code for a function. The compiler | |
3824 | will normally output all constants before the function; you need not define | |
3825 | this macro if this is OK. */ | |
3826 | /* #define CONSTANT_AFTER_FUNCTION_P(EXP) */ | |
3827 | ||
3828 | /* A C statement to output assembler commands to at the end of the constant | |
3829 | pool for a function. FUNNAME is a string giving the name of the function. | |
3830 | Should the return type of the function be required, you can obtain it via | |
3831 | FUNDECL. SIZE is the size, in bytes, of the constant pool that GNU CC wrote | |
3832 | immediately before this call. | |
3833 | ||
3834 | If no constant-pool epilogue is required, the usual case, you need not | |
3835 | define this macro. */ | |
3836 | /* #define ASM_OUTPUT_POOL_EPILOGUE (FILE FUNNAME FUNDECL SIZE) */ | |
3837 | ||
3838 | /* Define this macro as a C expression which is nonzero if C is used as a | |
3839 | logical line separator by the assembler. | |
3840 | ||
3841 | If you do not define this macro, the default is that only the character `;' | |
3842 | is treated as a logical line separator. */ | |
3843 | #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '|') | |
3844 | ||
3845 | /* These macros are provided by `real.h' for writing the definitions of | |
3846 | `ASM_OUTPUT_DOUBLE' and the like: */ | |
3847 | ||
3848 | /* These translate X, of type `REAL_VALUE_TYPE', to the target's floating point | |
3849 | representation, and store its bit pattern in the array of `long int' whose | |
3850 | address is L. The number of elements in the output array is determined by | |
3851 | the size of the desired target floating point data type: 32 bits of it go in | |
3852 | each `long int' array element. Each array element holds 32 bits of the | |
3853 | result, even if `long int' is wider than 32 bits on the host machine. | |
3854 | ||
3855 | The array element values are designed so that you can print them out using | |
3856 | `fprintf' in the order they should appear in the target machine's memory. */ | |
3857 | /* #define REAL_VALUE_TO_TARGET_SINGLE(X, L) */ | |
3858 | /* #define REAL_VALUE_TO_TARGET_DOUBLE(X, L) */ | |
3859 | /* #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(X, L) */ | |
3860 | ||
3861 | /* This macro converts X, of type `REAL_VALUE_TYPE', to a decimal number and | |
3862 | stores it as a string into STRING. You must pass, as STRING, the address of | |
3863 | a long enough block of space to hold the result. | |
3864 | ||
3865 | The argument FORMAT is a `printf'-specification that serves as a suggestion | |
3866 | for how to format the output string. */ | |
3867 | /* #define REAL_VALUE_TO_DECIMAL(X, FORMAT, STRING) */ | |
3868 | ||
3869 | \f | |
3870 | /* Output of Uninitialized Variables. */ | |
3871 | ||
3872 | /* A C statement (sans semicolon) to output to the stdio stream STREAM the | |
3873 | assembler definition of a common-label named NAME whose size is SIZE bytes. | |
3874 | The variable ROUNDED is the size rounded up to whatever alignment the caller | |
3875 | wants. | |
3876 | ||
3877 | Use the expression `assemble_name (STREAM, NAME)' to output the name itself; | |
3878 | before and after that, output the additional assembler syntax for defining | |
3879 | the name, and a newline. | |
3880 | ||
3881 | This macro controls how the assembler definitions of uninitialized global | |
3882 | variables are output. */ | |
3883 | /* #define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) */ | |
3884 | ||
3885 | /* Like `ASM_OUTPUT_COMMON' except takes the required alignment as a separate, | |
3886 | explicit argument. If you define this macro, it is used in place of | |
3887 | `ASM_OUTPUT_COMMON', and gives you more flexibility in handling the required | |
3888 | alignment of the variable. The alignment is specified as the number of | |
3889 | bits. | |
3890 | ||
3891 | Defined in svr4.h. */ | |
3892 | /* #define ASM_OUTPUT_ALIGNED_COMMON(STREAM, NAME, SIZE, ALIGNMENT) */ | |
3893 | ||
3894 | /* Like ASM_OUTPUT_ALIGNED_COMMON except that it takes an additional argument - | |
3895 | the DECL of the variable to be output, if there is one. This macro can be | |
3896 | called with DECL == NULL_TREE. If you define this macro, it is used in | |
3897 | place of both ASM_OUTPUT_COMMON and ASM_OUTPUT_ALIGNED_COMMON, and gives you | |
3898 | more flexibility in handling the destination of the variable. */ | |
3899 | /* #define ASM_OUTPUT_DECL_COMMON (STREAM, DECL, NAME, SIZE, ALIGNMENT) */ | |
3900 | ||
3901 | /* If defined, it is similar to `ASM_OUTPUT_COMMON', except that it is used | |
3902 | when NAME is shared. If not defined, `ASM_OUTPUT_COMMON' will be used. */ | |
3903 | /* #define ASM_OUTPUT_SHARED_COMMON(STREAM, NAME, SIZE, ROUNDED) */ | |
3904 | ||
3905 | /* A C statement (sans semicolon) to output to the stdio stream STREAM the | |
3906 | assembler definition of uninitialized global DECL named NAME whose size is | |
3907 | SIZE bytes. The variable ROUNDED is the size rounded up to whatever | |
3908 | alignment the caller wants. | |
3909 | ||
3910 | Try to use function `asm_output_bss' defined in `varasm.c' when defining | |
3911 | this macro. If unable, use the expression `assemble_name (STREAM, NAME)' to | |
3912 | output the name itself; before and after that, output the additional | |
3913 | assembler syntax for defining the name, and a newline. | |
3914 | ||
3915 | This macro controls how the assembler definitions of uninitialized global | |
3916 | variables are output. This macro exists to properly support languages like | |
3917 | `c++' which do not have `common' data. However, this macro currently is not | |
3918 | defined for all targets. If this macro and `ASM_OUTPUT_ALIGNED_BSS' are not | |
3919 | defined then `ASM_OUTPUT_COMMON' or `ASM_OUTPUT_ALIGNED_COMMON' or | |
3920 | `ASM_OUTPUT_DECL_COMMON' is used. */ | |
3921 | /* #define ASM_OUTPUT_BSS(STREAM, DECL, NAME, SIZE, ROUNDED) */ | |
3922 | ||
3923 | /* Like `ASM_OUTPUT_BSS' except takes the required alignment as a separate, | |
3924 | explicit argument. If you define this macro, it is used in place of | |
3925 | `ASM_OUTPUT_BSS', and gives you more flexibility in handling the required | |
3926 | alignment of the variable. The alignment is specified as the number of | |
3927 | bits. | |
3928 | ||
3929 | Try to use function `asm_output_aligned_bss' defined in file `varasm.c' when | |
3930 | defining this macro. */ | |
3931 | /* #define ASM_OUTPUT_ALIGNED_BSS(STREAM, DECL, NAME, SIZE, ALIGNMENT) */ | |
3932 | ||
3933 | /* If defined, it is similar to `ASM_OUTPUT_BSS', except that it is used when | |
3934 | NAME is shared. If not defined, `ASM_OUTPUT_BSS' will be used. */ | |
3935 | /* #define ASM_OUTPUT_SHARED_BSS(STREAM, DECL, NAME, SIZE, ROUNDED) */ | |
3936 | ||
3937 | /* A C statement (sans semicolon) to output to the stdio stream STREAM the | |
3938 | assembler definition of a local-common-label named NAME whose size is SIZE | |
3939 | bytes. The variable ROUNDED is the size rounded up to whatever alignment | |
3940 | the caller wants. | |
3941 | ||
3942 | Use the expression `assemble_name (STREAM, NAME)' to output the name itself; | |
3943 | before and after that, output the additional assembler syntax for defining | |
3944 | the name, and a newline. | |
3945 | ||
3946 | This macro controls how the assembler definitions of uninitialized static | |
3947 | variables are output. */ | |
3948 | /* #define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) */ | |
3949 | ||
3950 | /* Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a separate, | |
3951 | explicit argument. If you define this macro, it is used in place of | |
3952 | `ASM_OUTPUT_LOCAL', and gives you more flexibility in handling the required | |
3953 | alignment of the variable. The alignment is specified as the number of | |
3954 | bits. | |
3955 | ||
3956 | Defined in svr4.h. */ | |
3957 | /* #define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGNMENT) */ | |
3958 | ||
3959 | /* Like `ASM_OUTPUT_ALIGNED_LOCAL' except that it takes an additional | |
3960 | parameter - the DECL of variable to be output, if there is one. | |
3961 | This macro can be called with DECL == NULL_TREE. If you define | |
3962 | this macro, it is used in place of `ASM_OUTPUT_LOCAL' and | |
3963 | `ASM_OUTPUT_ALIGNED_LOCAL', and gives you more flexibility in | |
3964 | handling the destination of the variable. */ | |
3965 | /* #define ASM_OUTPUT_DECL_LOCAL(STREAM, DECL, NAME, SIZE, ALIGNMENT) */ | |
3966 | ||
3967 | /* If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is used when | |
3968 | NAME is shared. If not defined, `ASM_OUTPUT_LOCAL' will be used. */ | |
3969 | /* #define ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED) */ | |
3970 | ||
3971 | \f | |
3972 | /* Output and Generation of Labels. */ | |
3973 | ||
3974 | /* A C statement (sans semicolon) to output to the stdio stream STREAM the | |
3975 | assembler definition of a label named NAME. Use the expression | |
3976 | `assemble_name (STREAM, NAME)' to output the name itself; before and after | |
3977 | that, output the additional assembler syntax for defining the name, and a | |
3978 | newline. */ | |
3979 | #define ASM_OUTPUT_LABEL(STREAM, NAME) \ | |
3980 | do { \ | |
3981 | assemble_name (STREAM, NAME); \ | |
3982 | fputs (":\n", STREAM); \ | |
3983 | } while (0) | |
3984 | ||
3985 | /* A C statement to output to the stdio stream STREAM the assembler | |
3986 | definition of a symbol named SYMBOL. */ | |
3987 | #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL) \ | |
3988 | do { \ | |
3989 | if (SYMBOL_REF_FLAG (SYMBOL)) \ | |
3990 | { \ | |
3991 | fputs ("@fptr(", STREAM); \ | |
3992 | assemble_name (STREAM, XSTR (SYMBOL, 0)); \ | |
3993 | fputc (')', STREAM); \ | |
3994 | } \ | |
3995 | else \ | |
3996 | assemble_name (STREAM, XSTR (SYMBOL, 0)); \ | |
3997 | } while (0) | |
3998 | ||
3999 | /* A C statement (sans semicolon) to output to the stdio stream STREAM any text | |
4000 | necessary for declaring the name NAME of a function which is being defined. | |
4001 | This macro is responsible for outputting the label definition (perhaps using | |
4002 | `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL' tree node | |
4003 | representing the function. | |
4004 | ||
4005 | If this macro is not defined, then the function name is defined in the usual | |
4006 | manner as a label (by means of `ASM_OUTPUT_LABEL'). | |
4007 | ||
4008 | Defined in svr4.h. */ | |
4009 | /* #define ASM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) */ | |
4010 | ||
4011 | /* A C statement (sans semicolon) to output to the stdio stream STREAM any text | |
4012 | necessary for declaring the size of a function which is being defined. The | |
4013 | argument NAME is the name of the function. The argument DECL is the | |
4014 | `FUNCTION_DECL' tree node representing the function. | |
4015 | ||
4016 | If this macro is not defined, then the function size is not defined. | |
4017 | ||
4018 | Defined in svr4.h. */ | |
4019 | /* #define ASM_DECLARE_FUNCTION_SIZE(STREAM, NAME, DECL) */ | |
4020 | ||
4021 | /* A C statement (sans semicolon) to output to the stdio stream STREAM any text | |
4022 | necessary for declaring the name NAME of an initialized variable which is | |
4023 | being defined. This macro must output the label definition (perhaps using | |
4024 | `ASM_OUTPUT_LABEL'). The argument DECL is the `VAR_DECL' tree node | |
4025 | representing the variable. | |
4026 | ||
4027 | If this macro is not defined, then the variable name is defined in the usual | |
4028 | manner as a label (by means of `ASM_OUTPUT_LABEL'). | |
4029 | ||
4030 | Defined in svr4.h. */ | |
4031 | /* #define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL) */ | |
4032 | ||
4033 | /* A C statement (sans semicolon) to finish up declaring a variable name once | |
4034 | the compiler has processed its initializer fully and thus has had a chance | |
4035 | to determine the size of an array when controlled by an initializer. This | |
4036 | is used on systems where it's necessary to declare something about the size | |
4037 | of the object. | |
4038 | ||
4039 | If you don't define this macro, that is equivalent to defining it to do | |
4040 | nothing. | |
4041 | ||
4042 | Defined in svr4.h. */ | |
4043 | /* #define ASM_FINISH_DECLARE_OBJECT(STREAM, DECL, TOPLEVEL, ATEND) */ | |
4044 | ||
4045 | /* A C statement (sans semicolon) to output to the stdio stream STREAM some | |
4046 | commands that will make the label NAME global; that is, available for | |
4047 | reference from other files. Use the expression `assemble_name (STREAM, | |
4048 | NAME)' to output the name itself; before and after that, output the | |
4049 | additional assembler syntax for making that name global, and a newline. */ | |
4050 | #define ASM_GLOBALIZE_LABEL(STREAM,NAME) \ | |
4051 | do { \ | |
4052 | fputs ("\t.globl ", STREAM); \ | |
4053 | assemble_name (STREAM, NAME); \ | |
4054 | fputs ("\n", STREAM); \ | |
4055 | } while (0) | |
4056 | ||
4057 | /* A C statement (sans semicolon) to output to the stdio stream STREAM some | |
4058 | commands that will make the label NAME weak; that is, available for | |
4059 | reference from other files but only used if no other definition is | |
4060 | available. Use the expression `assemble_name (STREAM, NAME)' to output the | |
4061 | name itself; before and after that, output the additional assembler syntax | |
4062 | for making that name weak, and a newline. | |
4063 | ||
4064 | If you don't define this macro, GNU CC will not support weak symbols and you | |
4065 | should not define the `SUPPORTS_WEAK' macro. | |
4066 | ||
4067 | Defined in svr4.h. */ | |
4068 | /* #define ASM_WEAKEN_LABEL */ | |
4069 | ||
4070 | /* A C expression which evaluates to true if the target supports weak symbols. | |
4071 | ||
4072 | If you don't define this macro, `defaults.h' provides a default definition. | |
4073 | If `ASM_WEAKEN_LABEL' is defined, the default definition is `1'; otherwise, | |
4074 | it is `0'. Define this macro if you want to control weak symbol support | |
4075 | with a compiler flag such as `-melf'. */ | |
4076 | /* #define SUPPORTS_WEAK */ | |
4077 | ||
4078 | /* A C statement (sans semicolon) to mark DECL to be emitted as a | |
4079 | public symbol such that extra copies in multiple translation units | |
4080 | will be discarded by the linker. Define this macro if your object | |
4081 | file format provides support for this concept, such as the `COMDAT' | |
4082 | section flags in the Microsoft Windows PE/COFF format, and this | |
4083 | support requires changes to DECL, such as putting it in a separate | |
4084 | section. | |
4085 | ||
4086 | Defined in svr4.h. */ | |
4087 | /* #define MAKE_DECL_ONE_ONLY */ | |
4088 | ||
4089 | /* A C expression which evaluates to true if the target supports one-only | |
4090 | semantics. | |
4091 | ||
4092 | If you don't define this macro, `varasm.c' provides a default definition. | |
4093 | If `MAKE_DECL_ONE_ONLY' is defined, the default definition is `1'; | |
4094 | otherwise, it is `0'. Define this macro if you want to control one-only | |
4095 | symbol support with a compiler flag, or if setting the `DECL_ONE_ONLY' flag | |
4096 | is enough to mark a declaration to be emitted as one-only. */ | |
4097 | /* #define SUPPORTS_ONE_ONLY */ | |
4098 | ||
4099 | /* A C statement (sans semicolon) to output to the stdio stream STREAM any text | |
4100 | necessary for declaring the name of an external symbol named NAME which is | |
4101 | referenced in this compilation but not defined. The value of DECL is the | |
4102 | tree node for the declaration. | |
4103 | ||
4104 | This macro need not be defined if it does not need to output anything. The | |
4105 | GNU assembler and most Unix assemblers don't require anything. */ | |
4106 | /* #define ASM_OUTPUT_EXTERNAL(STREAM, DECL, NAME) */ | |
4107 | ||
4108 | /* A C statement (sans semicolon) to output on STREAM an assembler pseudo-op to | |
4109 | declare a library function name external. The name of the library function | |
4110 | is given by SYMREF, which has type `rtx' and is a `symbol_ref'. | |
4111 | ||
4112 | This macro need not be defined if it does not need to output anything. The | |
4113 | GNU assembler and most Unix assemblers don't require anything. | |
4114 | ||
4115 | Defined in svr4.h. */ | |
4116 | /* #define ASM_OUTPUT_EXTERNAL_LIBCALL(STREAM, SYMREF) */ | |
4117 | ||
4118 | /* A C statement (sans semicolon) to output to the stdio stream STREAM a | |
4119 | reference in assembler syntax to a label named NAME. This should add `_' to | |
4120 | the front of the name, if that is customary on your operating system, as it | |
4121 | is in most Berkeley Unix systems. This macro is used in `assemble_name'. */ | |
4122 | /* #define ASM_OUTPUT_LABELREF(STREAM, NAME) */ | |
4123 | ||
4124 | /* A C statement to output to the stdio stream STREAM a label whose name is | |
4125 | made from the string PREFIX and the number NUM. | |
4126 | ||
4127 | It is absolutely essential that these labels be distinct from the labels | |
4128 | used for user-level functions and variables. Otherwise, certain programs | |
4129 | will have name conflicts with internal labels. | |
4130 | ||
4131 | It is desirable to exclude internal labels from the symbol table of the | |
4132 | object file. Most assemblers have a naming convention for labels that | |
4133 | should be excluded; on many systems, the letter `L' at the beginning of a | |
4134 | label has this effect. You should find out what convention your system | |
4135 | uses, and follow it. | |
4136 | ||
4137 | The usual definition of this macro is as follows: | |
4138 | ||
4139 | fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) | |
4140 | ||
4141 | Defined in svr4.h. */ | |
4142 | /* #define ASM_OUTPUT_INTERNAL_LABEL(STREAM, PREFIX, NUM) */ | |
4143 | ||
4144 | /* A C statement to store into the string STRING a label whose name is made | |
4145 | from the string PREFIX and the number NUM. | |
4146 | ||
4147 | This string, when output subsequently by `assemble_name', should produce the | |
4148 | output that `ASM_OUTPUT_INTERNAL_LABEL' would produce with the same PREFIX | |
4149 | and NUM. | |
4150 | ||
4151 | If the string begins with `*', then `assemble_name' will output the rest of | |
4152 | the string unchanged. It is often convenient for | |
4153 | `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way. If the string doesn't | |
4154 | start with `*', then `ASM_OUTPUT_LABELREF' gets to output the string, and | |
4155 | may change it. (Of course, `ASM_OUTPUT_LABELREF' is also part of your | |
4156 | machine description, so you should know what it does on your machine.) | |
4157 | ||
4158 | Defined in svr4.h. */ | |
4159 | /* #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) */ | |
4160 | ||
4161 | /* A C expression to assign to OUTVAR (which is a variable of type `char *') a | |
4162 | newly allocated string made from the string NAME and the number NUMBER, with | |
4163 | some suitable punctuation added. Use `alloca' to get space for the string. | |
4164 | ||
4165 | The string will be used as an argument to `ASM_OUTPUT_LABELREF' to produce | |
4166 | an assembler label for an internal static variable whose name is NAME. | |
4167 | Therefore, the string must be such as to result in valid assembler code. | |
4168 | The argument NUMBER is different each time this macro is executed; it | |
4169 | prevents conflicts between similarly-named internal static variables in | |
4170 | different scopes. | |
4171 | ||
4172 | Ideally this string should not be a valid C identifier, to prevent any | |
4173 | conflict with the user's own symbols. Most assemblers allow periods or | |
4174 | percent signs in assembler symbols; putting at least one of these between | |
4175 | the name and the number will suffice. */ | |
4176 | #define ASM_FORMAT_PRIVATE_NAME(OUTVAR, NAME, NUMBER) \ | |
4177 | do { \ | |
4178 | (OUTVAR) = (char *) alloca (strlen ((NAME)) + 12); \ | |
4179 | sprintf ((OUTVAR), "%s.%ld", (NAME), (long)(NUMBER)); \ | |
4180 | } while (0) | |
4181 | ||
4182 | /* A C statement to output to the stdio stream STREAM assembler code which | |
4183 | defines (equates) the symbol NAME to have the value VALUE. | |
4184 | ||
4185 | If SET_ASM_OP is defined, a default definition is provided which is correct | |
4186 | for most systems. | |
4187 | ||
4188 | Defined in svr4.h. */ | |
4189 | /* #define ASM_OUTPUT_DEF(STREAM, NAME, VALUE) */ | |
4190 | ||
4191 | /* A C statement to output to the stdio stream STREAM assembler code which | |
4192 | defines (equates) the weak symbol NAME to have the value VALUE. | |
4193 | ||
4194 | Define this macro if the target only supports weak aliases; define | |
4195 | ASM_OUTPUT_DEF instead if possible. */ | |
4196 | /* #define ASM_OUTPUT_WEAK_ALIAS (STREAM, NAME, VALUE) */ | |
4197 | ||
4198 | /* Define this macro to override the default assembler names used for Objective | |
4199 | C methods. | |
4200 | ||
4201 | The default name is a unique method number followed by the name of the class | |
4202 | (e.g. `_1_Foo'). For methods in categories, the name of the category is | |
4203 | also included in the assembler name (e.g. `_1_Foo_Bar'). | |
4204 | ||
4205 | These names are safe on most systems, but make debugging difficult since the | |
4206 | method's selector is not present in the name. Therefore, particular systems | |
4207 | define other ways of computing names. | |
4208 | ||
4209 | BUF is an expression of type `char *' which gives you a buffer in which to | |
4210 | store the name; its length is as long as CLASS_NAME, CAT_NAME and SEL_NAME | |
4211 | put together, plus 50 characters extra. | |
4212 | ||
4213 | The argument IS_INST specifies whether the method is an instance method or a | |
4214 | class method; CLASS_NAME is the name of the class; CAT_NAME is the name of | |
4215 | the category (or NULL if the method is not in a category); and SEL_NAME is | |
4216 | the name of the selector. | |
4217 | ||
4218 | On systems where the assembler can handle quoted names, you can use this | |
4219 | macro to provide more human-readable names. */ | |
4220 | /* #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME) */ | |
4221 | ||
4222 | \f | |
4223 | /* Macros Controlling Initialization Routines. */ | |
4224 | ||
4225 | /* If defined, a C string constant for the assembler operation to identify the | |
4226 | following data as initialization code. If not defined, GNU CC will assume | |
4227 | such a section does not exist. When you are using special sections for | |
4228 | initialization and termination functions, this macro also controls how | |
4229 | `crtstuff.c' and `libgcc2.c' arrange to run the initialization functions. | |
4230 | ||
4231 | Defined in svr4.h. */ | |
4232 | /* #define INIT_SECTION_ASM_OP */ | |
4233 | ||
4234 | /* If defined, `main' will not call `__main' as described above. This macro | |
4235 | should be defined for systems that control the contents of the init section | |
4236 | on a symbol-by-symbol basis, such as OSF/1, and should not be defined | |
4237 | explicitly for systems that support `INIT_SECTION_ASM_OP'. */ | |
4238 | /* #define HAS_INIT_SECTION */ | |
4239 | ||
4240 | /* If defined, a C string constant for a switch that tells the linker that the | |
4241 | following symbol is an initialization routine. */ | |
4242 | /* #define LD_INIT_SWITCH */ | |
4243 | ||
4244 | /* If defined, a C string constant for a switch that tells the linker that the | |
4245 | following symbol is a finalization routine. */ | |
4246 | /* #define LD_FINI_SWITCH */ | |
4247 | ||
4248 | /* If defined, `main' will call `__main' despite the presence of | |
4249 | `INIT_SECTION_ASM_OP'. This macro should be defined for systems where the | |
4250 | init section is not actually run automatically, but is still useful for | |
4251 | collecting the lists of constructors and destructors. */ | |
4252 | /* #define INVOKE__main */ | |
4253 | ||
4254 | /* Define this macro as a C statement to output on the stream STREAM the | |
4255 | assembler code to arrange to call the function named NAME at initialization | |
4256 | time. | |
4257 | ||
4258 | Assume that NAME is the name of a C function generated automatically by the | |
4259 | compiler. This function takes no arguments. Use the function | |
4260 | `assemble_name' to output the name NAME; this performs any system-specific | |
4261 | syntactic transformations such as adding an underscore. | |
4262 | ||
4263 | If you don't define this macro, nothing special is output to arrange to call | |
4264 | the function. This is correct when the function will be called in some | |
4265 | other manner--for example, by means of the `collect2' program, which looks | |
4266 | through the symbol table to find these functions by their names. | |
4267 | ||
4268 | Defined in svr4.h. */ | |
4269 | /* #define ASM_OUTPUT_CONSTRUCTOR(STREAM, NAME) */ | |
4270 | ||
4271 | /* This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination functions | |
4272 | rather than initialization functions. | |
4273 | ||
4274 | Defined in svr4.h. */ | |
4275 | /* #define ASM_OUTPUT_DESTRUCTOR(STREAM, NAME) */ | |
4276 | ||
4277 | /* If your system uses `collect2' as the means of processing constructors, then | |
4278 | that program normally uses `nm' to scan an object file for constructor | |
4279 | functions to be called. On certain kinds of systems, you can define these | |
4280 | macros to make `collect2' work faster (and, in some cases, make it work at | |
4281 | all): */ | |
4282 | ||
4283 | /* Define this macro if the system uses COFF (Common Object File Format) object | |
4284 | files, so that `collect2' can assume this format and scan object files | |
4285 | directly for dynamic constructor/destructor functions. */ | |
4286 | /* #define OBJECT_FORMAT_COFF */ | |
4287 | ||
4288 | /* Define this macro if the system uses ROSE format object files, so that | |
4289 | `collect2' can assume this format and scan object files directly for dynamic | |
4290 | constructor/destructor functions. | |
4291 | ||
4292 | These macros are effective only in a native compiler; `collect2' as | |
4293 | part of a cross compiler always uses `nm' for the target machine. */ | |
4294 | /* #define OBJECT_FORMAT_ROSE */ | |
4295 | ||
4296 | /* Define this macro if the system uses ELF format object files. | |
4297 | ||
4298 | Defined in svr4.h. */ | |
4299 | /* #define OBJECT_FORMAT_ELF */ | |
4300 | ||
4301 | /* Define this macro as a C string constant containing the file name to use to | |
4302 | execute `nm'. The default is to search the path normally for `nm'. | |
4303 | ||
4304 | If your system supports shared libraries and has a program to list the | |
4305 | dynamic dependencies of a given library or executable, you can define these | |
4306 | macros to enable support for running initialization and termination | |
4307 | functions in shared libraries: */ | |
4308 | /* #define REAL_NM_FILE_NAME */ | |
4309 | ||
4310 | /* Define this macro to a C string constant containing the name of the program | |
4311 | which lists dynamic dependencies, like `"ldd"' under SunOS 4. */ | |
4312 | /* #define LDD_SUFFIX */ | |
4313 | ||
4314 | /* Define this macro to be C code that extracts filenames from the output of | |
4315 | the program denoted by `LDD_SUFFIX'. PTR is a variable of type `char *' | |
4316 | that points to the beginning of a line of output from `LDD_SUFFIX'. If the | |
4317 | line lists a dynamic dependency, the code must advance PTR to the beginning | |
4318 | of the filename on that line. Otherwise, it must set PTR to `NULL'. */ | |
4319 | /* #define PARSE_LDD_OUTPUT (PTR) */ | |
4320 | ||
4321 | \f | |
4322 | /* Output of Assembler Instructions. */ | |
4323 | ||
4324 | /* A C initializer containing the assembler's names for the machine registers, | |
4325 | each one as a C string constant. This is what translates register numbers | |
4326 | in the compiler into assembler language. */ | |
4327 | #define REGISTER_NAMES \ | |
4328 | { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", \ | |
4329 | "r11", "r12", "r13", "psw", "sp", "carry", "fp", "ap" } | |
4330 | ||
4331 | /* If defined, a C initializer for an array of structures containing a name and | |
4332 | a register number. This macro defines additional names for hard registers, | |
4333 | thus allowing the `asm' option in declarations to refer to registers using | |
4334 | alternate names. */ | |
4335 | #define ADDITIONAL_REGISTER_NAMES \ | |
4336 | { { "r14", 14 }, \ | |
4337 | { "r15", 15 } } | |
4338 | ||
4339 | /* Define this macro if you are using an unusual assembler that requires | |
4340 | different names for the machine instructions. | |
4341 | ||
4342 | The definition is a C statement or statements which output an assembler | |
4343 | instruction opcode to the stdio stream STREAM. The macro-operand PTR is a | |
4344 | variable of type `char *' which points to the opcode name in its "internal" | |
4345 | form--the form that is written in the machine description. The definition | |
4346 | should output the opcode name to STREAM, performing any translation you | |
4347 | desire, and increment the variable PTR to point at the end of the opcode so | |
4348 | that it will not be output twice. | |
4349 | ||
4350 | In fact, your macro definition may process less than the entire opcode name, | |
4351 | or more than the opcode name; but if you want to process text that includes | |
4352 | `%'-sequences to substitute operands, you must take care of the substitution | |
4353 | yourself. Just be sure to increment PTR over whatever text should not be | |
4354 | output normally. | |
4355 | ||
4356 | If you need to look at the operand values, they can be found as the elements | |
4357 | of `recog_data.operand'. | |
4358 | ||
4359 | If the macro definition does nothing, the instruction is output in the usual | |
4360 | way. */ | |
4361 | /* #define ASM_OUTPUT_OPCODE(STREAM, PTR) */ | |
4362 | ||
4363 | /* If defined, a C statement to be executed just prior to the output of | |
4364 | assembler code for INSN, to modify the extracted operands so they will be | |
4365 | output differently. | |
4366 | ||
4367 | Here the argument OPVEC is the vector containing the operands extracted from | |
4368 | INSN, and NOPERANDS is the number of elements of the vector which contain | |
4369 | meaningful data for this insn. The contents of this vector are what will be | |
4370 | used to convert the insn template into assembler code, so you can change the | |
4371 | assembler output by changing the contents of the vector. | |
4372 | ||
4373 | This macro is useful when various assembler syntaxes share a single file of | |
4374 | instruction patterns; by defining this macro differently, you can cause a | |
4375 | large class of instructions to be output differently (such as with | |
4376 | rearranged operands). Naturally, variations in assembler syntax affecting | |
4377 | individual insn patterns ought to be handled by writing conditional output | |
4378 | routines in those patterns. | |
4379 | ||
4380 | If this macro is not defined, it is equivalent to a null statement. */ | |
4381 | /* #define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) */ | |
4382 | ||
4383 | /* If defined, `FINAL_PRESCAN_INSN' will be called on each | |
4384 | `CODE_LABEL'. In that case, OPVEC will be a null pointer and | |
4385 | NOPERANDS will be zero. */ | |
4386 | /* #define FINAL_PRESCAN_LABEL */ | |
4387 | ||
4388 | /* A C compound statement to output to stdio stream STREAM the assembler syntax | |
4389 | for an instruction operand X. X is an RTL expression. | |
4390 | ||
4391 | CODE is a value that can be used to specify one of several ways of printing | |
4392 | the operand. It is used when identical operands must be printed differently | |
4393 | depending on the context. CODE comes from the `%' specification that was | |
4394 | used to request printing of the operand. If the specification was just | |
4395 | `%DIGIT' then CODE is 0; if the specification was `%LTR DIGIT' then CODE is | |
4396 | the ASCII code for LTR. | |
4397 | ||
4398 | If X is a register, this macro should print the register's name. The names | |
4399 | can be found in an array `reg_names' whose type is `char *[]'. `reg_names' | |
4400 | is initialized from `REGISTER_NAMES'. | |
4401 | ||
4402 | When the machine description has a specification `%PUNCT' (a `%' followed by | |
4403 | a punctuation character), this macro is called with a null pointer for X and | |
4404 | the punctuation character for CODE. */ | |
c6243b4c | 4405 | #define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE) |
4b58290f GK |
4406 | |
4407 | /* A C expression which evaluates to true if CODE is a valid punctuation | |
4408 | character for use in the `PRINT_OPERAND' macro. If | |
4409 | `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no punctuation | |
4410 | characters (except for the standard one, `%') are used in this way. */ | |
4411 | /* #define PRINT_OPERAND_PUNCT_VALID_P(CODE) */ | |
4412 | ||
4413 | /* A C compound statement to output to stdio stream STREAM the assembler syntax | |
4414 | for an instruction operand that is a memory reference whose address is X. X | |
4415 | is an RTL expression. | |
4416 | ||
4417 | On some machines, the syntax for a symbolic address depends on the section | |
4418 | that the address refers to. On these machines, define the macro | |
4419 | `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and | |
4420 | then check for it here. | |
4421 | ||
4422 | This declaration must be present. */ | |
c6243b4c | 4423 | #define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X) |
4b58290f GK |
4424 | |
4425 | /* A C statement, to be executed after all slot-filler instructions have been | |
4426 | output. If necessary, call `dbr_sequence_length' to determine the number of | |
4427 | slots filled in a sequence (zero if not currently outputting a sequence), to | |
4428 | decide how many no-ops to output, or whatever. | |
4429 | ||
4430 | Don't define this macro if it has nothing to do, but it is helpful in | |
4431 | reading assembly output if the extent of the delay sequence is made explicit | |
4432 | (e.g. with white space). | |
4433 | ||
4434 | Note that output routines for instructions with delay slots must be prepared | |
4435 | to deal with not being output as part of a sequence (i.e. when the | |
4436 | scheduling pass is not run, or when no slot fillers could be found.) The | |
4437 | variable `final_sequence' is null when not processing a sequence, otherwise | |
4438 | it contains the `sequence' rtx being output. */ | |
4439 | /* #define DBR_OUTPUT_SEQEND(FILE) */ | |
4440 | ||
4441 | /* If defined, C string expressions to be used for the `%R', `%L', `%U', and | |
4442 | `%I' options of `asm_fprintf' (see `final.c'). These are useful when a | |
4443 | single `md' file must support multiple assembler formats. In that case, the | |
4444 | various `tm.h' files can define these macros differently. | |
4445 | ||
4446 | USER_LABEL_PREFIX is defined in svr4.h. */ | |
4447 | #define REGISTER_PREFIX "" | |
4448 | #define LOCAL_LABEL_PREFIX "." | |
4449 | #define USER_LABEL_PREFIX "" | |
4450 | #define IMMEDIATE_PREFIX "#" | |
4451 | ||
4452 | /* If your target supports multiple dialects of assembler language (such as | |
4453 | different opcodes), define this macro as a C expression that gives the | |
4454 | numeric index of the assembler language dialect to use, with zero as the | |
4455 | first variant. | |
4456 | ||
4457 | If this macro is defined, you may use `{option0|option1|option2...}' | |
4458 | constructs in the output templates of patterns or in the first argument of | |
4459 | `asm_fprintf'. This construct outputs `option0', `option1' or `option2', | |
4460 | etc., if the value of `ASSEMBLER_DIALECT' is zero, one or two, etc. Any | |
4461 | special characters within these strings retain their usual meaning. | |
4462 | ||
4463 | If you do not define this macro, the characters `{', `|' and `}' do not have | |
4464 | any special meaning when used in templates or operands to `asm_fprintf'. | |
4465 | ||
4466 | Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX', | |
4467 | `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the variations | |
4468 | in assemble language syntax with that mechanism. Define `ASSEMBLER_DIALECT' | |
4469 | and use the `{option0|option1}' syntax if the syntax variant are larger and | |
4470 | involve such things as different opcodes or operand order. */ | |
4471 | /* #define ASSEMBLER_DIALECT */ | |
4472 | ||
4473 | /* A C expression to output to STREAM some assembler code which will push hard | |
4474 | register number REGNO onto the stack. The code need not be optimal, since | |
4475 | this macro is used only when profiling. */ | |
4476 | #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \ | |
4477 | fprintf (STREAM, "\tpush %d\n", REGNO) | |
4478 | ||
4479 | /* A C expression to output to STREAM some assembler code which will pop hard | |
4480 | register number REGNO off of the stack. The code need not be optimal, since | |
4481 | this macro is used only when profiling. */ | |
4482 | #define ASM_OUTPUT_REG_POP(STREAM, REGNO) \ | |
4483 | fprintf (STREAM, "\tpop %d\n", REGNO) | |
4484 | ||
4485 | \f | |
4486 | /* Output of dispatch tables. */ | |
4487 | ||
4488 | /* This port does not use the ASM_OUTPUT_ADDR_VEC_ELT macro, because | |
4489 | this could cause label alignment to appear between the 'br' and the table, | |
4490 | which would be bad. Instead, it controls the output of the table | |
4491 | itself. */ | |
4492 | #define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \ | |
c6243b4c | 4493 | xstormy16_output_addr_vec (file, LABEL, BODY) |
4b58290f GK |
4494 | |
4495 | /* Alignment for ADDR_VECs is the same as for code. */ | |
4496 | #define ADDR_VEC_ALIGN(ADDR_VEC) 1 | |
4497 | ||
4498 | \f | |
4499 | /* Assembler Commands for Exception Regions. */ | |
4500 | ||
4501 | /* A C expression to output text to mark the start of an exception region. | |
4502 | ||
4503 | This macro need not be defined on most platforms. */ | |
4504 | /* #define ASM_OUTPUT_EH_REGION_BEG() */ | |
4505 | ||
4506 | /* A C expression to output text to mark the end of an exception region. | |
4507 | ||
4508 | This macro need not be defined on most platforms. */ | |
4509 | /* #define ASM_OUTPUT_EH_REGION_END() */ | |
4510 | ||
4b58290f GK |
4511 | /* A C expression that is nonzero if the normal exception table output should |
4512 | be omitted. | |
4513 | ||
4514 | This macro need not be defined on most platforms. */ | |
4515 | /* #define OMIT_EH_TABLE() */ | |
4516 | ||
4517 | /* Alternate runtime support for looking up an exception at runtime and finding | |
4518 | the associated handler, if the default method won't work. | |
4519 | ||
4520 | This macro need not be defined on most platforms. */ | |
4521 | /* #define EH_TABLE_LOOKUP() */ | |
4522 | ||
4523 | /* A C expression that decides whether or not the current function needs to | |
4524 | have a function unwinder generated for it. See the file `except.c' for | |
4525 | details on when to define this, and how. */ | |
4526 | /* #define DOESNT_NEED_UNWINDER */ | |
4527 | ||
4528 | /* An rtx used to mask the return address found via RETURN_ADDR_RTX, so that it | |
4529 | does not contain any extraneous set bits in it. */ | |
4530 | /* #define MASK_RETURN_ADDR */ | |
4531 | ||
4532 | /* Define this macro to 0 if your target supports DWARF 2 frame unwind | |
4533 | information, but it does not yet work with exception handling. Otherwise, | |
4534 | if your target supports this information (if it defines | |
4535 | `INCOMING_RETURN_ADDR_RTX' and either `UNALIGNED_INT_ASM_OP' or | |
4536 | `OBJECT_FORMAT_ELF'), GCC will provide a default definition of 1. | |
4537 | ||
4538 | If this macro is defined to 1, the DWARF 2 unwinder will be the default | |
4539 | exception handling mechanism; otherwise, setjmp/longjmp will be used by | |
4540 | default. | |
4541 | ||
4542 | If this macro is defined to anything, the DWARF 2 unwinder will be used | |
4543 | instead of inline unwinders and __unwind_function in the non-setjmp case. */ | |
e27e731d | 4544 | #define DWARF2_UNWIND_INFO 0 |
4b58290f | 4545 | |
9defc9b7 RH |
4546 | /* Don't use __builtin_setjmp for unwinding, since it's tricky to get |
4547 | at the high 16 bits of an address. */ | |
4548 | #define DONT_USE_BUILTIN_SETJMP | |
4549 | #define JMP_BUF_SIZE 8 | |
4b58290f GK |
4550 | \f |
4551 | /* Assembler Commands for Alignment. */ | |
4552 | ||
4553 | /* The alignment (log base 2) to put in front of LABEL, which follows | |
4554 | a BARRIER. | |
4555 | ||
4556 | This macro need not be defined if you don't want any special alignment to be | |
4557 | done at such a time. Most machine descriptions do not currently define the | |
4558 | macro. */ | |
4559 | /* #define LABEL_ALIGN_AFTER_BARRIER(LABEL) */ | |
4560 | ||
4561 | /* The desired alignment for the location counter at the beginning | |
4562 | of a loop. | |
4563 | ||
4564 | This macro need not be defined if you don't want any special alignment to be | |
4565 | done at such a time. Most machine descriptions do not currently define the | |
4566 | macro. */ | |
4567 | /* #define LOOP_ALIGN(LABEL) */ | |
4568 | ||
4569 | /* A C statement to output to the stdio stream STREAM an assembler instruction | |
4570 | to advance the location counter by NBYTES bytes. Those bytes should be zero | |
4571 | when loaded. NBYTES will be a C expression of type `int'. | |
4572 | ||
4573 | Defined in elfos.h. */ | |
4574 | /* #define ASM_OUTPUT_SKIP(STREAM, NBYTES) */ | |
4575 | ||
4576 | /* Define this macro if `ASM_OUTPUT_SKIP' should not be used in the text | |
4577 | section because it fails put zeros in the bytes that are skipped. This is | |
4578 | true on many Unix systems, where the pseudo-op to skip bytes produces no-op | |
4579 | instructions rather than zeros when used in the text section. */ | |
4580 | /* #define ASM_NO_SKIP_IN_TEXT */ | |
4581 | ||
4582 | /* A C statement to output to the stdio stream STREAM an assembler command to | |
4583 | advance the location counter to a multiple of 2 to the POWER bytes. POWER | |
4584 | will be a C expression of type `int'. */ | |
4585 | #define ASM_OUTPUT_ALIGN(STREAM, POWER) \ | |
4586 | fprintf ((STREAM), "\t.p2align %d\n", (POWER)) | |
4587 | ||
4588 | \f | |
4589 | /* Macros Affecting all Debug Formats. */ | |
4590 | ||
4591 | /* A C expression that returns the DBX register number for the compiler | |
4592 | register number REGNO. In simple cases, the value of this expression may be | |
4593 | REGNO itself. But sometimes there are some registers that the compiler | |
4594 | knows about and DBX does not, or vice versa. In such cases, some register | |
4595 | may need to have one number in the compiler and another for DBX. | |
4596 | ||
4597 | If two registers have consecutive numbers inside GNU CC, and they can be | |
4598 | used as a pair to hold a multiword value, then they *must* have consecutive | |
4599 | numbers after renumbering with `DBX_REGISTER_NUMBER'. Otherwise, debuggers | |
4600 | will be unable to access such a pair, because they expect register pairs to | |
4601 | be consecutive in their own numbering scheme. | |
4602 | ||
4603 | If you find yourself defining `DBX_REGISTER_NUMBER' in way that does not | |
4604 | preserve register pairs, then what you must do instead is redefine the | |
4605 | actual register numbering scheme. | |
4606 | ||
4607 | This declaration is required. */ | |
4608 | #define DBX_REGISTER_NUMBER(REGNO) (REGNO) | |
4609 | ||
4610 | /* A C expression that returns the integer offset value for an automatic | |
4611 | variable having address X (an RTL expression). The default computation | |
4612 | assumes that X is based on the frame-pointer and gives the offset from the | |
4613 | frame-pointer. This is required for targets that produce debugging output | |
4614 | for DBX or COFF-style debugging output for SDB and allow the frame-pointer | |
4615 | to be eliminated when the `-g' options is used. */ | |
4616 | /* #define DEBUGGER_AUTO_OFFSET(X) */ | |
4617 | ||
4618 | /* A C expression that returns the integer offset value for an argument having | |
4619 | address X (an RTL expression). The nominal offset is OFFSET. */ | |
4620 | /* #define DEBUGGER_ARG_OFFSET(OFFSET, X) */ | |
4621 | ||
4622 | /* A C expression that returns the type of debugging output GNU CC produces | |
4623 | when the user specifies `-g' or `-ggdb'. Define this if you have arranged | |
4624 | for GNU CC to support more than one format of debugging output. Currently, | |
4625 | the allowable values are `DBX_DEBUG', `SDB_DEBUG', `DWARF_DEBUG', | |
4626 | `DWARF2_DEBUG', and `XCOFF_DEBUG'. | |
4627 | ||
4628 | The value of this macro only affects the default debugging output; the user | |
4629 | can always get a specific type of output by using `-gstabs', `-gcoff', | |
4630 | `-gdwarf-1', `-gdwarf-2', or `-gxcoff'. | |
4631 | ||
4632 | Defined in svr4.h. */ | |
4633 | #undef PREFERRED_DEBUGGING_TYPE | |
4634 | #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG | |
4635 | ||
4636 | \f | |
4637 | /* Specific Options for DBX Output. */ | |
4638 | ||
4639 | /* Define this macro if GNU CC should produce debugging output for DBX in | |
4640 | response to the `-g' option. | |
4641 | ||
4642 | Defined in svr4.h. */ | |
4643 | /* #define DBX_DEBUGGING_INFO */ | |
4644 | ||
4645 | /* Define this macro if GNU CC should produce XCOFF format debugging output in | |
4646 | response to the `-g' option. This is a variant of DBX format. */ | |
4647 | /* #define XCOFF_DEBUGGING_INFO */ | |
4648 | ||
4649 | /* Define this macro to control whether GNU CC should by default generate GDB's | |
4650 | extended version of DBX debugging information (assuming DBX-format debugging | |
4651 | information is enabled at all). If you don't define the macro, the default | |
4652 | is 1: always generate the extended information if there is any occasion to. */ | |
4653 | /* #define DEFAULT_GDB_EXTENSIONS */ | |
4654 | ||
4655 | /* Define this macro if all `.stabs' commands should be output while in the | |
4656 | text section. */ | |
4657 | /* #define DEBUG_SYMS_TEXT */ | |
4658 | ||
4659 | /* A C string constant naming the assembler pseudo op to use instead of | |
4660 | `.stabs' to define an ordinary debugging symbol. If you don't define this | |
4661 | macro, `.stabs' is used. This macro applies only to DBX debugging | |
4662 | information format. */ | |
4663 | /* #define ASM_STABS_OP */ | |
4664 | ||
4665 | /* A C string constant naming the assembler pseudo op to use instead of | |
4666 | `.stabd' to define a debugging symbol whose value is the current location. | |
4667 | If you don't define this macro, `.stabd' is used. This macro applies only | |
4668 | to DBX debugging information format. */ | |
4669 | /* #define ASM_STABD_OP */ | |
4670 | ||
4671 | /* A C string constant naming the assembler pseudo op to use instead of | |
4672 | `.stabn' to define a debugging symbol with no name. If you don't define | |
4673 | this macro, `.stabn' is used. This macro applies only to DBX debugging | |
4674 | information format. */ | |
4675 | /* #define ASM_STABN_OP */ | |
4676 | ||
4677 | /* Define this macro if DBX on your system does not support the construct | |
4678 | `xsTAGNAME'. On some systems, this construct is used to describe a forward | |
4679 | reference to a structure named TAGNAME. On other systems, this construct is | |
4680 | not supported at all. */ | |
4681 | /* #define DBX_NO_XREFS */ | |
4682 | ||
4683 | /* A symbol name in DBX-format debugging information is normally continued | |
4684 | (split into two separate `.stabs' directives) when it exceeds a certain | |
4685 | length (by default, 80 characters). On some operating systems, DBX requires | |
4686 | this splitting; on others, splitting must not be done. You can inhibit | |
4687 | splitting by defining this macro with the value zero. You can override the | |
4688 | default splitting-length by defining this macro as an expression for the | |
4689 | length you desire. */ | |
4690 | /* #define DBX_CONTIN_LENGTH */ | |
4691 | ||
4692 | /* Normally continuation is indicated by adding a `\' character to the end of a | |
4693 | `.stabs' string when a continuation follows. To use a different character | |
4694 | instead, define this macro as a character constant for the character you | |
4695 | want to use. Do not define this macro if backslash is correct for your | |
4696 | system. */ | |
4697 | /* #define DBX_CONTIN_CHAR */ | |
4698 | ||
4699 | /* Define this macro if it is necessary to go to the data section before | |
4700 | outputting the `.stabs' pseudo-op for a non-global static variable. */ | |
4701 | /* #define DBX_STATIC_STAB_DATA_SECTION */ | |
4702 | ||
4703 | /* The value to use in the "code" field of the `.stabs' directive for a | |
4704 | typedef. The default is `N_LSYM'. */ | |
4705 | /* #define DBX_TYPE_DECL_STABS_CODE */ | |
4706 | ||
4707 | /* The value to use in the "code" field of the `.stabs' directive for a static | |
4708 | variable located in the text section. DBX format does not provide any | |
4709 | "right" way to do this. The default is `N_FUN'. */ | |
4710 | /* #define DBX_STATIC_CONST_VAR_CODE */ | |
4711 | ||
4712 | /* The value to use in the "code" field of the `.stabs' directive for a | |
4713 | parameter passed in registers. DBX format does not provide any "right" way | |
4714 | to do this. The default is `N_RSYM'. */ | |
4715 | /* #define DBX_REGPARM_STABS_CODE */ | |
4716 | ||
4717 | /* The letter to use in DBX symbol data to identify a symbol as a parameter | |
4718 | passed in registers. DBX format does not customarily provide any way to do | |
4719 | this. The default is `'P''. */ | |
4720 | /* #define DBX_REGPARM_STABS_LETTER */ | |
4721 | ||
4722 | /* The letter to use in DBX symbol data to identify a symbol as a stack | |
4723 | parameter. The default is `'p''. */ | |
4724 | /* #define DBX_MEMPARM_STABS_LETTER */ | |
4725 | ||
4726 | /* Define this macro if the DBX information for a function and its arguments | |
4727 | should precede the assembler code for the function. Normally, in DBX | |
4728 | format, the debugging information entirely follows the assembler code. | |
4729 | ||
4730 | Defined in svr4.h. */ | |
4731 | /* #define DBX_FUNCTION_FIRST */ | |
4732 | ||
4733 | /* Define this macro if the `N_LBRAC' symbol for a block should precede the | |
4734 | debugging information for variables and functions defined in that block. | |
4735 | Normally, in DBX format, the `N_LBRAC' symbol comes first. */ | |
4736 | /* #define DBX_LBRAC_FIRST */ | |
4737 | ||
4738 | /* Define this macro if the value of a symbol describing the scope of a block | |
4739 | (`N_LBRAC' or `N_RBRAC') should be relative to the start of the enclosing | |
4740 | function. Normally, GNU C uses an absolute address. | |
4741 | ||
4742 | Defined in svr4.h. */ | |
4743 | /* #define DBX_BLOCKS_FUNCTION_RELATIVE */ | |
4744 | ||
4745 | /* Define this macro if GNU C should generate `N_BINCL' and `N_EINCL' | |
4746 | stabs for included header files, as on Sun systems. This macro | |
4747 | also directs GNU C to output a type number as a pair of a file | |
4748 | number and a type number within the file. Normally, GNU C does not | |
4749 | generate `N_BINCL' or `N_EINCL' stabs, and it outputs a single | |
4750 | number for a type number. */ | |
4751 | /* #define DBX_USE_BINCL */ | |
4752 | ||
4753 | \f | |
4754 | /* Open ended Hooks for DBX Output. */ | |
4755 | ||
4756 | /* Define this macro to say how to output to STREAM the debugging information | |
4757 | for the start of a scope level for variable names. The argument NAME is the | |
4758 | name of an assembler symbol (for use with `assemble_name') whose value is | |
4759 | the address where the scope begins. */ | |
4760 | /* #define DBX_OUTPUT_LBRAC(STREAM, NAME) */ | |
4761 | ||
4762 | /* Like `DBX_OUTPUT_LBRAC', but for the end of a scope level. */ | |
4763 | /* #define DBX_OUTPUT_RBRAC(STREAM, NAME) */ | |
4764 | ||
4765 | /* Define this macro if the target machine requires special handling to output | |
4766 | an enumeration type. The definition should be a C statement (sans | |
4767 | semicolon) to output the appropriate information to STREAM for the type | |
4768 | TYPE. */ | |
4769 | /* #define DBX_OUTPUT_ENUM(STREAM, TYPE) */ | |
4770 | ||
4771 | /* Define this macro if the target machine requires special output at the end | |
4772 | of the debugging information for a function. The definition should be a C | |
4773 | statement (sans semicolon) to output the appropriate information to STREAM. | |
4774 | FUNCTION is the `FUNCTION_DECL' node for the function. */ | |
4775 | /* #define DBX_OUTPUT_FUNCTION_END(STREAM, FUNCTION) */ | |
4776 | ||
4777 | /* Define this macro if you need to control the order of output of the standard | |
4778 | data types at the beginning of compilation. The argument SYMS is a `tree' | |
4779 | which is a chain of all the predefined global symbols, including names of | |
4780 | data types. | |
4781 | ||
4782 | Normally, DBX output starts with definitions of the types for integers and | |
4783 | characters, followed by all the other predefined types of the particular | |
4784 | language in no particular order. | |
4785 | ||
4786 | On some machines, it is necessary to output different particular types | |
4787 | first. To do this, define `DBX_OUTPUT_STANDARD_TYPES' to output those | |
4788 | symbols in the necessary order. Any predefined types that you don't | |
4789 | explicitly output will be output afterward in no particular order. | |
4790 | ||
4791 | Be careful not to define this macro so that it works only for C. There are | |
4792 | no global variables to access most of the built-in types, because another | |
4793 | language may have another set of types. The way to output a particular type | |
4794 | is to look through SYMS to see if you can find it. Here is an example: | |
4795 | ||
4796 | { | |
4797 | tree decl; | |
4798 | for (decl = syms; decl; decl = TREE_CHAIN (decl)) | |
4799 | if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), | |
4800 | "long int")) | |
4801 | dbxout_symbol (decl); | |
4802 | ... | |
4803 | } | |
4804 | ||
4805 | This does nothing if the expected type does not exist. | |
4806 | ||
4807 | See the function `init_decl_processing' in `c-decl.c' to find the names to | |
4808 | use for all the built-in C types. */ | |
4809 | /* #define DBX_OUTPUT_STANDARD_TYPES(SYMS) */ | |
4810 | ||
4811 | /* Some stabs encapsulation formats (in particular ECOFF), cannot | |
4812 | handle the `.stabs "",N_FUN,,0,0,Lscope-function-1' gdb dbx | |
f710504c | 4813 | extension construct. On those machines, define this macro to turn |
4b58290f GK |
4814 | this feature off without disturbing the rest of the gdb extensions. */ |
4815 | /* #define NO_DBX_FUNCTION_END */ | |
4816 | ||
4817 | \f | |
4818 | /* File names in DBX format. */ | |
4819 | ||
4820 | /* Define this if DBX wants to have the current directory recorded in each | |
4821 | object file. | |
4822 | ||
4823 | Note that the working directory is always recorded if GDB extensions are | |
4824 | enabled. */ | |
4825 | /* #define DBX_WORKING_DIRECTORY */ | |
4826 | ||
4827 | /* A C statement to output DBX debugging information to the stdio stream STREAM | |
4828 | which indicates that file NAME is the main source file--the file specified | |
4829 | as the input file for compilation. This macro is called only once, at the | |
4830 | beginning of compilation. | |
4831 | ||
4832 | This macro need not be defined if the standard form of output for DBX | |
4833 | debugging information is appropriate. | |
4834 | ||
4835 | Defined in svr4.h. */ | |
4836 | /* #define DBX_OUTPUT_MAIN_SOURCE_FILENAME(STREAM, NAME) */ | |
4837 | ||
4838 | /* A C statement to output DBX debugging information to the stdio stream STREAM | |
4839 | which indicates that the current directory during compilation is named NAME. | |
4840 | ||
4841 | This macro need not be defined if the standard form of output for DBX | |
4842 | debugging information is appropriate. */ | |
4843 | /* #define DBX_OUTPUT_MAIN_SOURCE_DIRECTORY(STREAM, NAME) */ | |
4844 | ||
4845 | /* A C statement to output DBX debugging information at the end of compilation | |
4846 | of the main source file NAME. | |
4847 | ||
4848 | If you don't define this macro, nothing special is output at the end of | |
4849 | compilation, which is correct for most machines. */ | |
4850 | /* #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(STREAM, NAME) */ | |
4851 | ||
4852 | /* A C statement to output DBX debugging information to the stdio stream STREAM | |
4853 | which indicates that file NAME is the current source file. This output is | |
4854 | generated each time input shifts to a different source file as a result of | |
4855 | `#include', the end of an included file, or a `#line' command. | |
4856 | ||
4857 | This macro need not be defined if the standard form of output for DBX | |
4858 | debugging information is appropriate. */ | |
4859 | /* #define DBX_OUTPUT_SOURCE_FILENAME(STREAM, NAME) */ | |
4860 | ||
4861 | \f | |
4862 | /* Macros for SDB and Dwarf Output. */ | |
4863 | ||
4864 | /* Define this macro if GNU CC should produce COFF-style debugging output for | |
4865 | SDB in response to the `-g' option. */ | |
4866 | /* #define SDB_DEBUGGING_INFO */ | |
4867 | ||
4868 | /* Define this macro if GNU CC should produce dwarf format debugging output in | |
4869 | response to the `-g' option. | |
4870 | ||
4871 | Defined in svr4.h. */ | |
4872 | /* #define DWARF_DEBUGGING_INFO */ | |
4873 | ||
4874 | /* Define this macro if GNU CC should produce dwarf version 2 format debugging | |
4875 | output in response to the `-g' option. | |
4876 | ||
4877 | To support optional call frame debugging information, you must also define | |
4878 | `INCOMING_RETURN_ADDR_RTX' and either set `RTX_FRAME_RELATED_P' on the | |
4879 | prologue insns if you use RTL for the prologue, or call `dwarf2out_def_cfa' | |
41441dc7 NB |
4880 | and `dwarf2out_reg_save' as appropriate from `TARGET_ASM_FUNCTION_PROLOGUE' |
4881 | if you don't. | |
4b58290f GK |
4882 | |
4883 | Defined in svr4.h. */ | |
4884 | /* #define DWARF2_DEBUGGING_INFO */ | |
4885 | ||
4886 | /* Define this macro if GNU CC should produce dwarf version 2-style | |
4887 | line numbers. This usually requires extending the assembler to | |
4888 | support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the | |
4889 | assembler configuration header files. */ | |
4890 | /* #define DWARF2_ASM_LINE_DEBUG_INFO 1 */ | |
4891 | ||
4892 | /* Define this macro if addresses in Dwarf 2 debugging info should not | |
4893 | be the same size as pointers on the target architecture. The | |
4894 | macro's value should be the size, in bytes, to use for addresses in | |
4895 | the debugging info. | |
4896 | ||
4897 | Some architectures use word addresses to refer to code locations, | |
4898 | but Dwarf 2 info always uses byte addresses. On such machines, | |
4899 | Dwarf 2 addresses need to be larger than the architecture's | |
4900 | pointers. */ | |
4901 | #define DWARF2_ADDR_SIZE 4 | |
4902 | ||
4903 | /* Define these macros to override the assembler syntax for the special SDB | |
4904 | assembler directives. See `sdbout.c' for a list of these macros and their | |
4905 | arguments. If the standard syntax is used, you need not define them | |
4906 | yourself. */ | |
4907 | /* #define PUT_SDB_... */ | |
4908 | ||
4909 | /* Some assemblers do not support a semicolon as a delimiter, even between SDB | |
4910 | assembler directives. In that case, define this macro to be the delimiter | |
4911 | to use (usually `\n'). It is not necessary to define a new set of | |
4912 | `PUT_SDB_OP' macros if this is the only change required. */ | |
4913 | /* #define SDB_DELIM */ | |
4914 | ||
4915 | /* Define this macro to override the usual method of constructing a dummy name | |
4916 | for anonymous structure and union types. See `sdbout.c' for more | |
4917 | information. */ | |
4918 | /* #define SDB_GENERATE_FAKE */ | |
4919 | ||
4920 | /* Define this macro to allow references to unknown structure, union, or | |
4921 | enumeration tags to be emitted. Standard COFF does not allow handling of | |
4922 | unknown references, MIPS ECOFF has support for it. */ | |
4923 | /* #define SDB_ALLOW_UNKNOWN_REFERENCES */ | |
4924 | ||
4925 | /* Define this macro to allow references to structure, union, or enumeration | |
4926 | tags that have not yet been seen to be handled. Some assemblers choke if | |
4927 | forward tags are used, while some require it. */ | |
4928 | /* #define SDB_ALLOW_FORWARD_REFERENCES */ | |
4929 | ||
4930 | \f | |
4931 | /* Miscellaneous Parameters. */ | |
4932 | ||
4933 | /* Define REAL_ARITHMETIC to use a software emulator for the target floating | |
4934 | point mode. Otherwise the host floating point mode is used. */ | |
4935 | #define REAL_ARITHMETIC | |
4936 | ||
4937 | /* Define this if you have defined special-purpose predicates in the file | |
4938 | `MACHINE.c'. This macro is called within an initializer of an array of | |
4939 | structures. The first field in the structure is the name of a predicate and | |
4940 | the second field is an array of rtl codes. For each predicate, list all rtl | |
4941 | codes that can be in expressions matched by the predicate. The list should | |
4942 | have a trailing comma. Here is an example of two entries in the list for a | |
4943 | typical RISC machine: | |
4944 | ||
4945 | #define PREDICATE_CODES \ | |
4946 | {"gen_reg_rtx_operand", {SUBREG, REG}}, \ | |
4947 | {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, | |
4948 | ||
4949 | Defining this macro does not affect the generated code (however, incorrect | |
4950 | definitions that omit an rtl code that may be matched by the predicate can | |
4951 | cause the compiler to malfunction). Instead, it allows the table built by | |
4952 | `genrecog' to be more compact and efficient, thus speeding up the compiler. | |
4953 | The most important predicates to include in the list specified by this macro | |
4954 | are thoses used in the most insn patterns. */ | |
4955 | #define PREDICATE_CODES \ | |
4956 | {"shift_operator", {ASHIFT, ASHIFTRT, LSHIFTRT }}, \ | |
4957 | {"equality_operator", {EQ, NE }}, \ | |
4958 | {"inequality_operator", {GE, GT, LE, LT, GEU, GTU, LEU, LTU }}, \ | |
c6243b4c | 4959 | {"xstormy16_ineqsi_operator", {LT, GE, LTU, GEU }}, |
4b58290f GK |
4960 | |
4961 | /* An alias for a machine mode name. This is the machine mode that elements of | |
4962 | a jump-table should have. */ | |
4963 | #define CASE_VECTOR_MODE SImode | |
4964 | ||
4965 | /* Define as C expression which evaluates to nonzero if the tablejump | |
4966 | instruction expects the table to contain offsets from the address of the | |
4967 | table. | |
4968 | Do not define this if the table should contain absolute addresses. */ | |
4969 | /* #define CASE_VECTOR_PC_RELATIVE 1 */ | |
4970 | ||
4971 | /* Define this if control falls through a `case' insn when the index value is | |
4972 | out of range. This means the specified default-label is actually ignored by | |
4973 | the `case' insn proper. */ | |
4974 | /* #define CASE_DROPS_THROUGH */ | |
4975 | ||
4976 | /* Define this to be the smallest number of different values for which it is | |
4977 | best to use a jump-table instead of a tree of conditional branches. The | |
4978 | default is four for machines with a `casesi' instruction and five otherwise. | |
4979 | This is best for most machines. */ | |
4980 | /* #define CASE_VALUES_THRESHOLD */ | |
4981 | ||
4982 | /* Define this macro if operations between registers with integral mode smaller | |
4983 | than a word are always performed on the entire register. Most RISC machines | |
4984 | have this property and most CISC machines do not. */ | |
4985 | #define WORD_REGISTER_OPERATIONS | |
4986 | ||
4987 | /* Define this macro to be a C expression indicating when insns that read | |
4988 | memory in MODE, an integral mode narrower than a word, set the bits outside | |
4989 | of MODE to be either the sign-extension or the zero-extension of the data | |
4990 | read. Return `SIGN_EXTEND' for values of MODE for which the insn | |
4991 | sign-extends, `ZERO_EXTEND' for which it zero-extends, and `NIL' for other | |
4992 | modes. | |
4993 | ||
4994 | This macro is not called with MODE non-integral or with a width greater than | |
4995 | or equal to `BITS_PER_WORD', so you may return any value in this case. Do | |
4996 | not define this macro if it would always return `NIL'. On machines where | |
4997 | this macro is defined, you will normally define it as the constant | |
4998 | `SIGN_EXTEND' or `ZERO_EXTEND'. */ | |
4999 | #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND | |
5000 | ||
5001 | /* Define if loading short immediate values into registers sign extends. */ | |
5002 | /* #define SHORT_IMMEDIATES_SIGN_EXTEND */ | |
5003 | ||
5004 | /* An alias for a tree code that should be used by default for conversion of | |
5005 | floating point values to fixed point. Normally, `FIX_ROUND_EXPR' is used. */ | |
5006 | /* #define IMPLICIT_FIX_EXPR */ | |
5007 | ||
5008 | /* Define this macro if the same instructions that convert a floating point | |
5009 | number to a signed fixed point number also convert validly to an unsigned | |
5010 | one. */ | |
5011 | /* #define FIXUNS_TRUNC_LIKE_FIX_TRUNC */ | |
5012 | ||
5013 | /* An alias for a tree code that is the easiest kind of division to compile | |
5014 | code for in the general case. It may be `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR', | |
5015 | `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four division operators differ | |
5016 | in how they round the result to an integer. `EASY_DIV_EXPR' is used when it | |
5017 | is permissible to use any of those kinds of division and the choice should | |
5018 | be made on the basis of efficiency. */ | |
5019 | #define EASY_DIV_EXPR TRUNC_DIV_EXPR | |
5020 | ||
5021 | /* The maximum number of bytes that a single instruction can move quickly from | |
5022 | memory to memory. */ | |
5023 | #define MOVE_MAX 2 | |
5024 | ||
5025 | /* The maximum number of bytes that a single instruction can move quickly from | |
5026 | memory to memory. If this is undefined, the default is `MOVE_MAX'. | |
5027 | Otherwise, it is the constant value that is the largest value that | |
5028 | `MOVE_MAX' can have at run-time. */ | |
5029 | /* #define MAX_MOVE_MAX */ | |
5030 | ||
5031 | /* A C expression that is nonzero if on this machine the number of bits | |
5032 | actually used for the count of a shift operation is equal to the number of | |
5033 | bits needed to represent the size of the object being shifted. When this | |
5034 | macro is non-zero, the compiler will assume that it is safe to omit a | |
5035 | sign-extend, zero-extend, and certain bitwise `and' instructions that | |
5036 | truncates the count of a shift operation. On machines that have | |
5037 | instructions that act on bitfields at variable positions, which may include | |
5038 | `bit test' instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables | |
5039 | deletion of truncations of the values that serve as arguments to bitfield | |
5040 | instructions. | |
5041 | ||
5042 | If both types of instructions truncate the count (for shifts) and position | |
5043 | (for bitfield operations), or if no variable-position bitfield instructions | |
5044 | exist, you should define this macro. | |
5045 | ||
5046 | However, on some machines, such as the 80386 and the 680x0, truncation only | |
5047 | applies to shift operations and not the (real or pretended) bitfield | |
5048 | operations. Define `SHIFT_COUNT_TRUNCATED' to be zero on such machines. | |
5049 | Instead, add patterns to the `md' file that include the implied truncation | |
5050 | of the shift instructions. | |
5051 | ||
5052 | You need not define this macro if it would always have the value of zero. */ | |
5053 | #define SHIFT_COUNT_TRUNCATED 1 | |
5054 | ||
5055 | /* A C expression which is nonzero if on this machine it is safe to "convert" | |
5056 | an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller | |
5057 | than INPREC) by merely operating on it as if it had only OUTPREC bits. | |
5058 | ||
5059 | On many machines, this expression can be 1. | |
5060 | ||
5061 | When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for | |
5062 | which `MODES_TIEABLE_P' is 0, suboptimal code can result. If this is the | |
5063 | case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve | |
5064 | things. */ | |
5065 | #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 | |
5066 | ||
5067 | /* A C expression describing the value returned by a comparison operator with | |
5068 | an integral mode and stored by a store-flag instruction (`sCOND') when the | |
5069 | condition is true. This description must apply to *all* the `sCOND' | |
5070 | patterns and all the comparison operators whose results have a `MODE_INT' | |
5071 | mode. | |
5072 | ||
5073 | A value of 1 or -1 means that the instruction implementing the comparison | |
5074 | operator returns exactly 1 or -1 when the comparison is true and 0 when the | |
5075 | comparison is false. Otherwise, the value indicates which bits of the | |
5076 | result are guaranteed to be 1 when the comparison is true. This value is | |
5077 | interpreted in the mode of the comparison operation, which is given by the | |
5078 | mode of the first operand in the `sCOND' pattern. Either the low bit or the | |
5079 | sign bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are used | |
5080 | by the compiler. | |
5081 | ||
5082 | If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will generate code | |
5083 | that depends only on the specified bits. It can also replace comparison | |
5084 | operators with equivalent operations if they cause the required bits to be | |
5085 | set, even if the remaining bits are undefined. For example, on a machine | |
5086 | whose comparison operators return an `SImode' value and where | |
5087 | `STORE_FLAG_VALUE' is defined as `0x80000000', saying that just the sign bit | |
5088 | is relevant, the expression | |
5089 | ||
5090 | (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) | |
5091 | ||
5092 | can be converted to | |
5093 | ||
5094 | (ashift:SI X (const_int N)) | |
5095 | ||
5096 | where N is the appropriate shift count to move the bit being tested into the | |
5097 | sign bit. | |
5098 | ||
5099 | There is no way to describe a machine that always sets the low-order bit for | |
5100 | a true value, but does not guarantee the value of any other bits, but we do | |
5101 | not know of any machine that has such an instruction. If you are trying to | |
5102 | port GNU CC to such a machine, include an instruction to perform a | |
5103 | logical-and of the result with 1 in the pattern for the comparison operators | |
5104 | and let us know. | |
5105 | ||
5106 | Often, a machine will have multiple instructions that obtain a value from a | |
5107 | comparison (or the condition codes). Here are rules to guide the choice of | |
5108 | value for `STORE_FLAG_VALUE', and hence the instructions to be used: | |
5109 | ||
5110 | * Use the shortest sequence that yields a valid definition for | |
5111 | `STORE_FLAG_VALUE'. It is more efficient for the compiler to | |
5112 | "normalize" the value (convert it to, e.g., 1 or 0) than for | |
5113 | the comparison operators to do so because there may be | |
5114 | opportunities to combine the normalization with other | |
5115 | operations. | |
5116 | ||
5117 | * For equal-length sequences, use a value of 1 or -1, with -1 | |
5118 | being slightly preferred on machines with expensive jumps and | |
5119 | 1 preferred on other machines. | |
5120 | ||
5121 | * As a second choice, choose a value of `0x80000001' if | |
5122 | instructions exist that set both the sign and low-order bits | |
5123 | but do not define the others. | |
5124 | ||
5125 | * Otherwise, use a value of `0x80000000'. | |
5126 | ||
5127 | Many machines can produce both the value chosen for `STORE_FLAG_VALUE' and | |
5128 | its negation in the same number of instructions. On those machines, you | |
5129 | should also define a pattern for those cases, e.g., one matching | |
5130 | ||
5131 | (set A (neg:M (ne:M B C))) | |
5132 | ||
5133 | Some machines can also perform `and' or `plus' operations on condition code | |
5134 | values with less instructions than the corresponding `sCOND' insn followed | |
5135 | by `and' or `plus'. On those machines, define the appropriate patterns. | |
5136 | Use the names `incscc' and `decscc', respectively, for the the patterns | |
5137 | which perform `plus' or `minus' operations on condition code values. See | |
5138 | `rs6000.md' for some examples. The GNU Superoptizer can be used to find | |
5139 | such instruction sequences on other machines. | |
5140 | ||
5141 | You need not define `STORE_FLAG_VALUE' if the machine has no store-flag | |
5142 | instructions. */ | |
5143 | /* #define STORE_FLAG_VALUE */ | |
5144 | ||
5145 | /* A C expression that gives a non-zero floating point value that is returned | |
5146 | when comparison operators with floating-point results are true. Define this | |
5147 | macro on machine that have comparison operations that return floating-point | |
5148 | values. If there are no such operations, do not define this macro. */ | |
5149 | /* #define FLOAT_STORE_FLAG_VALUE */ | |
5150 | ||
5151 | /* An alias for the machine mode for pointers. On most machines, define this | |
5152 | to be the integer mode corresponding to the width of a hardware pointer; | |
5153 | `SImode' on 32-bit machine or `DImode' on 64-bit machines. On some machines | |
5154 | you must define this to be one of the partial integer modes, such as | |
5155 | `PSImode'. | |
5156 | ||
5157 | The width of `Pmode' must be at least as large as the value of | |
5158 | `POINTER_SIZE'. If it is not equal, you must define the macro | |
5159 | `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to `Pmode'. */ | |
5160 | #define Pmode HImode | |
5161 | ||
5162 | /* An alias for the machine mode used for memory references to functions being | |
5163 | called, in `call' RTL expressions. On most machines this should be | |
5164 | `QImode'. */ | |
5165 | #define FUNCTION_MODE HImode | |
5166 | ||
5167 | /* A C expression for the maximum number of instructions above which the | |
5168 | function DECL should not be inlined. DECL is a `FUNCTION_DECL' node. | |
5169 | ||
5170 | The default definition of this macro is 64 plus 8 times the number of | |
5171 | arguments that the function accepts. Some people think a larger threshold | |
5172 | should be used on RISC machines. */ | |
5173 | /* #define INTEGRATE_THRESHOLD(DECL) */ | |
5174 | ||
5175 | /* Define this if the preprocessor should ignore `#sccs' directives and print | |
5176 | no error message. | |
5177 | ||
5178 | Defined in svr4.h. */ | |
5179 | /* #define SCCS_DIRECTIVE */ | |
5180 | ||
5181 | /* Define this macro if the system header files support C++ as well as C. This | |
5182 | macro inhibits the usual method of using system header files in C++, which | |
5183 | is to pretend that the file's contents are enclosed in `extern "C" {...}'. */ | |
5184 | #define NO_IMPLICIT_EXTERN_C | |
5185 | ||
5186 | /* Define this macro if you want to implement any pragmas. If defined, it | |
5187 | should be a C expression to be executed when #pragma is seen. The | |
5188 | argument GETC is a function which will return the next character in the | |
5189 | input stream, or EOF if no characters are left. The argument UNGETC is | |
5190 | a function which will push a character back into the input stream. The | |
5191 | argument NAME is the word following #pragma in the input stream. The input | |
5192 | stream pointer will be pointing just beyond the end of this word. The | |
5193 | expression should return true if it handled the pragma, false otherwise. | |
5194 | The input stream should be left undistrubed if false is returned, otherwise | |
5195 | it should be pointing at the next character after the end of the pragma. | |
5196 | Any characters left between the end of the pragma and the end of the line will | |
5197 | be ignored. | |
5198 | ||
5199 | It is generally a bad idea to implement new uses of `#pragma'. The only | |
5200 | reason to define this macro is for compatibility with other compilers that | |
5201 | do support `#pragma' for the sake of any user programs which already use it. */ | |
5202 | /* #define HANDLE_PRAGMA(GETC, UNGETC, NAME) handle_pragma (GETC, UNGETC, NAME) */ | |
5203 | ||
5204 | /* Define this macro to handle System V style pragmas: #pragma pack and | |
5205 | #pragma weak. Note, #pragma weak will only be supported if SUPPORT_WEAK is | |
5206 | defined. | |
5207 | ||
5208 | Defined in svr4.h. */ | |
5209 | #define HANDLE_SYSV_PRAGMA | |
5210 | ||
5211 | /* Define this macro if you want to support the Win32 style pragmas | |
5212 | #pragma pack(push,<n>) and #pragma pack(pop). */ | |
5213 | /* HANDLE_PRAGMA_PACK_PUSH_POP 1 */ | |
5214 | ||
4b58290f GK |
5215 | /* Define this macro to control use of the character `$' in identifier names. |
5216 | The value should be 0, 1, or 2. 0 means `$' is not allowed by default; 1 | |
5217 | means it is allowed by default if `-traditional' is used; 2 means it is | |
5218 | allowed by default provided `-ansi' is not used. 1 is the default; there is | |
5219 | no need to define this macro in that case. */ | |
5220 | /* #define DOLLARS_IN_IDENTIFIERS */ | |
5221 | ||
5222 | /* Define this macro if the assembler does not accept the character `$' in | |
5223 | label names. By default constructors and destructors in G++ have `$' in the | |
5224 | identifiers. If this macro is defined, `.' is used instead. | |
5225 | ||
5226 | Defined in svr4.h. */ | |
5227 | /* #define NO_DOLLAR_IN_LABEL */ | |
5228 | ||
5229 | /* Define this macro if the assembler does not accept the character `.' in | |
5230 | label names. By default constructors and destructors in G++ have names that | |
5231 | use `.'. If this macro is defined, these names are rewritten to avoid `.'. */ | |
5232 | /* #define NO_DOT_IN_LABEL */ | |
5233 | ||
5234 | /* Define this macro if the target system expects every program's `main' | |
5235 | function to return a standard "success" value by default (if no other value | |
5236 | is explicitly returned). | |
5237 | ||
5238 | The definition should be a C statement (sans semicolon) to generate the | |
5239 | appropriate rtl instructions. It is used only when compiling the end of | |
5240 | `main'. */ | |
5241 | /* #define DEFAULT_MAIN_RETURN */ | |
5242 | ||
5243 | /* Define this if the target system supports the function `atexit' from the | |
5244 | ANSI C standard. If this is not defined, and `INIT_SECTION_ASM_OP' is not | |
5245 | defined, a default `exit' function will be provided to support C++. | |
5246 | ||
5247 | Defined by svr4.h */ | |
5248 | /* #define HAVE_ATEXIT */ | |
5249 | ||
5250 | /* Define this if your `exit' function needs to do something besides calling an | |
5251 | external function `_cleanup' before terminating with `_exit'. The | |
5252 | `EXIT_BODY' macro is only needed if netiher `HAVE_ATEXIT' nor | |
5253 | `INIT_SECTION_ASM_OP' are defined. */ | |
5254 | /* #define EXIT_BODY */ | |
5255 | ||
5256 | /* Define this macro as a C expression that is nonzero if it is safe for the | |
5257 | delay slot scheduler to place instructions in the delay slot of INSN, even | |
5258 | if they appear to use a resource set or clobbered in INSN. INSN is always a | |
5259 | `jump_insn' or an `insn'; GNU CC knows that every `call_insn' has this | |
5260 | behavior. On machines where some `insn' or `jump_insn' is really a function | |
5261 | call and hence has this behavior, you should define this macro. | |
5262 | ||
5263 | You need not define this macro if it would always return zero. */ | |
5264 | /* #define INSN_SETS_ARE_DELAYED(INSN) */ | |
5265 | ||
5266 | /* Define this macro as a C expression that is nonzero if it is safe for the | |
5267 | delay slot scheduler to place instructions in the delay slot of INSN, even | |
5268 | if they appear to set or clobber a resource referenced in INSN. INSN is | |
5269 | always a `jump_insn' or an `insn'. On machines where some `insn' or | |
5270 | `jump_insn' is really a function call and its operands are registers whose | |
5271 | use is actually in the subroutine it calls, you should define this macro. | |
5272 | Doing so allows the delay slot scheduler to move instructions which copy | |
5273 | arguments into the argument registers into the delay slot of INSN. | |
5274 | ||
5275 | You need not define this macro if it would always return zero. */ | |
5276 | /* #define INSN_REFERENCES_ARE_DELAYED(INSN) */ | |
5277 | ||
5278 | /* In rare cases, correct code generation requires extra machine dependent | |
5279 | processing between the second jump optimization pass and delayed branch | |
5280 | scheduling. On those machines, define this macro as a C statement to act on | |
5281 | the code starting at INSN. */ | |
5282 | /* #define MACHINE_DEPENDENT_REORG(INSN) */ | |
5283 | ||
5284 | /* Define this macro if in some cases global symbols from one translation unit | |
5285 | may not be bound to undefined symbols in another translation unit without | |
5286 | user intervention. For instance, under Microsoft Windows symbols must be | |
5287 | explicitly imported from shared libraries (DLLs). */ | |
5288 | /* #define MULTIPLE_SYMBOL_SPACES */ | |
5289 | ||
5290 | /* A C expression for the maximum number of instructions to execute via | |
5291 | conditional execution instructions instead of a branch. A value of | |
5292 | BRANCH_COST+1 is the default if the machine does not use | |
5293 | cc0, and 1 if it does use cc0. */ | |
5294 | /* #define MAX_CONDITIONAL_EXECUTE */ | |
5295 | ||
5296 | /* A C statement that adds to tree CLOBBERS a set of STRING_CST trees for any | |
5297 | hard regs the port wishes to automatically clobber for all asms. */ | |
5298 | /* #define MD_ASM_CLOBBERS(CLOBBERS) */ | |
5299 | ||
5300 | /* Indicate how many instructions can be issued at the same time. */ | |
5301 | /* #define ISSUE_RATE */ | |
5302 | ||
5303 | /* A C statement which is executed by the Haifa scheduler at the beginning of | |
5304 | each block of instructions that are to be scheduled. FILE is either a null | |
5305 | pointer, or a stdio stream to write any debug output to. VERBOSE is the | |
5306 | verbose level provided by -fsched-verbose-<n>. */ | |
5307 | /* #define MD_SCHED_INIT (FILE, VERBOSE) */ | |
5308 | ||
5309 | /* A C statement which is executed by the Haifa scheduler after it has scheduled | |
5310 | the ready list to allow the machine description to reorder it (for example to | |
5311 | combine two small instructions together on VLIW machines). FILE is either a | |
5312 | null pointer, or a stdio stream to write any debug output to. VERBOSE is the | |
5313 | verbose level provided by -fsched-verbose-=<n>. READY is a pointer to the | |
5314 | ready list of instructions that are ready to be scheduled. N_READY is the | |
5315 | number of elements in the ready list. The scheduler reads the ready list in | |
5316 | reverse order, starting with READY[N_READY-1] and going to READY[0]. CLOCK | |
5317 | is the timer tick of the scheduler. CAN_ISSUE_MORE is an output parameter that | |
5318 | is set to the number of insns that can issue this clock; normally this is just | |
5319 | 'issue_rate' */ | |
5320 | /* #define MD_SCHED_REORDER (FILE, VERBOSE, READY, N_READY, CLOCK, CAN_ISSUE_MORE) */ | |
5321 | ||
5322 | /* A C statement which is executed by the Haifa scheduler after it has scheduled | |
5323 | an insn from the ready list. FILE is either a null pointer, or a stdio stream | |
5324 | to write any debug output to. VERBOSE is the verbose level provided by | |
5325 | -fsched-verbose-<n>. INSN is the instruction that was scheduled. MORE is the | |
5326 | number of instructions that can be issued in the current cycle. This macro | |
5327 | is responsible for updating the value of MORE (typically by (MORE)--). */ | |
5328 | /* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */ | |
5329 | ||
5330 | /* Define this to the largest integer machine mode which can be used for | |
5331 | operations other than load, store and copy operations. You need only define | |
5332 | this macro if the target holds values larger than word_mode in general purpose | |
5333 | registers. Most targets should not define this macro. */ | |
5334 | /* #define MAX_INTEGER_COMPUTATION_MODE */ | |
5335 | ||
5336 | /* Define this macro as a C string constant for the linker argument to link in the | |
5337 | system math library, or "" if the target does not have a separate math library. | |
5338 | You need only define this macro if the default of "-lm" is wrong. */ | |
5339 | /* #define MATH_LIBRARY */ | |
5340 | \f | |
5341 | /* Define the information needed to generate branch and scc insns. This is | |
5342 | stored from the compare operation. Note that we can't use "rtx" here | |
5343 | since it hasn't been defined! */ | |
5344 | ||
c6243b4c | 5345 | extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1; |
4b58290f | 5346 | |
c6243b4c | 5347 | /* End of xstormy16.h */ |