]>
Commit | Line | Data |
---|---|---|
ea36a3dd | 1 | /* Definitions of various defaults for tm.h macros. |
fbd26352 | 2 | Copyright (C) 1992-2019 Free Software Foundation, Inc. |
77b413c0 | 3 | Contributed by Ron Guilmette (rfg@monkeys.com) |
99803b25 | 4 | |
f12b58b3 | 5 | This file is part of GCC. |
99803b25 | 6 | |
f12b58b3 | 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 | |
8c4c00c1 | 9 | Software Foundation; either version 3, or (at your option) any later |
f12b58b3 | 10 | version. |
99803b25 | 11 | |
f12b58b3 | 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. | |
99803b25 | 16 | |
6bc9506f | 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 | |
8c4c00c1 | 24 | <http://www.gnu.org/licenses/>. */ |
99803b25 | 25 | |
0e66aa75 | 26 | #ifndef GCC_DEFAULTS_H |
27 | #define GCC_DEFAULTS_H | |
28 | ||
2d0a9e44 | 29 | /* How to start an assembler comment. */ |
30 | #ifndef ASM_COMMENT_START | |
31 | #define ASM_COMMENT_START ";#" | |
32 | #endif | |
33 | ||
805e22b2 | 34 | /* Store in OUTPUT a string (made with alloca) containing an |
35 | assembler-name for a local static variable or function named NAME. | |
b441e6f1 | 36 | LABELNO is an integer which is different for each call. */ |
37 | ||
805e22b2 | 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 | ||
b441e6f1 | 50 | #ifndef ASM_FORMAT_PRIVATE_NAME |
805e22b2 | 51 | # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ |
52 | do { const char *const name_ = (NAME); \ | |
4fd61bc6 | 53 | char *const output_ = (OUTPUT) = \ |
54 | (char *) alloca (strlen (name_) + 32); \ | |
805e22b2 | 55 | sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \ |
b441e6f1 | 56 | } while (0) |
57 | #endif | |
58 | ||
21dda4ee | 59 | /* Choose a reasonable default for ASM_OUTPUT_ASCII. */ |
99803b25 | 60 | |
61 | #ifndef ASM_OUTPUT_ASCII | |
62 | #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ | |
63 | do { \ | |
64 | FILE *_hide_asm_out_file = (MYFILE); \ | |
a61deedf | 65 | const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \ |
99803b25 | 66 | int _hide_thissize = (MYLENGTH); \ |
67 | { \ | |
68 | FILE *asm_out_file = _hide_asm_out_file; \ | |
a61deedf | 69 | const unsigned char *p = _hide_p; \ |
99803b25 | 70 | int thissize = _hide_thissize; \ |
71 | int i; \ | |
72 | fprintf (asm_out_file, "\t.ascii \""); \ | |
73 | \ | |
74 | for (i = 0; i < thissize; i++) \ | |
75 | { \ | |
19cb6b50 | 76 | int c = p[i]; \ |
99803b25 | 77 | if (c == '\"' || c == '\\') \ |
78 | putc ('\\', asm_out_file); \ | |
9af5ce0c | 79 | if (ISPRINT (c)) \ |
99803b25 | 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. \ | |
6c842310 | 86 | The VAX assembler fails to stop reading the escape \ |
99803b25 | 87 | after three digits, so this is the only way we \ |
88 | can get it to parse the data properly. */ \ | |
9af5ce0c | 89 | if (i < thissize - 1 && ISDIGIT (p[i + 1])) \ |
99803b25 | 90 | fprintf (asm_out_file, "\"\n\t.ascii \""); \ |
91 | } \ | |
92 | } \ | |
93 | fprintf (asm_out_file, "\"\n"); \ | |
94 | } \ | |
95 | } \ | |
96 | while (0) | |
97 | #endif | |
b4534d9a | 98 | |
bd81c5c3 | 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) \ | |
17d8e118 | 103 | do { fprintf ((FILE), "%s", SET_ASM_OP); \ |
bd81c5c3 | 104 | assemble_name (FILE, LABEL1); \ |
105 | fprintf (FILE, ","); \ | |
106 | assemble_name (FILE, LABEL2); \ | |
107 | fprintf (FILE, "\n"); \ | |
108 | } while (0) | |
109 | #endif | |
110 | #endif | |
9a0ce7db | 111 | |
85c0a25c | 112 | #ifndef IFUNC_ASM_TYPE |
113 | #define IFUNC_ASM_TYPE "gnu_indirect_function" | |
114 | #endif | |
115 | ||
7d070520 | 116 | #ifndef TLS_COMMON_ASM_OP |
117 | #define TLS_COMMON_ASM_OP ".tls_common" | |
118 | #endif | |
119 | ||
6968d8fb | 120 | #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON) |
121 | #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) \ | |
122 | do \ | |
123 | { \ | |
7d070520 | 124 | fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP); \ |
6968d8fb | 125 | assemble_name ((FILE), (NAME)); \ |
f03df321 | 126 | fprintf ((FILE), "," HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ |
6968d8fb | 127 | (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \ |
128 | } \ | |
129 | while (0) | |
130 | #endif | |
131 | ||
137900fa | 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 | ||
9bf98a09 | 138 | /* This is how to output the definition of a user-level label named |
2761b7cb | 139 | NAME, such as the label on variable NAME. */ |
9bf98a09 | 140 | |
141 | #ifndef ASM_OUTPUT_LABEL | |
142 | #define ASM_OUTPUT_LABEL(FILE,NAME) \ | |
c0e76f1f | 143 | do { \ |
144 | assemble_name ((FILE), (NAME)); \ | |
145 | fputs (":\n", (FILE)); \ | |
146 | } while (0) | |
9bf98a09 | 147 | #endif |
148 | ||
2761b7cb | 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 | ||
48126f0c | 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 | ||
afd6e1ea | 166 | /* This is how to output a reference to a user-level label named NAME. */ |
167 | ||
168 | #ifndef ASM_OUTPUT_LABELREF | |
c0e76f1f | 169 | #define ASM_OUTPUT_LABELREF(FILE,NAME) \ |
170 | do { \ | |
171 | fputs (user_label_prefix, (FILE)); \ | |
172 | fputs ((NAME), (FILE)); \ | |
66659825 | 173 | } while (0) |
afd6e1ea | 174 | #endif |
175 | ||
64e17633 | 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) \ | |
805e22b2 | 182 | (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM) |
64e17633 | 183 | #endif |
184 | ||
3285e530 | 185 | /* This is how we tell the assembler that a symbol is weak. */ |
0074c35b | 186 | #ifndef ASM_OUTPUT_WEAK_ALIAS |
187 | #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF) | |
3285e530 | 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) | |
f4a30bd7 | 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 | |
b0988db1 | 207 | #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \ |
f4a30bd7 | 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) | |
3285e530 | 217 | #endif |
0074c35b | 218 | #endif |
3285e530 | 219 | |
ef7af4c3 | 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); \ | |
85aa12f7 | 245 | fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \ |
ef7af4c3 | 246 | } \ |
247 | while (0) | |
248 | ||
a7424888 | 249 | #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \ |
ef7af4c3 | 250 | do \ |
251 | { \ | |
252 | fputs (SIZE_ASM_OP, STREAM); \ | |
a7424888 | 253 | assemble_name (STREAM, NAME); \ |
254 | fputs (", .-", STREAM); \ | |
255 | assemble_name (STREAM, NAME); \ | |
ef7af4c3 | 256 | putc ('\n', STREAM); \ |
257 | } \ | |
258 | while (0) | |
259 | ||
260 | #endif | |
261 | #endif | |
262 | ||
293c8430 | 263 | /* This determines whether or not we support weak symbols. SUPPORTS_WEAK |
264 | must be a preprocessor constant. */ | |
9a0ce7db | 265 | #ifndef SUPPORTS_WEAK |
ee0125fb | 266 | #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) |
9a0ce7db | 267 | #define SUPPORTS_WEAK 1 |
268 | #else | |
269 | #define SUPPORTS_WEAK 0 | |
270 | #endif | |
271 | #endif | |
19bce576 | 272 | |
293c8430 | 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 | ||
1488fe24 | 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 | ||
21419a5e | 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 | ||
9bb1c6fd | 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; | |
fbf0afd1 | 302 | see the documentation. */ |
9bb1c6fd | 303 | #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC |
304 | #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0 | |
2f9fc8ef | 305 | #endif |
306 | ||
778ac06a | 307 | /* This determines whether or not we need linkonce unwind information. */ |
2f9fc8ef | 308 | #ifndef TARGET_USES_WEAK_UNWIND_INFO |
309 | #define TARGET_USES_WEAK_UNWIND_INFO 0 | |
310 | #endif | |
311 | ||
226e4024 | 312 | /* By default, there is no prefix on user-defined symbols. */ |
313 | #ifndef USER_LABEL_PREFIX | |
314 | #define USER_LABEL_PREFIX "" | |
315 | #endif | |
316 | ||
ee055d40 | 317 | /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to |
9e7454d0 | 318 | provide a weak attribute. Else define it to nothing. |
ee055d40 | 319 | |
673b6e5a | 320 | This would normally belong in ansidecl.h, but SUPPORTS_WEAK is |
ee055d40 | 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 | ||
197e583a | 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 | |
2f9fc8ef | 338 | |
246dd815 | 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 | ||
19bce576 | 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. */ | |
cc7d6aed | 347 | #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) |
d757b8c9 | 348 | #define DWARF2_UNWIND_INFO 1 |
19bce576 | 349 | #endif |
189c9752 | 350 | |
01d15dc5 | 351 | /* If we have named sections, and we're using crtstuff to run ctors, |
352 | use them for registering eh frame information. */ | |
5908b37c | 353 | #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ |
552a60d3 | 354 | && !defined (EH_FRAME_THROUGH_COLLECT2) |
2cb4ac60 | 355 | #ifndef EH_FRAME_SECTION_NAME |
356 | #define EH_FRAME_SECTION_NAME ".eh_frame" | |
357 | #endif | |
a6881cf3 | 358 | #endif |
359 | ||
51601538 | 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 | ||
0973afac | 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 | ||
5d3b61f6 | 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 | ||
f564fb30 | 391 | #ifndef MASK_RETURN_ADDR |
392 | #define MASK_RETURN_ADDR NULL_RTX | |
393 | #endif | |
394 | ||
de2f3039 | 395 | /* Number of hardware registers that go into the DWARF-2 unwind info. |
396 | If not defined, equals FIRST_PSEUDO_REGISTER */ | |
397 | ||
398 | #ifndef DWARF_FRAME_REGISTERS | |
399 | #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER | |
400 | #endif | |
0e66aa75 | 401 | |
53a3f6d1 | 402 | /* Offsets recorded in opcodes are a multiple of this alignment factor. */ |
403 | #ifndef DWARF_CIE_DATA_ALIGNMENT | |
404 | #ifdef STACK_GROWS_DOWNWARD | |
405 | #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) | |
406 | #else | |
407 | #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) | |
408 | #endif | |
409 | #endif | |
410 | ||
411 | /* The DWARF 2 CFA column which tracks the return address. Normally this | |
412 | is the column for PC, or the first column after all of the hard | |
413 | registers. */ | |
414 | #ifndef DWARF_FRAME_RETURN_COLUMN | |
415 | #ifdef PC_REGNUM | |
416 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) | |
417 | #else | |
418 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS | |
419 | #endif | |
420 | #endif | |
421 | ||
1ff6063a | 422 | /* How to renumber registers for dbx and gdb. If not defined, assume |
423 | no renumbering is necessary. */ | |
424 | ||
425 | #ifndef DBX_REGISTER_NUMBER | |
426 | #define DBX_REGISTER_NUMBER(REGNO) (REGNO) | |
427 | #endif | |
428 | ||
53a3f6d1 | 429 | /* The mapping from gcc register number to DWARF 2 CFA column number. |
430 | By default, we just provide columns for all registers. */ | |
431 | #ifndef DWARF_FRAME_REGNUM | |
432 | #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) | |
433 | #endif | |
434 | ||
c0235a33 | 435 | /* The mapping from dwarf CFA reg number to internal dwarf reg numbers. */ |
436 | #ifndef DWARF_REG_TO_UNWIND_COLUMN | |
437 | #define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO) | |
438 | #endif | |
439 | ||
53a3f6d1 | 440 | /* Map register numbers held in the call frame info that gcc has |
441 | collected using DWARF_FRAME_REGNUM to those that should be output in | |
442 | .debug_frame and .eh_frame. */ | |
443 | #ifndef DWARF2_FRAME_REG_OUT | |
444 | #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) | |
445 | #endif | |
446 | ||
04dfc41a | 447 | /* The size of addresses as they appear in the Dwarf 2 data. |
448 | Some architectures use word addresses to refer to code locations, | |
449 | but Dwarf 2 info always uses byte addresses. On such machines, | |
450 | Dwarf 2 addresses need to be larger than the architecture's | |
451 | pointers. */ | |
452 | #ifndef DWARF2_ADDR_SIZE | |
4765975c | 453 | #define DWARF2_ADDR_SIZE ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT) |
04dfc41a | 454 | #endif |
455 | ||
456 | /* The size in bytes of a DWARF field indicating an offset or length | |
457 | relative to a debug info section, specified to be 4 bytes in the | |
458 | DWARF-2 specification. The SGI/MIPS ABI defines it to be the same | |
459 | as PTR_SIZE. */ | |
460 | #ifndef DWARF_OFFSET_SIZE | |
461 | #define DWARF_OFFSET_SIZE 4 | |
462 | #endif | |
463 | ||
464 | /* The size in bytes of a DWARF 4 type signature. */ | |
465 | #ifndef DWARF_TYPE_SIGNATURE_SIZE | |
466 | #define DWARF_TYPE_SIGNATURE_SIZE 8 | |
467 | #endif | |
468 | ||
0e66aa75 | 469 | /* Default sizes for base C types. If the sizes are different for |
470 | your target, you should override these values by defining the | |
471 | appropriate symbols in your tm.h file. */ | |
472 | ||
6852ad78 | 473 | #ifndef BITS_PER_WORD |
474 | #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD) | |
475 | #endif | |
476 | ||
0e66aa75 | 477 | #ifndef CHAR_TYPE_SIZE |
478 | #define CHAR_TYPE_SIZE BITS_PER_UNIT | |
479 | #endif | |
480 | ||
557840a9 | 481 | #ifndef BOOL_TYPE_SIZE |
482 | /* `bool' has size and alignment `1', on almost all platforms. */ | |
483 | #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE | |
484 | #endif | |
485 | ||
0e66aa75 | 486 | #ifndef SHORT_TYPE_SIZE |
487 | #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) | |
488 | #endif | |
489 | ||
490 | #ifndef INT_TYPE_SIZE | |
491 | #define INT_TYPE_SIZE BITS_PER_WORD | |
492 | #endif | |
493 | ||
494 | #ifndef LONG_TYPE_SIZE | |
495 | #define LONG_TYPE_SIZE BITS_PER_WORD | |
496 | #endif | |
497 | ||
498 | #ifndef LONG_LONG_TYPE_SIZE | |
499 | #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) | |
500 | #endif | |
501 | ||
502 | #ifndef WCHAR_TYPE_SIZE | |
503 | #define WCHAR_TYPE_SIZE INT_TYPE_SIZE | |
504 | #endif | |
505 | ||
0e66aa75 | 506 | #ifndef FLOAT_TYPE_SIZE |
507 | #define FLOAT_TYPE_SIZE BITS_PER_WORD | |
508 | #endif | |
509 | ||
510 | #ifndef DOUBLE_TYPE_SIZE | |
511 | #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
512 | #endif | |
513 | ||
514 | #ifndef LONG_DOUBLE_TYPE_SIZE | |
515 | #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
516 | #endif | |
517 | ||
c4503c0a | 518 | #ifndef DECIMAL32_TYPE_SIZE |
519 | #define DECIMAL32_TYPE_SIZE 32 | |
48e1416a | 520 | #endif |
c4503c0a | 521 | |
48e1416a | 522 | #ifndef DECIMAL64_TYPE_SIZE |
c4503c0a | 523 | #define DECIMAL64_TYPE_SIZE 64 |
48e1416a | 524 | #endif |
c4503c0a | 525 | |
526 | #ifndef DECIMAL128_TYPE_SIZE | |
527 | #define DECIMAL128_TYPE_SIZE 128 | |
528 | #endif | |
529 | ||
06f0b99c | 530 | #ifndef SHORT_FRACT_TYPE_SIZE |
531 | #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT | |
532 | #endif | |
533 | ||
534 | #ifndef FRACT_TYPE_SIZE | |
535 | #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2) | |
536 | #endif | |
537 | ||
538 | #ifndef LONG_FRACT_TYPE_SIZE | |
539 | #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4) | |
540 | #endif | |
541 | ||
542 | #ifndef LONG_LONG_FRACT_TYPE_SIZE | |
543 | #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8) | |
544 | #endif | |
545 | ||
546 | #ifndef SHORT_ACCUM_TYPE_SIZE | |
547 | #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2) | |
548 | #endif | |
549 | ||
550 | #ifndef ACCUM_TYPE_SIZE | |
551 | #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2) | |
552 | #endif | |
553 | ||
554 | #ifndef LONG_ACCUM_TYPE_SIZE | |
555 | #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2) | |
556 | #endif | |
557 | ||
558 | #ifndef LONG_LONG_ACCUM_TYPE_SIZE | |
559 | #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2) | |
560 | #endif | |
561 | ||
b0b1cbb9 | 562 | /* We let tm.h override the types used here, to handle trivial differences |
563 | such as the choice of unsigned int or long unsigned int for size_t. | |
564 | When machines start needing nontrivial differences in the size type, | |
565 | it would be best to do something here to figure out automatically | |
566 | from other information what type to use. */ | |
567 | ||
568 | #ifndef SIZE_TYPE | |
569 | #define SIZE_TYPE "long unsigned int" | |
570 | #endif | |
571 | ||
748e5d45 | 572 | #ifndef SIZETYPE |
573 | #define SIZETYPE SIZE_TYPE | |
574 | #endif | |
575 | ||
b0b1cbb9 | 576 | #ifndef PID_TYPE |
577 | #define PID_TYPE "int" | |
578 | #endif | |
579 | ||
580 | /* If GCC knows the exact uint_least16_t and uint_least32_t types from | |
581 | <stdint.h>, use them for char16_t and char32_t. Otherwise, use | |
582 | these guesses; getting the wrong type of a given width will not | |
583 | affect C++ name mangling because in C++ these are distinct types | |
584 | not typedefs. */ | |
585 | ||
82362779 | 586 | #ifndef CHAR8_TYPE |
587 | #define CHAR8_TYPE "unsigned char" | |
588 | #endif | |
589 | ||
b0b1cbb9 | 590 | #ifdef UINT_LEAST16_TYPE |
591 | #define CHAR16_TYPE UINT_LEAST16_TYPE | |
592 | #else | |
593 | #define CHAR16_TYPE "short unsigned int" | |
594 | #endif | |
595 | ||
596 | #ifdef UINT_LEAST32_TYPE | |
597 | #define CHAR32_TYPE UINT_LEAST32_TYPE | |
598 | #else | |
599 | #define CHAR32_TYPE "unsigned int" | |
600 | #endif | |
601 | ||
602 | #ifndef WCHAR_TYPE | |
603 | #define WCHAR_TYPE "int" | |
604 | #endif | |
605 | ||
606 | /* WCHAR_TYPE gets overridden by -fshort-wchar. */ | |
607 | #define MODIFIED_WCHAR_TYPE \ | |
608 | (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) | |
609 | ||
610 | #ifndef PTRDIFF_TYPE | |
611 | #define PTRDIFF_TYPE "long int" | |
612 | #endif | |
613 | ||
614 | #ifndef WINT_TYPE | |
615 | #define WINT_TYPE "unsigned int" | |
616 | #endif | |
617 | ||
618 | #ifndef INTMAX_TYPE | |
619 | #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
620 | ? "int" \ | |
621 | : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
622 | ? "long int" \ | |
623 | : "long long int")) | |
624 | #endif | |
625 | ||
626 | #ifndef UINTMAX_TYPE | |
627 | #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
628 | ? "unsigned int" \ | |
629 | : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ | |
630 | ? "long unsigned int" \ | |
631 | : "long long unsigned int")) | |
632 | #endif | |
633 | ||
634 | ||
635 | /* There are no default definitions of these <stdint.h> types. */ | |
636 | ||
637 | #ifndef SIG_ATOMIC_TYPE | |
638 | #define SIG_ATOMIC_TYPE ((const char *) NULL) | |
639 | #endif | |
640 | ||
641 | #ifndef INT8_TYPE | |
642 | #define INT8_TYPE ((const char *) NULL) | |
643 | #endif | |
644 | ||
645 | #ifndef INT16_TYPE | |
646 | #define INT16_TYPE ((const char *) NULL) | |
647 | #endif | |
648 | ||
649 | #ifndef INT32_TYPE | |
650 | #define INT32_TYPE ((const char *) NULL) | |
651 | #endif | |
652 | ||
653 | #ifndef INT64_TYPE | |
654 | #define INT64_TYPE ((const char *) NULL) | |
655 | #endif | |
656 | ||
657 | #ifndef UINT8_TYPE | |
658 | #define UINT8_TYPE ((const char *) NULL) | |
659 | #endif | |
660 | ||
661 | #ifndef UINT16_TYPE | |
662 | #define UINT16_TYPE ((const char *) NULL) | |
663 | #endif | |
664 | ||
665 | #ifndef UINT32_TYPE | |
666 | #define UINT32_TYPE ((const char *) NULL) | |
667 | #endif | |
668 | ||
669 | #ifndef UINT64_TYPE | |
670 | #define UINT64_TYPE ((const char *) NULL) | |
671 | #endif | |
672 | ||
673 | #ifndef INT_LEAST8_TYPE | |
674 | #define INT_LEAST8_TYPE ((const char *) NULL) | |
675 | #endif | |
676 | ||
677 | #ifndef INT_LEAST16_TYPE | |
678 | #define INT_LEAST16_TYPE ((const char *) NULL) | |
679 | #endif | |
680 | ||
681 | #ifndef INT_LEAST32_TYPE | |
682 | #define INT_LEAST32_TYPE ((const char *) NULL) | |
683 | #endif | |
684 | ||
685 | #ifndef INT_LEAST64_TYPE | |
686 | #define INT_LEAST64_TYPE ((const char *) NULL) | |
687 | #endif | |
688 | ||
689 | #ifndef UINT_LEAST8_TYPE | |
690 | #define UINT_LEAST8_TYPE ((const char *) NULL) | |
691 | #endif | |
692 | ||
693 | #ifndef UINT_LEAST16_TYPE | |
694 | #define UINT_LEAST16_TYPE ((const char *) NULL) | |
695 | #endif | |
696 | ||
697 | #ifndef UINT_LEAST32_TYPE | |
698 | #define UINT_LEAST32_TYPE ((const char *) NULL) | |
699 | #endif | |
700 | ||
701 | #ifndef UINT_LEAST64_TYPE | |
702 | #define UINT_LEAST64_TYPE ((const char *) NULL) | |
703 | #endif | |
704 | ||
705 | #ifndef INT_FAST8_TYPE | |
706 | #define INT_FAST8_TYPE ((const char *) NULL) | |
707 | #endif | |
708 | ||
709 | #ifndef INT_FAST16_TYPE | |
710 | #define INT_FAST16_TYPE ((const char *) NULL) | |
711 | #endif | |
712 | ||
713 | #ifndef INT_FAST32_TYPE | |
714 | #define INT_FAST32_TYPE ((const char *) NULL) | |
715 | #endif | |
716 | ||
717 | #ifndef INT_FAST64_TYPE | |
718 | #define INT_FAST64_TYPE ((const char *) NULL) | |
719 | #endif | |
720 | ||
721 | #ifndef UINT_FAST8_TYPE | |
722 | #define UINT_FAST8_TYPE ((const char *) NULL) | |
723 | #endif | |
724 | ||
725 | #ifndef UINT_FAST16_TYPE | |
726 | #define UINT_FAST16_TYPE ((const char *) NULL) | |
727 | #endif | |
728 | ||
729 | #ifndef UINT_FAST32_TYPE | |
730 | #define UINT_FAST32_TYPE ((const char *) NULL) | |
731 | #endif | |
732 | ||
733 | #ifndef UINT_FAST64_TYPE | |
734 | #define UINT_FAST64_TYPE ((const char *) NULL) | |
735 | #endif | |
736 | ||
737 | #ifndef INTPTR_TYPE | |
738 | #define INTPTR_TYPE ((const char *) NULL) | |
739 | #endif | |
740 | ||
741 | #ifndef UINTPTR_TYPE | |
742 | #define UINTPTR_TYPE ((const char *) NULL) | |
743 | #endif | |
744 | ||
3cf24182 | 745 | /* Width in bits of a pointer. Mind the value of the macro `Pmode'. */ |
746 | #ifndef POINTER_SIZE | |
747 | #define POINTER_SIZE BITS_PER_WORD | |
748 | #endif | |
4765975c | 749 | #ifndef POINTER_SIZE_UNITS |
750 | #define POINTER_SIZE_UNITS ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT) | |
751 | #endif | |
752 | ||
3cf24182 | 753 | |
14e6e4d4 | 754 | #ifndef PIC_OFFSET_TABLE_REGNUM |
755 | #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM | |
756 | #endif | |
757 | ||
260e669e | 758 | #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED |
759 | #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 0 | |
760 | #endif | |
761 | ||
3aa0c315 | 762 | #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES |
763 | #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0 | |
764 | #endif | |
765 | ||
3c5c992f | 766 | #ifndef TARGET_DECLSPEC |
3aa0c315 | 767 | #if TARGET_DLLIMPORT_DECL_ATTRIBUTES |
3c5c992f | 768 | /* If the target supports the "dllimport" attribute, users are |
769 | probably used to the "__declspec" syntax. */ | |
770 | #define TARGET_DECLSPEC 1 | |
771 | #else | |
772 | #define TARGET_DECLSPEC 0 | |
773 | #endif | |
774 | #endif | |
775 | ||
96842e40 | 776 | /* By default, the preprocessor should be invoked the same way in C++ |
777 | as in C. */ | |
778 | #ifndef CPLUSPLUS_CPP_SPEC | |
779 | #ifdef CPP_SPEC | |
780 | #define CPLUSPLUS_CPP_SPEC CPP_SPEC | |
781 | #endif | |
782 | #endif | |
783 | ||
f89331aa | 784 | #ifndef ACCUMULATE_OUTGOING_ARGS |
785 | #define ACCUMULATE_OUTGOING_ARGS 0 | |
786 | #endif | |
787 | ||
3f3d5ad4 | 788 | /* By default, use the GNU runtime for Objective C. */ |
789 | #ifndef NEXT_OBJC_RUNTIME | |
790 | #define NEXT_OBJC_RUNTIME 0 | |
791 | #endif | |
792 | ||
f89331aa | 793 | /* Supply a default definition for PUSH_ARGS. */ |
794 | #ifndef PUSH_ARGS | |
795 | #ifdef PUSH_ROUNDING | |
796 | #define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS | |
797 | #else | |
798 | #define PUSH_ARGS 0 | |
799 | #endif | |
800 | #endif | |
801 | ||
8c69f6fb | 802 | /* Decide whether a function's arguments should be processed |
803 | from first to last or from last to first. | |
804 | ||
805 | They should if the stack and args grow in opposite directions, but | |
806 | only if we have push insns. */ | |
807 | ||
808 | #ifdef PUSH_ROUNDING | |
809 | ||
810 | #ifndef PUSH_ARGS_REVERSED | |
811 | #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) | |
812 | #define PUSH_ARGS_REVERSED PUSH_ARGS | |
813 | #endif | |
814 | #endif | |
815 | ||
816 | #endif | |
817 | ||
818 | #ifndef PUSH_ARGS_REVERSED | |
819 | #define PUSH_ARGS_REVERSED 0 | |
820 | #endif | |
821 | ||
65c05dfd | 822 | /* Default value for the alignment (in bits) a C conformant malloc has to |
823 | provide. This default is intended to be safe and always correct. */ | |
824 | #ifndef MALLOC_ABI_ALIGNMENT | |
825 | #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD | |
826 | #endif | |
827 | ||
9dc9d0d3 | 828 | /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY. |
829 | STACK_BOUNDARY is required. */ | |
830 | #ifndef PREFERRED_STACK_BOUNDARY | |
831 | #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY | |
832 | #endif | |
833 | ||
27a7a23a | 834 | /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not |
835 | defined. */ | |
836 | #ifndef INCOMING_STACK_BOUNDARY | |
837 | #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY | |
838 | #endif | |
839 | ||
6b5553e5 | 840 | #ifndef TARGET_DEFAULT_PACK_STRUCT |
841 | #define TARGET_DEFAULT_PACK_STRUCT 0 | |
842 | #endif | |
843 | ||
5c43f650 | 844 | /* By default, the vtable entries are void pointers, the so the alignment |
845 | is the same as pointer alignment. The value of this macro specifies | |
846 | the alignment of the vtable entry in bits. It should be defined only | |
7299020b | 847 | when special alignment is necessary. */ |
5c43f650 | 848 | #ifndef TARGET_VTABLE_ENTRY_ALIGN |
849 | #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE | |
850 | #endif | |
851 | ||
852 | /* There are a few non-descriptor entries in the vtable at offsets below | |
853 | zero. If these entries must be padded (say, to preserve the alignment | |
854 | specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of | |
855 | words in each data entry. */ | |
856 | #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE | |
857 | #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1 | |
858 | #endif | |
859 | ||
5c0b8490 | 860 | /* Decide whether it is safe to use a local alias for a virtual function |
861 | when constructing thunks. */ | |
862 | #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P | |
863 | #ifdef ASM_OUTPUT_DEF | |
864 | #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1 | |
865 | #else | |
866 | #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0 | |
867 | #endif | |
868 | #endif | |
869 | ||
07b8a412 | 870 | /* Decide whether target supports aliases. */ |
871 | #ifndef TARGET_SUPPORTS_ALIASES | |
872 | #ifdef ASM_OUTPUT_DEF | |
873 | #define TARGET_SUPPORTS_ALIASES 1 | |
874 | #else | |
875 | #define TARGET_SUPPORTS_ALIASES 0 | |
876 | #endif | |
877 | #endif | |
878 | ||
ad5818ae | 879 | /* Select a format to encode pointers in exception handling data. We |
880 | prefer those that result in fewer dynamic relocations. Assume no | |
881 | special support here and encode direct references. */ | |
882 | #ifndef ASM_PREFERRED_EH_DATA_FORMAT | |
883 | #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr | |
884 | #endif | |
885 | ||
3aba38cc | 886 | /* By default, the C++ compiler will use the lowest bit of the pointer |
887 | to function to indicate a pointer-to-member-function points to a | |
888 | virtual member function. However, if FUNCTION_BOUNDARY indicates | |
889 | function addresses aren't always even, the lowest bit of the delta | |
890 | field will be used. */ | |
891 | #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION | |
892 | #define TARGET_PTRMEMFUNC_VBIT_LOCATION \ | |
893 | (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \ | |
894 | ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta) | |
895 | #endif | |
896 | ||
1a6f9700 | 897 | #ifndef DEFAULT_GDB_EXTENSIONS |
898 | #define DEFAULT_GDB_EXTENSIONS 1 | |
899 | #endif | |
900 | ||
901 | /* If more than one debugging type is supported, you must define | |
346e0763 | 902 | PREFERRED_DEBUGGING_TYPE to choose the default. */ |
1a6f9700 | 903 | |
4c52ff7a | 904 | #if 1 < (defined (DBX_DEBUGGING_INFO) \ |
346e0763 | 905 | + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \ |
906 | + defined (VMS_DEBUGGING_INFO)) | |
1a6f9700 | 907 | #ifndef PREFERRED_DEBUGGING_TYPE |
346e0763 | 908 | #error You must define PREFERRED_DEBUGGING_TYPE |
1a6f9700 | 909 | #endif /* no PREFERRED_DEBUGGING_TYPE */ |
346e0763 | 910 | |
911 | /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE | |
912 | here so other code needn't care. */ | |
913 | #elif defined DBX_DEBUGGING_INFO | |
1a6f9700 | 914 | #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG |
346e0763 | 915 | |
a328e031 | 916 | #elif defined DWARF2_DEBUGGING_INFO || defined DWARF2_LINENO_DEBUGGING_INFO |
1a6f9700 | 917 | #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG |
346e0763 | 918 | |
919 | #elif defined VMS_DEBUGGING_INFO | |
8d60d2bc | 920 | #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG |
346e0763 | 921 | |
922 | #elif defined XCOFF_DEBUGGING_INFO | |
1a6f9700 | 923 | #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG |
1a6f9700 | 924 | |
346e0763 | 925 | #else |
926 | /* No debugging format is supported by this target. */ | |
1a6f9700 | 927 | #define PREFERRED_DEBUGGING_TYPE NO_DEBUG |
928 | #endif | |
929 | ||
f2f543a3 | 930 | #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL |
931 | #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false | |
932 | #endif | |
933 | ||
597ff315 | 934 | /* True if the targets integer-comparison functions return { 0, 1, 2 |
30e9913f | 935 | } to indicate { <, ==, > }. False if { -1, 0, 1 } is used |
936 | instead. The libgcc routines are biased. */ | |
937 | #ifndef TARGET_LIB_INT_CMP_BIASED | |
938 | #define TARGET_LIB_INT_CMP_BIASED (true) | |
939 | #endif | |
940 | ||
ef936590 | 941 | /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files, |
942 | then the word-endianness is the same as for integers. */ | |
aa870c1b | 943 | #ifndef FLOAT_WORDS_BIG_ENDIAN |
944 | #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN | |
945 | #endif | |
946 | ||
76c64076 | 947 | #ifndef REG_WORDS_BIG_ENDIAN |
948 | #define REG_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN | |
949 | #endif | |
950 | ||
f3dde807 | 951 | |
c4503c0a | 952 | #ifndef TARGET_DEC_EVAL_METHOD |
953 | #define TARGET_DEC_EVAL_METHOD 2 | |
954 | #endif | |
955 | ||
4f18499c | 956 | #ifndef HAS_LONG_COND_BRANCH |
957 | #define HAS_LONG_COND_BRANCH 0 | |
958 | #endif | |
959 | ||
960 | #ifndef HAS_LONG_UNCOND_BRANCH | |
961 | #define HAS_LONG_UNCOND_BRANCH 0 | |
962 | #endif | |
963 | ||
70ac8784 | 964 | /* Determine whether __cxa_atexit, rather than atexit, is used to |
7299020b | 965 | register C++ destructors for local statics and global objects. */ |
70ac8784 | 966 | #ifndef DEFAULT_USE_CXA_ATEXIT |
967 | #define DEFAULT_USE_CXA_ATEXIT 0 | |
968 | #endif | |
969 | ||
026d3868 | 970 | #if GCC_VERSION >= 3000 && defined IN_GCC |
971 | /* These old constraint macros shouldn't appear anywhere in a | |
972 | configuration using MD constraint definitions. */ | |
48ea5577 | 973 | #endif |
974 | ||
05c1aa95 | 975 | /* Determin whether the target runtime library is Bionic */ |
976 | #ifndef TARGET_HAS_BIONIC | |
977 | #define TARGET_HAS_BIONIC 0 | |
978 | #endif | |
979 | ||
8f4be2be | 980 | /* Indicate that CLZ and CTZ are undefined at zero. */ |
9e7454d0 | 981 | #ifndef CLZ_DEFINED_VALUE_AT_ZERO |
8f4be2be | 982 | #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
983 | #endif | |
9e7454d0 | 984 | #ifndef CTZ_DEFINED_VALUE_AT_ZERO |
8f4be2be | 985 | #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
986 | #endif | |
987 | ||
194b1cc5 | 988 | /* Provide a default value for STORE_FLAG_VALUE. */ |
989 | #ifndef STORE_FLAG_VALUE | |
990 | #define STORE_FLAG_VALUE 1 | |
991 | #endif | |
992 | ||
0ba2d907 | 993 | /* This macro is used to determine what the largest unit size that |
994 | move_by_pieces can use is. */ | |
995 | ||
996 | /* MOVE_MAX_PIECES is the number of bytes at a time which we can | |
997 | move efficiently, as opposed to MOVE_MAX which is the maximum | |
998 | number of bytes we can move with a single instruction. */ | |
999 | ||
1000 | #ifndef MOVE_MAX_PIECES | |
1001 | #define MOVE_MAX_PIECES MOVE_MAX | |
1002 | #endif | |
1003 | ||
0ec3791c | 1004 | /* STORE_MAX_PIECES is the number of bytes at a time that we can |
1005 | store efficiently. Due to internal GCC limitations, this is | |
1006 | MOVE_MAX_PIECES limited by the number of bytes GCC can represent | |
1007 | for an immediate constant. */ | |
1008 | ||
1009 | #ifndef STORE_MAX_PIECES | |
1010 | #define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT)) | |
1011 | #endif | |
1012 | ||
3e346f54 | 1013 | /* Likewise for block comparisons. */ |
1014 | #ifndef COMPARE_MAX_PIECES | |
1015 | #define COMPARE_MAX_PIECES MOVE_MAX_PIECES | |
1016 | #endif | |
1017 | ||
c3997e3d | 1018 | #ifndef MAX_MOVE_MAX |
1019 | #define MAX_MOVE_MAX MOVE_MAX | |
1020 | #endif | |
1021 | ||
1022 | #ifndef MIN_UNITS_PER_WORD | |
1023 | #define MIN_UNITS_PER_WORD UNITS_PER_WORD | |
1024 | #endif | |
1025 | ||
d7c908eb | 1026 | #ifndef MAX_BITS_PER_WORD |
1027 | #define MAX_BITS_PER_WORD BITS_PER_WORD | |
1028 | #endif | |
1029 | ||
891a1732 | 1030 | #ifndef STACK_POINTER_OFFSET |
1031 | #define STACK_POINTER_OFFSET 0 | |
1032 | #endif | |
1033 | ||
0b43a491 | 1034 | #ifndef LOCAL_REGNO |
1035 | #define LOCAL_REGNO(REGNO) 0 | |
1036 | #endif | |
1037 | ||
d44f2f7c | 1038 | #ifndef HONOR_REG_ALLOC_ORDER |
1039 | #define HONOR_REG_ALLOC_ORDER 0 | |
1040 | #endif | |
1041 | ||
13c5e7bf | 1042 | /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, |
1043 | the stack pointer does not matter. The value is tested only in | |
1044 | functions that have frame pointers. */ | |
1045 | #ifndef EXIT_IGNORE_STACK | |
1046 | #define EXIT_IGNORE_STACK 0 | |
1047 | #endif | |
1048 | ||
0f5c9560 | 1049 | /* Assume that case vectors are not pc-relative. */ |
1050 | #ifndef CASE_VECTOR_PC_RELATIVE | |
1051 | #define CASE_VECTOR_PC_RELATIVE 0 | |
1052 | #endif | |
1053 | ||
a27e3913 | 1054 | /* Force minimum alignment to be able to use the least significant bits |
1055 | for distinguishing descriptor addresses from code addresses. */ | |
1056 | #define FUNCTION_ALIGNMENT(ALIGN) \ | |
1057 | (lang_hooks.custom_function_descriptors \ | |
1058 | && targetm.calls.custom_function_descriptors > 0 \ | |
1059 | ? MAX ((ALIGN), \ | |
1060 | 2 * targetm.calls.custom_function_descriptors * BITS_PER_UNIT)\ | |
1061 | : (ALIGN)) | |
1062 | ||
4ee9c684 | 1063 | /* Assume that trampolines need function alignment. */ |
1064 | #ifndef TRAMPOLINE_ALIGNMENT | |
a27e3913 | 1065 | #define TRAMPOLINE_ALIGNMENT FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY) |
4ee9c684 | 1066 | #endif |
1067 | ||
a6e6eeae | 1068 | /* Register mappings for target machines without register windows. */ |
1069 | #ifndef INCOMING_REGNO | |
1070 | #define INCOMING_REGNO(N) (N) | |
1071 | #endif | |
1072 | ||
1073 | #ifndef OUTGOING_REGNO | |
1074 | #define OUTGOING_REGNO(N) (N) | |
1075 | #endif | |
1076 | ||
98de49b3 | 1077 | #ifndef SHIFT_COUNT_TRUNCATED |
1078 | #define SHIFT_COUNT_TRUNCATED 0 | |
1079 | #endif | |
1080 | ||
7151fd0e | 1081 | #ifndef LEGITIMATE_PIC_OPERAND_P |
1082 | #define LEGITIMATE_PIC_OPERAND_P(X) 1 | |
1083 | #endif | |
1084 | ||
e9ff93b1 | 1085 | #ifndef TARGET_MEM_CONSTRAINT |
1086 | #define TARGET_MEM_CONSTRAINT 'm' | |
1087 | #endif | |
1088 | ||
8665fd86 | 1089 | #ifndef REVERSIBLE_CC_MODE |
1090 | #define REVERSIBLE_CC_MODE(MODE) 0 | |
1091 | #endif | |
1092 | ||
2ca6f7cc | 1093 | /* Biggest alignment supported by the object file format of this machine. */ |
1094 | #ifndef MAX_OFILE_ALIGNMENT | |
1095 | #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT | |
1096 | #endif | |
1097 | ||
d28d5017 | 1098 | #ifndef FRAME_GROWS_DOWNWARD |
1099 | #define FRAME_GROWS_DOWNWARD 0 | |
1100 | #endif | |
1101 | ||
a26d6c60 | 1102 | #ifndef RETURN_ADDR_IN_PREVIOUS_FRAME |
1103 | #define RETURN_ADDR_IN_PREVIOUS_FRAME 0 | |
1104 | #endif | |
1105 | ||
12d886b8 | 1106 | /* On most machines, the CFA coincides with the first incoming parm. */ |
1107 | #ifndef ARG_POINTER_CFA_OFFSET | |
c9b5e4ec | 1108 | #define ARG_POINTER_CFA_OFFSET(FNDECL) \ |
1109 | (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size) | |
12d886b8 | 1110 | #endif |
1111 | ||
89fa767a | 1112 | /* On most machines, we use the CFA as DW_AT_frame_base. */ |
1113 | #ifndef CFA_FRAME_BASE_OFFSET | |
1114 | #define CFA_FRAME_BASE_OFFSET(FNDECL) 0 | |
1115 | #endif | |
1116 | ||
12d886b8 | 1117 | /* The offset from the incoming value of %sp to the top of the stack frame |
1118 | for the current function. */ | |
1119 | #ifndef INCOMING_FRAME_SP_OFFSET | |
1120 | #define INCOMING_FRAME_SP_OFFSET 0 | |
1121 | #endif | |
1122 | ||
695595bc | 1123 | #ifndef HARD_REGNO_NREGS_HAS_PADDING |
1124 | #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0 | |
1125 | #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1 | |
1126 | #endif | |
1127 | ||
63c68695 | 1128 | #ifndef OUTGOING_REG_PARM_STACK_SPACE |
22c61100 | 1129 | #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0 |
63c68695 | 1130 | #endif |
1131 | ||
27a7a23a | 1132 | /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by |
1133 | the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best | |
1134 | effort stack alignment supported by the backend. If the backend | |
1135 | supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and | |
1136 | MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack | |
1137 | boundary will limit the maximum guaranteed stack alignment. */ | |
1138 | #ifdef MAX_STACK_ALIGNMENT | |
1139 | #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT | |
1140 | #else | |
1141 | #define MAX_STACK_ALIGNMENT STACK_BOUNDARY | |
1142 | #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY | |
1143 | #endif | |
1144 | ||
1145 | #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY) | |
1146 | ||
ad33891d | 1147 | #ifndef LOCAL_ALIGNMENT |
1148 | #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT | |
1149 | #endif | |
1150 | ||
1151 | #ifndef STACK_SLOT_ALIGNMENT | |
1152 | #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \ | |
1153 | ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN)) | |
1154 | #endif | |
1155 | ||
76cbc2a0 | 1156 | #ifndef LOCAL_DECL_ALIGNMENT |
1157 | #define LOCAL_DECL_ALIGNMENT(DECL) \ | |
1158 | LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) | |
1159 | #endif | |
1160 | ||
8645d3e7 | 1161 | #ifndef MINIMUM_ALIGNMENT |
1162 | #define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN) | |
1163 | #endif | |
1164 | ||
02421213 | 1165 | /* Alignment value for attribute ((aligned)). */ |
1166 | #ifndef ATTRIBUTE_ALIGNED_VALUE | |
1167 | #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT | |
1168 | #endif | |
1169 | ||
181dd1c5 | 1170 | /* For most ports anything that evaluates to a constant symbolic |
1171 | or integer value is acceptable as a constant address. */ | |
1172 | #ifndef CONSTANT_ADDRESS_P | |
1173 | #define CONSTANT_ADDRESS_P(X) (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE) | |
1174 | #endif | |
1175 | ||
b2e48750 | 1176 | #ifndef MAX_FIXED_MODE_SIZE |
1177 | #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) | |
1178 | #endif | |
1179 | ||
4aafe913 | 1180 | /* Nonzero if structures and unions should be returned in memory. |
1181 | ||
1182 | This should only be defined if compatibility with another compiler or | |
1183 | with an ABI is needed, because it results in slower code. */ | |
1184 | ||
1185 | #ifndef DEFAULT_PCC_STRUCT_RETURN | |
1186 | #define DEFAULT_PCC_STRUCT_RETURN 1 | |
1187 | #endif | |
e754ed1d | 1188 | |
0791e28d | 1189 | #ifndef PCC_BITFIELD_TYPE_MATTERS |
1190 | #define PCC_BITFIELD_TYPE_MATTERS false | |
1191 | #endif | |
1192 | ||
91f95f00 | 1193 | #ifndef INSN_SETS_ARE_DELAYED |
1194 | #define INSN_SETS_ARE_DELAYED(INSN) false | |
1195 | #endif | |
1196 | ||
6d7f2074 | 1197 | #ifndef INSN_REFERENCES_ARE_DELAYED |
1198 | #define INSN_REFERENCES_ARE_DELAYED(INSN) false | |
1199 | #endif | |
1200 | ||
93516111 | 1201 | #ifndef NO_FUNCTION_CSE |
1202 | #define NO_FUNCTION_CSE false | |
1203 | #endif | |
1204 | ||
e239bb25 | 1205 | #ifndef HARD_REGNO_RENAME_OK |
1206 | #define HARD_REGNO_RENAME_OK(FROM, TO) true | |
1207 | #endif | |
1208 | ||
10ea5dad | 1209 | #ifndef EPILOGUE_USES |
1210 | #define EPILOGUE_USES(REG) false | |
1211 | #endif | |
1212 | ||
25ecdd6d | 1213 | #ifndef ARGS_GROW_DOWNWARD |
1214 | #define ARGS_GROW_DOWNWARD 0 | |
1215 | #endif | |
1216 | ||
2b785411 | 1217 | #ifndef STACK_GROWS_DOWNWARD |
1218 | #define STACK_GROWS_DOWNWARD 0 | |
1219 | #endif | |
1220 | ||
279a4851 | 1221 | #ifndef STACK_PUSH_CODE |
1222 | #if STACK_GROWS_DOWNWARD | |
1223 | #define STACK_PUSH_CODE PRE_DEC | |
1224 | #else | |
1225 | #define STACK_PUSH_CODE PRE_INC | |
1226 | #endif | |
1227 | #endif | |
1228 | ||
e9abca4f | 1229 | /* Default value for flag_pie when flag_pie is initialized to -1: |
1230 | --enable-default-pie: Default flag_pie to -fPIE. | |
1231 | --disable-default-pie: Default flag_pie to 0. | |
1232 | */ | |
1233 | #ifdef ENABLE_DEFAULT_PIE | |
1234 | # ifndef DEFAULT_FLAG_PIE | |
1235 | # define DEFAULT_FLAG_PIE 2 | |
1236 | # endif | |
1237 | #else | |
1238 | # define DEFAULT_FLAG_PIE 0 | |
1239 | #endif | |
1240 | ||
0f861224 | 1241 | #ifndef SWITCHABLE_TARGET |
1242 | #define SWITCHABLE_TARGET 0 | |
1243 | #endif | |
1244 | ||
1245 | /* If the target supports integers that are wider than two | |
1246 | HOST_WIDE_INTs on the host compiler, then the target should define | |
1247 | TARGET_SUPPORTS_WIDE_INT and make the appropriate fixups. | |
1248 | Otherwise the compiler really is not robust. */ | |
1249 | #ifndef TARGET_SUPPORTS_WIDE_INT | |
1250 | #define TARGET_SUPPORTS_WIDE_INT 0 | |
1251 | #endif | |
1252 | ||
d0b99710 | 1253 | #ifndef SHORT_IMMEDIATES_SIGN_EXTEND |
1254 | #define SHORT_IMMEDIATES_SIGN_EXTEND 0 | |
1255 | #endif | |
1256 | ||
94f1fba7 | 1257 | #ifndef WORD_REGISTER_OPERATIONS |
1258 | #define WORD_REGISTER_OPERATIONS 0 | |
1259 | #endif | |
1260 | ||
91af28a2 | 1261 | #ifndef LOAD_EXTEND_OP |
1262 | #define LOAD_EXTEND_OP(M) UNKNOWN | |
1263 | #endif | |
1264 | ||
3f840859 | 1265 | #ifndef INITIAL_FRAME_ADDRESS_RTX |
1266 | #define INITIAL_FRAME_ADDRESS_RTX NULL | |
1267 | #endif | |
1268 | ||
3dd01ce6 | 1269 | #ifndef SETUP_FRAME_ADDRESSES |
1270 | #define SETUP_FRAME_ADDRESSES() do { } while (0) | |
1271 | #endif | |
1272 | ||
a9e2e8b5 | 1273 | #ifndef DYNAMIC_CHAIN_ADDRESS |
1274 | #define DYNAMIC_CHAIN_ADDRESS(x) (x) | |
1275 | #endif | |
1276 | ||
440a66da | 1277 | #ifndef FRAME_ADDR_RTX |
1278 | #define FRAME_ADDR_RTX(x) (x) | |
1279 | #endif | |
1280 | ||
e6daccdf | 1281 | #ifndef REVERSE_CONDITION |
1282 | #define REVERSE_CONDITION(code, mode) reverse_condition (code) | |
1283 | #endif | |
1284 | ||
6bf973f6 | 1285 | #ifndef TARGET_PECOFF |
1286 | #define TARGET_PECOFF 0 | |
1287 | #endif | |
1288 | ||
66303da2 | 1289 | #ifndef TARGET_COFF |
1290 | #define TARGET_COFF 0 | |
1291 | #endif | |
1292 | ||
05aaca92 | 1293 | #ifndef EH_RETURN_HANDLER_RTX |
1294 | #define EH_RETURN_HANDLER_RTX NULL | |
1295 | #endif | |
1296 | ||
e754ed1d | 1297 | #ifdef GCC_INSN_FLAGS_H |
1298 | /* Dependent default target macro definitions | |
1299 | ||
1300 | This section of defaults.h defines target macros that depend on generated | |
1301 | headers. This is a bit awkward: We want to put all default definitions | |
1302 | for target macros in defaults.h, but some of the defaults depend on the | |
1303 | HAVE_* flags defines of insn-flags.h. But insn-flags.h is not always | |
1304 | included by files that do include defaults.h. | |
1305 | ||
1306 | Fortunately, the default macro definitions that depend on the HAVE_* | |
1307 | macros are also the ones that will only be used inside GCC itself, i.e. | |
1308 | not in the gen* programs or in target objects like libgcc. | |
1309 | ||
1310 | Obviously, it would be best to keep this section of defaults.h as small | |
1311 | as possible, by converting the macros defined below to target hooks or | |
1312 | functions. | |
1313 | */ | |
1314 | ||
e754ed1d | 1315 | /* The default branch cost is 1. */ |
1316 | #ifndef BRANCH_COST | |
1317 | #define BRANCH_COST(speed_p, predictable_p) 1 | |
1318 | #endif | |
1319 | ||
1320 | /* If a memory-to-memory move would take MOVE_RATIO or more simple | |
f135a8d4 | 1321 | move-instruction sequences, we will do a cpymem or libcall instead. */ |
e754ed1d | 1322 | |
1323 | #ifndef MOVE_RATIO | |
f135a8d4 | 1324 | #if defined (HAVE_cpymemqi) || defined (HAVE_cpymemhi) || defined (HAVE_cpymemsi) || defined (HAVE_cpymemdi) || defined (HAVE_cpymemti) |
e754ed1d | 1325 | #define MOVE_RATIO(speed) 2 |
1326 | #else | |
1327 | /* If we are optimizing for space (-Os), cut down the default move ratio. */ | |
1328 | #define MOVE_RATIO(speed) ((speed) ? 15 : 3) | |
1329 | #endif | |
1330 | #endif | |
1331 | ||
1332 | /* If a clear memory operation would take CLEAR_RATIO or more simple | |
1333 | move-instruction sequences, we will do a setmem or libcall instead. */ | |
1334 | ||
1335 | #ifndef CLEAR_RATIO | |
1336 | #if defined (HAVE_setmemqi) || defined (HAVE_setmemhi) || defined (HAVE_setmemsi) || defined (HAVE_setmemdi) || defined (HAVE_setmemti) | |
1337 | #define CLEAR_RATIO(speed) 2 | |
1338 | #else | |
1339 | /* If we are optimizing for space, cut down the default clear ratio. */ | |
1340 | #define CLEAR_RATIO(speed) ((speed) ? 15 :3) | |
1341 | #endif | |
1342 | #endif | |
1343 | ||
1344 | /* If a memory set (to value other than zero) operation would take | |
f135a8d4 | 1345 | SET_RATIO or more simple move-instruction sequences, we will do a setmem |
e754ed1d | 1346 | or libcall instead. */ |
1347 | #ifndef SET_RATIO | |
9af5ce0c | 1348 | #define SET_RATIO(speed) MOVE_RATIO (speed) |
e754ed1d | 1349 | #endif |
1350 | ||
e754ed1d | 1351 | /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. |
1352 | Normally move_insn, so Pmode stack pointer. */ | |
1353 | ||
1354 | #ifndef STACK_SAVEAREA_MODE | |
1355 | #define STACK_SAVEAREA_MODE(LEVEL) Pmode | |
1356 | #endif | |
1357 | ||
1358 | /* Supply a default definition of STACK_SIZE_MODE for | |
1359 | allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ | |
1360 | ||
1361 | #ifndef STACK_SIZE_MODE | |
1362 | #define STACK_SIZE_MODE word_mode | |
1363 | #endif | |
1364 | ||
6957b94e | 1365 | /* Default value for flag_stack_protect when flag_stack_protect is initialized to -1: |
1366 | --enable-default-ssp: Default flag_stack_protect to -fstack-protector-strong. | |
1367 | --disable-default-ssp: Default flag_stack_protect to 0. | |
1368 | */ | |
1369 | #ifdef ENABLE_DEFAULT_SSP | |
1370 | # ifndef DEFAULT_FLAG_SSP | |
1371 | # define DEFAULT_FLAG_SSP 3 | |
1372 | # endif | |
1373 | #else | |
1374 | # define DEFAULT_FLAG_SSP 0 | |
1375 | #endif | |
1376 | ||
e754ed1d | 1377 | /* Provide default values for the macros controlling stack checking. */ |
1378 | ||
1379 | /* The default is neither full builtin stack checking... */ | |
1380 | #ifndef STACK_CHECK_BUILTIN | |
1381 | #define STACK_CHECK_BUILTIN 0 | |
1382 | #endif | |
1383 | ||
1384 | /* ...nor static builtin stack checking. */ | |
1385 | #ifndef STACK_CHECK_STATIC_BUILTIN | |
1386 | #define STACK_CHECK_STATIC_BUILTIN 0 | |
1387 | #endif | |
1388 | ||
1389 | /* The default interval is one page (4096 bytes). */ | |
1390 | #ifndef STACK_CHECK_PROBE_INTERVAL_EXP | |
1391 | #define STACK_CHECK_PROBE_INTERVAL_EXP 12 | |
1392 | #endif | |
1393 | ||
1394 | /* The default is not to move the stack pointer. */ | |
1395 | #ifndef STACK_CHECK_MOVING_SP | |
1396 | #define STACK_CHECK_MOVING_SP 0 | |
1397 | #endif | |
1398 | ||
1399 | /* This is a kludge to try to capture the discrepancy between the old | |
1400 | mechanism (generic stack checking) and the new mechanism (static | |
1401 | builtin stack checking). STACK_CHECK_PROTECT needs to be bumped | |
1402 | for the latter because part of the protection area is effectively | |
1403 | included in STACK_CHECK_MAX_FRAME_SIZE for the former. */ | |
1404 | #ifdef STACK_CHECK_PROTECT | |
1405 | #define STACK_OLD_CHECK_PROTECT STACK_CHECK_PROTECT | |
1406 | #else | |
218e3e4e | 1407 | #define STACK_OLD_CHECK_PROTECT \ |
5ee1325b | 1408 | (!global_options.x_flag_exceptions \ |
218e3e4e | 1409 | ? 75 * UNITS_PER_WORD \ |
5ee1325b | 1410 | : targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ |
1411 | ? 4 * 1024 \ | |
1412 | : 8 * 1024) | |
e754ed1d | 1413 | #endif |
1414 | ||
1415 | /* Minimum amount of stack required to recover from an anticipated stack | |
1416 | overflow detection. The default value conveys an estimate of the amount | |
1417 | of stack required to propagate an exception. */ | |
1418 | #ifndef STACK_CHECK_PROTECT | |
218e3e4e | 1419 | #define STACK_CHECK_PROTECT \ |
5ee1325b | 1420 | (!global_options.x_flag_exceptions \ |
1421 | ? 4 * 1024 \ | |
1422 | : targetm_common.except_unwind_info (&global_options) == UI_SJLJ \ | |
1423 | ? 8 * 1024 \ | |
1424 | : 12 * 1024) | |
e754ed1d | 1425 | #endif |
1426 | ||
1427 | /* Make the maximum frame size be the largest we can and still only need | |
1428 | one probe per function. */ | |
1429 | #ifndef STACK_CHECK_MAX_FRAME_SIZE | |
1430 | #define STACK_CHECK_MAX_FRAME_SIZE \ | |
1431 | ((1 << STACK_CHECK_PROBE_INTERVAL_EXP) - UNITS_PER_WORD) | |
1432 | #endif | |
1433 | ||
1434 | /* This is arbitrary, but should be large enough everywhere. */ | |
1435 | #ifndef STACK_CHECK_FIXED_FRAME_SIZE | |
1436 | #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) | |
1437 | #endif | |
1438 | ||
1439 | /* Provide a reasonable default for the maximum size of an object to | |
1440 | allocate in the fixed frame. We may need to be able to make this | |
1441 | controllable by the user at some point. */ | |
1442 | #ifndef STACK_CHECK_MAX_VAR_SIZE | |
1443 | #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) | |
1444 | #endif | |
1445 | ||
0f0e309f | 1446 | /* By default, the C++ compiler will use function addresses in the |
1447 | vtable entries. Setting this nonzero tells the compiler to use | |
1448 | function descriptors instead. The value of this macro says how | |
1449 | many words wide the descriptor is (normally 2). It is assumed | |
1450 | that the address of a function descriptor may be treated as a | |
1451 | pointer to a function. */ | |
1452 | #ifndef TARGET_VTABLE_USES_DESCRIPTORS | |
1453 | #define TARGET_VTABLE_USES_DESCRIPTORS 0 | |
1454 | #endif | |
1455 | ||
e754ed1d | 1456 | #endif /* GCC_INSN_FLAGS_H */ |
1457 | ||
f78f10d6 | 1458 | #ifndef DWARF_GNAT_ENCODINGS_DEFAULT |
1459 | #define DWARF_GNAT_ENCODINGS_DEFAULT DWARF_GNAT_ENCODINGS_GDB | |
1460 | #endif | |
1461 | ||
2a281353 | 1462 | #endif /* ! GCC_DEFAULTS_H */ |