OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [lib/] [gcc/] [or1knd-elf/] [4.8.0/] [plugin/] [include/] [defaults.h] - Blame information for rev 35

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.