From 9fdecdb73045a2aa50de0ab25332cdc9950ca137 Mon Sep 17 00:00:00 2001 From: Tom Wood Date: Fri, 9 Apr 1993 23:45:02 +0000 Subject: [PATCH] Initial revision From-SVN: r4072 --- gcc/config/i386/next.h | 191 +++++++++++++ gcc/config/i386/t-next | 5 + gcc/config/i386/x-next | 8 + gcc/config/i386/xm-next.h | 5 + gcc/config/nextstep.c | 83 ++++++ gcc/config/nextstep.h | 563 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 855 insertions(+) create mode 100644 gcc/config/i386/next.h create mode 100644 gcc/config/i386/t-next create mode 100644 gcc/config/i386/x-next create mode 100644 gcc/config/i386/xm-next.h create mode 100644 gcc/config/nextstep.c create mode 100644 gcc/config/nextstep.h diff --git a/gcc/config/i386/next.h b/gcc/config/i386/next.h new file mode 100644 index 00000000000..4d95cd29499 --- /dev/null +++ b/gcc/config/i386/next.h @@ -0,0 +1,191 @@ +/* Target definitions for GNU compiler for Intel x86 CPU running NeXTSTEP + Copyright (C) 1993 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. */ + +#include "i386/i386.h" +#include "i386/bsd.h" +#include "nextstep.h" + +/* By default, target has a 80387, with IEEE FP. */ + +#undef TARGET_DEFAULT +#define TARGET_DEFAULT (1|0100) + +/* Implicit library calls should use memcpy, not bcopy, etc. */ + +#define TARGET_MEM_FUNCTIONS + +/* Machines that use the AT&T assembler syntax + also return floating point values in an FP register. + Define how to find the value returned by a function. + VALTYPE is the data type of the value (as a tree). + If the precise function being called is known, FUNC is its FUNCTION_DECL; + otherwise, FUNC is 0. */ + +#undef VALUE_REGNO +#define VALUE_REGNO(MODE) \ + (((MODE)==SFmode || (MODE)==DFmode) ? FIRST_FLOAT_REG : 0) + +/* 1 if N is a possible register number for a function value. */ + +#undef FUNCTION_VALUE_REGNO_P +#define FUNCTION_VALUE_REGNO_P(N) ((N) == 0 || (N)== FIRST_FLOAT_REG) + +#ifdef REAL_VALUE_TO_TARGET_DOUBLE +#undef ASM_OUTPUT_DOUBLE +#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ + do { \ + long hex[2]; \ + REAL_VALUE_TO_TARGET_DOUBLE (VALUE, hex); \ + fprintf (FILE, "\t.long 0x%x\n\t.long 0x%x\n", hex[0], hex[1]); \ + } while (0) +#endif + +/* This is how to output an assembler line defining a `float' constant. */ + +#ifdef REAL_VALUE_TO_TARGET_SINGLE +#undef ASM_OUTPUT_FLOAT +#define ASM_OUTPUT_FLOAT(FILE,VALUE) \ + do { \ + long hex; \ + REAL_VALUE_TO_TARGET_SINGLE (VALUE, hex); \ + fprintf (FILE, "\t.long 0x%x\n", hex); \ + } while (0) +#endif + +/* A C statement or statements which output an assembler instruction + opcode to the stdio stream STREAM. The macro-operand PTR is a + variable of type `char *' which points to the opcode name in its + "internal" form--the form that is written in the machine description. + + GAS version 1.38.1 doesn't understand the `repz' opcode mnemonic. + So use `repe' instead. */ + +#undef ASM_OUTPUT_OPCODE +#define ASM_OUTPUT_OPCODE(STREAM, PTR) \ +{ \ + if ((PTR)[0] == 'r' \ + && (PTR)[1] == 'e' \ + && (PTR)[2] == 'p') \ + { \ + if ((PTR)[3] == 'z') \ + { \ + fprintf (STREAM, "repe"); \ + (PTR) += 4; \ + } \ + else if ((PTR)[3] == 'n' && (PTR)[4] == 'z') \ + { \ + fprintf (STREAM, "repne"); \ + (PTR) += 5; \ + } \ + } \ +} + +/* Define macro used to output shift-double opcodes when the shift + count is in %cl. Some assemblers require %cl as an argument; + some don't. + + GAS requires the %cl argument, so override unx386.h. */ + +#undef AS3_SHIFT_DOUBLE +#define AS3_SHIFT_DOUBLE(a,b,c,d) AS3 (a,b,c,d) + +/* Print opcodes the way that GAS expects them. */ +#define GAS_MNEMONICS 1 + +/* Names to predefine in the preprocessor for this target machine. */ + +#undef CPP_PREDEFINES +#define CPP_PREDEFINES "-Di386 -DNeXT -Dunix -D__MACH__ -D__LITTLE_ENDIAN__ -D__ARCHITECTURE__=\"i386\"" + +/* This accounts for the return pc and saved fp on the i386. */ + +#define OBJC_FORWARDING_STACK_OFFSET 8 +#define OBJC_FORWARDING_MIN_OFFSET 8 + +/* Output to assembler file text saying following lines + may contain character constants, extra white space, comments, etc. */ + +#undef ASM_APP_ON +#define ASM_APP_ON "#APP\n" + +/* Output to assembler file text saying following lines + no longer contain unusual constructs. */ + +#undef ASM_APP_OFF +#define ASM_APP_OFF "#NO_APP\n" + +#undef ASM_OUTPUT_REG_PUSH +#define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ + fprintf (FILE, "\tpushl %se%s\n", "%", reg_names[REGNO]) + +#undef ASM_OUTPUT_REG_POP +#define ASM_OUTPUT_REG_POP(FILE,REGNO) \ + fprintf (FILE, "\tpopl %se%s\n", "%", reg_names[REGNO]) + +/* This is being overridden because the default i386 configuration + generates calls to "_mcount". NeXT system libraries all use + "mcount". */ + +#undef FUNCTION_PROFILER +#define FUNCTION_PROFILER(FILE, LABELNO) \ +{ \ + if (flag_pic) \ + { \ + fprintf (FILE, "\tleal %sP%d@GOTOFF(%%ebx),%%edx\n", \ + LPREFIX, (LABELNO)); \ + fprintf (FILE, "\tcall *mcount@GOT(%%ebx)\n"); \ + } \ + else \ + { \ + fprintf (FILE, "\tmovl $%sP%d,%%edx\n", LPREFIX, (LABELNO)); \ + fprintf (FILE, "\tcall mcount\n"); \ + } \ +} + +/* BEGIN Calling Convention CHANGES */ + +/* These changes violate the Intel/Unix ABI. Specifically, they + change the way that space for a block return value is passed to a + function. The ABI says that the pointer is passed on the stack. + We change to pass the pointer in %ebx. This makes the NeXT + Objective-C forwarding mechanism possible to implement on an i386. */ + +/* Do NOT pass address of structure values on the stack. */ + +#undef STRUCT_VALUE_INCOMING +#undef STRUCT_VALUE + +/* Pass them in %ebx. */ + +#undef STRUCT_VALUE_REGNUM +#define STRUCT_VALUE_REGNUM 3 + +/* Because we are passing the pointer in a register, we don't need to + rely on the callee to pop it. */ + +#undef RETURN_POPS_ARGS +#define RETURN_POPS_ARGS(FUNTYPE,SIZE) \ + (TREE_CODE (FUNTYPE) == IDENTIFIER_NODE \ + ? 0 \ + : (TARGET_RTD \ + && (TYPE_ARG_TYPES (FUNTYPE) == 0 \ + || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE))) \ + == void_type_node))) ? (SIZE) : 0) + +/* END Calling Convention CHANGES */ diff --git a/gcc/config/i386/t-next b/gcc/config/i386/t-next new file mode 100644 index 00000000000..7dbe1808a26 --- /dev/null +++ b/gcc/config/i386/t-next @@ -0,0 +1,5 @@ +# libgcc1.c is not needed, since the standard library has these functions. +LIBGCC1= + +# Specify other dirs of system header files to be fixed. +OTHER_FIXINCLUDES_DIRS= /LocalDeveloper/Headers diff --git a/gcc/config/i386/x-next b/gcc/config/i386/x-next new file mode 100644 index 00000000000..81d2f3f68a2 --- /dev/null +++ b/gcc/config/i386/x-next @@ -0,0 +1,8 @@ +# Make assignments for compiling on NeXT with their compiler version. +CC=cc -traditional-cpp +OLDCC=cc -traditional-cpp + +libgcc2.a: stdarg.h + +stdarg.h: + cp $(srcdir)/gstdarg.h ./stdarg.h diff --git a/gcc/config/i386/xm-next.h b/gcc/config/i386/xm-next.h new file mode 100644 index 00000000000..bf903281a0d --- /dev/null +++ b/gcc/config/i386/xm-next.h @@ -0,0 +1,5 @@ +#include "i386/xm-i386.h" + +/* malloc does better with chunks the size of a page. */ + +#define OBSTACK_CHUNK_SIZE (getpagesize ()) diff --git a/gcc/config/nextstep.c b/gcc/config/nextstep.c new file mode 100644 index 00000000000..e339b8d4981 --- /dev/null +++ b/gcc/config/nextstep.c @@ -0,0 +1,83 @@ +/* Functions for generic NeXT as target machine for GNU C compiler. + Copyright (C) 1989, 1990, 1991, 1992, 1993 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. */ + +/* Make everything that used to go in the text section really go there. */ + +int flag_no_mach_text_sections = 0; + +#define OPT_STRCMP(opt) (!strncmp (opt, p, sizeof (opt)-1)) + +/* 1 if handle_pragma has been called yet. */ + +static int pragma_initialized; + +/* Initial setting of `optimize'. */ + +static int initial_optimize_flag; + +extern char *get_directive_line (); + +/* Called from check_newline via the macro HANDLE_PRAGMA. + FINPUT is the source file input stream. */ + +void +handle_pragma (finput, get_line_function) + FILE *finput; + char *(*get_line_function) (); +{ + register char *p = (*get_line_function) (finput); + + /* Record initial setting of optimize flag, so we can restore it. */ + if (!pragma_initialized) + { + pragma_initialized = 1; + initial_optimize_flag = optimize; + } + + if (OPT_STRCMP ("CC_OPT_ON")) + { + optimize = 1, obey_regdecls = 0; + warning ("optimization turned on"); + } + else if (OPT_STRCMP ("CC_OPT_OFF")) + { + optimize = 0, obey_regdecls = 1; + warning ("optimization turned off"); + } + else if (OPT_STRCMP ("CC_OPT_RESTORE")) + { + extern int initial_optimize_flag; + + if (optimize != initial_optimize_flag) + { + if (initial_optimize_flag) + obey_regdecls = 0; + else + obey_regdecls = 1; + optimize = initial_optimize_flag; + } + warning ("optimization level restored"); + } + else if (OPT_STRCMP ("CC_WRITABLE_STRINGS")) + flag_writable_strings = 1; + else if (OPT_STRCMP ("CC_NON_WRITABLE_STRINGS")) + flag_writable_strings = 0; + else if (OPT_STRCMP ("CC_NO_MACH_TEXT_SECTIONS")) + flag_no_mach_text_sections = 1; +} diff --git a/gcc/config/nextstep.h b/gcc/config/nextstep.h new file mode 100644 index 00000000000..0e299192d5d --- /dev/null +++ b/gcc/config/nextstep.h @@ -0,0 +1,563 @@ +/* next.h -- operating system specific defines to be used when + targeting GCC for NeXTSTEP. + Copyright (C) 1989, 1990, 1991, 1992, 1993 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. */ + +/* Use new NeXT include file search path. + In a cross compiler with NeXT as target, don't expect + the host to use Next's directory scheme. */ + +#ifndef CROSS_COMPILE +#undef INCLUDE_DEFAULTS +#define INCLUDE_DEFAULTS \ + { \ + { GPLUSPLUS_INCLUDE_DIR, 1}, \ + { GCC_INCLUDE_DIR, 0}, \ + { LOCAL_INCLUDE_DIR, 0}, \ + { "/NextDeveloper/Headers", 0}, \ + { "/NextDeveloper/Headers/ansi", 0}, \ + { "/NextDeveloper/Headers/bsd", 0}, \ + { "/LocalDeveloper/Headers", 0}, \ + { "/LocalDeveloper/Headers/ansi", 0}, \ + { "/LocalDeveloper/Headers/bsd", 0}, \ + { "/NextDeveloper/2.0CompatibleHeaders", 0}, \ + { STANDARD_INCLUDE_DIR, 0}, \ + { 0, 0} \ + } +#endif /* CROSS_COMPILE */ + +/* Search for compiler tools in /lib. */ + +#undef STANDARD_EXEC_PREFIX +#define STANDARD_EXEC_PREFIX "/lib/" + +#undef EXTRA_FORMAT_FUNCTIONS +#define EXTRA_FORMAT_FUNCTIONS \ + "NXPrintf", FALSE, 2, FALSE, \ + "NXScanf", TRUE, 2, FALSE, \ + "NXVPrintf", FALSE, 2, TRUE, \ + "NXVScanf", TRUE, 2, TRUE, \ + "DPSPrintf", FALSE, 2, FALSE, \ + "bsd_sprintf", FALSE, 2, FALSE, \ + "bsd_vsprintf", FALSE, 2, TRUE, + +/* Use NeXT's special calling convention for sending an Objc message. */ + +#define NEXT_OBJC_RUNTIME + +/* NeXT-private compiler modifications */ + +#define NeXT_OBJC + +/* We have atexit. */ + +#define HAVE_ATEXIT + +/* Enable recent gcc to compile under the old gcc in Next release 1.0. */ + +#define __inline inline + +/* wchar_t is unsigned short */ + +#undef WCHAR_TYPE +#define WCHAR_TYPE "short unsigned int" +#undef WCHAR_TYPE_SIZE +#define WCHAR_TYPE_SIZE (BITS_PER_WORD / 2) + +/* Don't default to pcc-struct-return, because gcc is the only compiler, and + we want to retain compatibility with older gcc versions. */ + +#undef DEFAULT_PCC_STRUCT_RETURN +#define DEFAULT_PCC_STRUCT_RETURN 0 + +/* These compiler options take n arguments. */ + +#undef WORD_SWITCH_TAKES_ARG +#define WORD_SWITCH_TAKES_ARG(STR) \ + (!strcmp (STR, "Ttext") ? 1 : \ + !strcmp (STR, "Tdata") ? 1 : \ + !strcmp (STR, "Tbss") ? 1 : \ + !strcmp (STR, "include") ? 1 : \ + !strcmp (STR, "imacros") ? 1 : \ + !strcmp (STR, "segalign") ? 1 : \ + !strcmp (STR, "seg1addr") ? 1 : \ + !strcmp (STR, "segaddr") ? 2 : \ + !strcmp (STR, "sectobjectsymbols") ? 2 : \ + !strcmp (STR, "segprot") ? 3 : \ + !strcmp (STR, "sectcreate") ? 3 : \ + !strcmp (STR, "sectalign") ? 3 : \ + !strcmp (STR, "segcreate") ? 3 : \ + !strcmp (STR, "sectorder") ? 3 : \ + !strcmp (STR, "aux-info") ? 1 : \ + !strcmp (STR, "siff-mask") ? 1 : \ + !strcmp (STR, "siff-filter") ? 1 : \ + !strcmp (STR, "siff-warning") ? 1 : \ + !strcmp (STR, "arch") ? 1 : \ + !strcmp (STR, "pagezero_size") ? 1 : \ + 0) + +#undef WORD_SWITCH +#define WORD_SWITCH(STR) \ + (WORD_SWITCH_TAKES_ARG (STR) \ + || !strcmp (STR, "bsd") \ + || !strcmp (STR, "object") \ + || !strcmp (STR, "ObjC") \ + || !strcmp (STR, "all_load")) + +/* Machine dependent ccp options. */ + +#undef CPP_SPEC +#define CPP_SPEC "%{!traditional: -D__STDC__} \ + %{posixstrict:-D_POSIX_SOURCE} \ + %{!posixstrict:%{bsd:-D__STRICT_BSD__} \ + %{posix:-D_POSIX_SOURCE} \ + %{!ansi:-D_NEXT_SOURCE}} \ + %{MD:-MD %M} %{MMD:-MMD %M}" + +/* Machine dependent ld options. */ + +#undef LINK_SPEC +#define LINK_SPEC "%{Z} %{M} \ +%{execute*} %{preload*} %{fvmlib*} \ +%{segalign*} %{seg1addr*} %{segaddr*} %{segprot*} \ +%{pagezero_size*} \ +%{seglinkedit*} %{noseglinkedit*} \ +%{sectcreate*} %{sectalign*} %{sectobjectsymbols}\ +%{segcreate*} %{Mach*} %{whyload} %{w} \ +%{sectorder*} %{whatsloaded} %{ObjC} %{all_load} %{object}" + +/* Machine dependent libraries. */ + +#undef LIB_SPEC +#define LIB_SPEC "%{!posix*:-lsys_s} %{posix*:-lposix}" + +/* We specify crt0.o as -lcrt0.o so that ld will search the library path. */ + +#undef STARTFILE_SPEC +#define STARTFILE_SPEC \ + "%{!posix*:%{pg:-lgcrt0.o}%{!pg: \ + %{p:%e-p profiling is no longer supported. Use -pg instead.} \ + %{!p:-lcrt0.o}}}\ + %{posix*:%{pg:-lgposixcrt0.o}%{!pg: \ + %{p:%e-p profiling is no longer supported. Use -pg instead.} \ + %{!p:-lposixcrt0.o}}}" + +/* Why not? */ + +#undef DOLLARS_IN_IDENTIFIERS +#define DOLLARS_IN_IDENTIFIERS 2 + +/* Allow #sscs (but don't do anything). */ + +#define SCCS_DIRECTIVE + +/* We use Dbx symbol format. */ + +#undef SDB_DEBUGGING_INFO +#undef XCOFF_DEBUGGING_INFO +#define DBX_DEBUGGING_INFO + +/* This saves a fair amount of space. */ + +#undef DBX_CONTIN_LENGTH +#define DBX_CONTIN_LENGTH 0 + +/* These screw up NeXT's gdb at the moment, so don't use them. */ + +#undef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY +#define DBX_OUTPUT_MAIN_SOURCE_DIRECTORY(FILE, FILENAME) + +/* These come from bsd386.h, but are specific to sequent, so make sure + they don't bite us. */ + +#undef DBX_NO_XREFS +#undef DBX_CONTIN_LENGTH + +/* gdb needs a null N_SO at the end of each file for scattered loading. */ + +#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END +#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \ + fprintf (FILE, \ + "\t.text\n\t.stabs \"%s\",%d,0,0,Letext\nLetext:\n", \ + "" , N_SO) + +/* Don't use .gcc_compiled symbols to communicate with GDB; + They interfere with numerically sorted symbol lists. */ + +#undef ASM_IDENTIFY_GCC +#define ASM_IDENTIFY_GCC(asm_out_file) +#undef INIT_SECTION_ASM_OP +#define INIT_SECTION_ASM_OP +#undef INVOKE__main + +#undef ASM_OUTPUT_CONSTRUCTOR +#define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ + do { constructor_section (); \ + ASM_OUTPUT_ALIGN (FILE, 1); \ + fprintf (FILE, "\t.long "); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + fprintf (FILE, ".reference .constructors_used\n"); \ + } while (0) + +#undef ASM_OUTPUT_DESTRUCTOR +#define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ + do { destructor_section (); \ + ASM_OUTPUT_ALIGN (FILE, 1); \ + fprintf (FILE, "\t.long "); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + fprintf (FILE, ".reference .destructors_used\n"); \ + } while (0) + +#undef ASM_FILE_START +#define ASM_FILE_START(FILE) \ + fprintf (FILE, "\t.file\t\"%s\"\n", dump_base_name); + +#undef ASM_FILE_END +#define ASM_FILE_END(FILE) \ + do { \ + extern char *language_string; \ + if (strcmp (language_string, "GNU C++") == 0) \ + { \ + constructor_section (); \ + destructor_section (); \ + ASM_OUTPUT_ALIGN (FILE, 1); \ + } \ + } while (0) + +/* How to parse #pragma's */ + +#undef HANDLE_PRAGMA +#define HANDLE_PRAGMA(finput) handle_pragma (finput, &get_directive_line) + +/* Give methods pretty symbol names on NeXT. */ + +#undef OBJC_GEN_METHOD_LABEL +#define OBJC_GEN_METHOD_LABEL(BUF,IS_INST,CLASS_NAME,CAT_NAME,SEL_NAME,NUM) \ + do { if (CAT_NAME) \ + sprintf (BUF, "%c[%s(%s) %s]", (IS_INST) ? '-' : '+', \ + (CLASS_NAME), (CAT_NAME), (SEL_NAME)); \ + else \ + sprintf (BUF, "%c[%s %s]", (IS_INST) ? '-' : '+', \ + (CLASS_NAME), (SEL_NAME)); \ + } while (0) + +/* Wrap new method names in quotes so the assembler doesn't gag. + Make Objective-C internal symbols local. */ + +#undef ASM_OUTPUT_LABELREF +#define ASM_OUTPUT_LABELREF(FILE,NAME) \ + do { if (NAME[0] == '+' || NAME[0] == '-') fprintf (FILE, "\"%s\"", NAME); \ + else if (!strncmp (NAME, "_OBJC_", 6)) fprintf (FILE, "L%s", NAME); \ + else if (!strncmp (NAME, ".objc_class_name_", 17)) \ + fprintf (FILE, "%s", NAME); \ + else fprintf (FILE, "_%s", NAME); } while (0) + +#undef ALIGN_ASM_OP +#define ALIGN_ASM_OP ".align" + +#undef ASM_OUTPUT_ALIGN +#define ASM_OUTPUT_ALIGN(FILE,LOG) \ + if ((LOG) != 0) \ + fprintf (FILE, "\t%s %d\n", ALIGN_ASM_OP, (LOG)) + +/* Ensure correct alignment of bss data. */ + +#undef ASM_OUTPUT_ALIGNED_LOCAL +#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \ +( fputs (".lcomm ", (FILE)), \ + assemble_name ((FILE), (NAME)), \ + fprintf ((FILE), ",%u,%u\n", (SIZE), floor_log2 ((ALIGN) / BITS_PER_UNIT))) + +/* Output #ident as a .ident. */ + +#undef ASM_OUTPUT_IDENT +#define ASM_OUTPUT_IDENT(FILE, NAME) fprintf (FILE, "\t.ident \"%s\"\n", NAME); + +/* The maximum alignment which the object file format can support. + For NeXT's Mach-O format, this is 2^15. */ + +#undef MAX_OFILE_ALIGNMENT +#define MAX_OFILE_ALIGNMENT 0x8000 + +/* Create new Mach-O sections. */ + +#undef SECTION_FUNCTION +#define SECTION_FUNCTION(FUNCTION, SECTION, DIRECTIVE, WAS_TEXT, OBJC) \ +void \ +FUNCTION () \ +{ \ + extern void text_section (); \ + extern void objc_section_init (); \ + extern int flag_no_mach_text_sections; \ + \ + if (WAS_TEXT && flag_no_mach_text_sections) \ + text_section (); \ + else if (in_section != SECTION) \ + { \ + if (OBJC) \ + objc_section_init (); \ + fprintf (asm_out_file, "%s\n", DIRECTIVE); \ + in_section = SECTION; \ + } \ +} \ + +#undef EXTRA_SECTIONS +#define EXTRA_SECTIONS \ + in_const, in_cstring, in_literal4, in_literal8, \ + in_constructor, in_destructor, \ + in_objc_class, in_objc_meta_class, in_objc_category, \ + in_objc_class_vars, in_objc_instance_vars, \ + in_objc_cls_meth, in_objc_inst_meth, \ + in_objc_cat_cls_meth, in_objc_cat_inst_meth, \ + in_objc_selector_refs, \ + in_objc_symbols, in_objc_module_info, \ + in_objc_protocol, in_objc_string_object, \ + in_objc_class_names, in_objc_meth_var_names, \ + in_objc_meth_var_types, in_objc_cls_refs + +#undef EXTRA_SECTION_FUNCTIONS +#define EXTRA_SECTION_FUNCTIONS \ +SECTION_FUNCTION (const_section, \ + in_const, \ + ".const", 1, 0) \ +SECTION_FUNCTION (cstring_section, \ + in_cstring, \ + ".cstring", 1, 0) \ +SECTION_FUNCTION (literal4_section, \ + in_literal4, \ + ".literal4", 1, 0) \ +SECTION_FUNCTION (literal8_section, \ + in_literal8, \ + ".literal8", 1, 0) \ +SECTION_FUNCTION (constructor_section, \ + in_constructor, \ + ".constructor", 0, 0) \ +SECTION_FUNCTION (destructor_section, \ + in_destructor, \ + ".destructor", 0, 0) \ +SECTION_FUNCTION (objc_class_section, \ + in_objc_class, \ + ".objc_class", 0, 1) \ +SECTION_FUNCTION (objc_meta_class_section, \ + in_objc_meta_class, \ + ".objc_meta_class", 0, 1) \ +SECTION_FUNCTION (objc_category_section, \ + in_objc_category, \ + ".objc_category", 0, 1) \ +SECTION_FUNCTION (objc_class_vars_section, \ + in_objc_class_vars, \ + ".objc_class_vars", 0, 1) \ +SECTION_FUNCTION (objc_instance_vars_section, \ + in_objc_instance_vars, \ + ".objc_instance_vars", 0, 1) \ +SECTION_FUNCTION (objc_cls_meth_section, \ + in_objc_cls_meth, \ + ".objc_cls_meth", 0, 1) \ +SECTION_FUNCTION (objc_inst_meth_section, \ + in_objc_inst_meth, \ + ".objc_inst_meth", 0, 1) \ +SECTION_FUNCTION (objc_cat_cls_meth_section, \ + in_objc_cat_cls_meth, \ + ".objc_cat_cls_meth", 0, 1) \ +SECTION_FUNCTION (objc_cat_inst_meth_section, \ + in_objc_cat_inst_meth, \ + ".objc_cat_inst_meth", 0, 1) \ +SECTION_FUNCTION (objc_selector_refs_section, \ + in_objc_selector_refs, \ + ".objc_message_refs", 0, 1) \ +SECTION_FUNCTION (objc_symbols_section, \ + in_objc_symbols, \ + ".objc_symbols", 0, 1) \ +SECTION_FUNCTION (objc_module_info_section, \ + in_objc_module_info, \ + ".objc_module_info", 0, 1) \ +SECTION_FUNCTION (objc_protocol_section, \ + in_objc_protocol, \ + ".objc_protocol", 0, 1) \ +SECTION_FUNCTION (objc_string_object_section, \ + in_objc_string_object, \ + ".objc_string_object", 0, 1) \ +SECTION_FUNCTION (objc_class_names_section, \ + in_objc_class_names, \ + ".objc_class_names", 0, 1) \ +SECTION_FUNCTION (objc_meth_var_names_section, \ + in_objc_meth_var_names, \ + ".objc_meth_var_names", 0, 1) \ +SECTION_FUNCTION (objc_meth_var_types_section, \ + in_objc_meth_var_types, \ + ".objc_meth_var_types", 0, 1) \ +SECTION_FUNCTION (objc_cls_refs_section, \ + in_objc_cls_refs, \ + ".objc_cls_refs", 0, 1) \ + \ +void \ +objc_section_init () \ +{ \ + static int been_here = 0; \ + \ + if (been_here == 0) \ + { \ + been_here = 1; \ + objc_class_section (); \ + objc_meta_class_section (); \ + objc_cat_cls_meth_section (); \ + objc_cat_inst_meth_section (); \ + objc_cls_meth_section (); \ + objc_inst_meth_section (); \ + objc_selector_refs_section (); \ + objc_symbols_section (); \ + objc_category_section (); \ + objc_protocol_section (); \ + objc_class_vars_section (); \ + objc_instance_vars_section (); \ + objc_module_info_section (); \ + objc_string_object_section (); \ + objc_class_names_section (); \ + objc_meth_var_names_section (); \ + objc_meth_var_types_section (); \ + objc_cls_refs_section (); \ + } \ +} + +#undef READONLY_DATA_SECTION +#define READONLY_DATA_SECTION const_section + +#undef SELECT_SECTION +#define SELECT_SECTION(exp,reloc) \ + do \ + { \ + if (TREE_CODE (exp) == STRING_CST) \ + { \ + if (flag_writable_strings) \ + data_section (); \ + else if (TREE_STRING_LENGTH (exp) != \ + strlen (TREE_STRING_POINTER (exp)) + 1) \ + readonly_data_section (); \ + else \ + cstring_section (); \ + } \ + else if (TREE_CODE (exp) == INTEGER_CST \ + || TREE_CODE (exp) == REAL_CST) \ + { \ + tree size = TYPE_SIZE (TREE_TYPE (exp)); \ + \ + if (TREE_CODE (size) == INTEGER_CST && \ + TREE_INT_CST_LOW (size) == 4 && \ + TREE_INT_CST_HIGH (size) == 0) \ + literal4_section (); \ + else if (TREE_CODE (size) == INTEGER_CST && \ + TREE_INT_CST_LOW (size) == 8 && \ + TREE_INT_CST_HIGH (size) == 0) \ + literal8_section (); \ + else \ + readonly_data_section (); \ + } \ + else if (TREE_CODE (exp) == CONSTRUCTOR \ + && TREE_TYPE (exp) \ + && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE \ + && TYPE_NAME (TREE_TYPE (exp)) \ + && TREE_CODE (TYPE_NAME (TREE_TYPE (exp))) == IDENTIFIER_NODE \ + && IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (exp)))) \ + { \ + if (!strcmp (IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (exp))), \ + "NXConstantString")) \ + objc_string_object_section (); \ + else if ((TREE_READONLY (exp) || TREE_CONSTANT (exp)) \ + && !TREE_SIDE_EFFECTS (exp)) \ + readonly_data_section (); \ + else \ + data_section (); \ + } \ + else if (TREE_CODE (exp) == VAR_DECL && \ + DECL_NAME (exp) && \ + TREE_CODE (DECL_NAME (exp)) == IDENTIFIER_NODE && \ + IDENTIFIER_POINTER (DECL_NAME (exp)) && \ + !strncmp (IDENTIFIER_POINTER (DECL_NAME (exp)), "_OBJC_", 6)) \ + { \ + const char *name = IDENTIFIER_POINTER (DECL_NAME (exp)); \ + \ + if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20)) \ + objc_cls_meth_section (); \ + else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23)) \ + objc_inst_meth_section (); \ + else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20)) \ + objc_cat_cls_meth_section (); \ + else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23)) \ + objc_cat_inst_meth_section (); \ + else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22)) \ + objc_class_vars_section (); \ + else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25)) \ + objc_instance_vars_section (); \ + else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22)) \ + objc_cat_cls_meth_section (); \ + else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17)) \ + objc_class_names_section (); \ + else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20)) \ + objc_meth_var_names_section (); \ + else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20)) \ + objc_meth_var_types_section (); \ + else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22)) \ + objc_cls_refs_section (); \ + else if (!strncmp (name, "_OBJC_CLASS_", 12)) \ + objc_class_section (); \ + else if (!strncmp (name, "_OBJC_METACLASS_", 16)) \ + objc_meta_class_section (); \ + else if (!strncmp (name, "_OBJC_CATEGORY_", 15)) \ + objc_category_section (); \ + else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25)) \ + objc_selector_refs_section (); \ + else if (!strncmp (name, "_OBJC_SYMBOLS", 13)) \ + objc_symbols_section (); \ + else if (!strncmp (name, "_OBJC_MODULES", 13)) \ + objc_module_info_section (); \ + else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32)) \ + objc_cat_inst_meth_section (); \ + else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29)) \ + objc_cat_cls_meth_section (); \ + else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20)) \ + objc_cat_cls_meth_section (); \ + else if (!strncmp (name, "_OBJC_PROTOCOL_", 15)) \ + objc_protocol_section (); \ + else if ((TREE_READONLY (exp) || TREE_CONSTANT (exp)) \ + && !TREE_SIDE_EFFECTS (exp)) \ + readonly_data_section (); \ + else \ + data_section (); \ + } \ + else if ((TREE_READONLY (exp) || TREE_CONSTANT (exp)) \ + && !TREE_SIDE_EFFECTS (exp)) \ + readonly_data_section (); \ + else \ + data_section (); \ + } \ + while (0) + +#undef SELECT_RTX_SECTION +#define SELECT_RTX_SECTION(mode, rtx) \ + do \ + { \ + if (GET_MODE_SIZE(mode) == 8) \ + literal8_section(); \ + else if (GET_MODE_SIZE(mode) == 4) \ + literal4_section(); \ + else \ + const_section (); \ + } \ + while (0) -- 2.30.2