0,0 → 1,1168 |
/* Definitions of various defaults for tm.h macros. |
Copyright (C) 1992, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
2005, 2007, 2008, 2009, 2010 |
Free Software Foundation, Inc. |
Contributed by Ron Guilmette (rfg@monkeys.com) |
|
This file is part of GCC. |
|
GCC is free software; you can redistribute it and/or modify it under |
the terms of the GNU General Public License as published by the Free |
Software Foundation; either version 3, or (at your option) any later |
version. |
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
WARRANTY; without even the implied warranty of MERCHANTABILITY or |
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
for more details. |
|
Under Section 7 of GPL version 3, you are granted additional |
permissions described in the GCC Runtime Library Exception, version |
3.1, as published by the Free Software Foundation. |
|
You should have received a copy of the GNU General Public License and |
a copy of the GCC Runtime Library Exception along with this program; |
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
<http://www.gnu.org/licenses/>. */ |
|
#ifndef GCC_DEFAULTS_H |
#define GCC_DEFAULTS_H |
|
#ifndef GET_ENVIRONMENT |
#define GET_ENVIRONMENT(VALUE, NAME) do { (VALUE) = getenv (NAME); } while (0) |
#endif |
|
#define obstack_chunk_alloc ((void *(*) (long)) xmalloc) |
#define obstack_chunk_free ((void (*) (void *)) free) |
#define OBSTACK_CHUNK_SIZE 0 |
#define gcc_obstack_init(OBSTACK) \ |
_obstack_begin ((OBSTACK), OBSTACK_CHUNK_SIZE, 0, \ |
obstack_chunk_alloc, \ |
obstack_chunk_free) |
|
/* Store in OUTPUT a string (made with alloca) containing an |
assembler-name for a local static variable or function named NAME. |
LABELNO is an integer which is different for each call. */ |
|
#ifndef ASM_PN_FORMAT |
# ifndef NO_DOT_IN_LABEL |
# define ASM_PN_FORMAT "%s.%lu" |
# else |
# ifndef NO_DOLLAR_IN_LABEL |
# define ASM_PN_FORMAT "%s$%lu" |
# else |
# define ASM_PN_FORMAT "__%s_%lu" |
# endif |
# endif |
#endif /* ! ASM_PN_FORMAT */ |
|
#ifndef ASM_FORMAT_PRIVATE_NAME |
# define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ |
do { const char *const name_ = (NAME); \ |
char *const output_ = (OUTPUT) = \ |
(char *) alloca (strlen (name_) + 32); \ |
sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \ |
} while (0) |
#endif |
|
/* Choose a reasonable default for ASM_OUTPUT_ASCII. */ |
|
#ifndef ASM_OUTPUT_ASCII |
#define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ |
do { \ |
FILE *_hide_asm_out_file = (MYFILE); \ |
const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \ |
int _hide_thissize = (MYLENGTH); \ |
{ \ |
FILE *asm_out_file = _hide_asm_out_file; \ |
const unsigned char *p = _hide_p; \ |
int thissize = _hide_thissize; \ |
int i; \ |
fprintf (asm_out_file, "\t.ascii \""); \ |
\ |
for (i = 0; i < thissize; i++) \ |
{ \ |
int c = p[i]; \ |
if (c == '\"' || c == '\\') \ |
putc ('\\', asm_out_file); \ |
if (ISPRINT(c)) \ |
putc (c, asm_out_file); \ |
else \ |
{ \ |
fprintf (asm_out_file, "\\%o", c); \ |
/* After an octal-escape, if a digit follows, \ |
terminate one string constant and start another. \ |
The VAX assembler fails to stop reading the escape \ |
after three digits, so this is the only way we \ |
can get it to parse the data properly. */ \ |
if (i < thissize - 1 && ISDIGIT(p[i + 1])) \ |
fprintf (asm_out_file, "\"\n\t.ascii \""); \ |
} \ |
} \ |
fprintf (asm_out_file, "\"\n"); \ |
} \ |
} \ |
while (0) |
#endif |
|
/* This is how we tell the assembler to equate two values. */ |
#ifdef SET_ASM_OP |
#ifndef ASM_OUTPUT_DEF |
#define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \ |
do { fprintf ((FILE), "%s", SET_ASM_OP); \ |
assemble_name (FILE, LABEL1); \ |
fprintf (FILE, ","); \ |
assemble_name (FILE, LABEL2); \ |
fprintf (FILE, "\n"); \ |
} while (0) |
#endif |
#endif |
|
#ifndef TLS_COMMON_ASM_OP |
#define TLS_COMMON_ASM_OP ".tls_common" |
#endif |
|
#if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON) |
#define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) \ |
do \ |
{ \ |
fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP); \ |
assemble_name ((FILE), (NAME)); \ |
fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ |
(SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \ |
} \ |
while (0) |
#endif |
|
/* Decide whether to defer emitting the assembler output for an equate |
of two values. The default is to not defer output. */ |
#ifndef TARGET_DEFERRED_OUTPUT_DEFS |
#define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false |
#endif |
|
/* This is how to output the definition of a user-level label named |
NAME, such as the label on a static function or variable NAME. */ |
|
#ifndef ASM_OUTPUT_LABEL |
#define ASM_OUTPUT_LABEL(FILE,NAME) \ |
do { assemble_name ((FILE), (NAME)); fputs (":\n", (FILE)); } while (0) |
#endif |
|
/* Output the definition of a compiler-generated label named NAME. */ |
#ifndef ASM_OUTPUT_INTERNAL_LABEL |
#define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME) \ |
do { \ |
assemble_name_raw ((FILE), (NAME)); \ |
fputs (":\n", (FILE)); \ |
} while (0) |
#endif |
|
/* This is how to output a reference to a user-level label named NAME. */ |
|
#ifndef ASM_OUTPUT_LABELREF |
#define ASM_OUTPUT_LABELREF(FILE,NAME) asm_fprintf ((FILE), "%U%s", (NAME)) |
#endif |
|
/* Allow target to print debug info labels specially. This is useful for |
VLIW targets, since debug info labels should go into the middle of |
instruction bundles instead of breaking them. */ |
|
#ifndef ASM_OUTPUT_DEBUG_LABEL |
#define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \ |
(*targetm.asm_out.internal_label) (FILE, PREFIX, NUM) |
#endif |
|
/* This is how we tell the assembler that a symbol is weak. */ |
#ifndef ASM_OUTPUT_WEAK_ALIAS |
#if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF) |
#define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE) \ |
do \ |
{ \ |
ASM_WEAKEN_LABEL (STREAM, NAME); \ |
if (VALUE) \ |
ASM_OUTPUT_DEF (STREAM, NAME, VALUE); \ |
} \ |
while (0) |
#endif |
#endif |
|
/* This is how we tell the assembler that a symbol is a weak alias to |
another symbol that doesn't require the other symbol to be defined. |
Uses of the former will turn into weak uses of the latter, i.e., |
uses that, in case the latter is undefined, will not cause errors, |
and will add it to the symbol table as weak undefined. However, if |
the latter is referenced directly, a strong reference prevails. */ |
#ifndef ASM_OUTPUT_WEAKREF |
#if defined HAVE_GAS_WEAKREF |
#define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \ |
do \ |
{ \ |
fprintf ((FILE), "\t.weakref\t"); \ |
assemble_name ((FILE), (NAME)); \ |
fprintf ((FILE), ","); \ |
assemble_name ((FILE), (VALUE)); \ |
fprintf ((FILE), "\n"); \ |
} \ |
while (0) |
#endif |
#endif |
|
/* How to emit a .type directive. */ |
#ifndef ASM_OUTPUT_TYPE_DIRECTIVE |
#if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT |
#define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE) \ |
do \ |
{ \ |
fputs (TYPE_ASM_OP, STREAM); \ |
assemble_name (STREAM, NAME); \ |
fputs (", ", STREAM); \ |
fprintf (STREAM, TYPE_OPERAND_FMT, TYPE); \ |
putc ('\n', STREAM); \ |
} \ |
while (0) |
#endif |
#endif |
|
/* How to emit a .size directive. */ |
#ifndef ASM_OUTPUT_SIZE_DIRECTIVE |
#ifdef SIZE_ASM_OP |
#define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE) \ |
do \ |
{ \ |
HOST_WIDE_INT size_ = (SIZE); \ |
fputs (SIZE_ASM_OP, STREAM); \ |
assemble_name (STREAM, NAME); \ |
fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \ |
} \ |
while (0) |
|
#define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \ |
do \ |
{ \ |
fputs (SIZE_ASM_OP, STREAM); \ |
assemble_name (STREAM, NAME); \ |
fputs (", .-", STREAM); \ |
assemble_name (STREAM, NAME); \ |
putc ('\n', STREAM); \ |
} \ |
while (0) |
|
#endif |
#endif |
|
/* This determines whether or not we support weak symbols. */ |
#ifndef SUPPORTS_WEAK |
#if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) |
#define SUPPORTS_WEAK 1 |
#else |
#define SUPPORTS_WEAK 0 |
#endif |
#endif |
|
/* This determines whether or not we support the discriminator |
attribute in the .loc directive. */ |
#ifndef SUPPORTS_DISCRIMINATOR |
#ifdef HAVE_GAS_DISCRIMINATOR |
#define SUPPORTS_DISCRIMINATOR 1 |
#else |
#define SUPPORTS_DISCRIMINATOR 0 |
#endif |
#endif |
|
/* This determines whether or not we support link-once semantics. */ |
#ifndef SUPPORTS_ONE_ONLY |
#ifdef MAKE_DECL_ONE_ONLY |
#define SUPPORTS_ONE_ONLY 1 |
#else |
#define SUPPORTS_ONE_ONLY 0 |
#endif |
#endif |
|
/* This determines whether weak symbols must be left out of a static |
archive's table of contents. Defining this macro to be nonzero has |
the consequence that certain symbols will not be made weak that |
otherwise would be. The C++ ABI requires this macro to be zero; |
see the documentation. */ |
#ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC |
#define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0 |
#endif |
|
/* This determines whether or not we need linkonce unwind information. */ |
#ifndef TARGET_USES_WEAK_UNWIND_INFO |
#define TARGET_USES_WEAK_UNWIND_INFO 0 |
#endif |
|
/* By default, there is no prefix on user-defined symbols. */ |
#ifndef USER_LABEL_PREFIX |
#define USER_LABEL_PREFIX "" |
#endif |
|
/* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to |
provide a weak attribute. Else define it to nothing. |
|
This would normally belong in ansidecl.h, but SUPPORTS_WEAK is |
not available at that time. |
|
Note, this is only for use by target files which we know are to be |
compiled by GCC. */ |
#ifndef TARGET_ATTRIBUTE_WEAK |
# if SUPPORTS_WEAK |
# define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak)) |
# else |
# define TARGET_ATTRIBUTE_WEAK |
# endif |
#endif |
|
/* Determines whether we may use common symbols to represent one-only |
semantics (a.k.a. "vague linkage"). */ |
#ifndef USE_COMMON_FOR_ONE_ONLY |
# define USE_COMMON_FOR_ONE_ONLY 1 |
#endif |
|
/* By default we can assume that all global symbols are in one namespace, |
across all shared libraries. */ |
#ifndef MULTIPLE_SYMBOL_SPACES |
# define MULTIPLE_SYMBOL_SPACES 0 |
#endif |
|
/* If the target supports init_priority C++ attribute, give |
SUPPORTS_INIT_PRIORITY a nonzero value. */ |
#ifndef SUPPORTS_INIT_PRIORITY |
#define SUPPORTS_INIT_PRIORITY 1 |
#endif /* SUPPORTS_INIT_PRIORITY */ |
|
/* If duplicate library search directories can be removed from a |
linker command without changing the linker's semantics, give this |
symbol a nonzero. */ |
#ifndef LINK_ELIMINATE_DUPLICATE_LDIRECTORIES |
#define LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 0 |
#endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */ |
|
/* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that |
the rest of the DWARF 2 frame unwind support is also provided. */ |
#if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) \ |
&& !defined (TARGET_UNWIND_INFO) |
#define DWARF2_UNWIND_INFO 1 |
#endif |
|
/* If we have named sections, and we're using crtstuff to run ctors, |
use them for registering eh frame information. */ |
#if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ |
&& !defined(EH_FRAME_IN_DATA_SECTION) |
#ifndef EH_FRAME_SECTION_NAME |
#define EH_FRAME_SECTION_NAME ".eh_frame" |
#endif |
#endif |
|
/* On many systems, different EH table encodings are used under |
difference circumstances. Some will require runtime relocations; |
some will not. For those that do not require runtime relocations, |
we would like to make the table read-only. However, since the |
read-only tables may need to be combined with read-write tables |
that do require runtime relocation, it is not safe to make the |
tables read-only unless the linker will merge read-only and |
read-write sections into a single read-write section. If your |
linker does not have this ability, but your system is such that no |
encoding used with non-PIC code will ever require a runtime |
relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in |
your target configuration file. */ |
#ifndef EH_TABLES_CAN_BE_READ_ONLY |
#ifdef HAVE_LD_RO_RW_SECTION_MIXING |
#define EH_TABLES_CAN_BE_READ_ONLY 1 |
#else |
#define EH_TABLES_CAN_BE_READ_ONLY 0 |
#endif |
#endif |
|
/* If we have named section and we support weak symbols, then use the |
.jcr section for recording java classes which need to be registered |
at program start-up time. */ |
#if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK |
#ifndef JCR_SECTION_NAME |
#define JCR_SECTION_NAME ".jcr" |
#endif |
#endif |
|
/* This decision to use a .jcr section can be overridden by defining |
USE_JCR_SECTION to 0 in target file. This is necessary if target |
can define JCR_SECTION_NAME but does not have crtstuff or |
linker support for .jcr section. */ |
#ifndef TARGET_USE_JCR_SECTION |
#ifdef JCR_SECTION_NAME |
#define TARGET_USE_JCR_SECTION 1 |
#else |
#define TARGET_USE_JCR_SECTION 0 |
#endif |
#endif |
|
/* Number of hardware registers that go into the DWARF-2 unwind info. |
If not defined, equals FIRST_PSEUDO_REGISTER */ |
|
#ifndef DWARF_FRAME_REGISTERS |
#define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER |
#endif |
|
/* How to renumber registers for dbx and gdb. If not defined, assume |
no renumbering is necessary. */ |
|
#ifndef DBX_REGISTER_NUMBER |
#define DBX_REGISTER_NUMBER(REGNO) (REGNO) |
#endif |
|
/* Default sizes for base C types. If the sizes are different for |
your target, you should override these values by defining the |
appropriate symbols in your tm.h file. */ |
|
#ifndef BITS_PER_UNIT |
#define BITS_PER_UNIT 8 |
#endif |
|
#ifndef BITS_PER_WORD |
#define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD) |
#endif |
|
#ifndef CHAR_TYPE_SIZE |
#define CHAR_TYPE_SIZE BITS_PER_UNIT |
#endif |
|
#ifndef BOOL_TYPE_SIZE |
/* `bool' has size and alignment `1', on almost all platforms. */ |
#define BOOL_TYPE_SIZE CHAR_TYPE_SIZE |
#endif |
|
#ifndef SHORT_TYPE_SIZE |
#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) |
#endif |
|
#ifndef INT_TYPE_SIZE |
#define INT_TYPE_SIZE BITS_PER_WORD |
#endif |
|
#ifndef LONG_TYPE_SIZE |
#define LONG_TYPE_SIZE BITS_PER_WORD |
#endif |
|
#ifndef LONG_LONG_TYPE_SIZE |
#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) |
#endif |
|
#ifndef WCHAR_TYPE_SIZE |
#define WCHAR_TYPE_SIZE INT_TYPE_SIZE |
#endif |
|
#ifndef FLOAT_TYPE_SIZE |
#define FLOAT_TYPE_SIZE BITS_PER_WORD |
#endif |
|
#ifndef DOUBLE_TYPE_SIZE |
#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) |
#endif |
|
#ifndef LONG_DOUBLE_TYPE_SIZE |
#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) |
#endif |
|
#ifndef DECIMAL32_TYPE_SIZE |
#define DECIMAL32_TYPE_SIZE 32 |
#endif |
|
#ifndef DECIMAL64_TYPE_SIZE |
#define DECIMAL64_TYPE_SIZE 64 |
#endif |
|
#ifndef DECIMAL128_TYPE_SIZE |
#define DECIMAL128_TYPE_SIZE 128 |
#endif |
|
#ifndef SHORT_FRACT_TYPE_SIZE |
#define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT |
#endif |
|
#ifndef FRACT_TYPE_SIZE |
#define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2) |
#endif |
|
#ifndef LONG_FRACT_TYPE_SIZE |
#define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4) |
#endif |
|
#ifndef LONG_LONG_FRACT_TYPE_SIZE |
#define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8) |
#endif |
|
#ifndef SHORT_ACCUM_TYPE_SIZE |
#define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2) |
#endif |
|
#ifndef ACCUM_TYPE_SIZE |
#define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2) |
#endif |
|
#ifndef LONG_ACCUM_TYPE_SIZE |
#define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2) |
#endif |
|
#ifndef LONG_LONG_ACCUM_TYPE_SIZE |
#define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2) |
#endif |
|
/* We let tm.h override the types used here, to handle trivial differences |
such as the choice of unsigned int or long unsigned int for size_t. |
When machines start needing nontrivial differences in the size type, |
it would be best to do something here to figure out automatically |
from other information what type to use. */ |
|
#ifndef SIZE_TYPE |
#define SIZE_TYPE "long unsigned int" |
#endif |
|
#ifndef PID_TYPE |
#define PID_TYPE "int" |
#endif |
|
/* If GCC knows the exact uint_least16_t and uint_least32_t types from |
<stdint.h>, use them for char16_t and char32_t. Otherwise, use |
these guesses; getting the wrong type of a given width will not |
affect C++ name mangling because in C++ these are distinct types |
not typedefs. */ |
|
#ifdef UINT_LEAST16_TYPE |
#define CHAR16_TYPE UINT_LEAST16_TYPE |
#else |
#define CHAR16_TYPE "short unsigned int" |
#endif |
|
#ifdef UINT_LEAST32_TYPE |
#define CHAR32_TYPE UINT_LEAST32_TYPE |
#else |
#define CHAR32_TYPE "unsigned int" |
#endif |
|
#ifndef WCHAR_TYPE |
#define WCHAR_TYPE "int" |
#endif |
|
/* WCHAR_TYPE gets overridden by -fshort-wchar. */ |
#define MODIFIED_WCHAR_TYPE \ |
(flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) |
|
#ifndef PTRDIFF_TYPE |
#define PTRDIFF_TYPE "long int" |
#endif |
|
#ifndef WINT_TYPE |
#define WINT_TYPE "unsigned int" |
#endif |
|
#ifndef INTMAX_TYPE |
#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
? "int" \ |
: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
? "long int" \ |
: "long long int")) |
#endif |
|
#ifndef UINTMAX_TYPE |
#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
? "unsigned int" \ |
: ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
? "long unsigned int" \ |
: "long long unsigned int")) |
#endif |
|
|
/* There are no default definitions of these <stdint.h> types. */ |
|
#ifndef SIG_ATOMIC_TYPE |
#define SIG_ATOMIC_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT8_TYPE |
#define INT8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT16_TYPE |
#define INT16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT32_TYPE |
#define INT32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT64_TYPE |
#define INT64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT8_TYPE |
#define UINT8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT16_TYPE |
#define UINT16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT32_TYPE |
#define UINT32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT64_TYPE |
#define UINT64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_LEAST8_TYPE |
#define INT_LEAST8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_LEAST16_TYPE |
#define INT_LEAST16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_LEAST32_TYPE |
#define INT_LEAST32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_LEAST64_TYPE |
#define INT_LEAST64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_LEAST8_TYPE |
#define UINT_LEAST8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_LEAST16_TYPE |
#define UINT_LEAST16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_LEAST32_TYPE |
#define UINT_LEAST32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_LEAST64_TYPE |
#define UINT_LEAST64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_FAST8_TYPE |
#define INT_FAST8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_FAST16_TYPE |
#define INT_FAST16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_FAST32_TYPE |
#define INT_FAST32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INT_FAST64_TYPE |
#define INT_FAST64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_FAST8_TYPE |
#define UINT_FAST8_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_FAST16_TYPE |
#define UINT_FAST16_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_FAST32_TYPE |
#define UINT_FAST32_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINT_FAST64_TYPE |
#define UINT_FAST64_TYPE ((const char *) NULL) |
#endif |
|
#ifndef INTPTR_TYPE |
#define INTPTR_TYPE ((const char *) NULL) |
#endif |
|
#ifndef UINTPTR_TYPE |
#define UINTPTR_TYPE ((const char *) NULL) |
#endif |
|
/* Width in bits of a pointer. Mind the value of the macro `Pmode'. */ |
#ifndef POINTER_SIZE |
#define POINTER_SIZE BITS_PER_WORD |
#endif |
|
#ifndef PIC_OFFSET_TABLE_REGNUM |
#define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM |
#endif |
|
#ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES |
#define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0 |
#endif |
|
#ifndef TARGET_DECLSPEC |
#if TARGET_DLLIMPORT_DECL_ATTRIBUTES |
/* If the target supports the "dllimport" attribute, users are |
probably used to the "__declspec" syntax. */ |
#define TARGET_DECLSPEC 1 |
#else |
#define TARGET_DECLSPEC 0 |
#endif |
#endif |
|
/* By default, the preprocessor should be invoked the same way in C++ |
as in C. */ |
#ifndef CPLUSPLUS_CPP_SPEC |
#ifdef CPP_SPEC |
#define CPLUSPLUS_CPP_SPEC CPP_SPEC |
#endif |
#endif |
|
#ifndef ACCUMULATE_OUTGOING_ARGS |
#define ACCUMULATE_OUTGOING_ARGS 0 |
#endif |
|
/* Supply a default definition for PUSH_ARGS. */ |
#ifndef PUSH_ARGS |
#ifdef PUSH_ROUNDING |
#define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS |
#else |
#define PUSH_ARGS 0 |
#endif |
#endif |
|
/* Decide whether a function's arguments should be processed |
from first to last or from last to first. |
|
They should if the stack and args grow in opposite directions, but |
only if we have push insns. */ |
|
#ifdef PUSH_ROUNDING |
|
#ifndef PUSH_ARGS_REVERSED |
#if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) |
#define PUSH_ARGS_REVERSED PUSH_ARGS |
#endif |
#endif |
|
#endif |
|
#ifndef PUSH_ARGS_REVERSED |
#define PUSH_ARGS_REVERSED 0 |
#endif |
|
/* Default value for the alignment (in bits) a C conformant malloc has to |
provide. This default is intended to be safe and always correct. */ |
#ifndef MALLOC_ABI_ALIGNMENT |
#define MALLOC_ABI_ALIGNMENT BITS_PER_WORD |
#endif |
|
/* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY. |
STACK_BOUNDARY is required. */ |
#ifndef PREFERRED_STACK_BOUNDARY |
#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY |
#endif |
|
/* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not |
defined. */ |
#ifndef INCOMING_STACK_BOUNDARY |
#define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY |
#endif |
|
#ifndef TARGET_DEFAULT_PACK_STRUCT |
#define TARGET_DEFAULT_PACK_STRUCT 0 |
#endif |
|
/* By default, the C++ compiler will use function addresses in the |
vtable entries. Setting this nonzero tells the compiler to use |
function descriptors instead. The value of this macro says how |
many words wide the descriptor is (normally 2). It is assumed |
that the address of a function descriptor may be treated as a |
pointer to a function. */ |
#ifndef TARGET_VTABLE_USES_DESCRIPTORS |
#define TARGET_VTABLE_USES_DESCRIPTORS 0 |
#endif |
|
/* By default, the vtable entries are void pointers, the so the alignment |
is the same as pointer alignment. The value of this macro specifies |
the alignment of the vtable entry in bits. It should be defined only |
when special alignment is necessary. */ |
#ifndef TARGET_VTABLE_ENTRY_ALIGN |
#define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE |
#endif |
|
/* There are a few non-descriptor entries in the vtable at offsets below |
zero. If these entries must be padded (say, to preserve the alignment |
specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of |
words in each data entry. */ |
#ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE |
#define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1 |
#endif |
|
/* Decide whether it is safe to use a local alias for a virtual function |
when constructing thunks. */ |
#ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P |
#ifdef ASM_OUTPUT_DEF |
#define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1 |
#else |
#define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0 |
#endif |
#endif |
|
/* Select a format to encode pointers in exception handling data. We |
prefer those that result in fewer dynamic relocations. Assume no |
special support here and encode direct references. */ |
#ifndef ASM_PREFERRED_EH_DATA_FORMAT |
#define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr |
#endif |
|
/* By default, the C++ compiler will use the lowest bit of the pointer |
to function to indicate a pointer-to-member-function points to a |
virtual member function. However, if FUNCTION_BOUNDARY indicates |
function addresses aren't always even, the lowest bit of the delta |
field will be used. */ |
#ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION |
#define TARGET_PTRMEMFUNC_VBIT_LOCATION \ |
(FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \ |
? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta) |
#endif |
|
#ifndef DEFAULT_GDB_EXTENSIONS |
#define DEFAULT_GDB_EXTENSIONS 1 |
#endif |
|
/* If more than one debugging type is supported, you must define |
PREFERRED_DEBUGGING_TYPE to choose the default. */ |
|
#if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \ |
+ defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \ |
+ defined (VMS_DEBUGGING_INFO)) |
#ifndef PREFERRED_DEBUGGING_TYPE |
#error You must define PREFERRED_DEBUGGING_TYPE |
#endif /* no PREFERRED_DEBUGGING_TYPE */ |
|
/* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE |
here so other code needn't care. */ |
#elif defined DBX_DEBUGGING_INFO |
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG |
|
#elif defined SDB_DEBUGGING_INFO |
#define PREFERRED_DEBUGGING_TYPE SDB_DEBUG |
|
#elif defined DWARF2_DEBUGGING_INFO |
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG |
|
#elif defined VMS_DEBUGGING_INFO |
#define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG |
|
#elif defined XCOFF_DEBUGGING_INFO |
#define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG |
|
#else |
/* No debugging format is supported by this target. */ |
#define PREFERRED_DEBUGGING_TYPE NO_DEBUG |
#endif |
|
#ifndef LARGEST_EXPONENT_IS_NORMAL |
#define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0 |
#endif |
|
#ifndef ROUND_TOWARDS_ZERO |
#define ROUND_TOWARDS_ZERO 0 |
#endif |
|
#ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL |
#define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false |
#endif |
|
/* True if the targets integer-comparison functions return { 0, 1, 2 |
} to indicate { <, ==, > }. False if { -1, 0, 1 } is used |
instead. The libgcc routines are biased. */ |
#ifndef TARGET_LIB_INT_CMP_BIASED |
#define TARGET_LIB_INT_CMP_BIASED (true) |
#endif |
|
/* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files, |
then the word-endianness is the same as for integers. */ |
#ifndef FLOAT_WORDS_BIG_ENDIAN |
#define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN |
#endif |
|
#ifdef TARGET_FLT_EVAL_METHOD |
#define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1 |
#else |
#define TARGET_FLT_EVAL_METHOD 0 |
#define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0 |
#endif |
|
#ifndef TARGET_DEC_EVAL_METHOD |
#define TARGET_DEC_EVAL_METHOD 2 |
#endif |
|
#ifndef HOT_TEXT_SECTION_NAME |
#define HOT_TEXT_SECTION_NAME ".text.hot" |
#endif |
|
#ifndef UNLIKELY_EXECUTED_TEXT_SECTION_NAME |
#define UNLIKELY_EXECUTED_TEXT_SECTION_NAME ".text.unlikely" |
#endif |
|
#ifndef HAS_LONG_COND_BRANCH |
#define HAS_LONG_COND_BRANCH 0 |
#endif |
|
#ifndef HAS_LONG_UNCOND_BRANCH |
#define HAS_LONG_UNCOND_BRANCH 0 |
#endif |
|
/* By default, only attempt to parallelize bitwise operations, and |
possibly adds/subtracts using bit-twiddling. */ |
#ifndef UNITS_PER_SIMD_WORD |
#define UNITS_PER_SIMD_WORD(MODE) UNITS_PER_WORD |
#endif |
|
/* Determine whether __cxa_atexit, rather than atexit, is used to |
register C++ destructors for local statics and global objects. */ |
#ifndef DEFAULT_USE_CXA_ATEXIT |
#define DEFAULT_USE_CXA_ATEXIT 0 |
#endif |
|
/* If none of these macros are defined, the port must use the new |
technique of defining constraints in the machine description. |
tm_p.h will define those macros that machine-independent code |
still uses. */ |
#if !defined CONSTRAINT_LEN \ |
&& !defined REG_CLASS_FROM_LETTER \ |
&& !defined REG_CLASS_FROM_CONSTRAINT \ |
&& !defined CONST_OK_FOR_LETTER_P \ |
&& !defined CONST_OK_FOR_CONSTRAINT_P \ |
&& !defined CONST_DOUBLE_OK_FOR_LETTER_P \ |
&& !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P \ |
&& !defined EXTRA_CONSTRAINT \ |
&& !defined EXTRA_CONSTRAINT_STR \ |
&& !defined EXTRA_MEMORY_CONSTRAINT \ |
&& !defined EXTRA_ADDRESS_CONSTRAINT |
|
#define USE_MD_CONSTRAINTS |
|
#if GCC_VERSION >= 3000 && defined IN_GCC |
/* These old constraint macros shouldn't appear anywhere in a |
configuration using MD constraint definitions. */ |
#pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \ |
CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT |
#endif |
|
#else /* old constraint mechanism in use */ |
|
/* Determine whether extra constraint letter should be handled |
via address reload (like 'o'). */ |
#ifndef EXTRA_MEMORY_CONSTRAINT |
#define EXTRA_MEMORY_CONSTRAINT(C,STR) 0 |
#endif |
|
/* Determine whether extra constraint letter should be handled |
as an address (like 'p'). */ |
#ifndef EXTRA_ADDRESS_CONSTRAINT |
#define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0 |
#endif |
|
/* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN |
for all the characters that it does not want to change, so things like the |
'length' of a digit in a matching constraint is an implementation detail, |
and not part of the interface. */ |
#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 |
|
#ifndef CONSTRAINT_LEN |
#define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR) |
#endif |
|
#if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P) |
#define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C) |
#endif |
|
#if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P) |
#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \ |
CONST_DOUBLE_OK_FOR_LETTER_P (OP, C) |
#endif |
|
#ifndef REG_CLASS_FROM_CONSTRAINT |
#define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C) |
#endif |
|
#if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR) |
#define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C) |
#endif |
|
#endif /* old constraint mechanism in use */ |
|
#ifndef REGISTER_MOVE_COST |
#define REGISTER_MOVE_COST(m, x, y) 2 |
#endif |
|
/* Determine whether the entire c99 runtime |
is present in the runtime library. */ |
#ifndef TARGET_C99_FUNCTIONS |
#define TARGET_C99_FUNCTIONS 0 |
#endif |
|
/* Determine whether the target runtime library has |
a sincos implementation following the GNU extension. */ |
#ifndef TARGET_HAS_SINCOS |
#define TARGET_HAS_SINCOS 0 |
#endif |
|
/* Indicate that CLZ and CTZ are undefined at zero. */ |
#ifndef CLZ_DEFINED_VALUE_AT_ZERO |
#define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
#endif |
#ifndef CTZ_DEFINED_VALUE_AT_ZERO |
#define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
#endif |
|
/* Provide a default value for STORE_FLAG_VALUE. */ |
#ifndef STORE_FLAG_VALUE |
#define STORE_FLAG_VALUE 1 |
#endif |
|
/* This macro is used to determine what the largest unit size that |
move_by_pieces can use is. */ |
|
/* MOVE_MAX_PIECES is the number of bytes at a time which we can |
move efficiently, as opposed to MOVE_MAX which is the maximum |
number of bytes we can move with a single instruction. */ |
|
#ifndef MOVE_MAX_PIECES |
#define MOVE_MAX_PIECES MOVE_MAX |
#endif |
|
#ifndef STACK_POINTER_OFFSET |
#define STACK_POINTER_OFFSET 0 |
#endif |
|
#ifndef LOCAL_REGNO |
#define LOCAL_REGNO(REGNO) 0 |
#endif |
|
/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, |
the stack pointer does not matter. The value is tested only in |
functions that have frame pointers. */ |
#ifndef EXIT_IGNORE_STACK |
#define EXIT_IGNORE_STACK 0 |
#endif |
|
/* Assume that case vectors are not pc-relative. */ |
#ifndef CASE_VECTOR_PC_RELATIVE |
#define CASE_VECTOR_PC_RELATIVE 0 |
#endif |
|
/* Assume that trampolines need function alignment. */ |
#ifndef TRAMPOLINE_ALIGNMENT |
#define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY |
#endif |
|
/* Register mappings for target machines without register windows. */ |
#ifndef INCOMING_REGNO |
#define INCOMING_REGNO(N) (N) |
#endif |
|
#ifndef OUTGOING_REGNO |
#define OUTGOING_REGNO(N) (N) |
#endif |
|
#ifndef SHIFT_COUNT_TRUNCATED |
#define SHIFT_COUNT_TRUNCATED 0 |
#endif |
|
#ifndef LEGITIMATE_PIC_OPERAND_P |
#define LEGITIMATE_PIC_OPERAND_P(X) 1 |
#endif |
|
#ifndef TARGET_MEM_CONSTRAINT |
#define TARGET_MEM_CONSTRAINT 'm' |
#endif |
|
#ifndef REVERSIBLE_CC_MODE |
#define REVERSIBLE_CC_MODE(MODE) 0 |
#endif |
|
/* Biggest alignment supported by the object file format of this machine. */ |
#ifndef MAX_OFILE_ALIGNMENT |
#define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT |
#endif |
|
#ifndef FRAME_GROWS_DOWNWARD |
#define FRAME_GROWS_DOWNWARD 0 |
#endif |
|
/* On most machines, the CFA coincides with the first incoming parm. */ |
#ifndef ARG_POINTER_CFA_OFFSET |
#define ARG_POINTER_CFA_OFFSET(FNDECL) \ |
(FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size) |
#endif |
|
/* On most machines, we use the CFA as DW_AT_frame_base. */ |
#ifndef CFA_FRAME_BASE_OFFSET |
#define CFA_FRAME_BASE_OFFSET(FNDECL) 0 |
#endif |
|
/* The offset from the incoming value of %sp to the top of the stack frame |
for the current function. */ |
#ifndef INCOMING_FRAME_SP_OFFSET |
#define INCOMING_FRAME_SP_OFFSET 0 |
#endif |
|
#ifndef HARD_REGNO_NREGS_HAS_PADDING |
#define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0 |
#define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1 |
#endif |
|
#ifndef OUTGOING_REG_PARM_STACK_SPACE |
#define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0 |
#endif |
|
/* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by |
the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best |
effort stack alignment supported by the backend. If the backend |
supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and |
MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack |
boundary will limit the maximum guaranteed stack alignment. */ |
#ifdef MAX_STACK_ALIGNMENT |
#define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT |
#else |
#define MAX_STACK_ALIGNMENT STACK_BOUNDARY |
#define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY |
#endif |
|
#define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY) |
|
#ifndef LOCAL_ALIGNMENT |
#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT |
#endif |
|
#ifndef STACK_SLOT_ALIGNMENT |
#define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \ |
((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN)) |
#endif |
|
#ifndef LOCAL_DECL_ALIGNMENT |
#define LOCAL_DECL_ALIGNMENT(DECL) \ |
LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) |
#endif |
|
#ifndef MINIMUM_ALIGNMENT |
#define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN) |
#endif |
|
/* Alignment value for attribute ((aligned)). */ |
#ifndef ATTRIBUTE_ALIGNED_VALUE |
#define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT |
#endif |
|
/* Many ports have no mode-dependent addresses (except possibly autoincrement |
and autodecrement addresses, which are handled by target-independent code |
in recog.c). */ |
#ifndef GO_IF_MODE_DEPENDENT_ADDRESS |
#define GO_IF_MODE_DEPENDENT_ADDRESS(X, WIN) |
#endif |
|
/* For most ports anything that evaluates to a constant symbolic |
or integer value is acceptable as a constant address. */ |
#ifndef CONSTANT_ADDRESS_P |
#define CONSTANT_ADDRESS_P(X) (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE) |
#endif |
|
#endif /* ! GCC_DEFAULTS_H */ |