]>
Commit | Line | Data |
---|---|---|
eff01bb6 | 1 | /* Definitions of various defaults for tm.h macros. |
5624e564 | 2 | Copyright (C) 1992-2015 Free Software Foundation, Inc. |
b33c316c | 3 | Contributed by Ron Guilmette (rfg@monkeys.com) |
c53a8ab6 | 4 | |
1322177d | 5 | This file is part of GCC. |
c53a8ab6 | 6 | |
1322177d LB |
7 | GCC is free software; you can redistribute it and/or modify it under |
8 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 9 | Software Foundation; either version 3, or (at your option) any later |
1322177d | 10 | version. |
c53a8ab6 | 11 | |
1322177d LB |
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 | for more details. | |
c53a8ab6 | 16 | |
748086b7 JJ |
17 | Under Section 7 of GPL version 3, you are granted additional |
18 | permissions described in the GCC Runtime Library Exception, version | |
19 | 3.1, as published by the Free Software Foundation. | |
20 | ||
21 | You should have received a copy of the GNU General Public License and | |
22 | a copy of the GCC Runtime Library Exception along with this program; | |
23 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |
9dcd6f09 | 24 | <http://www.gnu.org/licenses/>. */ |
c53a8ab6 | 25 | |
d8ea8f28 ZW |
26 | #ifndef GCC_DEFAULTS_H |
27 | #define GCC_DEFAULTS_H | |
28 | ||
ded49a7f RH |
29 | /* How to start an assembler comment. */ |
30 | #ifndef ASM_COMMENT_START | |
31 | #define ASM_COMMENT_START ";#" | |
32 | #endif | |
33 | ||
4977bab6 ZW |
34 | /* Store in OUTPUT a string (made with alloca) containing an |
35 | assembler-name for a local static variable or function named NAME. | |
7b73db04 CH |
36 | LABELNO is an integer which is different for each call. */ |
37 | ||
4977bab6 ZW |
38 | #ifndef ASM_PN_FORMAT |
39 | # ifndef NO_DOT_IN_LABEL | |
40 | # define ASM_PN_FORMAT "%s.%lu" | |
41 | # else | |
42 | # ifndef NO_DOLLAR_IN_LABEL | |
43 | # define ASM_PN_FORMAT "%s$%lu" | |
44 | # else | |
45 | # define ASM_PN_FORMAT "__%s_%lu" | |
46 | # endif | |
47 | # endif | |
48 | #endif /* ! ASM_PN_FORMAT */ | |
49 | ||
7b73db04 | 50 | #ifndef ASM_FORMAT_PRIVATE_NAME |
4977bab6 ZW |
51 | # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ |
52 | do { const char *const name_ = (NAME); \ | |
28dab132 BI |
53 | char *const output_ = (OUTPUT) = \ |
54 | (char *) alloca (strlen (name_) + 32); \ | |
4977bab6 | 55 | sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \ |
7b73db04 CH |
56 | } while (0) |
57 | #endif | |
58 | ||
e0a21ab9 | 59 | /* Choose a reasonable default for ASM_OUTPUT_ASCII. */ |
c53a8ab6 RS |
60 | |
61 | #ifndef ASM_OUTPUT_ASCII | |
62 | #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ | |
63 | do { \ | |
64 | FILE *_hide_asm_out_file = (MYFILE); \ | |
47ee9bcb | 65 | const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \ |
c53a8ab6 RS |
66 | int _hide_thissize = (MYLENGTH); \ |
67 | { \ | |
68 | FILE *asm_out_file = _hide_asm_out_file; \ | |
47ee9bcb | 69 | const unsigned char *p = _hide_p; \ |
c53a8ab6 RS |
70 | int thissize = _hide_thissize; \ |
71 | int i; \ | |
72 | fprintf (asm_out_file, "\t.ascii \""); \ | |
73 | \ | |
74 | for (i = 0; i < thissize; i++) \ | |
75 | { \ | |
b3694847 | 76 | int c = p[i]; \ |
c53a8ab6 RS |
77 | if (c == '\"' || c == '\\') \ |
78 | putc ('\\', asm_out_file); \ | |
c3284718 | 79 | if (ISPRINT (c)) \ |
c53a8ab6 RS |
80 | putc (c, asm_out_file); \ |
81 | else \ | |
82 | { \ | |
83 | fprintf (asm_out_file, "\\%o", c); \ | |
84 | /* After an octal-escape, if a digit follows, \ | |
85 | terminate one string constant and start another. \ | |
8aeea6e6 | 86 | The VAX assembler fails to stop reading the escape \ |
c53a8ab6 RS |
87 | after three digits, so this is the only way we \ |
88 | can get it to parse the data properly. */ \ | |
c3284718 | 89 | if (i < thissize - 1 && ISDIGIT (p[i + 1])) \ |
c53a8ab6 RS |
90 | fprintf (asm_out_file, "\"\n\t.ascii \""); \ |
91 | } \ | |
92 | } \ | |
93 | fprintf (asm_out_file, "\"\n"); \ | |
94 | } \ | |
95 | } \ | |
96 | while (0) | |
97 | #endif | |
d0d4af87 | 98 | |
650f773a JW |
99 | /* This is how we tell the assembler to equate two values. */ |
100 | #ifdef SET_ASM_OP | |
101 | #ifndef ASM_OUTPUT_DEF | |
102 | #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \ | |
e8638df0 | 103 | do { fprintf ((FILE), "%s", SET_ASM_OP); \ |
650f773a JW |
104 | assemble_name (FILE, LABEL1); \ |
105 | fprintf (FILE, ","); \ | |
106 | assemble_name (FILE, LABEL2); \ | |
107 | fprintf (FILE, "\n"); \ | |
108 | } while (0) | |
109 | #endif | |
110 | #endif | |
daefd78b | 111 | |
ba885ec5 NS |
112 | #ifndef IFUNC_ASM_TYPE |
113 | #define IFUNC_ASM_TYPE "gnu_indirect_function" | |
114 | #endif | |
115 | ||
f1c26cad RO |
116 | #ifndef TLS_COMMON_ASM_OP |
117 | #define TLS_COMMON_ASM_OP ".tls_common" | |
118 | #endif | |
119 | ||
a13e882c JJ |
120 | #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON) |
121 | #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) \ | |
122 | do \ | |
123 | { \ | |
f1c26cad | 124 | fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP); \ |
a13e882c | 125 | assemble_name ((FILE), (NAME)); \ |
16998094 | 126 | fprintf ((FILE), "," HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ |
a13e882c JJ |
127 | (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \ |
128 | } \ | |
129 | while (0) | |
130 | #endif | |
131 | ||
083b6717 JDA |
132 | /* Decide whether to defer emitting the assembler output for an equate |
133 | of two values. The default is to not defer output. */ | |
134 | #ifndef TARGET_DEFERRED_OUTPUT_DEFS | |
135 | #define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false | |
136 | #endif | |
137 | ||
4ad5e05d | 138 | /* This is how to output the definition of a user-level label named |
135a687e | 139 | NAME, such as the label on variable NAME. */ |
4ad5e05d KG |
140 | |
141 | #ifndef ASM_OUTPUT_LABEL | |
142 | #define ASM_OUTPUT_LABEL(FILE,NAME) \ | |
5e3929ed DA |
143 | do { \ |
144 | assemble_name ((FILE), (NAME)); \ | |
145 | fputs (":\n", (FILE)); \ | |
146 | } while (0) | |
4ad5e05d KG |
147 | #endif |
148 | ||
135a687e KT |
149 | /* This is how to output the definition of a user-level label named |
150 | NAME, such as the label on a function. */ | |
151 | ||
152 | #ifndef ASM_OUTPUT_FUNCTION_LABEL | |
153 | #define ASM_OUTPUT_FUNCTION_LABEL(FILE, NAME, DECL) \ | |
154 | ASM_OUTPUT_LABEL ((FILE), (NAME)) | |
155 | #endif | |
156 | ||
57829bc4 MM |
157 | /* Output the definition of a compiler-generated label named NAME. */ |
158 | #ifndef ASM_OUTPUT_INTERNAL_LABEL | |
159 | #define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME) \ | |
160 | do { \ | |
161 | assemble_name_raw ((FILE), (NAME)); \ | |
162 | fputs (":\n", (FILE)); \ | |
163 | } while (0) | |
164 | #endif | |
165 | ||
81d77cda RK |
166 | /* This is how to output a reference to a user-level label named NAME. */ |
167 | ||
168 | #ifndef ASM_OUTPUT_LABELREF | |
5e3929ed DA |
169 | #define ASM_OUTPUT_LABELREF(FILE,NAME) \ |
170 | do { \ | |
171 | fputs (user_label_prefix, (FILE)); \ | |
172 | fputs ((NAME), (FILE)); \ | |
173 | } while (0); | |
81d77cda RK |
174 | #endif |
175 | ||
8215347e JW |
176 | /* Allow target to print debug info labels specially. This is useful for |
177 | VLIW targets, since debug info labels should go into the middle of | |
178 | instruction bundles instead of breaking them. */ | |
179 | ||
180 | #ifndef ASM_OUTPUT_DEBUG_LABEL | |
181 | #define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \ | |
4977bab6 | 182 | (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM) |
8215347e JW |
183 | #endif |
184 | ||
3aa8ab7b | 185 | /* This is how we tell the assembler that a symbol is weak. */ |
20c93f7c RO |
186 | #ifndef ASM_OUTPUT_WEAK_ALIAS |
187 | #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF) | |
3aa8ab7b L |
188 | #define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE) \ |
189 | do \ | |
190 | { \ | |
191 | ASM_WEAKEN_LABEL (STREAM, NAME); \ | |
192 | if (VALUE) \ | |
193 | ASM_OUTPUT_DEF (STREAM, NAME, VALUE); \ | |
194 | } \ | |
195 | while (0) | |
a0203ca7 AO |
196 | #endif |
197 | #endif | |
198 | ||
199 | /* This is how we tell the assembler that a symbol is a weak alias to | |
200 | another symbol that doesn't require the other symbol to be defined. | |
201 | Uses of the former will turn into weak uses of the latter, i.e., | |
202 | uses that, in case the latter is undefined, will not cause errors, | |
203 | and will add it to the symbol table as weak undefined. However, if | |
204 | the latter is referenced directly, a strong reference prevails. */ | |
205 | #ifndef ASM_OUTPUT_WEAKREF | |
206 | #if defined HAVE_GAS_WEAKREF | |
ff2d10c1 | 207 | #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \ |
a0203ca7 AO |
208 | do \ |
209 | { \ | |
210 | fprintf ((FILE), "\t.weakref\t"); \ | |
211 | assemble_name ((FILE), (NAME)); \ | |
212 | fprintf ((FILE), ","); \ | |
213 | assemble_name ((FILE), (VALUE)); \ | |
214 | fprintf ((FILE), "\n"); \ | |
215 | } \ | |
216 | while (0) | |
3aa8ab7b | 217 | #endif |
20c93f7c | 218 | #endif |
3aa8ab7b | 219 | |
2be2ac70 ZW |
220 | /* How to emit a .type directive. */ |
221 | #ifndef ASM_OUTPUT_TYPE_DIRECTIVE | |
222 | #if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT | |
223 | #define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE) \ | |
224 | do \ | |
225 | { \ | |
226 | fputs (TYPE_ASM_OP, STREAM); \ | |
227 | assemble_name (STREAM, NAME); \ | |
228 | fputs (", ", STREAM); \ | |
229 | fprintf (STREAM, TYPE_OPERAND_FMT, TYPE); \ | |
230 | putc ('\n', STREAM); \ | |
231 | } \ | |
232 | while (0) | |
233 | #endif | |
234 | #endif | |
235 | ||
236 | /* How to emit a .size directive. */ | |
237 | #ifndef ASM_OUTPUT_SIZE_DIRECTIVE | |
238 | #ifdef SIZE_ASM_OP | |
239 | #define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE) \ | |
240 | do \ | |
241 | { \ | |
242 | HOST_WIDE_INT size_ = (SIZE); \ | |
243 | fputs (SIZE_ASM_OP, STREAM); \ | |
244 | assemble_name (STREAM, NAME); \ | |
90ff44cf | 245 | fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \ |
2be2ac70 ZW |
246 | } \ |
247 | while (0) | |
248 | ||
99086d59 | 249 | #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \ |
2be2ac70 ZW |
250 | do \ |
251 | { \ | |
252 | fputs (SIZE_ASM_OP, STREAM); \ | |
99086d59 ZW |
253 | assemble_name (STREAM, NAME); \ |
254 | fputs (", .-", STREAM); \ | |
255 | assemble_name (STREAM, NAME); \ | |
2be2ac70 ZW |
256 | putc ('\n', STREAM); \ |
257 | } \ | |
258 | while (0) | |
259 | ||
260 | #endif | |
261 | #endif | |
262 | ||
74b90fe2 JDA |
263 | /* This determines whether or not we support weak symbols. SUPPORTS_WEAK |
264 | must be a preprocessor constant. */ | |
daefd78b | 265 | #ifndef SUPPORTS_WEAK |
79c4e63f | 266 | #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) |
daefd78b JM |
267 | #define SUPPORTS_WEAK 1 |
268 | #else | |
269 | #define SUPPORTS_WEAK 0 | |
270 | #endif | |
271 | #endif | |
a6ab3aad | 272 | |
74b90fe2 JDA |
273 | /* This determines whether or not we support weak symbols during target |
274 | code generation. TARGET_SUPPORTS_WEAK can be any valid C expression. */ | |
275 | #ifndef TARGET_SUPPORTS_WEAK | |
276 | #define TARGET_SUPPORTS_WEAK (SUPPORTS_WEAK) | |
277 | #endif | |
278 | ||
ed5ef2e4 CC |
279 | /* This determines whether or not we support the discriminator |
280 | attribute in the .loc directive. */ | |
281 | #ifndef SUPPORTS_DISCRIMINATOR | |
282 | #ifdef HAVE_GAS_DISCRIMINATOR | |
283 | #define SUPPORTS_DISCRIMINATOR 1 | |
284 | #else | |
285 | #define SUPPORTS_DISCRIMINATOR 0 | |
286 | #endif | |
287 | #endif | |
288 | ||
1ca894a0 MM |
289 | /* This determines whether or not we support link-once semantics. */ |
290 | #ifndef SUPPORTS_ONE_ONLY | |
291 | #ifdef MAKE_DECL_ONE_ONLY | |
292 | #define SUPPORTS_ONE_ONLY 1 | |
293 | #else | |
294 | #define SUPPORTS_ONE_ONLY 0 | |
295 | #endif | |
296 | #endif | |
297 | ||
0524c91d MA |
298 | /* This determines whether weak symbols must be left out of a static |
299 | archive's table of contents. Defining this macro to be nonzero has | |
300 | the consequence that certain symbols will not be made weak that | |
301 | otherwise would be. The C++ ABI requires this macro to be zero; | |
8c27b7d4 | 302 | see the documentation. */ |
0524c91d MA |
303 | #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC |
304 | #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0 | |
4746cf84 MA |
305 | #endif |
306 | ||
ea4b7848 | 307 | /* This determines whether or not we need linkonce unwind information. */ |
4746cf84 MA |
308 | #ifndef TARGET_USES_WEAK_UNWIND_INFO |
309 | #define TARGET_USES_WEAK_UNWIND_INFO 0 | |
310 | #endif | |
311 | ||
d48fd218 ZW |
312 | /* By default, there is no prefix on user-defined symbols. */ |
313 | #ifndef USER_LABEL_PREFIX | |
314 | #define USER_LABEL_PREFIX "" | |
315 | #endif | |
316 | ||
8f08ea1e | 317 | /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to |
f676971a | 318 | provide a weak attribute. Else define it to nothing. |
8f08ea1e | 319 | |
d02af173 | 320 | This would normally belong in ansidecl.h, but SUPPORTS_WEAK is |
8f08ea1e L |
321 | not available at that time. |
322 | ||
323 | Note, this is only for use by target files which we know are to be | |
324 | compiled by GCC. */ | |
325 | #ifndef TARGET_ATTRIBUTE_WEAK | |
326 | # if SUPPORTS_WEAK | |
327 | # define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak)) | |
328 | # else | |
329 | # define TARGET_ATTRIBUTE_WEAK | |
330 | # endif | |
331 | #endif | |
332 | ||
15072eb1 ZW |
333 | /* By default we can assume that all global symbols are in one namespace, |
334 | across all shared libraries. */ | |
335 | #ifndef MULTIPLE_SYMBOL_SPACES | |
336 | # define MULTIPLE_SYMBOL_SPACES 0 | |
337 | #endif | |
4746cf84 | 338 | |
ea4f1fce JO |
339 | /* If the target supports init_priority C++ attribute, give |
340 | SUPPORTS_INIT_PRIORITY a nonzero value. */ | |
341 | #ifndef SUPPORTS_INIT_PRIORITY | |
342 | #define SUPPORTS_INIT_PRIORITY 1 | |
343 | #endif /* SUPPORTS_INIT_PRIORITY */ | |
344 | ||
a6ab3aad JM |
345 | /* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that |
346 | the rest of the DWARF 2 frame unwind support is also provided. */ | |
f0a0390e | 347 | #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) |
0021b564 | 348 | #define DWARF2_UNWIND_INFO 1 |
a6ab3aad | 349 | #endif |
b366352b | 350 | |
2cc07db4 RH |
351 | /* If we have named sections, and we're using crtstuff to run ctors, |
352 | use them for registering eh frame information. */ | |
bc2a8f08 | 353 | #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ |
c3284718 | 354 | && !defined (EH_FRAME_IN_DATA_SECTION) |
7c262518 RH |
355 | #ifndef EH_FRAME_SECTION_NAME |
356 | #define EH_FRAME_SECTION_NAME ".eh_frame" | |
357 | #endif | |
31cf0144 JM |
358 | #endif |
359 | ||
1a35e62d MM |
360 | /* On many systems, different EH table encodings are used under |
361 | difference circumstances. Some will require runtime relocations; | |
362 | some will not. For those that do not require runtime relocations, | |
363 | we would like to make the table read-only. However, since the | |
364 | read-only tables may need to be combined with read-write tables | |
365 | that do require runtime relocation, it is not safe to make the | |
366 | tables read-only unless the linker will merge read-only and | |
367 | read-write sections into a single read-write section. If your | |
368 | linker does not have this ability, but your system is such that no | |
369 | encoding used with non-PIC code will ever require a runtime | |
370 | relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in | |
371 | your target configuration file. */ | |
372 | #ifndef EH_TABLES_CAN_BE_READ_ONLY | |
373 | #ifdef HAVE_LD_RO_RW_SECTION_MIXING | |
374 | #define EH_TABLES_CAN_BE_READ_ONLY 1 | |
375 | #else | |
376 | #define EH_TABLES_CAN_BE_READ_ONLY 0 | |
377 | #endif | |
378 | #endif | |
379 | ||
9a522505 TS |
380 | /* Provide defaults for stuff that may not be defined when using |
381 | sjlj exceptions. */ | |
382 | #ifndef EH_RETURN_DATA_REGNO | |
383 | #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM | |
384 | #endif | |
385 | ||
a8a6b3df TS |
386 | /* Offset between the eh handler address and entry in eh tables. */ |
387 | #ifndef RETURN_ADDR_OFFSET | |
388 | #define RETURN_ADDR_OFFSET 0 | |
389 | #endif | |
390 | ||
cbc7d031 TS |
391 | #ifndef MASK_RETURN_ADDR |
392 | #define MASK_RETURN_ADDR NULL_RTX | |
393 | #endif | |
394 | ||
6351543d AG |
395 | /* If we have named section and we support weak symbols, then use the |
396 | .jcr section for recording java classes which need to be registered | |
397 | at program start-up time. */ | |
398 | #if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK | |
399 | #ifndef JCR_SECTION_NAME | |
400 | #define JCR_SECTION_NAME ".jcr" | |
401 | #endif | |
402 | #endif | |
403 | ||
adb35797 | 404 | /* This decision to use a .jcr section can be overridden by defining |
e50e6b88 DS |
405 | USE_JCR_SECTION to 0 in target file. This is necessary if target |
406 | can define JCR_SECTION_NAME but does not have crtstuff or | |
407 | linker support for .jcr section. */ | |
408 | #ifndef TARGET_USE_JCR_SECTION | |
409 | #ifdef JCR_SECTION_NAME | |
410 | #define TARGET_USE_JCR_SECTION 1 | |
411 | #else | |
412 | #define TARGET_USE_JCR_SECTION 0 | |
413 | #endif | |
414 | #endif | |
415 | ||
c478efd1 GDR |
416 | /* Number of hardware registers that go into the DWARF-2 unwind info. |
417 | If not defined, equals FIRST_PSEUDO_REGISTER */ | |
418 | ||
419 | #ifndef DWARF_FRAME_REGISTERS | |
420 | #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER | |
421 | #endif | |
d8ea8f28 | 422 | |
db42e39d RH |
423 | /* Offsets recorded in opcodes are a multiple of this alignment factor. */ |
424 | #ifndef DWARF_CIE_DATA_ALIGNMENT | |
425 | #ifdef STACK_GROWS_DOWNWARD | |
426 | #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) | |
427 | #else | |
428 | #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) | |
429 | #endif | |
430 | #endif | |
431 | ||
432 | /* The DWARF 2 CFA column which tracks the return address. Normally this | |
433 | is the column for PC, or the first column after all of the hard | |
434 | registers. */ | |
435 | #ifndef DWARF_FRAME_RETURN_COLUMN | |
436 | #ifdef PC_REGNUM | |
437 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) | |
438 | #else | |
439 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS | |
440 | #endif | |
441 | #endif | |
442 | ||
4617e3b5 KG |
443 | /* How to renumber registers for dbx and gdb. If not defined, assume |
444 | no renumbering is necessary. */ | |
445 | ||
446 | #ifndef DBX_REGISTER_NUMBER | |
447 | #define DBX_REGISTER_NUMBER(REGNO) (REGNO) | |
448 | #endif | |
449 | ||
db42e39d RH |
450 | /* The mapping from gcc register number to DWARF 2 CFA column number. |
451 | By default, we just provide columns for all registers. */ | |
452 | #ifndef DWARF_FRAME_REGNUM | |
453 | #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) | |
454 | #endif | |
455 | ||
a66272f6 OH |
456 | /* The mapping from dwarf CFA reg number to internal dwarf reg numbers. */ |
457 | #ifndef DWARF_REG_TO_UNWIND_COLUMN | |
458 | #define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO) | |
459 | #endif | |
460 | ||
db42e39d RH |
461 | /* Map register numbers held in the call frame info that gcc has |
462 | collected using DWARF_FRAME_REGNUM to those that should be output in | |
463 | .debug_frame and .eh_frame. */ | |
464 | #ifndef DWARF2_FRAME_REG_OUT | |
465 | #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) | |
466 | #endif | |
467 | ||
948d330e RH |
468 | /* The size of addresses as they appear in the Dwarf 2 data. |
469 | Some architectures use word addresses to refer to code locations, | |
470 | but Dwarf 2 info always uses byte addresses. On such machines, | |
471 | Dwarf 2 addresses need to be larger than the architecture's | |
472 | pointers. */ | |
473 | #ifndef DWARF2_ADDR_SIZE | |
50b6ee8b | 474 | #define DWARF2_ADDR_SIZE ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT) |
948d330e RH |
475 | #endif |
476 | ||
477 | /* The size in bytes of a DWARF field indicating an offset or length | |
478 | relative to a debug info section, specified to be 4 bytes in the | |
479 | DWARF-2 specification. The SGI/MIPS ABI defines it to be the same | |
480 | as PTR_SIZE. */ | |
481 | #ifndef DWARF_OFFSET_SIZE | |
482 | #define DWARF_OFFSET_SIZE 4 | |
483 | #endif | |
484 | ||
485 | /* The size in bytes of a DWARF 4 type signature. */ | |
486 | #ifndef DWARF_TYPE_SIGNATURE_SIZE | |
487 | #define DWARF_TYPE_SIGNATURE_SIZE 8 | |
488 | #endif | |
489 | ||
d8ea8f28 ZW |
490 | /* Default sizes for base C types. If the sizes are different for |
491 | your target, you should override these values by defining the | |
492 | appropriate symbols in your tm.h file. */ | |
493 | ||
807e902e KZ |
494 | #if BITS_PER_UNIT == 8 |
495 | #define LOG2_BITS_PER_UNIT 3 | |
496 | #elif BITS_PER_UNIT == 16 | |
497 | #define LOG2_BITS_PER_UNIT 4 | |
498 | #else | |
499 | #error Unknown BITS_PER_UNIT | |
500 | #endif | |
501 | ||
e81dd381 KG |
502 | #ifndef BITS_PER_WORD |
503 | #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD) | |
504 | #endif | |
505 | ||
d8ea8f28 ZW |
506 | #ifndef CHAR_TYPE_SIZE |
507 | #define CHAR_TYPE_SIZE BITS_PER_UNIT | |
508 | #endif | |
509 | ||
609688f3 JM |
510 | #ifndef BOOL_TYPE_SIZE |
511 | /* `bool' has size and alignment `1', on almost all platforms. */ | |
512 | #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE | |
513 | #endif | |
514 | ||
d8ea8f28 ZW |
515 | #ifndef SHORT_TYPE_SIZE |
516 | #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) | |
517 | #endif | |
518 | ||
519 | #ifndef INT_TYPE_SIZE | |
520 | #define INT_TYPE_SIZE BITS_PER_WORD | |
521 | #endif | |
522 | ||
523 | #ifndef LONG_TYPE_SIZE | |
524 | #define LONG_TYPE_SIZE BITS_PER_WORD | |
525 | #endif | |
526 | ||
527 | #ifndef LONG_LONG_TYPE_SIZE | |
528 | #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) | |
529 | #endif | |
530 | ||
531 | #ifndef WCHAR_TYPE_SIZE | |
532 | #define WCHAR_TYPE_SIZE INT_TYPE_SIZE | |
533 | #endif | |
534 | ||
d8ea8f28 ZW |
535 | #ifndef FLOAT_TYPE_SIZE |
536 | #define FLOAT_TYPE_SIZE BITS_PER_WORD | |
537 | #endif | |
538 | ||
539 | #ifndef DOUBLE_TYPE_SIZE | |
540 | #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
541 | #endif | |
542 | ||
543 | #ifndef LONG_DOUBLE_TYPE_SIZE | |
544 | #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
545 | #endif | |
546 | ||
9a8ce21f JG |
547 | #ifndef DECIMAL32_TYPE_SIZE |
548 | #define DECIMAL32_TYPE_SIZE 32 | |
b8698a0f | 549 | #endif |
9a8ce21f | 550 | |
b8698a0f | 551 | #ifndef DECIMAL64_TYPE_SIZE |
9a8ce21f | 552 | #define DECIMAL64_TYPE_SIZE 64 |
b8698a0f | 553 | #endif |
9a8ce21f JG |
554 | |
555 | #ifndef DECIMAL128_TYPE_SIZE | |
556 | #define DECIMAL128_TYPE_SIZE 128 | |
557 | #endif | |
558 | ||
325217ed CF |
559 | #ifndef SHORT_FRACT_TYPE_SIZE |
560 | #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT | |
561 | #endif | |
562 | ||
563 | #ifndef FRACT_TYPE_SIZE | |
564 | #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2) | |
565 | #endif | |
566 | ||
567 | #ifndef LONG_FRACT_TYPE_SIZE | |
568 | #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4) | |
569 | #endif | |
570 | ||
571 | #ifndef LONG_LONG_FRACT_TYPE_SIZE | |
572 | #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8) | |
573 | #endif | |
574 | ||
575 | #ifndef SHORT_ACCUM_TYPE_SIZE | |
576 | #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2) | |
577 | #endif | |
578 | ||
579 | #ifndef ACCUM_TYPE_SIZE | |
580 | #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2) | |
581 | #endif | |
582 | ||
583 | #ifndef LONG_ACCUM_TYPE_SIZE | |
584 | #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2) | |
585 | #endif | |
586 | ||
587 | #ifndef LONG_LONG_ACCUM_TYPE_SIZE | |
588 | #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2) | |
589 | #endif | |
590 | ||
1ffc7157 FXC |
591 | /* We let tm.h override the types used here, to handle trivial differences |
592 | such as the choice of unsigned int or long unsigned int for size_t. | |
593 | When machines start needing nontrivial differences in the size type, | |
594 | it would be best to do something here to figure out automatically | |
595 | from other information what type to use. */ | |
596 | ||
597 | #ifndef SIZE_TYPE | |
598 | #define SIZE_TYPE "long unsigned int" | |
599 | #endif | |
600 | ||
18dae016 TG |
601 | #ifndef SIZETYPE |
602 | #define SIZETYPE SIZE_TYPE | |
603 | #endif | |
604 | ||
1ffc7157 FXC |
605 | #ifndef PID_TYPE |
606 | #define PID_TYPE "int" | |
607 | #endif | |
608 | ||
609 | /* If GCC knows the exact uint_least16_t and uint_least32_t types from | |
610 | <stdint.h>, use them for char16_t and char32_t. Otherwise, use | |
611 | these guesses; getting the wrong type of a given width will not | |
612 | affect C++ name mangling because in C++ these are distinct types | |
613 | not typedefs. */ | |
614 | ||
615 | #ifdef UINT_LEAST16_TYPE | |
616 | #define CHAR16_TYPE UINT_LEAST16_TYPE | |
617 | #else | |
618 | #define CHAR16_TYPE "short unsigned int" | |
619 | #endif | |
620 | ||
621 | #ifdef UINT_LEAST32_TYPE | |
622 | #define CHAR32_TYPE UINT_LEAST32_TYPE | |
623 | #else | |
624 | #define CHAR32_TYPE "unsigned int" | |
625 | #endif | |
626 | ||
627 | #ifndef WCHAR_TYPE | |
628 | #define WCHAR_TYPE "int" | |
629 | #endif | |
630 | ||
631 | /* WCHAR_TYPE gets overridden by -fshort-wchar. */ | |
632 | #define MODIFIED_WCHAR_TYPE \ | |
633 | (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) | |
634 | ||
635 | #ifndef PTRDIFF_TYPE | |
636 | #define PTRDIFF_TYPE "long int" | |
637 | #endif | |
638 | ||
639 | #ifndef WINT_TYPE | |
640 | #define WINT_TYPE "unsigned int" | |
641 | #endif | |
642 | ||
643 | #ifndef INTMAX_TYPE | |
644 | #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
645 | ? "int" \ | |
646 | : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
647 | ? "long int" \ | |
648 | : "long long int")) | |
649 | #endif | |
650 | ||
651 | #ifndef UINTMAX_TYPE | |
652 | #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
653 | ? "unsigned int" \ | |
654 | : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
655 | ? "long unsigned int" \ | |
656 | : "long long unsigned int")) | |
657 | #endif | |
658 | ||
659 | ||
660 | /* There are no default definitions of these <stdint.h> types. */ | |
661 | ||
662 | #ifndef SIG_ATOMIC_TYPE | |
663 | #define SIG_ATOMIC_TYPE ((const char *) NULL) | |
664 | #endif | |
665 | ||
666 | #ifndef INT8_TYPE | |
667 | #define INT8_TYPE ((const char *) NULL) | |
668 | #endif | |
669 | ||
670 | #ifndef INT16_TYPE | |
671 | #define INT16_TYPE ((const char *) NULL) | |
672 | #endif | |
673 | ||
674 | #ifndef INT32_TYPE | |
675 | #define INT32_TYPE ((const char *) NULL) | |
676 | #endif | |
677 | ||
678 | #ifndef INT64_TYPE | |
679 | #define INT64_TYPE ((const char *) NULL) | |
680 | #endif | |
681 | ||
682 | #ifndef UINT8_TYPE | |
683 | #define UINT8_TYPE ((const char *) NULL) | |
684 | #endif | |
685 | ||
686 | #ifndef UINT16_TYPE | |
687 | #define UINT16_TYPE ((const char *) NULL) | |
688 | #endif | |
689 | ||
690 | #ifndef UINT32_TYPE | |
691 | #define UINT32_TYPE ((const char *) NULL) | |
692 | #endif | |
693 | ||
694 | #ifndef UINT64_TYPE | |
695 | #define UINT64_TYPE ((const char *) NULL) | |
696 | #endif | |
697 | ||
698 | #ifndef INT_LEAST8_TYPE | |
699 | #define INT_LEAST8_TYPE ((const char *) NULL) | |
700 | #endif | |
701 | ||
702 | #ifndef INT_LEAST16_TYPE | |
703 | #define INT_LEAST16_TYPE ((const char *) NULL) | |
704 | #endif | |
705 | ||
706 | #ifndef INT_LEAST32_TYPE | |
707 | #define INT_LEAST32_TYPE ((const char *) NULL) | |
708 | #endif | |
709 | ||
710 | #ifndef INT_LEAST64_TYPE | |
711 | #define INT_LEAST64_TYPE ((const char *) NULL) | |
712 | #endif | |
713 | ||
714 | #ifndef UINT_LEAST8_TYPE | |
715 | #define UINT_LEAST8_TYPE ((const char *) NULL) | |
716 | #endif | |
717 | ||
718 | #ifndef UINT_LEAST16_TYPE | |
719 | #define UINT_LEAST16_TYPE ((const char *) NULL) | |
720 | #endif | |
721 | ||
722 | #ifndef UINT_LEAST32_TYPE | |
723 | #define UINT_LEAST32_TYPE ((const char *) NULL) | |
724 | #endif | |
725 | ||
726 | #ifndef UINT_LEAST64_TYPE | |
727 | #define UINT_LEAST64_TYPE ((const char *) NULL) | |
728 | #endif | |
729 | ||
730 | #ifndef INT_FAST8_TYPE | |
731 | #define INT_FAST8_TYPE ((const char *) NULL) | |
732 | #endif | |
733 | ||
734 | #ifndef INT_FAST16_TYPE | |
735 | #define INT_FAST16_TYPE ((const char *) NULL) | |
736 | #endif | |
737 | ||
738 | #ifndef INT_FAST32_TYPE | |
739 | #define INT_FAST32_TYPE ((const char *) NULL) | |
740 | #endif | |
741 | ||
742 | #ifndef INT_FAST64_TYPE | |
743 | #define INT_FAST64_TYPE ((const char *) NULL) | |
744 | #endif | |
745 | ||
746 | #ifndef UINT_FAST8_TYPE | |
747 | #define UINT_FAST8_TYPE ((const char *) NULL) | |
748 | #endif | |
749 | ||
750 | #ifndef UINT_FAST16_TYPE | |
751 | #define UINT_FAST16_TYPE ((const char *) NULL) | |
752 | #endif | |
753 | ||
754 | #ifndef UINT_FAST32_TYPE | |
755 | #define UINT_FAST32_TYPE ((const char *) NULL) | |
756 | #endif | |
757 | ||
758 | #ifndef UINT_FAST64_TYPE | |
759 | #define UINT_FAST64_TYPE ((const char *) NULL) | |
760 | #endif | |
761 | ||
762 | #ifndef INTPTR_TYPE | |
763 | #define INTPTR_TYPE ((const char *) NULL) | |
764 | #endif | |
765 | ||
766 | #ifndef UINTPTR_TYPE | |
767 | #define UINTPTR_TYPE ((const char *) NULL) | |
768 | #endif | |
769 | ||
2465bf76 KG |
770 | /* Width in bits of a pointer. Mind the value of the macro `Pmode'. */ |
771 | #ifndef POINTER_SIZE | |
772 | #define POINTER_SIZE BITS_PER_WORD | |
773 | #endif | |
50b6ee8b DD |
774 | #ifndef POINTER_SIZE_UNITS |
775 | #define POINTER_SIZE_UNITS ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT) | |
776 | #endif | |
777 | ||
2465bf76 | 778 | |
848e0190 JH |
779 | #ifndef PIC_OFFSET_TABLE_REGNUM |
780 | #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM | |
781 | #endif | |
782 | ||
f8fe0a4a JM |
783 | #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED |
784 | #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 0 | |
785 | #endif | |
786 | ||
b2ca3702 MM |
787 | #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES |
788 | #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0 | |
789 | #endif | |
790 | ||
63c5b495 | 791 | #ifndef TARGET_DECLSPEC |
b2ca3702 | 792 | #if TARGET_DLLIMPORT_DECL_ATTRIBUTES |
63c5b495 MM |
793 | /* If the target supports the "dllimport" attribute, users are |
794 | probably used to the "__declspec" syntax. */ | |
795 | #define TARGET_DECLSPEC 1 | |
796 | #else | |
797 | #define TARGET_DECLSPEC 0 | |
798 | #endif | |
799 | #endif | |
800 | ||
a9374841 MM |
801 | /* By default, the preprocessor should be invoked the same way in C++ |
802 | as in C. */ | |
803 | #ifndef CPLUSPLUS_CPP_SPEC | |
804 | #ifdef CPP_SPEC | |
805 | #define CPLUSPLUS_CPP_SPEC CPP_SPEC | |
806 | #endif | |
807 | #endif | |
808 | ||
bf501a65 RH |
809 | #ifndef ACCUMULATE_OUTGOING_ARGS |
810 | #define ACCUMULATE_OUTGOING_ARGS 0 | |
811 | #endif | |
812 | ||
fea3ca91 IS |
813 | /* By default, use the GNU runtime for Objective C. */ |
814 | #ifndef NEXT_OBJC_RUNTIME | |
815 | #define NEXT_OBJC_RUNTIME 0 | |
816 | #endif | |
817 | ||
bf501a65 RH |
818 | /* Supply a default definition for PUSH_ARGS. */ |
819 | #ifndef PUSH_ARGS | |
820 | #ifdef PUSH_ROUNDING | |
821 | #define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS | |
822 | #else | |
823 | #define PUSH_ARGS 0 | |
824 | #endif | |
825 | #endif | |
826 | ||
9d6bef95 JM |
827 | /* Decide whether a function's arguments should be processed |
828 | from first to last or from last to first. | |
829 | ||
830 | They should if the stack and args grow in opposite directions, but | |
831 | only if we have push insns. */ | |
832 | ||
833 | #ifdef PUSH_ROUNDING | |
834 | ||
835 | #ifndef PUSH_ARGS_REVERSED | |
836 | #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) | |
837 | #define PUSH_ARGS_REVERSED PUSH_ARGS | |
838 | #endif | |
839 | #endif | |
840 | ||
841 | #endif | |
842 | ||
843 | #ifndef PUSH_ARGS_REVERSED | |
844 | #define PUSH_ARGS_REVERSED 0 | |
845 | #endif | |
846 | ||
95331614 OH |
847 | /* Default value for the alignment (in bits) a C conformant malloc has to |
848 | provide. This default is intended to be safe and always correct. */ | |
849 | #ifndef MALLOC_ABI_ALIGNMENT | |
850 | #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD | |
851 | #endif | |
852 | ||
31cdd499 ZW |
853 | /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY. |
854 | STACK_BOUNDARY is required. */ | |
855 | #ifndef PREFERRED_STACK_BOUNDARY | |
856 | #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY | |
857 | #endif | |
858 | ||
2e3f842f L |
859 | /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not |
860 | defined. */ | |
861 | #ifndef INCOMING_STACK_BOUNDARY | |
862 | #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY | |
863 | #endif | |
864 | ||
467cecf3 JB |
865 | #ifndef TARGET_DEFAULT_PACK_STRUCT |
866 | #define TARGET_DEFAULT_PACK_STRUCT 0 | |
867 | #endif | |
868 | ||
a6f5e048 RH |
869 | /* By default, the vtable entries are void pointers, the so the alignment |
870 | is the same as pointer alignment. The value of this macro specifies | |
871 | the alignment of the vtable entry in bits. It should be defined only | |
4b7e68e7 | 872 | when special alignment is necessary. */ |
a6f5e048 RH |
873 | #ifndef TARGET_VTABLE_ENTRY_ALIGN |
874 | #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE | |
875 | #endif | |
876 | ||
877 | /* There are a few non-descriptor entries in the vtable at offsets below | |
878 | zero. If these entries must be padded (say, to preserve the alignment | |
879 | specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of | |
880 | words in each data entry. */ | |
881 | #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE | |
882 | #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1 | |
883 | #endif | |
884 | ||
4a77e08c DS |
885 | /* Decide whether it is safe to use a local alias for a virtual function |
886 | when constructing thunks. */ | |
887 | #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P | |
888 | #ifdef ASM_OUTPUT_DEF | |
889 | #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1 | |
890 | #else | |
891 | #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0 | |
892 | #endif | |
893 | #endif | |
894 | ||
2a1ee410 RH |
895 | /* Select a format to encode pointers in exception handling data. We |
896 | prefer those that result in fewer dynamic relocations. Assume no | |
897 | special support here and encode direct references. */ | |
898 | #ifndef ASM_PREFERRED_EH_DATA_FORMAT | |
899 | #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr | |
900 | #endif | |
901 | ||
f3c55c97 AO |
902 | /* By default, the C++ compiler will use the lowest bit of the pointer |
903 | to function to indicate a pointer-to-member-function points to a | |
904 | virtual member function. However, if FUNCTION_BOUNDARY indicates | |
905 | function addresses aren't always even, the lowest bit of the delta | |
906 | field will be used. */ | |
907 | #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION | |
908 | #define TARGET_PTRMEMFUNC_VBIT_LOCATION \ | |
909 | (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \ | |
910 | ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta) | |
911 | #endif | |
912 | ||
5f0e9ea2 GK |
913 | #ifndef DEFAULT_GDB_EXTENSIONS |
914 | #define DEFAULT_GDB_EXTENSIONS 1 | |
915 | #endif | |
916 | ||
917 | /* If more than one debugging type is supported, you must define | |
f8ca7e49 | 918 | PREFERRED_DEBUGGING_TYPE to choose the default. */ |
5f0e9ea2 | 919 | |
f8ca7e49 ZW |
920 | #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \ |
921 | + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \ | |
922 | + defined (VMS_DEBUGGING_INFO)) | |
5f0e9ea2 | 923 | #ifndef PREFERRED_DEBUGGING_TYPE |
f8ca7e49 | 924 | #error You must define PREFERRED_DEBUGGING_TYPE |
5f0e9ea2 | 925 | #endif /* no PREFERRED_DEBUGGING_TYPE */ |
f8ca7e49 ZW |
926 | |
927 | /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE | |
928 | here so other code needn't care. */ | |
929 | #elif defined DBX_DEBUGGING_INFO | |
5f0e9ea2 | 930 | #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG |
f8ca7e49 ZW |
931 | |
932 | #elif defined SDB_DEBUGGING_INFO | |
5f0e9ea2 | 933 | #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG |
f8ca7e49 ZW |
934 | |
935 | #elif defined DWARF2_DEBUGGING_INFO | |
5f0e9ea2 | 936 | #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG |
f8ca7e49 ZW |
937 | |
938 | #elif defined VMS_DEBUGGING_INFO | |
7a0c8d71 | 939 | #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG |
f8ca7e49 ZW |
940 | |
941 | #elif defined XCOFF_DEBUGGING_INFO | |
5f0e9ea2 | 942 | #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG |
5f0e9ea2 | 943 | |
f8ca7e49 ZW |
944 | #else |
945 | /* No debugging format is supported by this target. */ | |
5f0e9ea2 GK |
946 | #define PREFERRED_DEBUGGING_TYPE NO_DEBUG |
947 | #endif | |
948 | ||
c15c90bb ZW |
949 | #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL |
950 | #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false | |
951 | #endif | |
952 | ||
6cb38cd4 | 953 | /* True if the targets integer-comparison functions return { 0, 1, 2 |
b3f8d95d MM |
954 | } to indicate { <, ==, > }. False if { -1, 0, 1 } is used |
955 | instead. The libgcc routines are biased. */ | |
956 | #ifndef TARGET_LIB_INT_CMP_BIASED | |
957 | #define TARGET_LIB_INT_CMP_BIASED (true) | |
958 | #endif | |
959 | ||
2d295af5 ZW |
960 | /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files, |
961 | then the word-endianness is the same as for integers. */ | |
efdc7e19 RH |
962 | #ifndef FLOAT_WORDS_BIG_ENDIAN |
963 | #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN | |
964 | #endif | |
965 | ||
c0a6a1ef BS |
966 | #ifndef REG_WORDS_BIG_ENDIAN |
967 | #define REG_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN | |
968 | #endif | |
969 | ||
8ce94e44 JM |
970 | #ifdef TARGET_FLT_EVAL_METHOD |
971 | #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1 | |
972 | #else | |
d57a4b98 | 973 | #define TARGET_FLT_EVAL_METHOD 0 |
8ce94e44 | 974 | #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0 |
d57a4b98 RH |
975 | #endif |
976 | ||
9a8ce21f JG |
977 | #ifndef TARGET_DEC_EVAL_METHOD |
978 | #define TARGET_DEC_EVAL_METHOD 2 | |
979 | #endif | |
980 | ||
750054a2 CT |
981 | #ifndef HAS_LONG_COND_BRANCH |
982 | #define HAS_LONG_COND_BRANCH 0 | |
983 | #endif | |
984 | ||
985 | #ifndef HAS_LONG_UNCOND_BRANCH | |
986 | #define HAS_LONG_UNCOND_BRANCH 0 | |
987 | #endif | |
988 | ||
4bafaa6f | 989 | /* Determine whether __cxa_atexit, rather than atexit, is used to |
4b7e68e7 | 990 | register C++ destructors for local statics and global objects. */ |
4bafaa6f L |
991 | #ifndef DEFAULT_USE_CXA_ATEXIT |
992 | #define DEFAULT_USE_CXA_ATEXIT 0 | |
993 | #endif | |
994 | ||
f38840db ZW |
995 | #if GCC_VERSION >= 3000 && defined IN_GCC |
996 | /* These old constraint macros shouldn't appear anywhere in a | |
997 | configuration using MD constraint definitions. */ | |
97488870 R |
998 | #endif |
999 | ||
4bd5abca SM |
1000 | /* Determin whether the target runtime library is Bionic */ |
1001 | #ifndef TARGET_HAS_BIONIC | |
1002 | #define TARGET_HAS_BIONIC 0 | |
1003 | #endif | |
1004 | ||
7dba8395 | 1005 | /* Indicate that CLZ and CTZ are undefined at zero. */ |
f676971a | 1006 | #ifndef CLZ_DEFINED_VALUE_AT_ZERO |
7dba8395 RH |
1007 | #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
1008 | #endif | |
f676971a | 1009 | #ifndef CTZ_DEFINED_VALUE_AT_ZERO |
7dba8395 RH |
1010 | #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
1011 | #endif | |
1012 | ||
06f31100 RS |
1013 | /* Provide a default value for STORE_FLAG_VALUE. */ |
1014 | #ifndef STORE_FLAG_VALUE | |
1015 | #define STORE_FLAG_VALUE 1 | |
1016 | #endif | |
1017 | ||
436bcda1 GK |
1018 | /* This macro is used to determine what the largest unit size that |
1019 | move_by_pieces can use is. */ | |
1020 | ||
1021 | /* MOVE_MAX_PIECES is the number of bytes at a time which we can | |
1022 | move efficiently, as opposed to MOVE_MAX which is the maximum | |
1023 | number of bytes we can move with a single instruction. */ | |
1024 | ||
1025 | #ifndef MOVE_MAX_PIECES | |
1026 | #define MOVE_MAX_PIECES MOVE_MAX | |
1027 | #endif | |
1028 | ||
7cbed008 JG |
1029 | /* STORE_MAX_PIECES is the number of bytes at a time that we can |
1030 | store efficiently. Due to internal GCC limitations, this is | |
1031 | MOVE_MAX_PIECES limited by the number of bytes GCC can represent | |
1032 | for an immediate constant. */ | |
1033 | ||
1034 | #ifndef STORE_MAX_PIECES | |
1035 | #define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT)) | |
1036 | #endif | |
1037 | ||
bcbaaba1 RS |
1038 | #ifndef MAX_MOVE_MAX |
1039 | #define MAX_MOVE_MAX MOVE_MAX | |
1040 | #endif | |
1041 | ||
1042 | #ifndef MIN_UNITS_PER_WORD | |
1043 | #define MIN_UNITS_PER_WORD UNITS_PER_WORD | |
1044 | #endif | |
1045 | ||
d1465187 RS |
1046 | #ifndef MAX_BITS_PER_WORD |
1047 | #define MAX_BITS_PER_WORD BITS_PER_WORD | |
1048 | #endif | |
1049 | ||
a594a19c GK |
1050 | #ifndef STACK_POINTER_OFFSET |
1051 | #define STACK_POINTER_OFFSET 0 | |
1052 | #endif | |
1053 | ||
cca8fb0e KH |
1054 | #ifndef LOCAL_REGNO |
1055 | #define LOCAL_REGNO(REGNO) 0 | |
1056 | #endif | |
1057 | ||
ed15c598 KC |
1058 | #ifndef HONOR_REG_ALLOC_ORDER |
1059 | #define HONOR_REG_ALLOC_ORDER 0 | |
1060 | #endif | |
1061 | ||
9d05bbce KH |
1062 | /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, |
1063 | the stack pointer does not matter. The value is tested only in | |
1064 | functions that have frame pointers. */ | |
1065 | #ifndef EXIT_IGNORE_STACK | |
1066 | #define EXIT_IGNORE_STACK 0 | |
1067 | #endif | |
1068 | ||
0ede749d KH |
1069 | /* Assume that case vectors are not pc-relative. */ |
1070 | #ifndef CASE_VECTOR_PC_RELATIVE | |
1071 | #define CASE_VECTOR_PC_RELATIVE 0 | |
1072 | #endif | |
1073 | ||
6de9cd9a DN |
1074 | /* Assume that trampolines need function alignment. */ |
1075 | #ifndef TRAMPOLINE_ALIGNMENT | |
1076 | #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY | |
1077 | #endif | |
1078 | ||
d220de0e KH |
1079 | /* Register mappings for target machines without register windows. */ |
1080 | #ifndef INCOMING_REGNO | |
1081 | #define INCOMING_REGNO(N) (N) | |
1082 | #endif | |
1083 | ||
1084 | #ifndef OUTGOING_REGNO | |
1085 | #define OUTGOING_REGNO(N) (N) | |
1086 | #endif | |
1087 | ||
bee07d3f KH |
1088 | #ifndef SHIFT_COUNT_TRUNCATED |
1089 | #define SHIFT_COUNT_TRUNCATED 0 | |
1090 | #endif | |
1091 | ||
2e4e72b1 ZW |
1092 | #ifndef LEGITIMATE_PIC_OPERAND_P |
1093 | #define LEGITIMATE_PIC_OPERAND_P(X) 1 | |
1094 | #endif | |
1095 | ||
a4edaf83 AK |
1096 | #ifndef TARGET_MEM_CONSTRAINT |
1097 | #define TARGET_MEM_CONSTRAINT 'm' | |
1098 | #endif | |
1099 | ||
1f8551b2 KH |
1100 | #ifndef REVERSIBLE_CC_MODE |
1101 | #define REVERSIBLE_CC_MODE(MODE) 0 | |
1102 | #endif | |
1103 | ||
07e15286 DE |
1104 | /* Biggest alignment supported by the object file format of this machine. */ |
1105 | #ifndef MAX_OFILE_ALIGNMENT | |
1106 | #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT | |
1107 | #endif | |
1108 | ||
f62c8a5c JJ |
1109 | #ifndef FRAME_GROWS_DOWNWARD |
1110 | #define FRAME_GROWS_DOWNWARD 0 | |
1111 | #endif | |
1112 | ||
2e612c47 MF |
1113 | #ifndef RETURN_ADDR_IN_PREVIOUS_FRAME |
1114 | #define RETURN_ADDR_IN_PREVIOUS_FRAME 0 | |
1115 | #endif | |
1116 | ||
30e6f306 RH |
1117 | /* On most machines, the CFA coincides with the first incoming parm. */ |
1118 | #ifndef ARG_POINTER_CFA_OFFSET | |
d17c29c3 PB |
1119 | #define ARG_POINTER_CFA_OFFSET(FNDECL) \ |
1120 | (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size) | |
30e6f306 RH |
1121 | #endif |
1122 | ||
35d177a2 AO |
1123 | /* On most machines, we use the CFA as DW_AT_frame_base. */ |
1124 | #ifndef CFA_FRAME_BASE_OFFSET | |
1125 | #define CFA_FRAME_BASE_OFFSET(FNDECL) 0 | |
1126 | #endif | |
1127 | ||
30e6f306 RH |
1128 | /* The offset from the incoming value of %sp to the top of the stack frame |
1129 | for the current function. */ | |
1130 | #ifndef INCOMING_FRAME_SP_OFFSET | |
1131 | #define INCOMING_FRAME_SP_OFFSET 0 | |
1132 | #endif | |
1133 | ||
8521c414 JM |
1134 | #ifndef HARD_REGNO_NREGS_HAS_PADDING |
1135 | #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0 | |
1136 | #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1 | |
1137 | #endif | |
1138 | ||
ac294f0b | 1139 | #ifndef OUTGOING_REG_PARM_STACK_SPACE |
81464b2c | 1140 | #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0 |
ac294f0b KT |
1141 | #endif |
1142 | ||
2e3f842f L |
1143 | /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by |
1144 | the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best | |
1145 | effort stack alignment supported by the backend. If the backend | |
1146 | supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and | |
1147 | MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack | |
1148 | boundary will limit the maximum guaranteed stack alignment. */ | |
1149 | #ifdef MAX_STACK_ALIGNMENT | |
1150 | #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT | |
1151 | #else | |
1152 | #define MAX_STACK_ALIGNMENT STACK_BOUNDARY | |
1153 | #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY | |
1154 | #endif | |
1155 | ||
1156 | #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY) | |
1157 | ||
76fe54f0 L |
1158 | #ifndef LOCAL_ALIGNMENT |
1159 | #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT | |
1160 | #endif | |
1161 | ||
1162 | #ifndef STACK_SLOT_ALIGNMENT | |
1163 | #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \ | |
1164 | ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN)) | |
1165 | #endif | |
1166 | ||
9bfaf89d JJ |
1167 | #ifndef LOCAL_DECL_ALIGNMENT |
1168 | #define LOCAL_DECL_ALIGNMENT(DECL) \ | |
1169 | LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) | |
1170 | #endif | |
1171 | ||
ae58e548 JJ |
1172 | #ifndef MINIMUM_ALIGNMENT |
1173 | #define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN) | |
1174 | #endif | |
1175 | ||
6e4f1168 L |
1176 | /* Alignment value for attribute ((aligned)). */ |
1177 | #ifndef ATTRIBUTE_ALIGNED_VALUE | |
1178 | #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT | |
1179 | #endif | |
1180 | ||
08e931f3 RS |
1181 | #ifndef SLOW_UNALIGNED_ACCESS |
1182 | #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT | |
1183 | #endif | |
1184 | ||
4003023f NC |
1185 | /* For most ports anything that evaluates to a constant symbolic |
1186 | or integer value is acceptable as a constant address. */ | |
1187 | #ifndef CONSTANT_ADDRESS_P | |
1188 | #define CONSTANT_ADDRESS_P(X) (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE) | |
1189 | #endif | |
1190 | ||
1c314335 L |
1191 | #ifndef MAX_FIXED_MODE_SIZE |
1192 | #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) | |
1193 | #endif | |
1194 | ||
5498f011 JM |
1195 | /* Nonzero if structures and unions should be returned in memory. |
1196 | ||
1197 | This should only be defined if compatibility with another compiler or | |
1198 | with an ABI is needed, because it results in slower code. */ | |
1199 | ||
1200 | #ifndef DEFAULT_PCC_STRUCT_RETURN | |
1201 | #define DEFAULT_PCC_STRUCT_RETURN 1 | |
1202 | #endif | |
77ec4307 | 1203 | |
1d0275e2 TS |
1204 | #ifndef PCC_BITFIELD_TYPE_MATTERS |
1205 | #define PCC_BITFIELD_TYPE_MATTERS false | |
1206 | #endif | |
1207 | ||
0923e946 TS |
1208 | #ifndef INSN_SETS_ARE_DELAYED |
1209 | #define INSN_SETS_ARE_DELAYED(INSN) false | |
1210 | #endif | |
1211 | ||
6e37129a TS |
1212 | #ifndef INSN_REFERENCES_ARE_DELAYED |
1213 | #define INSN_REFERENCES_ARE_DELAYED(INSN) false | |
1214 | #endif | |
1215 | ||
1e8552c2 TS |
1216 | #ifndef NO_FUNCTION_CSE |
1217 | #define NO_FUNCTION_CSE false | |
1218 | #endif | |
1219 | ||
aedf2c02 TS |
1220 | #ifndef HARD_REGNO_RENAME_OK |
1221 | #define HARD_REGNO_RENAME_OK(FROM, TO) true | |
1222 | #endif | |
1223 | ||
a3699d66 TS |
1224 | #ifndef EPILOGUE_USES |
1225 | #define EPILOGUE_USES(REG) false | |
1226 | #endif | |
1227 | ||
376bddab TS |
1228 | #ifndef ARGS_GROW_DOWNWARD |
1229 | #define ARGS_GROW_DOWNWARD 0 | |
1230 | #endif | |
1231 | ||
77ec4307 SB |
1232 | #ifdef GCC_INSN_FLAGS_H |
1233 | /* Dependent default target macro definitions | |
1234 | ||
1235 | This section of defaults.h defines target macros that depend on generated | |
1236 | headers. This is a bit awkward: We want to put all default definitions | |
1237 | for target macros in defaults.h, but some of the defaults depend on the | |
1238 | HAVE_* flags defines of insn-flags.h. But insn-flags.h is not always | |
1239 | included by files that do include defaults.h. | |
1240 | ||
1241 | Fortunately, the default macro definitions that depend on the HAVE_* | |
1242 | macros are also the ones that will only be used inside GCC itself, i.e. | |
1243 | not in the gen* programs or in target objects like libgcc. | |
1244 | ||
1245 | Obviously, it would be best to keep this section of defaults.h as small | |
1246 | as possible, by converting the macros defined below to target hooks or | |
1247 | functions. | |
1248 | */ | |
1249 | ||
77ec4307 SB |
1250 | /* The default branch cost is 1. */ |
1251 | #ifndef BRANCH_COST | |
1252 | #define BRANCH_COST(speed_p, predictable_p) 1 | |
1253 | #endif | |
1254 | ||
1255 | /* If a memory-to-memory move would take MOVE_RATIO or more simple | |
1256 | move-instruction sequences, we will do a movmem or libcall instead. */ | |
1257 | ||
1258 | #ifndef MOVE_RATIO | |
1259 | #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti) | |
1260 | #define MOVE_RATIO(speed) 2 | |
1261 | #else | |
1262 | /* If we are optimizing for space (-Os), cut down the default move ratio. */ | |
1263 | #define MOVE_RATIO(speed) ((speed) ? 15 : 3) | |
1264 | #endif | |
1265 | #endif | |
1266 | ||
1267 | /* If a clear memory operation would take CLEAR_RATIO or more simple | |
1268 | move-instruction sequences, we will do a setmem or libcall instead. */ | |
1269 | ||
1270 | #ifndef CLEAR_RATIO | |
1271 | #if defined (HAVE_setmemqi) || defined (HAVE_setmemhi) || defined (HAVE_setmemsi) || defined (HAVE_setmemdi) || defined (HAVE_setmemti) | |
1272 | #define CLEAR_RATIO(speed) 2 | |
1273 | #else | |
1274 | /* If we are optimizing for space, cut down the default clear ratio. */ | |
1275 | #define CLEAR_RATIO(speed) ((speed) ? 15 :3) | |
1276 | #endif | |
1277 | #endif | |
1278 | ||
1279 | /* If a memory set (to value other than zero) operation would take | |
1280 | SET_RATIO or more simple move-instruction sequences, we will do a movmem | |
1281 | or libcall instead. */ | |
1282 | #ifndef SET_RATIO | |
c3284718 | 1283 | #define SET_RATIO(speed) MOVE_RATIO (speed) |
77ec4307 SB |
1284 | #endif |
1285 | ||
1286 | /* Supply a default definition for FUNCTION_ARG_PADDING: | |
1287 | usually pad upward, but pad short args downward on | |
1288 | big-endian machines. */ | |
1289 | ||
1290 | #define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ | |
1291 | (! BYTES_BIG_ENDIAN \ | |
1292 | ? upward \ | |
1293 | : (((MODE) == BLKmode \ | |
1294 | ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ | |
1295 | && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ | |
1296 | : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ | |
1297 | ? downward : upward)) | |
1298 | ||
1299 | #ifndef FUNCTION_ARG_PADDING | |
1300 | #define FUNCTION_ARG_PADDING(MODE, TYPE) \ | |
1301 | DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) | |
1302 | #endif | |
1303 | ||
77ec4307 SB |
1304 | /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. |
1305 | Normally move_insn, so Pmode stack pointer. */ | |
1306 | ||
1307 | #ifndef STACK_SAVEAREA_MODE | |
1308 | #define STACK_SAVEAREA_MODE(LEVEL) Pmode | |
1309 | #endif | |
1310 | ||
1311 | /* Supply a default definition of STACK_SIZE_MODE for | |
1312 | allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ | |
1313 | ||
1314 | #ifndef STACK_SIZE_MODE | |
1315 | #define STACK_SIZE_MODE word_mode | |
1316 | #endif | |
1317 | ||
1318 | /* Provide default values for the macros controlling stack checking. */ | |
1319 | ||
1320 | /* The default is neither full builtin stack checking... */ | |
1321 | #ifndef STACK_CHECK_BUILTIN | |
1322 | #define STACK_CHECK_BUILTIN 0 | |
1323 | #endif | |
1324 | ||
1325 | /* ...nor static builtin stack checking. */ | |
1326 | #ifndef STACK_CHECK_STATIC_BUILTIN | |
1327 | #define STACK_CHECK_STATIC_BUILTIN 0 | |
1328 | #endif | |
1329 | ||
1330 | /* The default interval is one page (4096 bytes). */ | |
1331 | #ifndef STACK_CHECK_PROBE_INTERVAL_EXP | |
1332 | #define STACK_CHECK_PROBE_INTERVAL_EXP 12 | |
1333 | #endif | |
1334 | ||
1335 | /* The default is not to move the stack pointer. */ | |
1336 | #ifndef STACK_CHECK_MOVING_SP | |
1337 | #define STACK_CHECK_MOVING_SP 0 | |
1338 | #endif | |
1339 | ||
1340 | /* This is a kludge to try to capture the discrepancy between the old | |
1341 | mechanism (generic stack checking) and the new mechanism (static | |
1342 | builtin stack checking). STACK_CHECK_PROTECT needs to be bumped | |
1343 | for the latter because part of the protection area is effectively | |
1344 | included in STACK_CHECK_MAX_FRAME_SIZE for the former. */ | |
1345 | #ifdef STACK_CHECK_PROTECT | |
1346 | #define STACK_OLD_CHECK_PROTECT STACK_CHECK_PROTECT | |
1347 | #else | |
677f3fa8 JM |
1348 | #define STACK_OLD_CHECK_PROTECT \ |
1349 | (targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ | |
1350 | ? 75 * UNITS_PER_WORD \ | |
d5fabb58 | 1351 | : 8 * 1024) |
77ec4307 SB |
1352 | #endif |
1353 | ||
1354 | /* Minimum amount of stack required to recover from an anticipated stack | |
1355 | overflow detection. The default value conveys an estimate of the amount | |
1356 | of stack required to propagate an exception. */ | |
1357 | #ifndef STACK_CHECK_PROTECT | |
677f3fa8 JM |
1358 | #define STACK_CHECK_PROTECT \ |
1359 | (targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ | |
1360 | ? 75 * UNITS_PER_WORD \ | |
d5fabb58 | 1361 | : 12 * 1024) |
77ec4307 SB |
1362 | #endif |
1363 | ||
1364 | /* Make the maximum frame size be the largest we can and still only need | |
1365 | one probe per function. */ | |
1366 | #ifndef STACK_CHECK_MAX_FRAME_SIZE | |
1367 | #define STACK_CHECK_MAX_FRAME_SIZE \ | |
1368 | ((1 << STACK_CHECK_PROBE_INTERVAL_EXP) - UNITS_PER_WORD) | |
1369 | #endif | |
1370 | ||
1371 | /* This is arbitrary, but should be large enough everywhere. */ | |
1372 | #ifndef STACK_CHECK_FIXED_FRAME_SIZE | |
1373 | #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) | |
1374 | #endif | |
1375 | ||
1376 | /* Provide a reasonable default for the maximum size of an object to | |
1377 | allocate in the fixed frame. We may need to be able to make this | |
1378 | controllable by the user at some point. */ | |
1379 | #ifndef STACK_CHECK_MAX_VAR_SIZE | |
1380 | #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) | |
1381 | #endif | |
1382 | ||
7894073c SE |
1383 | /* By default, the C++ compiler will use function addresses in the |
1384 | vtable entries. Setting this nonzero tells the compiler to use | |
1385 | function descriptors instead. The value of this macro says how | |
1386 | many words wide the descriptor is (normally 2). It is assumed | |
1387 | that the address of a function descriptor may be treated as a | |
1388 | pointer to a function. */ | |
1389 | #ifndef TARGET_VTABLE_USES_DESCRIPTORS | |
1390 | #define TARGET_VTABLE_USES_DESCRIPTORS 0 | |
1391 | #endif | |
1392 | ||
3bd36029 RS |
1393 | #ifndef SWITCHABLE_TARGET |
1394 | #define SWITCHABLE_TARGET 0 | |
1395 | #endif | |
1396 | ||
807e902e KZ |
1397 | /* If the target supports integers that are wider than two |
1398 | HOST_WIDE_INTs on the host compiler, then the target should define | |
1399 | TARGET_SUPPORTS_WIDE_INT and make the appropriate fixups. | |
1400 | Otherwise the compiler really is not robust. */ | |
1401 | #ifndef TARGET_SUPPORTS_WIDE_INT | |
1402 | #define TARGET_SUPPORTS_WIDE_INT 0 | |
1403 | #endif | |
1404 | ||
08b7ff1e TS |
1405 | #ifndef HAVE_simple_return |
1406 | #define HAVE_simple_return 0 | |
1407 | static inline rtx | |
1408 | gen_simple_return () | |
1409 | { | |
1410 | gcc_unreachable (); | |
1411 | return NULL; | |
1412 | } | |
1413 | #endif | |
1414 | ||
1415 | #ifndef HAVE_return | |
1416 | #define HAVE_return 0 | |
1417 | static inline rtx | |
1418 | gen_return () | |
1419 | { | |
1420 | gcc_unreachable (); | |
1421 | return NULL; | |
1422 | } | |
1423 | #endif | |
1424 | ||
5251b8b3 TS |
1425 | #ifndef HAVE_epilogue |
1426 | #define HAVE_epilogue 0 | |
1427 | static inline rtx | |
1428 | gen_epilogue () | |
1429 | { | |
1430 | gcc_unreachable (); | |
1431 | return NULL; | |
1432 | } | |
1433 | #endif | |
1434 | ||
77ec4307 SB |
1435 | #endif /* GCC_INSN_FLAGS_H */ |
1436 | ||
88657302 | 1437 | #endif /* ! GCC_DEFAULTS_H */ |