4c7e15910e
for that kind of flags -- the TARGET_CPU_DEFAULT is used to choose the cpu type to generate code for...) Fixes PR 10357.
667 lines
23 KiB
C
667 lines
23 KiB
C
/* Definitions of target machine for GNU compiler,
|
||
for i386 NetBSD systems.
|
||
Copyright (C) 1998 Free Software Foundation, Inc.
|
||
|
||
This file is part of GNU CC.
|
||
|
||
GNU CC 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 2, or (at your option)
|
||
any later version.
|
||
|
||
GNU CC 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.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GNU CC; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
/* This is used on i386 platforms that use the ELF format.
|
||
This was taken from the NetBSD/alpha configuration, and modified
|
||
for NetBSD/i386 by Christos Zoulas <christos@netbsd.org> */
|
||
|
||
/* Get generic i386 definitions. */
|
||
|
||
#include <i386/gstabs.h>
|
||
|
||
/* Get perform_* macros to build libgcc.a. */
|
||
#include <i386/perform.h>
|
||
|
||
/* Get generic NetBSD ELF definitions. We will override these if necessary. */
|
||
|
||
#define NETBSD_ELF
|
||
#include <netbsd.h>
|
||
|
||
#define OBJECT_FORMAT_ELF
|
||
|
||
/* This goes away when the math-emulator is fixed */
|
||
#undef TARGET_DEFAULT
|
||
#define TARGET_DEFAULT \
|
||
(MASK_80387 | MASK_IEEE_FP | MASK_FLOAT_RETURNS | MASK_NO_FANCY_MATH_387)
|
||
|
||
/*
|
||
* DBX stabs definitions. Same as Solaris and other i386 ELF platforms.
|
||
*/
|
||
|
||
#undef DBX_CONTIN_CHAR
|
||
#define DBX_CONTIN_CHAR '?'
|
||
|
||
/* When generating stabs debugging, use N_BINCL entries. */
|
||
|
||
#define DBX_USE_BINCL
|
||
|
||
/* Make LBRAC and RBRAC addresses relative to the start of the
|
||
function. The native Solaris stabs debugging format works this
|
||
way, gdb expects it, and it reduces the number of relocation
|
||
entries. */
|
||
|
||
#define DBX_BLOCKS_FUNCTION_RELATIVE 1
|
||
|
||
/* When using stabs, gcc2_compiled must be a stabs entry, not an
|
||
ordinary symbol, or gdb won't see it. Furthermore, since gdb reads
|
||
the input piecemeal, starting with each N_SO, it's a lot easier if
|
||
the gcc2 flag symbol is *after* the N_SO rather than before it. So
|
||
we emit an N_OPT stab there. */
|
||
|
||
#define ASM_IDENTIFY_GCC(FILE) \
|
||
do \
|
||
{ \
|
||
if (write_symbols != DBX_DEBUG) \
|
||
fputs ("gcc2_compiled.:\n", FILE); \
|
||
} \
|
||
while (0)
|
||
|
||
#define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) \
|
||
do \
|
||
{ \
|
||
if (write_symbols == DBX_DEBUG) \
|
||
fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE); \
|
||
} \
|
||
while (0)
|
||
|
||
/* Like block addresses, stabs line numbers are relative to the
|
||
current function. */
|
||
|
||
#define ASM_OUTPUT_SOURCE_LINE(file, line) \
|
||
do \
|
||
{ \
|
||
static int sym_lineno = 1; \
|
||
fprintf (file, ".stabn 68,0,%d,.LM%d-", \
|
||
line, sym_lineno); \
|
||
assemble_name (file, \
|
||
XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
|
||
fprintf (file, "\n.LM%d:\n", sym_lineno); \
|
||
sym_lineno += 1; \
|
||
} \
|
||
while (0)
|
||
|
||
/* In order for relative line numbers to work, we must output the
|
||
stabs entry for the function name first. */
|
||
|
||
#define DBX_FUNCTION_FIRST
|
||
|
||
/* Generate a blank trailing N_SO to mark the end of the .o file, since
|
||
we can't depend upon the linker to mark .o file boundaries with
|
||
embedded stabs. (XXX do we need this?) */
|
||
|
||
#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
|
||
do \
|
||
{ \
|
||
text_section (); \
|
||
fprintf (FILE, \
|
||
"\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO); \
|
||
} \
|
||
while (0)
|
||
|
||
|
||
#undef ASM_FINAL_SPEC
|
||
|
||
/* Names to predefine in the preprocessor for this target machine.
|
||
XXX NetBSD, by convention, shouldn't do __alpha, but lots of applications
|
||
expect it because that's what OSF/1 does. */
|
||
|
||
/* NetBSD Extension to GNU C: __KPRINTF_ATTRIBUTE__ */
|
||
|
||
#undef CPP_PREDEFINES
|
||
#define CPP_PREDEFINES "\
|
||
-Di386 -D__NetBSD__ -D__ELF__ -D__KPRINTF_ATTRIBUTE__ \
|
||
-Asystem(unix) -Asystem(NetBSD) -Acpu(i386) -Amachine(i386)"
|
||
|
||
/* Make gcc agree with <machine/ansi.h> */
|
||
|
||
#undef SIZE_TYPE
|
||
#define SIZE_TYPE "unsigned int"
|
||
|
||
#undef PTRDIFF_TYPE
|
||
#define PTRDIFF_TYPE "int"
|
||
|
||
#undef WCHAR_TYPE
|
||
#define WCHAR_TYPE "int"
|
||
|
||
#undef WCHAR_UNSIGNED
|
||
#define WCHAR_UNSIGNED 0
|
||
|
||
#undef WCHAR_TYPE_SIZE
|
||
#define WCHAR_TYPE_SIZE 32
|
||
|
||
/* Output assembler code to FILE to increment profiler label # LABELNO
|
||
for profiling a function entry. Under NetBSD/i386, the assembler does
|
||
nothing special with -pg. */
|
||
|
||
#undef ASM_APP_ON
|
||
#define ASM_APP_ON "#APP\n"
|
||
|
||
#undef ASM_APP_OFF
|
||
#define ASM_APP_OFF "#NO_APP\n"
|
||
|
||
#define bsd4_4
|
||
#undef HAS_INIT_SECTION
|
||
|
||
#undef ASM_FILE_START
|
||
#define ASM_FILE_START(FILE) \
|
||
{ \
|
||
output_file_directive (FILE, main_input_filename); \
|
||
fprintf (FILE, "\t.version\t\"01.01\"\n"); \
|
||
}
|
||
|
||
/* Provide a LINK_SPEC appropriate for a NetBSD/alpha ELF target. Only
|
||
the linker emulation is i386-specific. The rest are
|
||
common to all ELF targets, except for the name of the start function. */
|
||
|
||
#undef LINK_SPEC
|
||
#define LINK_SPEC \
|
||
"-m elf_i386 \
|
||
%{assert*} %{R*} \
|
||
%{shared:-shared} \
|
||
%{!shared: \
|
||
-dc -dp \
|
||
%{!nostdlib:%{!r*:%{!e*:-e __start}}} \
|
||
%{!static: \
|
||
%{rdynamic:-export-dynamic} \
|
||
%{!dynamic-linker:-dynamic-linker /usr/libexec/ld.elf_so}} \
|
||
%{static:-static}}"
|
||
|
||
#undef DEFAULT_VTABLE_THUNKS
|
||
#define DEFAULT_VTABLE_THUNKS 1
|
||
|
||
/* Attach a special .ident directive to the end of the file to identify
|
||
the version of GCC which compiled this code. The format of the
|
||
.ident string is patterned after the ones produced by native svr4
|
||
C compilers. */
|
||
|
||
/* Output #ident as a .ident. */
|
||
|
||
/* This is how to allocate empty space in some section. The .zero
|
||
pseudo-op is used for this on most svr4 assemblers. */
|
||
#undef SKIP_ASM_OP
|
||
#define SKIP_ASM_OP "\t.zero"
|
||
|
||
#undef ASM_OUTPUT_SKIP
|
||
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
|
||
fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE))
|
||
|
||
/* Output the label which precedes a jumptable. Note that for all svr4
|
||
systems where we actually generate jumptables (which is to say every
|
||
svr4 target except i386, where we use casesi instead) we put the jump-
|
||
tables into the .rodata section and since other stuff could have been
|
||
put into the .rodata section prior to any given jumptable, we have to
|
||
make sure that the location counter for the .rodata section gets pro-
|
||
perly re-aligned prior to the actual beginning of the jump table. */
|
||
|
||
#define ALIGN_ASM_OP ".align"
|
||
|
||
#ifndef ASM_OUTPUT_BEFORE_CASE_LABEL
|
||
#define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
|
||
ASM_OUTPUT_ALIGN ((FILE), 2);
|
||
#endif
|
||
|
||
#undef ASM_OUTPUT_CASE_LABEL
|
||
#define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE) \
|
||
do { \
|
||
ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE) \
|
||
ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); \
|
||
} while (0)
|
||
|
||
/* The standard SVR4 assembler seems to require that certain builtin
|
||
library routines (e.g. .udiv) be explicitly declared as .globl
|
||
in each assembly file where they are referenced. */
|
||
|
||
#define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \
|
||
ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
|
||
|
||
/* This says how to output assembler code to declare an
|
||
uninitialized external linkage data object. Under SVR4,
|
||
the linker seems to want the alignment of data objects
|
||
to depend on their types. We do exactly that here. */
|
||
|
||
#define COMMON_ASM_OP ".comm"
|
||
|
||
#undef ASM_OUTPUT_ALIGN
|
||
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
|
||
if ((LOG)!=0) fprintf ((FILE), "\t.align %d\n", 1 << (LOG))
|
||
|
||
#undef ASM_OUTPUT_ALIGNED_COMMON
|
||
#define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \
|
||
do { \
|
||
fprintf ((FILE), "\t%s\t", COMMON_ASM_OP); \
|
||
assemble_name ((FILE), (NAME)); \
|
||
fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT); \
|
||
} while (0)
|
||
|
||
/* This says how to output assembler code to declare an
|
||
uninitialized internal linkage data object. Under SVR4,
|
||
the linker seems to want the alignment of data objects
|
||
to depend on their types. We do exactly that here. */
|
||
|
||
#define LOCAL_ASM_OP ".local"
|
||
|
||
#undef ASM_OUTPUT_ALIGNED_LOCAL
|
||
#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \
|
||
do { \
|
||
fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP); \
|
||
assemble_name ((FILE), (NAME)); \
|
||
fprintf ((FILE), "\n"); \
|
||
ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN); \
|
||
} while (0)
|
||
|
||
/* This is the pseudo-op used to generate a 32-bit word of data with a
|
||
specific value in some section. */
|
||
|
||
#define INT_ASM_OP ".long"
|
||
|
||
/* This is the pseudo-op used to generate a contiguous sequence of byte
|
||
values from a double-quoted string WITHOUT HAVING A TERMINATING NUL
|
||
AUTOMATICALLY APPENDED. This is the same for most svr4 assemblers. */
|
||
|
||
#undef ASCII_DATA_ASM_OP
|
||
#define ASCII_DATA_ASM_OP ".ascii"
|
||
|
||
/* Support const sections and the ctors and dtors sections for g++.
|
||
Note that there appears to be two different ways to support const
|
||
sections at the moment. You can either #define the symbol
|
||
READONLY_DATA_SECTION (giving it some code which switches to the
|
||
readonly data section) or else you can #define the symbols
|
||
EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and
|
||
SELECT_RTX_SECTION. We do both here just to be on the safe side. */
|
||
|
||
#define USE_CONST_SECTION 1
|
||
|
||
#define CONST_SECTION_ASM_OP ".section\t.rodata"
|
||
|
||
/* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
|
||
|
||
Note that we want to give these sections the SHF_WRITE attribute
|
||
because these sections will actually contain data (i.e. tables of
|
||
addresses of functions in the current root executable or shared library
|
||
file) and, in the case of a shared library, the relocatable addresses
|
||
will have to be properly resolved/relocated (and then written into) by
|
||
the dynamic linker when it actually attaches the given shared library
|
||
to the executing process. (Note that on SVR4, you may wish to use the
|
||
`-z text' option to the ELF linker, when building a shared library, as
|
||
an additional check that you are doing everything right. But if you do
|
||
use the `-z text' option when building a shared library, you will get
|
||
errors unless the .ctors and .dtors sections are marked as writable
|
||
via the SHF_WRITE attribute.) */
|
||
|
||
#define CTORS_SECTION_ASM_OP ".section\t.ctors,\"aw\""
|
||
#define DTORS_SECTION_ASM_OP ".section\t.dtors,\"aw\""
|
||
|
||
/* On svr4, we *do* have support for the .init and .fini sections, and we
|
||
can put stuff in there to be executed before and after `main'. We let
|
||
crtstuff.c and other files know this by defining the following symbols.
|
||
The definitions say how to change sections to the .init and .fini
|
||
sections. This is the same for all known svr4 assemblers. */
|
||
|
||
#define INIT_SECTION_ASM_OP ".section\t.init"
|
||
#define FINI_SECTION_ASM_OP ".section\t.fini"
|
||
|
||
/* A default list of other sections which we might be "in" at any given
|
||
time. For targets that use additional sections (e.g. .tdesc) you
|
||
should override this definition in the target-specific file which
|
||
includes this file. */
|
||
|
||
#undef EXTRA_SECTIONS
|
||
#define EXTRA_SECTIONS in_const, in_ctors, in_dtors
|
||
|
||
/* A default list of extra section function definitions. For targets
|
||
that use additional sections (e.g. .tdesc) you should override this
|
||
definition in the target-specific file which includes this file. */
|
||
|
||
#undef EXTRA_SECTION_FUNCTIONS
|
||
#define EXTRA_SECTION_FUNCTIONS \
|
||
CONST_SECTION_FUNCTION \
|
||
CTORS_SECTION_FUNCTION \
|
||
DTORS_SECTION_FUNCTION
|
||
|
||
#undef READONLY_DATA_SECTION
|
||
#define READONLY_DATA_SECTION() const_section ()
|
||
|
||
extern void text_section ();
|
||
|
||
#define CONST_SECTION_FUNCTION \
|
||
void \
|
||
const_section () \
|
||
{ \
|
||
if (!USE_CONST_SECTION) \
|
||
text_section(); \
|
||
else if (in_section != in_const) \
|
||
{ \
|
||
fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP); \
|
||
in_section = in_const; \
|
||
} \
|
||
}
|
||
|
||
#define CTORS_SECTION_FUNCTION \
|
||
void \
|
||
ctors_section () \
|
||
{ \
|
||
if (in_section != in_ctors) \
|
||
{ \
|
||
fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP); \
|
||
in_section = in_ctors; \
|
||
} \
|
||
}
|
||
|
||
#define DTORS_SECTION_FUNCTION \
|
||
void \
|
||
dtors_section () \
|
||
{ \
|
||
if (in_section != in_dtors) \
|
||
{ \
|
||
fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP); \
|
||
in_section = in_dtors; \
|
||
} \
|
||
}
|
||
|
||
/* Switch into a generic section.
|
||
This is currently only used to support section attributes.
|
||
|
||
We make the section read-only and executable for a function decl,
|
||
read-only for a const data decl, and writable for a non-const data decl. */
|
||
#define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC) \
|
||
fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, \
|
||
(DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" : \
|
||
(DECL) && DECL_READONLY_SECTION (DECL, RELOC) ? "a" : "aw")
|
||
|
||
|
||
/* A C statement (sans semicolon) to output an element in the table of
|
||
global constructors. */
|
||
#define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
|
||
do { \
|
||
ctors_section (); \
|
||
fprintf (FILE, "\t%s\t ", INT_ASM_OP); \
|
||
assemble_name (FILE, NAME); \
|
||
fprintf (FILE, "\n"); \
|
||
} while (0)
|
||
|
||
/* A C statement (sans semicolon) to output an element in the table of
|
||
global destructors. */
|
||
#define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
|
||
do { \
|
||
dtors_section (); \
|
||
fprintf (FILE, "\t%s\t ", INT_ASM_OP); \
|
||
assemble_name (FILE, NAME); \
|
||
fprintf (FILE, "\n"); \
|
||
} while (0)
|
||
|
||
/* A C statement or statements to switch to the appropriate
|
||
section for output of DECL. DECL is either a `VAR_DECL' node
|
||
or a constant of some sort. RELOC indicates whether forming
|
||
the initial value of DECL requires link-time relocations. */
|
||
|
||
#define SELECT_SECTION(DECL,RELOC) \
|
||
{ \
|
||
if (TREE_CODE (DECL) == STRING_CST) \
|
||
{ \
|
||
if (! flag_writable_strings) \
|
||
const_section (); \
|
||
else \
|
||
data_section (); \
|
||
} \
|
||
else if (TREE_CODE (DECL) == VAR_DECL) \
|
||
{ \
|
||
if ((flag_pic && RELOC) \
|
||
|| !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL) \
|
||
|| !DECL_INITIAL (DECL) \
|
||
|| (DECL_INITIAL (DECL) != error_mark_node \
|
||
&& !TREE_CONSTANT (DECL_INITIAL (DECL)))) \
|
||
data_section (); \
|
||
else \
|
||
const_section (); \
|
||
} \
|
||
else \
|
||
const_section (); \
|
||
}
|
||
|
||
/* A C statement or statements to switch to the appropriate
|
||
section for output of RTX in mode MODE. RTX is some kind
|
||
of constant in RTL. The argument MODE is redundant except
|
||
in the case of a `const_int' rtx. Currently, these always
|
||
go into the const section. */
|
||
|
||
#undef SELECT_RTX_SECTION
|
||
#define SELECT_RTX_SECTION(MODE,RTX) const_section()
|
||
|
||
/* Define the strings used for the special svr4 .type and .size directives.
|
||
These strings generally do not vary from one system running svr4 to
|
||
another, but if a given system (e.g. m88k running svr) needs to use
|
||
different pseudo-op names for these, they may be overridden in the
|
||
file which includes this one. */
|
||
|
||
#define TYPE_ASM_OP ".type"
|
||
#define SIZE_ASM_OP ".size"
|
||
|
||
/* The following macro defines the format used to output the second
|
||
operand of the .type assembler directive. Different svr4 assemblers
|
||
expect various different forms for this operand. The one given here
|
||
is just a default. You may need to override it in your machine-
|
||
specific tm.h file (depending upon the particulars of your assembler). */
|
||
|
||
#define TYPE_OPERAND_FMT "@%s"
|
||
|
||
/* Write the extra assembler code needed to declare a function's result.
|
||
Most svr4 assemblers don't require any special declaration of the
|
||
result value, but there are exceptions. */
|
||
|
||
#ifndef ASM_DECLARE_RESULT
|
||
#define ASM_DECLARE_RESULT(FILE, RESULT)
|
||
#endif
|
||
|
||
/* These macros generate the special .type and .size directives which
|
||
are used to set the corresponding fields of the linker symbol table
|
||
entries in an ELF object file under SVR4. These macros also output
|
||
the starting labels for the relevant functions/objects. */
|
||
|
||
/* Write the extra assembler code needed to declare a function properly.
|
||
Some svr4 assemblers need to also have something extra said about the
|
||
function's return value. We allow for that here. */
|
||
|
||
#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \
|
||
do { \
|
||
fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \
|
||
assemble_name (FILE, NAME); \
|
||
putc (',', FILE); \
|
||
fprintf (FILE, TYPE_OPERAND_FMT, "function"); \
|
||
putc ('\n', FILE); \
|
||
ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \
|
||
ASM_OUTPUT_LABEL(FILE, NAME); \
|
||
} while (0)
|
||
|
||
/* Write the extra assembler code needed to declare an object properly. */
|
||
|
||
#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \
|
||
do { \
|
||
fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \
|
||
assemble_name (FILE, NAME); \
|
||
putc (',', FILE); \
|
||
fprintf (FILE, TYPE_OPERAND_FMT, "object"); \
|
||
putc ('\n', FILE); \
|
||
size_directive_output = 0; \
|
||
if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \
|
||
{ \
|
||
size_directive_output = 1; \
|
||
fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \
|
||
assemble_name (FILE, NAME); \
|
||
putc (',', FILE); \
|
||
fprintf (FILE, HOST_WIDE_INT_PRINT_DEC, \
|
||
int_size_in_bytes (TREE_TYPE (DECL))); \
|
||
fputc ('\n', FILE); \
|
||
} \
|
||
ASM_OUTPUT_LABEL(FILE, NAME); \
|
||
} while (0)
|
||
|
||
/* Output the size directive for a decl in rest_of_decl_compilation
|
||
in the case where we did not do so before the initializer.
|
||
Once we find the error_mark_node, we know that the value of
|
||
size_directive_output was set
|
||
by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */
|
||
|
||
#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \
|
||
do { \
|
||
char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \
|
||
if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \
|
||
&& ! AT_END && TOP_LEVEL \
|
||
&& DECL_INITIAL (DECL) == error_mark_node \
|
||
&& !size_directive_output) \
|
||
{ \
|
||
size_directive_output = 1; \
|
||
fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \
|
||
assemble_name (FILE, name); \
|
||
putc (',', FILE); \
|
||
fprintf (FILE, HOST_WIDE_INT_PRINT_DEC, \
|
||
int_size_in_bytes (TREE_TYPE (DECL))); \
|
||
fputc ('\n', FILE); \
|
||
} \
|
||
} while (0)
|
||
|
||
/* This is how to declare the size of a function. */
|
||
|
||
#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \
|
||
do { \
|
||
if (!flag_inhibit_size_directive) \
|
||
{ \
|
||
char label[256]; \
|
||
static int labelno; \
|
||
labelno++; \
|
||
ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \
|
||
ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \
|
||
fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \
|
||
assemble_name (FILE, (FNAME)); \
|
||
fprintf (FILE, ","); \
|
||
assemble_name (FILE, label); \
|
||
fprintf (FILE, "-"); \
|
||
assemble_name (FILE, (FNAME)); \
|
||
putc ('\n', FILE); \
|
||
} \
|
||
} while (0)
|
||
|
||
/* This is how we tell the assembler that two symbols have the same value. */
|
||
|
||
#define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \
|
||
do { assemble_name(FILE, NAME1); \
|
||
fputs(" = ", FILE); \
|
||
assemble_name(FILE, NAME2); \
|
||
fputc('\n', FILE); } while (0)
|
||
|
||
/* A table of bytes codes used by the ASM_OUTPUT_ASCII and
|
||
ASM_OUTPUT_LIMITED_STRING macros. Each byte in the table
|
||
corresponds to a particular byte value [0..255]. For any
|
||
given byte value, if the value in the corresponding table
|
||
position is zero, the given character can be output directly.
|
||
If the table value is 1, the byte must be output as a \ooo
|
||
octal escape. If the tables value is anything else, then the
|
||
byte value should be output as a \ followed by the value
|
||
in the table. Note that we can use standard UN*X escape
|
||
sequences for many control characters, but we don't use
|
||
\a to represent BEL because some svr4 assemblers (e.g. on
|
||
the i386) don't know about that. Also, we don't use \v
|
||
since some versions of gas, such as 2.2 did not accept it. */
|
||
|
||
#define ESCAPES \
|
||
"\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
|
||
\0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
|
||
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\
|
||
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\
|
||
\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
|
||
\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
|
||
\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
|
||
\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1"
|
||
|
||
/* Some svr4 assemblers have a limit on the number of characters which
|
||
can appear in the operand of a .string directive. If your assembler
|
||
has such a limitation, you should define STRING_LIMIT to reflect that
|
||
limit. Note that at least some svr4 assemblers have a limit on the
|
||
actual number of bytes in the double-quoted string, and that they
|
||
count each character in an escape sequence as one byte. Thus, an
|
||
escape sequence like \377 would count as four bytes.
|
||
|
||
If your target assembler doesn't support the .string directive, you
|
||
should define this to zero.
|
||
*/
|
||
|
||
#define STRING_LIMIT ((unsigned) 256)
|
||
|
||
#define STRING_ASM_OP ".string"
|
||
|
||
/*
|
||
* We always use gas here, so we don't worry about ECOFF assembler problems.
|
||
*/
|
||
#undef TARGET_GAS
|
||
#define TARGET_GAS (1)
|
||
|
||
#if 0
|
||
#undef PREFERRED_DEBUGGING_TYPE
|
||
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
|
||
#endif
|
||
|
||
/* The following macros are stolen from i386v4.h */
|
||
/* These have to be defined to get PIC code correct */
|
||
|
||
/* This is how to output an element of a case-vector that is relative.
|
||
This is only used for PIC code. See comments by the `casesi' insn in
|
||
i386.md for an explanation of the expression this outputs. */
|
||
|
||
#undef ASM_OUTPUT_ADDR_DIFF_ELT
|
||
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
|
||
fprintf (FILE, "\t.long _GLOBAL_OFFSET_TABLE_+[.-%s%d]\n", LPREFIX, VALUE)
|
||
|
||
/* Indicate that jump tables go in the text section. This is
|
||
necessary when compiling PIC code. */
|
||
|
||
#define JUMP_TABLES_IN_TEXT_SECTION 1
|
||
|
||
/* Default to pcc-struct-return, because this is the ELF abi and
|
||
we don't care about compatibility with older gcc versions. */
|
||
#define DEFAULT_PCC_STRUCT_RETURN 1
|
||
|
||
/* Profiling routines, partially copied from i386/osfrose.h. */
|
||
|
||
/* Redefine this to use %eax instead of %edx. */
|
||
#undef FUNCTION_PROFILER
|
||
#define FUNCTION_PROFILER(FILE, LABELNO) \
|
||
{ \
|
||
if (flag_pic) \
|
||
{ \
|
||
fprintf (FILE, "\tcall __mcount@PLT\n"); \
|
||
} \
|
||
else \
|
||
{ \
|
||
fprintf (FILE, "\tcall __mcount\n"); \
|
||
} \
|
||
}
|
||
|
||
/* Put relocations in the constant pool in the writable data section. */
|
||
#undef SELECT_RTX_SECTION
|
||
#define SELECT_RTX_SECTION(MODE,RTX) \
|
||
{ \
|
||
if (flag_pic && symbolic_operand (RTX)) \
|
||
data_section (); \
|
||
else \
|
||
readonly_data_section (); \
|
||
}
|
||
|
||
/* Use sjlj exceptions. */
|
||
#define DWARF2_UNWIND_INFO 0
|