|
0
|
1 /* Definitions of various defaults for tm.h macros.
|
|
|
2 Copyright (C) 1992, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
|
|
3 2005, 2007, 2008, 2009
|
|
|
4 Free Software Foundation, Inc.
|
|
|
5 Contributed by Ron Guilmette (rfg@monkeys.com)
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
9 GCC is free software; you can redistribute it and/or modify it under
|
|
|
10 the terms of the GNU General Public License as published by the Free
|
|
|
11 Software Foundation; either version 3, or (at your option) any later
|
|
|
12 version.
|
|
|
13
|
|
|
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
17 for more details.
|
|
|
18
|
|
|
19 Under Section 7 of GPL version 3, you are granted additional
|
|
|
20 permissions described in the GCC Runtime Library Exception, version
|
|
|
21 3.1, as published by the Free Software Foundation.
|
|
|
22
|
|
|
23 You should have received a copy of the GNU General Public License and
|
|
|
24 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
25 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
26 <http://www.gnu.org/licenses/>. */
|
|
|
27
|
|
|
28 #ifndef GCC_DEFAULTS_H
|
|
|
29 #define GCC_DEFAULTS_H
|
|
|
30
|
|
|
31 #ifndef GET_ENVIRONMENT
|
|
|
32 #define GET_ENVIRONMENT(VALUE, NAME) do { (VALUE) = getenv (NAME); } while (0)
|
|
|
33 #endif
|
|
|
34
|
|
|
35 #define obstack_chunk_alloc ((void *(*) (long)) xmalloc)
|
|
|
36 #define obstack_chunk_free ((void (*) (void *)) free)
|
|
|
37 #define OBSTACK_CHUNK_SIZE 0
|
|
|
38 #define gcc_obstack_init(OBSTACK) \
|
|
|
39 _obstack_begin ((OBSTACK), OBSTACK_CHUNK_SIZE, 0, \
|
|
|
40 obstack_chunk_alloc, \
|
|
|
41 obstack_chunk_free)
|
|
|
42
|
|
|
43 /* Store in OUTPUT a string (made with alloca) containing an
|
|
|
44 assembler-name for a local static variable or function named NAME.
|
|
|
45 LABELNO is an integer which is different for each call. */
|
|
|
46
|
|
|
47 #ifndef ASM_PN_FORMAT
|
|
|
48 # ifndef NO_DOT_IN_LABEL
|
|
|
49 # define ASM_PN_FORMAT "%s.%lu"
|
|
|
50 # else
|
|
|
51 # ifndef NO_DOLLAR_IN_LABEL
|
|
|
52 # define ASM_PN_FORMAT "%s$%lu"
|
|
|
53 # else
|
|
|
54 # define ASM_PN_FORMAT "__%s_%lu"
|
|
|
55 # endif
|
|
|
56 # endif
|
|
|
57 #endif /* ! ASM_PN_FORMAT */
|
|
|
58
|
|
|
59 #ifndef ASM_FORMAT_PRIVATE_NAME
|
|
|
60 # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
|
|
|
61 do { const char *const name_ = (NAME); \
|
|
|
62 char *const output_ = (OUTPUT) = \
|
|
|
63 (char *) alloca (strlen (name_) + 32); \
|
|
|
64 sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \
|
|
|
65 } while (0)
|
|
|
66 #endif
|
|
|
67
|
|
|
68 /* Choose a reasonable default for ASM_OUTPUT_ASCII. */
|
|
|
69
|
|
|
70 #ifndef ASM_OUTPUT_ASCII
|
|
|
71 #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
|
|
|
72 do { \
|
|
|
73 FILE *_hide_asm_out_file = (MYFILE); \
|
|
|
74 const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \
|
|
|
75 int _hide_thissize = (MYLENGTH); \
|
|
|
76 { \
|
|
|
77 FILE *asm_out_file = _hide_asm_out_file; \
|
|
|
78 const unsigned char *p = _hide_p; \
|
|
|
79 int thissize = _hide_thissize; \
|
|
|
80 int i; \
|
|
|
81 fprintf (asm_out_file, "\t.ascii \""); \
|
|
|
82 \
|
|
|
83 for (i = 0; i < thissize; i++) \
|
|
|
84 { \
|
|
|
85 int c = p[i]; \
|
|
|
86 if (c == '\"' || c == '\\') \
|
|
|
87 putc ('\\', asm_out_file); \
|
|
|
88 if (ISPRINT(c)) \
|
|
|
89 putc (c, asm_out_file); \
|
|
|
90 else \
|
|
|
91 { \
|
|
|
92 fprintf (asm_out_file, "\\%o", c); \
|
|
|
93 /* After an octal-escape, if a digit follows, \
|
|
|
94 terminate one string constant and start another. \
|
|
|
95 The VAX assembler fails to stop reading the escape \
|
|
|
96 after three digits, so this is the only way we \
|
|
|
97 can get it to parse the data properly. */ \
|
|
|
98 if (i < thissize - 1 && ISDIGIT(p[i + 1])) \
|
|
|
99 fprintf (asm_out_file, "\"\n\t.ascii \""); \
|
|
|
100 } \
|
|
|
101 } \
|
|
|
102 fprintf (asm_out_file, "\"\n"); \
|
|
|
103 } \
|
|
|
104 } \
|
|
|
105 while (0)
|
|
|
106 #endif
|
|
|
107
|
|
|
108 /* This is how we tell the assembler to equate two values. */
|
|
|
109 #ifdef SET_ASM_OP
|
|
|
110 #ifndef ASM_OUTPUT_DEF
|
|
|
111 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \
|
|
|
112 do { fprintf ((FILE), "%s", SET_ASM_OP); \
|
|
|
113 assemble_name (FILE, LABEL1); \
|
|
|
114 fprintf (FILE, ","); \
|
|
|
115 assemble_name (FILE, LABEL2); \
|
|
|
116 fprintf (FILE, "\n"); \
|
|
|
117 } while (0)
|
|
|
118 #endif
|
|
|
119 #endif
|
|
|
120
|
|
|
121 #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON)
|
|
|
122 #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) \
|
|
|
123 do \
|
|
|
124 { \
|
|
|
125 fprintf ((FILE), "\t.tls_common\t"); \
|
|
|
126 assemble_name ((FILE), (NAME)); \
|
|
|
127 fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \
|
|
|
128 (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \
|
|
|
129 } \
|
|
|
130 while (0)
|
|
|
131 #endif
|
|
|
132
|
|
|
133 /* Decide whether to defer emitting the assembler output for an equate
|
|
|
134 of two values. The default is to not defer output. */
|
|
|
135 #ifndef TARGET_DEFERRED_OUTPUT_DEFS
|
|
|
136 #define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false
|
|
|
137 #endif
|
|
|
138
|
|
|
139 /* This is how to output the definition of a user-level label named
|
|
|
140 NAME, such as the label on a static function or variable NAME. */
|
|
|
141
|
|
|
142 #ifndef ASM_OUTPUT_LABEL
|
|
|
143 #define ASM_OUTPUT_LABEL(FILE,NAME) \
|
|
|
144 do { assemble_name ((FILE), (NAME)); fputs (":\n", (FILE)); } while (0)
|
|
|
145 #endif
|
|
|
146
|
|
|
147 /* Output the definition of a compiler-generated label named NAME. */
|
|
|
148 #ifndef ASM_OUTPUT_INTERNAL_LABEL
|
|
|
149 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME) \
|
|
|
150 do { \
|
|
|
151 assemble_name_raw ((FILE), (NAME)); \
|
|
|
152 fputs (":\n", (FILE)); \
|
|
|
153 } while (0)
|
|
|
154 #endif
|
|
|
155
|
|
|
156 /* This is how to output a reference to a user-level label named NAME. */
|
|
|
157
|
|
|
158 #ifndef ASM_OUTPUT_LABELREF
|
|
|
159 #define ASM_OUTPUT_LABELREF(FILE,NAME) asm_fprintf ((FILE), "%U%s", (NAME))
|
|
|
160 #endif
|
|
|
161
|
|
|
162 /* Allow target to print debug info labels specially. This is useful for
|
|
|
163 VLIW targets, since debug info labels should go into the middle of
|
|
|
164 instruction bundles instead of breaking them. */
|
|
|
165
|
|
|
166 #ifndef ASM_OUTPUT_DEBUG_LABEL
|
|
|
167 #define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \
|
|
|
168 (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM)
|
|
|
169 #endif
|
|
|
170
|
|
|
171 /* This is how we tell the assembler that a symbol is weak. */
|
|
|
172 #ifndef ASM_OUTPUT_WEAK_ALIAS
|
|
|
173 #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF)
|
|
|
174 #define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE) \
|
|
|
175 do \
|
|
|
176 { \
|
|
|
177 ASM_WEAKEN_LABEL (STREAM, NAME); \
|
|
|
178 if (VALUE) \
|
|
|
179 ASM_OUTPUT_DEF (STREAM, NAME, VALUE); \
|
|
|
180 } \
|
|
|
181 while (0)
|
|
|
182 #endif
|
|
|
183 #endif
|
|
|
184
|
|
|
185 /* This is how we tell the assembler that a symbol is a weak alias to
|
|
|
186 another symbol that doesn't require the other symbol to be defined.
|
|
|
187 Uses of the former will turn into weak uses of the latter, i.e.,
|
|
|
188 uses that, in case the latter is undefined, will not cause errors,
|
|
|
189 and will add it to the symbol table as weak undefined. However, if
|
|
|
190 the latter is referenced directly, a strong reference prevails. */
|
|
|
191 #ifndef ASM_OUTPUT_WEAKREF
|
|
|
192 #if defined HAVE_GAS_WEAKREF
|
|
|
193 #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \
|
|
|
194 do \
|
|
|
195 { \
|
|
|
196 fprintf ((FILE), "\t.weakref\t"); \
|
|
|
197 assemble_name ((FILE), (NAME)); \
|
|
|
198 fprintf ((FILE), ","); \
|
|
|
199 assemble_name ((FILE), (VALUE)); \
|
|
|
200 fprintf ((FILE), "\n"); \
|
|
|
201 } \
|
|
|
202 while (0)
|
|
|
203 #endif
|
|
|
204 #endif
|
|
|
205
|
|
|
206 /* How to emit a .type directive. */
|
|
|
207 #ifndef ASM_OUTPUT_TYPE_DIRECTIVE
|
|
|
208 #if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT
|
|
|
209 #define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE) \
|
|
|
210 do \
|
|
|
211 { \
|
|
|
212 fputs (TYPE_ASM_OP, STREAM); \
|
|
|
213 assemble_name (STREAM, NAME); \
|
|
|
214 fputs (", ", STREAM); \
|
|
|
215 fprintf (STREAM, TYPE_OPERAND_FMT, TYPE); \
|
|
|
216 putc ('\n', STREAM); \
|
|
|
217 } \
|
|
|
218 while (0)
|
|
|
219 #endif
|
|
|
220 #endif
|
|
|
221
|
|
|
222 /* How to emit a .size directive. */
|
|
|
223 #ifndef ASM_OUTPUT_SIZE_DIRECTIVE
|
|
|
224 #ifdef SIZE_ASM_OP
|
|
|
225 #define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE) \
|
|
|
226 do \
|
|
|
227 { \
|
|
|
228 HOST_WIDE_INT size_ = (SIZE); \
|
|
|
229 fputs (SIZE_ASM_OP, STREAM); \
|
|
|
230 assemble_name (STREAM, NAME); \
|
|
|
231 fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \
|
|
|
232 } \
|
|
|
233 while (0)
|
|
|
234
|
|
|
235 #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \
|
|
|
236 do \
|
|
|
237 { \
|
|
|
238 fputs (SIZE_ASM_OP, STREAM); \
|
|
|
239 assemble_name (STREAM, NAME); \
|
|
|
240 fputs (", .-", STREAM); \
|
|
|
241 assemble_name (STREAM, NAME); \
|
|
|
242 putc ('\n', STREAM); \
|
|
|
243 } \
|
|
|
244 while (0)
|
|
|
245
|
|
|
246 #endif
|
|
|
247 #endif
|
|
|
248
|
|
|
249 /* This determines whether or not we support weak symbols. */
|
|
|
250 #ifndef SUPPORTS_WEAK
|
|
|
251 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
|
|
|
252 #define SUPPORTS_WEAK 1
|
|
|
253 #else
|
|
|
254 #define SUPPORTS_WEAK 0
|
|
|
255 #endif
|
|
|
256 #endif
|
|
|
257
|
|
|
258 /* This determines whether or not we support link-once semantics. */
|
|
|
259 #ifndef SUPPORTS_ONE_ONLY
|
|
|
260 #ifdef MAKE_DECL_ONE_ONLY
|
|
|
261 #define SUPPORTS_ONE_ONLY 1
|
|
|
262 #else
|
|
|
263 #define SUPPORTS_ONE_ONLY 0
|
|
|
264 #endif
|
|
|
265 #endif
|
|
|
266
|
|
|
267 /* This determines whether weak symbols must be left out of a static
|
|
|
268 archive's table of contents. Defining this macro to be nonzero has
|
|
|
269 the consequence that certain symbols will not be made weak that
|
|
|
270 otherwise would be. The C++ ABI requires this macro to be zero;
|
|
|
271 see the documentation. */
|
|
|
272 #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC
|
|
|
273 #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0
|
|
|
274 #endif
|
|
|
275
|
|
|
276 /* This determines whether or not we need linkonce unwind information. */
|
|
|
277 #ifndef TARGET_USES_WEAK_UNWIND_INFO
|
|
|
278 #define TARGET_USES_WEAK_UNWIND_INFO 0
|
|
|
279 #endif
|
|
|
280
|
|
|
281 /* By default, there is no prefix on user-defined symbols. */
|
|
|
282 #ifndef USER_LABEL_PREFIX
|
|
|
283 #define USER_LABEL_PREFIX ""
|
|
|
284 #endif
|
|
|
285
|
|
|
286 /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to
|
|
|
287 provide a weak attribute. Else define it to nothing.
|
|
|
288
|
|
|
289 This would normally belong in ansidecl.h, but SUPPORTS_WEAK is
|
|
|
290 not available at that time.
|
|
|
291
|
|
|
292 Note, this is only for use by target files which we know are to be
|
|
|
293 compiled by GCC. */
|
|
|
294 #ifndef TARGET_ATTRIBUTE_WEAK
|
|
|
295 # if SUPPORTS_WEAK
|
|
|
296 # define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak))
|
|
|
297 # else
|
|
|
298 # define TARGET_ATTRIBUTE_WEAK
|
|
|
299 # endif
|
|
|
300 #endif
|
|
|
301
|
|
|
302 /* Determines whether we may use common symbols to represent one-only
|
|
|
303 semantics (a.k.a. "vague linkage"). */
|
|
|
304 #ifndef USE_COMMON_FOR_ONE_ONLY
|
|
|
305 # define USE_COMMON_FOR_ONE_ONLY 1
|
|
|
306 #endif
|
|
|
307
|
|
|
308 /* By default we can assume that all global symbols are in one namespace,
|
|
|
309 across all shared libraries. */
|
|
|
310 #ifndef MULTIPLE_SYMBOL_SPACES
|
|
|
311 # define MULTIPLE_SYMBOL_SPACES 0
|
|
|
312 #endif
|
|
|
313
|
|
|
314 /* If the target supports init_priority C++ attribute, give
|
|
|
315 SUPPORTS_INIT_PRIORITY a nonzero value. */
|
|
|
316 #ifndef SUPPORTS_INIT_PRIORITY
|
|
|
317 #define SUPPORTS_INIT_PRIORITY 1
|
|
|
318 #endif /* SUPPORTS_INIT_PRIORITY */
|
|
|
319
|
|
|
320 /* If duplicate library search directories can be removed from a
|
|
|
321 linker command without changing the linker's semantics, give this
|
|
|
322 symbol a nonzero. */
|
|
|
323 #ifndef LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
|
|
|
324 #define LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 0
|
|
|
325 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
|
|
|
326
|
|
|
327 /* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that
|
|
|
328 the rest of the DWARF 2 frame unwind support is also provided. */
|
|
|
329 #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) \
|
|
|
330 && !defined (TARGET_UNWIND_INFO)
|
|
|
331 #define DWARF2_UNWIND_INFO 1
|
|
|
332 #endif
|
|
|
333
|
|
|
334 /* If we have named sections, and we're using crtstuff to run ctors,
|
|
|
335 use them for registering eh frame information. */
|
|
|
336 #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \
|
|
|
337 && !defined(EH_FRAME_IN_DATA_SECTION)
|
|
|
338 #ifndef EH_FRAME_SECTION_NAME
|
|
|
339 #define EH_FRAME_SECTION_NAME ".eh_frame"
|
|
|
340 #endif
|
|
|
341 #endif
|
|
|
342
|
|
|
343 /* On many systems, different EH table encodings are used under
|
|
|
344 difference circumstances. Some will require runtime relocations;
|
|
|
345 some will not. For those that do not require runtime relocations,
|
|
|
346 we would like to make the table read-only. However, since the
|
|
|
347 read-only tables may need to be combined with read-write tables
|
|
|
348 that do require runtime relocation, it is not safe to make the
|
|
|
349 tables read-only unless the linker will merge read-only and
|
|
|
350 read-write sections into a single read-write section. If your
|
|
|
351 linker does not have this ability, but your system is such that no
|
|
|
352 encoding used with non-PIC code will ever require a runtime
|
|
|
353 relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in
|
|
|
354 your target configuration file. */
|
|
|
355 #ifndef EH_TABLES_CAN_BE_READ_ONLY
|
|
|
356 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
|
|
|
357 #define EH_TABLES_CAN_BE_READ_ONLY 1
|
|
|
358 #else
|
|
|
359 #define EH_TABLES_CAN_BE_READ_ONLY 0
|
|
|
360 #endif
|
|
|
361 #endif
|
|
|
362
|
|
|
363 /* If we have named section and we support weak symbols, then use the
|
|
|
364 .jcr section for recording java classes which need to be registered
|
|
|
365 at program start-up time. */
|
|
|
366 #if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK
|
|
|
367 #ifndef JCR_SECTION_NAME
|
|
|
368 #define JCR_SECTION_NAME ".jcr"
|
|
|
369 #endif
|
|
|
370 #endif
|
|
|
371
|
|
|
372 /* This decision to use a .jcr section can be overridden by defining
|
|
|
373 USE_JCR_SECTION to 0 in target file. This is necessary if target
|
|
|
374 can define JCR_SECTION_NAME but does not have crtstuff or
|
|
|
375 linker support for .jcr section. */
|
|
|
376 #ifndef TARGET_USE_JCR_SECTION
|
|
|
377 #ifdef JCR_SECTION_NAME
|
|
|
378 #define TARGET_USE_JCR_SECTION 1
|
|
|
379 #else
|
|
|
380 #define TARGET_USE_JCR_SECTION 0
|
|
|
381 #endif
|
|
|
382 #endif
|
|
|
383
|
|
|
384 /* Number of hardware registers that go into the DWARF-2 unwind info.
|
|
|
385 If not defined, equals FIRST_PSEUDO_REGISTER */
|
|
|
386
|
|
|
387 #ifndef DWARF_FRAME_REGISTERS
|
|
|
388 #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER
|
|
|
389 #endif
|
|
|
390
|
|
|
391 /* How to renumber registers for dbx and gdb. If not defined, assume
|
|
|
392 no renumbering is necessary. */
|
|
|
393
|
|
|
394 #ifndef DBX_REGISTER_NUMBER
|
|
|
395 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
|
|
|
396 #endif
|
|
|
397
|
|
|
398 /* Default sizes for base C types. If the sizes are different for
|
|
|
399 your target, you should override these values by defining the
|
|
|
400 appropriate symbols in your tm.h file. */
|
|
|
401
|
|
|
402 #ifndef BITS_PER_UNIT
|
|
|
403 #define BITS_PER_UNIT 8
|
|
|
404 #endif
|
|
|
405
|
|
|
406 #ifndef BITS_PER_WORD
|
|
|
407 #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD)
|
|
|
408 #endif
|
|
|
409
|
|
|
410 #ifndef CHAR_TYPE_SIZE
|
|
|
411 #define CHAR_TYPE_SIZE BITS_PER_UNIT
|
|
|
412 #endif
|
|
|
413
|
|
|
414 #ifndef BOOL_TYPE_SIZE
|
|
|
415 /* `bool' has size and alignment `1', on almost all platforms. */
|
|
|
416 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
|
|
|
417 #endif
|
|
|
418
|
|
|
419 #ifndef SHORT_TYPE_SIZE
|
|
|
420 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
|
|
|
421 #endif
|
|
|
422
|
|
|
423 #ifndef INT_TYPE_SIZE
|
|
|
424 #define INT_TYPE_SIZE BITS_PER_WORD
|
|
|
425 #endif
|
|
|
426
|
|
|
427 #ifndef LONG_TYPE_SIZE
|
|
|
428 #define LONG_TYPE_SIZE BITS_PER_WORD
|
|
|
429 #endif
|
|
|
430
|
|
|
431 #ifndef LONG_LONG_TYPE_SIZE
|
|
|
432 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
|
|
|
433 #endif
|
|
|
434
|
|
|
435 #ifndef WCHAR_TYPE_SIZE
|
|
|
436 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
|
|
|
437 #endif
|
|
|
438
|
|
|
439 #ifndef FLOAT_TYPE_SIZE
|
|
|
440 #define FLOAT_TYPE_SIZE BITS_PER_WORD
|
|
|
441 #endif
|
|
|
442
|
|
|
443 #ifndef DOUBLE_TYPE_SIZE
|
|
|
444 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
|
|
|
445 #endif
|
|
|
446
|
|
|
447 #ifndef LONG_DOUBLE_TYPE_SIZE
|
|
|
448 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
|
|
|
449 #endif
|
|
|
450
|
|
|
451 #ifndef DECIMAL32_TYPE_SIZE
|
|
|
452 #define DECIMAL32_TYPE_SIZE 32
|
|
|
453 #endif
|
|
|
454
|
|
|
455 #ifndef DECIMAL64_TYPE_SIZE
|
|
|
456 #define DECIMAL64_TYPE_SIZE 64
|
|
|
457 #endif
|
|
|
458
|
|
|
459 #ifndef DECIMAL128_TYPE_SIZE
|
|
|
460 #define DECIMAL128_TYPE_SIZE 128
|
|
|
461 #endif
|
|
|
462
|
|
|
463 #ifndef SHORT_FRACT_TYPE_SIZE
|
|
|
464 #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT
|
|
|
465 #endif
|
|
|
466
|
|
|
467 #ifndef FRACT_TYPE_SIZE
|
|
|
468 #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2)
|
|
|
469 #endif
|
|
|
470
|
|
|
471 #ifndef LONG_FRACT_TYPE_SIZE
|
|
|
472 #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4)
|
|
|
473 #endif
|
|
|
474
|
|
|
475 #ifndef LONG_LONG_FRACT_TYPE_SIZE
|
|
|
476 #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8)
|
|
|
477 #endif
|
|
|
478
|
|
|
479 #ifndef SHORT_ACCUM_TYPE_SIZE
|
|
|
480 #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2)
|
|
|
481 #endif
|
|
|
482
|
|
|
483 #ifndef ACCUM_TYPE_SIZE
|
|
|
484 #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2)
|
|
|
485 #endif
|
|
|
486
|
|
|
487 #ifndef LONG_ACCUM_TYPE_SIZE
|
|
|
488 #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2)
|
|
|
489 #endif
|
|
|
490
|
|
|
491 #ifndef LONG_LONG_ACCUM_TYPE_SIZE
|
|
|
492 #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2)
|
|
|
493 #endif
|
|
|
494
|
|
|
495 /* Width in bits of a pointer. Mind the value of the macro `Pmode'. */
|
|
|
496 #ifndef POINTER_SIZE
|
|
|
497 #define POINTER_SIZE BITS_PER_WORD
|
|
|
498 #endif
|
|
|
499
|
|
|
500 #ifndef PIC_OFFSET_TABLE_REGNUM
|
|
|
501 #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM
|
|
|
502 #endif
|
|
|
503
|
|
|
504 #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES
|
|
|
505 #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0
|
|
|
506 #endif
|
|
|
507
|
|
|
508 #ifndef TARGET_DECLSPEC
|
|
|
509 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
|
|
|
510 /* If the target supports the "dllimport" attribute, users are
|
|
|
511 probably used to the "__declspec" syntax. */
|
|
|
512 #define TARGET_DECLSPEC 1
|
|
|
513 #else
|
|
|
514 #define TARGET_DECLSPEC 0
|
|
|
515 #endif
|
|
|
516 #endif
|
|
|
517
|
|
|
518 /* By default, the preprocessor should be invoked the same way in C++
|
|
|
519 as in C. */
|
|
|
520 #ifndef CPLUSPLUS_CPP_SPEC
|
|
|
521 #ifdef CPP_SPEC
|
|
|
522 #define CPLUSPLUS_CPP_SPEC CPP_SPEC
|
|
|
523 #endif
|
|
|
524 #endif
|
|
|
525
|
|
|
526 #ifndef ACCUMULATE_OUTGOING_ARGS
|
|
|
527 #define ACCUMULATE_OUTGOING_ARGS 0
|
|
|
528 #endif
|
|
|
529
|
|
|
530 /* Supply a default definition for PUSH_ARGS. */
|
|
|
531 #ifndef PUSH_ARGS
|
|
|
532 #ifdef PUSH_ROUNDING
|
|
|
533 #define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS
|
|
|
534 #else
|
|
|
535 #define PUSH_ARGS 0
|
|
|
536 #endif
|
|
|
537 #endif
|
|
|
538
|
|
|
539 /* Decide whether a function's arguments should be processed
|
|
|
540 from first to last or from last to first.
|
|
|
541
|
|
|
542 They should if the stack and args grow in opposite directions, but
|
|
|
543 only if we have push insns. */
|
|
|
544
|
|
|
545 #ifdef PUSH_ROUNDING
|
|
|
546
|
|
|
547 #ifndef PUSH_ARGS_REVERSED
|
|
|
548 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
|
|
|
549 #define PUSH_ARGS_REVERSED PUSH_ARGS
|
|
|
550 #endif
|
|
|
551 #endif
|
|
|
552
|
|
|
553 #endif
|
|
|
554
|
|
|
555 #ifndef PUSH_ARGS_REVERSED
|
|
|
556 #define PUSH_ARGS_REVERSED 0
|
|
|
557 #endif
|
|
|
558
|
|
|
559 /* Default value for the alignment (in bits) a C conformant malloc has to
|
|
|
560 provide. This default is intended to be safe and always correct. */
|
|
|
561 #ifndef MALLOC_ABI_ALIGNMENT
|
|
|
562 #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD
|
|
|
563 #endif
|
|
|
564
|
|
|
565 /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY.
|
|
|
566 STACK_BOUNDARY is required. */
|
|
|
567 #ifndef PREFERRED_STACK_BOUNDARY
|
|
|
568 #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
|
|
|
569 #endif
|
|
|
570
|
|
|
571 /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not
|
|
|
572 defined. */
|
|
|
573 #ifndef INCOMING_STACK_BOUNDARY
|
|
|
574 #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY
|
|
|
575 #endif
|
|
|
576
|
|
|
577 #ifndef TARGET_DEFAULT_PACK_STRUCT
|
|
|
578 #define TARGET_DEFAULT_PACK_STRUCT 0
|
|
|
579 #endif
|
|
|
580
|
|
|
581 /* By default, the C++ compiler will use function addresses in the
|
|
|
582 vtable entries. Setting this nonzero tells the compiler to use
|
|
|
583 function descriptors instead. The value of this macro says how
|
|
|
584 many words wide the descriptor is (normally 2). It is assumed
|
|
|
585 that the address of a function descriptor may be treated as a
|
|
|
586 pointer to a function. */
|
|
|
587 #ifndef TARGET_VTABLE_USES_DESCRIPTORS
|
|
|
588 #define TARGET_VTABLE_USES_DESCRIPTORS 0
|
|
|
589 #endif
|
|
|
590
|
|
|
591 /* By default, the vtable entries are void pointers, the so the alignment
|
|
|
592 is the same as pointer alignment. The value of this macro specifies
|
|
|
593 the alignment of the vtable entry in bits. It should be defined only
|
|
|
594 when special alignment is necessary. */
|
|
|
595 #ifndef TARGET_VTABLE_ENTRY_ALIGN
|
|
|
596 #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE
|
|
|
597 #endif
|
|
|
598
|
|
|
599 /* There are a few non-descriptor entries in the vtable at offsets below
|
|
|
600 zero. If these entries must be padded (say, to preserve the alignment
|
|
|
601 specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of
|
|
|
602 words in each data entry. */
|
|
|
603 #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE
|
|
|
604 #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1
|
|
|
605 #endif
|
|
|
606
|
|
|
607 /* Decide whether it is safe to use a local alias for a virtual function
|
|
|
608 when constructing thunks. */
|
|
|
609 #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P
|
|
|
610 #ifdef ASM_OUTPUT_DEF
|
|
|
611 #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1
|
|
|
612 #else
|
|
|
613 #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0
|
|
|
614 #endif
|
|
|
615 #endif
|
|
|
616
|
|
|
617 /* Select a format to encode pointers in exception handling data. We
|
|
|
618 prefer those that result in fewer dynamic relocations. Assume no
|
|
|
619 special support here and encode direct references. */
|
|
|
620 #ifndef ASM_PREFERRED_EH_DATA_FORMAT
|
|
|
621 #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr
|
|
|
622 #endif
|
|
|
623
|
|
|
624 /* By default, the C++ compiler will use the lowest bit of the pointer
|
|
|
625 to function to indicate a pointer-to-member-function points to a
|
|
|
626 virtual member function. However, if FUNCTION_BOUNDARY indicates
|
|
|
627 function addresses aren't always even, the lowest bit of the delta
|
|
|
628 field will be used. */
|
|
|
629 #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION
|
|
|
630 #define TARGET_PTRMEMFUNC_VBIT_LOCATION \
|
|
|
631 (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \
|
|
|
632 ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta)
|
|
|
633 #endif
|
|
|
634
|
|
|
635 #ifndef DEFAULT_GDB_EXTENSIONS
|
|
|
636 #define DEFAULT_GDB_EXTENSIONS 1
|
|
|
637 #endif
|
|
|
638
|
|
|
639 /* If more than one debugging type is supported, you must define
|
|
|
640 PREFERRED_DEBUGGING_TYPE to choose the default. */
|
|
|
641
|
|
|
642 #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \
|
|
|
643 + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \
|
|
|
644 + defined (VMS_DEBUGGING_INFO))
|
|
|
645 #ifndef PREFERRED_DEBUGGING_TYPE
|
|
|
646 #error You must define PREFERRED_DEBUGGING_TYPE
|
|
|
647 #endif /* no PREFERRED_DEBUGGING_TYPE */
|
|
|
648
|
|
|
649 /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE
|
|
|
650 here so other code needn't care. */
|
|
|
651 #elif defined DBX_DEBUGGING_INFO
|
|
|
652 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
|
|
|
653
|
|
|
654 #elif defined SDB_DEBUGGING_INFO
|
|
|
655 #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
|
|
|
656
|
|
|
657 #elif defined DWARF2_DEBUGGING_INFO
|
|
|
658 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
|
|
|
659
|
|
|
660 #elif defined VMS_DEBUGGING_INFO
|
|
|
661 #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
|
|
|
662
|
|
|
663 #elif defined XCOFF_DEBUGGING_INFO
|
|
|
664 #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
|
|
|
665
|
|
|
666 #else
|
|
|
667 /* No debugging format is supported by this target. */
|
|
|
668 #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
|
|
|
669 #endif
|
|
|
670
|
|
|
671 #ifndef LARGEST_EXPONENT_IS_NORMAL
|
|
|
672 #define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0
|
|
|
673 #endif
|
|
|
674
|
|
|
675 #ifndef ROUND_TOWARDS_ZERO
|
|
|
676 #define ROUND_TOWARDS_ZERO 0
|
|
|
677 #endif
|
|
|
678
|
|
|
679 #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL
|
|
|
680 #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false
|
|
|
681 #endif
|
|
|
682
|
|
|
683 /* True if the targets integer-comparison functions return { 0, 1, 2
|
|
|
684 } to indicate { <, ==, > }. False if { -1, 0, 1 } is used
|
|
|
685 instead. The libgcc routines are biased. */
|
|
|
686 #ifndef TARGET_LIB_INT_CMP_BIASED
|
|
|
687 #define TARGET_LIB_INT_CMP_BIASED (true)
|
|
|
688 #endif
|
|
|
689
|
|
|
690 /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files,
|
|
|
691 then the word-endianness is the same as for integers. */
|
|
|
692 #ifndef FLOAT_WORDS_BIG_ENDIAN
|
|
|
693 #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
|
|
|
694 #endif
|
|
|
695
|
|
|
696 #ifndef TARGET_FLT_EVAL_METHOD
|
|
|
697 #define TARGET_FLT_EVAL_METHOD 0
|
|
|
698 #endif
|
|
|
699
|
|
|
700 #ifndef TARGET_DEC_EVAL_METHOD
|
|
|
701 #define TARGET_DEC_EVAL_METHOD 2
|
|
|
702 #endif
|
|
|
703
|
|
|
704 #ifndef HOT_TEXT_SECTION_NAME
|
|
|
705 #define HOT_TEXT_SECTION_NAME ".text.hot"
|
|
|
706 #endif
|
|
|
707
|
|
|
708 #ifndef UNLIKELY_EXECUTED_TEXT_SECTION_NAME
|
|
|
709 #define UNLIKELY_EXECUTED_TEXT_SECTION_NAME ".text.unlikely"
|
|
|
710 #endif
|
|
|
711
|
|
|
712 #ifndef HAS_LONG_COND_BRANCH
|
|
|
713 #define HAS_LONG_COND_BRANCH 0
|
|
|
714 #endif
|
|
|
715
|
|
|
716 #ifndef HAS_LONG_UNCOND_BRANCH
|
|
|
717 #define HAS_LONG_UNCOND_BRANCH 0
|
|
|
718 #endif
|
|
|
719
|
|
|
720 /* By default, only attempt to parallelize bitwise operations, and
|
|
|
721 possibly adds/subtracts using bit-twiddling. */
|
|
|
722 #ifndef UNITS_PER_SIMD_WORD
|
|
|
723 #define UNITS_PER_SIMD_WORD(MODE) UNITS_PER_WORD
|
|
|
724 #endif
|
|
|
725
|
|
|
726 /* Determine whether __cxa_atexit, rather than atexit, is used to
|
|
|
727 register C++ destructors for local statics and global objects. */
|
|
|
728 #ifndef DEFAULT_USE_CXA_ATEXIT
|
|
|
729 #define DEFAULT_USE_CXA_ATEXIT 0
|
|
|
730 #endif
|
|
|
731
|
|
|
732 /* If none of these macros are defined, the port must use the new
|
|
|
733 technique of defining constraints in the machine description.
|
|
|
734 tm_p.h will define those macros that machine-independent code
|
|
|
735 still uses. */
|
|
|
736 #if !defined CONSTRAINT_LEN \
|
|
|
737 && !defined REG_CLASS_FROM_LETTER \
|
|
|
738 && !defined REG_CLASS_FROM_CONSTRAINT \
|
|
|
739 && !defined CONST_OK_FOR_LETTER_P \
|
|
|
740 && !defined CONST_OK_FOR_CONSTRAINT_P \
|
|
|
741 && !defined CONST_DOUBLE_OK_FOR_LETTER_P \
|
|
|
742 && !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P \
|
|
|
743 && !defined EXTRA_CONSTRAINT \
|
|
|
744 && !defined EXTRA_CONSTRAINT_STR \
|
|
|
745 && !defined EXTRA_MEMORY_CONSTRAINT \
|
|
|
746 && !defined EXTRA_ADDRESS_CONSTRAINT
|
|
|
747
|
|
|
748 #define USE_MD_CONSTRAINTS
|
|
|
749
|
|
|
750 #if GCC_VERSION >= 3000 && defined IN_GCC
|
|
|
751 /* These old constraint macros shouldn't appear anywhere in a
|
|
|
752 configuration using MD constraint definitions. */
|
|
|
753 #pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \
|
|
|
754 CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT
|
|
|
755 #endif
|
|
|
756
|
|
|
757 #else /* old constraint mechanism in use */
|
|
|
758
|
|
|
759 /* Determine whether extra constraint letter should be handled
|
|
|
760 via address reload (like 'o'). */
|
|
|
761 #ifndef EXTRA_MEMORY_CONSTRAINT
|
|
|
762 #define EXTRA_MEMORY_CONSTRAINT(C,STR) 0
|
|
|
763 #endif
|
|
|
764
|
|
|
765 /* Determine whether extra constraint letter should be handled
|
|
|
766 as an address (like 'p'). */
|
|
|
767 #ifndef EXTRA_ADDRESS_CONSTRAINT
|
|
|
768 #define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0
|
|
|
769 #endif
|
|
|
770
|
|
|
771 /* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN
|
|
|
772 for all the characters that it does not want to change, so things like the
|
|
|
773 'length' of a digit in a matching constraint is an implementation detail,
|
|
|
774 and not part of the interface. */
|
|
|
775 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
|
|
|
776
|
|
|
777 #ifndef CONSTRAINT_LEN
|
|
|
778 #define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR)
|
|
|
779 #endif
|
|
|
780
|
|
|
781 #if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P)
|
|
|
782 #define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C)
|
|
|
783 #endif
|
|
|
784
|
|
|
785 #if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P)
|
|
|
786 #define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \
|
|
|
787 CONST_DOUBLE_OK_FOR_LETTER_P (OP, C)
|
|
|
788 #endif
|
|
|
789
|
|
|
790 #ifndef REG_CLASS_FROM_CONSTRAINT
|
|
|
791 #define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C)
|
|
|
792 #endif
|
|
|
793
|
|
|
794 #if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR)
|
|
|
795 #define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C)
|
|
|
796 #endif
|
|
|
797
|
|
|
798 #endif /* old constraint mechanism in use */
|
|
|
799
|
|
|
800 #ifndef REGISTER_MOVE_COST
|
|
|
801 #define REGISTER_MOVE_COST(m, x, y) 2
|
|
|
802 #endif
|
|
|
803
|
|
|
804 /* Determine whether the entire c99 runtime
|
|
|
805 is present in the runtime library. */
|
|
|
806 #ifndef TARGET_C99_FUNCTIONS
|
|
|
807 #define TARGET_C99_FUNCTIONS 0
|
|
|
808 #endif
|
|
|
809
|
|
|
810 /* Determine whether the target runtime library has
|
|
|
811 a sincos implementation following the GNU extension. */
|
|
|
812 #ifndef TARGET_HAS_SINCOS
|
|
|
813 #define TARGET_HAS_SINCOS 0
|
|
|
814 #endif
|
|
|
815
|
|
|
816 /* Indicate that CLZ and CTZ are undefined at zero. */
|
|
|
817 #ifndef CLZ_DEFINED_VALUE_AT_ZERO
|
|
|
818 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0
|
|
|
819 #endif
|
|
|
820 #ifndef CTZ_DEFINED_VALUE_AT_ZERO
|
|
|
821 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0
|
|
|
822 #endif
|
|
|
823
|
|
|
824 /* Provide a default value for STORE_FLAG_VALUE. */
|
|
|
825 #ifndef STORE_FLAG_VALUE
|
|
|
826 #define STORE_FLAG_VALUE 1
|
|
|
827 #endif
|
|
|
828
|
|
|
829 /* This macro is used to determine what the largest unit size that
|
|
|
830 move_by_pieces can use is. */
|
|
|
831
|
|
|
832 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
|
|
|
833 move efficiently, as opposed to MOVE_MAX which is the maximum
|
|
|
834 number of bytes we can move with a single instruction. */
|
|
|
835
|
|
|
836 #ifndef MOVE_MAX_PIECES
|
|
|
837 #define MOVE_MAX_PIECES MOVE_MAX
|
|
|
838 #endif
|
|
|
839
|
|
|
840 #ifndef STACK_POINTER_OFFSET
|
|
|
841 #define STACK_POINTER_OFFSET 0
|
|
|
842 #endif
|
|
|
843
|
|
|
844 #ifndef LOCAL_REGNO
|
|
|
845 #define LOCAL_REGNO(REGNO) 0
|
|
|
846 #endif
|
|
|
847
|
|
|
848 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
|
|
|
849 the stack pointer does not matter. The value is tested only in
|
|
|
850 functions that have frame pointers. */
|
|
|
851 #ifndef EXIT_IGNORE_STACK
|
|
|
852 #define EXIT_IGNORE_STACK 0
|
|
|
853 #endif
|
|
|
854
|
|
|
855 /* Assume that case vectors are not pc-relative. */
|
|
|
856 #ifndef CASE_VECTOR_PC_RELATIVE
|
|
|
857 #define CASE_VECTOR_PC_RELATIVE 0
|
|
|
858 #endif
|
|
|
859
|
|
|
860 /* Assume that trampolines need function alignment. */
|
|
|
861 #ifndef TRAMPOLINE_ALIGNMENT
|
|
|
862 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
|
|
|
863 #endif
|
|
|
864
|
|
|
865 /* Register mappings for target machines without register windows. */
|
|
|
866 #ifndef INCOMING_REGNO
|
|
|
867 #define INCOMING_REGNO(N) (N)
|
|
|
868 #endif
|
|
|
869
|
|
|
870 #ifndef OUTGOING_REGNO
|
|
|
871 #define OUTGOING_REGNO(N) (N)
|
|
|
872 #endif
|
|
|
873
|
|
|
874 #ifndef SHIFT_COUNT_TRUNCATED
|
|
|
875 #define SHIFT_COUNT_TRUNCATED 0
|
|
|
876 #endif
|
|
|
877
|
|
|
878 #ifndef LEGITIMIZE_ADDRESS
|
|
|
879 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)
|
|
|
880 #endif
|
|
|
881
|
|
|
882 #ifndef LEGITIMATE_PIC_OPERAND_P
|
|
|
883 #define LEGITIMATE_PIC_OPERAND_P(X) 1
|
|
|
884 #endif
|
|
|
885
|
|
|
886 #ifndef TARGET_MEM_CONSTRAINT
|
|
|
887 #define TARGET_MEM_CONSTRAINT 'm'
|
|
|
888 #endif
|
|
|
889
|
|
|
890 #ifndef REVERSIBLE_CC_MODE
|
|
|
891 #define REVERSIBLE_CC_MODE(MODE) 0
|
|
|
892 #endif
|
|
|
893
|
|
|
894 /* Biggest alignment supported by the object file format of this machine. */
|
|
|
895 #ifndef MAX_OFILE_ALIGNMENT
|
|
|
896 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
|
|
|
897 #endif
|
|
|
898
|
|
|
899 #ifndef FRAME_GROWS_DOWNWARD
|
|
|
900 #define FRAME_GROWS_DOWNWARD 0
|
|
|
901 #endif
|
|
|
902
|
|
|
903 /* On most machines, the CFA coincides with the first incoming parm. */
|
|
|
904 #ifndef ARG_POINTER_CFA_OFFSET
|
|
|
905 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL)
|
|
|
906 #endif
|
|
|
907
|
|
|
908 /* On most machines, we use the CFA as DW_AT_frame_base. */
|
|
|
909 #ifndef CFA_FRAME_BASE_OFFSET
|
|
|
910 #define CFA_FRAME_BASE_OFFSET(FNDECL) 0
|
|
|
911 #endif
|
|
|
912
|
|
|
913 /* The offset from the incoming value of %sp to the top of the stack frame
|
|
|
914 for the current function. */
|
|
|
915 #ifndef INCOMING_FRAME_SP_OFFSET
|
|
|
916 #define INCOMING_FRAME_SP_OFFSET 0
|
|
|
917 #endif
|
|
|
918
|
|
|
919 #ifndef HARD_REGNO_NREGS_HAS_PADDING
|
|
|
920 #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0
|
|
|
921 #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1
|
|
|
922 #endif
|
|
|
923
|
|
|
924 #ifndef OUTGOING_REG_PARM_STACK_SPACE
|
|
|
925 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0
|
|
|
926 #endif
|
|
|
927
|
|
|
928 /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by
|
|
|
929 the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best
|
|
|
930 effort stack alignment supported by the backend. If the backend
|
|
|
931 supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and
|
|
|
932 MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack
|
|
|
933 boundary will limit the maximum guaranteed stack alignment. */
|
|
|
934 #ifdef MAX_STACK_ALIGNMENT
|
|
|
935 #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT
|
|
|
936 #else
|
|
|
937 #define MAX_STACK_ALIGNMENT STACK_BOUNDARY
|
|
|
938 #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY
|
|
|
939 #endif
|
|
|
940
|
|
|
941 #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY)
|
|
|
942
|
|
|
943 #ifndef LOCAL_ALIGNMENT
|
|
|
944 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
|
|
|
945 #endif
|
|
|
946
|
|
|
947 #ifndef STACK_SLOT_ALIGNMENT
|
|
|
948 #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \
|
|
|
949 ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN))
|
|
|
950 #endif
|
|
|
951
|
|
|
952 #ifndef LOCAL_DECL_ALIGNMENT
|
|
|
953 #define LOCAL_DECL_ALIGNMENT(DECL) \
|
|
|
954 LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL))
|
|
|
955 #endif
|
|
|
956
|
|
|
957 /* Alignment value for attribute ((aligned)). */
|
|
|
958 #ifndef ATTRIBUTE_ALIGNED_VALUE
|
|
|
959 #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT
|
|
|
960 #endif
|
|
|
961
|
|
|
962 #endif /* ! GCC_DEFAULTS_H */
|
