+2001-04-11 Stan Shebs <shebs@apple.com>
+
+ Add Darwin (Mac OS X kernel) native support.
+ * config.gcc (powerpc-*-darwin*): Add native bits.
+ * config/darwin.c: New file, generic Darwin support functions.
+ * config/darwin.h: New file, generic Darwin definitions.
+ * config/darwin-protos.h: New file, generic Darwin prototypes.
+ * rs6000/darwin.h: New file, Darwin for PowerPC.
+ * rs6000/t-darwin: New file, Darwin makefile fragment.
+ * rs6000/rs6000.h (OBJECT_MACHO): New macro.
+ (TARGET_MACHO): Ditto.
+ (rs6000_abi): Add ABI_DARWIN.
+ (RS6000_REG_SAVE): Add ABI_DARWIN case.
+ (RS6000_SAVE_AREA): Ditto.
+ (FP_ARG_MAX_REG): Ditto.
+ (RETURN_ADDRESS_OFFSET): Ditto.
+ * rs6000/rs6000.c (rs6000_legitimize_address): Add TARGET_MACHO
+ cases.
+ (rs6000_emit_move): Add ABI_DARWIN cases.
+ (print_operand): Ditto.
+ (first_reg_to_save): Ditto.
+ (rs6000_stack_info): Ditto, also align stack by 16 instead of 8.
+ (debug_stack_info): Ditto.
+ (rs6000_emit_prologue): Ditto.
+ (rs6000_emit_epilogue): Ditto.
+ (output_profiler_hook): Ditto.
+ (output_function_profiler): Ditto.
+ (rs6000_add_gc_roots): Call machopic_add_gc_roots if TARGET_MACHO.
+ (output_mi_thunk): Add TARGET_MACHO case.
+ (add_compiler_stub): Ditto.
+ (output_compiler_stub): Ditto.
+ (no_previous_def): Ditto.
+ (output_call): Ditto.
+ (machopic_output_stub): Ditto.
+ (rs6000_machopic_legitimize_pic_address): Ditto.
+ (toc_section): Ditto.
+ * rs6000/rs6000.md (addsi3_high): New TARGET_MACHO pattern.
+ (macho_high): Ditto.
+ (macho_low): Ditto.
+ (movsi_low): Ditto.
+ (load_macho_picbase): Ditto.
+ (call): Add TARGET_MACHO case to modify function.
+ (call_value): Ditto.
+ (call_nonlocal_sysv): Add ABI_DARWIN case.
+ (call_value_nonlocal_sysv): Ditto.
+ * rs6000/rs6000-protos.h (rs6000_machopic_legitimize_pic_address):
+ Add prototype.
+ (machopic_output_stub): Ditto.
+ * ginclude/stddef.h: Test _BSD_WCHAR_T_DEFINED_.
+
2001-04-11 Mark Mitchell <mark@codesourcery.com>
* dwarf2out.c (modified_type_die): Don't create new types here.
tmake_file=rs6000/t-beos
;;
powerpc-*-darwin*)
+ cpu_type=rs6000
+ tm_file="${tm_file} darwin.h rs6000/darwin.h"
+ tm_p_file="${tm_p_file} darwin-protos.h"
+ tmake_file=rs6000/t-darwin
xm_file=rs6000/xm-darwin.h
xmake_file=rs6000/x-darwin
+ extra_objs="darwin.o"
+ # Darwin linker does collect2 functionality
+ use_collect2=no
;;
powerpc-*-sysv*)
tm_file="${tm_file} svr4.h rs6000/sysv4.h"
--- /dev/null
+/* Prototypes.
+ Copyright (C) 2001 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+extern int name_needs_quotes PARAMS ((const char *));
+
+extern void machopic_validate_stub_or_non_lazy_ptr PARAMS ((const char *, int));
+
+extern char *machopic_function_base_name PARAMS ((void));
+extern char *machopic_non_lazy_ptr_name PARAMS ((const char*));
+extern char *machopic_stub_name PARAMS ((const char*));
+
+extern void machopic_add_gc_roots PARAMS ((void));
+
+extern void machopic_picsymbol_stub_section PARAMS ((void));
+extern void machopic_symbol_stub_section PARAMS ((void));
+extern void machopic_lazy_symbol_ptr_section PARAMS ((void));
+extern void machopic_nl_symbol_ptr_section PARAMS ((void));
+
+#ifdef RTX_CODE
+
+extern int machopic_operand_p PARAMS ((rtx));
+extern enum machopic_addr_class machopic_classify_name PARAMS ((const char*));
+
+extern rtx machopic_indirect_data_reference PARAMS ((rtx, rtx));
+extern rtx machopic_indirect_call_target PARAMS ((rtx));
+extern rtx machopic_legitimize_pic_address PARAMS ((rtx, enum machine_mode, rtx));
+
+#endif /* RTX_CODE */
+
+#ifdef TREE_CODE
+
+extern enum machopic_addr_class machopic_classify_ident PARAMS ((tree));
+extern void machopic_define_ident PARAMS ((tree));
+extern void machopic_define_name PARAMS ((const char*));
+extern int machopic_name_defined_p PARAMS ((const char*));
+extern int machopic_ident_defined_p PARAMS ((tree));
+
+#endif /* TREE_CODE */
+
+extern void machopic_finish PARAMS ((FILE *));
--- /dev/null
+/* Functions for generic Darwin as target machine for GNU C compiler.
+ Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001
+ Free Software Foundation, Inc.
+ Contributed by Apple Computer 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+#include "config.h"
+#include "system.h"
+#include "rtl.h"
+#include "regs.h"
+#include "hard-reg-set.h"
+#include "real.h"
+#include "insn-config.h"
+#include "conditions.h"
+#include "insn-flags.h"
+#include "output.h"
+#include "insn-attr.h"
+#include "flags.h"
+#include "tree.h"
+#include "expr.h"
+#include "reload.h"
+/* need for IDENTIFIER_GLOBAL_VALUE and IDENTIFIER_LOCAL_VALUE */
+#include "c-tree.h"
+#include "function.h"
+#include "ggc.h"
+
+#include "darwin-protos.h"
+
+extern void machopic_output_stub PARAMS ((FILE *, const char *, const char *));
+
+static int machopic_data_defined_p PARAMS ((const char *));
+static int func_name_maybe_scoped PARAMS ((const char *));
+
+/* Make everything that used to go in the text section really go there. */
+
+int flag_no_mach_text_sections = 0;
+
+int
+name_needs_quotes (name)
+ const char *name;
+{
+ int c;
+ while ((c = *name++) != '\0')
+ if (!isalnum (c) && c != '_')
+ return 1;
+ return 0;
+}
+
+/*
+ * flag_pic = 1 ... generate only indirections
+ * flag_pic = 2 ... generate indirections and pure code
+ */
+
+/* This module assumes that (const (symbol_ref "foo")) is a legal pic
+ reference, which will not be changed. */
+
+static tree machopic_defined_list;
+
+enum machopic_addr_class
+machopic_classify_ident (ident)
+ tree ident;
+{
+ const char *name = IDENTIFIER_POINTER (ident);
+ int lprefix = (((name[0] == '*' || name[0] == '&')
+ && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
+ || ( name[0] == '_'
+ && name[1] == 'O'
+ && name[2] == 'B'
+ && name[3] == 'J'
+ && name[4] == 'C'
+ && name[5] == '_'));
+ tree temp, decl = lookup_name_darwin (ident);
+
+ if (!decl)
+ {
+ if (lprefix)
+ {
+ const char *name = IDENTIFIER_POINTER (ident);
+ int len = strlen (name);
+
+ if ((len > 5 && !strcmp (name + len - 5, "$stub"))
+ || (len > 6 && !strcmp (name + len - 6, "$stub\"")))
+ return MACHOPIC_DEFINED_FUNCTION;
+ return MACHOPIC_DEFINED_DATA;
+ }
+
+ for (temp = machopic_defined_list;
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ {
+ if (ident == TREE_VALUE (temp))
+ return MACHOPIC_DEFINED_DATA;
+ }
+
+ if (TREE_ASM_WRITTEN (ident))
+ return MACHOPIC_DEFINED_DATA;
+
+ return MACHOPIC_UNDEFINED;
+ }
+
+ /* variable declarations */
+ else if (TREE_CODE (decl) == VAR_DECL)
+ {
+ if ((DECL_INITIAL (decl)
+ || TREE_STATIC (decl))
+ && ! TREE_PUBLIC (decl))
+ return MACHOPIC_DEFINED_DATA;
+ }
+
+ /* function declarations */
+ else if (TREE_CODE (decl) == FUNCTION_DECL
+ && (!DECL_EXTERNAL (decl)))
+ {
+ if (TREE_STATIC (decl)
+ || TREE_ASM_WRITTEN (decl))
+ return MACHOPIC_DEFINED_FUNCTION;
+ }
+
+ for (temp = machopic_defined_list; temp != NULL_TREE; temp = TREE_CHAIN (temp))
+ {
+ if (ident == TREE_VALUE (temp))
+ {
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ return MACHOPIC_DEFINED_FUNCTION;
+ else
+ return MACHOPIC_DEFINED_DATA;
+ }
+ }
+
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ if (lprefix)
+ return MACHOPIC_DEFINED_FUNCTION;
+ else
+ return MACHOPIC_UNDEFINED_FUNCTION;
+ }
+ else
+ {
+ if (lprefix)
+ return MACHOPIC_DEFINED_DATA;
+ else
+ return MACHOPIC_UNDEFINED_DATA;
+ }
+}
+
+
+enum machopic_addr_class
+machopic_classify_name (name)
+ const char *name;
+{
+ return machopic_classify_ident (get_identifier (name));
+}
+
+int
+machopic_ident_defined_p (ident)
+ tree ident;
+{
+ switch (machopic_classify_ident (ident))
+ {
+ case MACHOPIC_UNDEFINED:
+ case MACHOPIC_UNDEFINED_DATA:
+ case MACHOPIC_UNDEFINED_FUNCTION:
+ return 0;
+ default:
+ return 1;
+ }
+}
+
+static int
+machopic_data_defined_p (name)
+ const char *name;
+{
+ switch (machopic_classify_ident (get_identifier (name)))
+ {
+ case MACHOPIC_DEFINED_DATA:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+int
+machopic_name_defined_p (name)
+ const char *name;
+{
+ return machopic_ident_defined_p (get_identifier (name));
+}
+
+void
+machopic_define_ident (ident)
+ tree ident;
+{
+ if (!machopic_ident_defined_p (ident))
+ machopic_defined_list =
+ tree_cons (NULL_TREE, ident, machopic_defined_list);
+}
+
+void
+machopic_define_name (name)
+ const char *name;
+{
+ machopic_define_ident (get_identifier (name));
+}
+
+tree
+lookup_name_darwin (name)
+ tree name;
+{
+ tree val;
+
+ if (!global_bindings_p()
+ && IDENTIFIER_LOCAL_VALUE (name))
+ val = IDENTIFIER_LOCAL_VALUE (name);
+ else
+ val = IDENTIFIER_GLOBAL_VALUE (name);
+ return val;
+}
+
+/* This is a static to make inline functions work. The rtx
+ representing the PIC base symbol always points to here. */
+
+static char function_base[32];
+
+static int current_pic_label_num;
+
+char *
+machopic_function_base_name ()
+{
+ static char *name = NULL;
+ static const char *current_name;
+
+ current_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
+
+ if (name != current_name)
+ {
+ current_function_uses_pic_offset_table = 1;
+
+ /* Save mucho space and time. Some of the C++ mangled names are over
+ 700 characters long! Note that we produce a label containing a '-'
+ if the function we're compiling is an Objective-C method, as evinced
+ by the incredibly scientific test below. This is because code in
+ rs6000.c makes the same ugly test when loading the PIC reg. */
+
+ ++current_pic_label_num;
+ if (*current_name == '+' || *current_name == '-')
+ sprintf (function_base, "*\"L-%d$pb\"", current_pic_label_num);
+ else
+ sprintf (function_base, "*L%d$pb", current_pic_label_num);
+
+ name = current_name;
+ }
+
+ return function_base;
+}
+
+static tree machopic_non_lazy_pointers = NULL;
+
+/* Return a non-lazy pointer name corresponding to the given name,
+ either by finding it in our list of pointer names, or by generating
+ a new one. */
+
+char *
+machopic_non_lazy_ptr_name (name)
+ const char *name;
+{
+ tree temp, ident = get_identifier (name);
+
+ for (temp = machopic_non_lazy_pointers;
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ {
+ if (ident == TREE_VALUE (temp))
+ return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+ }
+
+ {
+ char *buffer;
+ tree ptr_name;
+
+ buffer = alloca (strlen (name) + 20);
+
+ strcpy (buffer, "&L");
+ if (name[0] == '*')
+ strcat (buffer, name+1);
+ else
+ {
+ strcat (buffer, "_");
+ strcat (buffer, name);
+ }
+
+ strcat (buffer, "$non_lazy_ptr");
+ ptr_name = get_identifier (buffer);
+
+ machopic_non_lazy_pointers
+ = tree_cons (ptr_name, ident, machopic_non_lazy_pointers);
+
+ TREE_USED (machopic_non_lazy_pointers) = 0;
+
+ return IDENTIFIER_POINTER (ptr_name);
+ }
+}
+
+static tree machopic_stubs = 0;
+
+/* Make sure the GC knows about our homemade lists. */
+
+void
+machopic_add_gc_roots ()
+{
+ ggc_add_tree_root (&machopic_defined_list, 1);
+ ggc_add_tree_root (&machopic_non_lazy_pointers, 1);
+ ggc_add_tree_root (&machopic_stubs, 1);
+}
+
+/* Return the name of the stub corresponding to the given name,
+ generating a new stub name if necessary. */
+
+char *
+machopic_stub_name (name)
+ const char *name;
+{
+ tree temp, ident = get_identifier (name);
+
+ for (temp = machopic_stubs;
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ {
+ if (ident == TREE_VALUE (temp))
+ return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+ }
+
+ {
+ char *buffer;
+ tree ptr_name;
+ int needs_quotes = name_needs_quotes (name);
+
+ buffer = alloca (strlen (name) + 20);
+
+ if (needs_quotes)
+ strcpy (buffer, "&\"L");
+ else
+ strcpy (buffer, "&L");
+ if (name[0] == '*')
+ {
+ strcat (buffer, name+1);
+ }
+ else
+ {
+ strcat (buffer, "_");
+ strcat (buffer, name);
+ }
+
+ if (needs_quotes)
+ strcat (buffer, "$stub\"");
+ else
+ strcat (buffer, "$stub");
+ ptr_name = get_identifier (buffer);
+
+ machopic_stubs = tree_cons (ptr_name, ident, machopic_stubs);
+ TREE_USED (machopic_stubs) = 0;
+
+ return IDENTIFIER_POINTER (ptr_name);
+ }
+}
+
+void
+machopic_validate_stub_or_non_lazy_ptr (name, validate_stub)
+ const char *name;
+ int validate_stub;
+{
+ tree temp, ident = get_identifier (name);
+
+ for (temp = (validate_stub ? machopic_stubs : machopic_non_lazy_pointers);
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ if (ident == TREE_PURPOSE (temp))
+ {
+ /* Mark both the stub or non-lazy pointer as well as the
+ original symbol as being referenced. */
+ TREE_USED (temp) = 1;
+ if (TREE_CODE (TREE_VALUE (temp)) == IDENTIFIER_NODE)
+ TREE_SYMBOL_REFERENCED (TREE_VALUE (temp)) = 1;
+ }
+}
+
+/* Transform ORIG, which may be any data source, to the corresponding
+ source using indirections. */
+
+rtx
+machopic_indirect_data_reference (orig, reg)
+ rtx orig, reg;
+{
+ rtx ptr_ref = orig;
+
+ if (! MACHOPIC_INDIRECT)
+ return orig;
+
+ if (GET_CODE (orig) == SYMBOL_REF)
+ {
+ const char *name = XSTR (orig, 0);
+
+ if (machopic_data_defined_p (name))
+ {
+ rtx pic_base = gen_rtx (SYMBOL_REF, Pmode,
+ machopic_function_base_name ());
+ rtx offset = gen_rtx (CONST, Pmode,
+ gen_rtx (MINUS, Pmode, orig, pic_base));
+
+#if defined (TARGET_TOC) /* i.e., PowerPC */
+ rtx hi_sum_reg = reg;
+
+ if (reg == NULL)
+ abort ();
+
+ emit_insn (gen_rtx (SET, Pmode, hi_sum_reg,
+ gen_rtx (PLUS, Pmode, pic_offset_table_rtx,
+ gen_rtx (HIGH, Pmode, offset))));
+ emit_insn (gen_rtx (SET, Pmode, reg,
+ gen_rtx (LO_SUM, Pmode, hi_sum_reg, offset)));
+
+ orig = reg;
+#else
+#if defined (HAVE_lo_sum)
+ if (reg == 0) abort ();
+
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (HIGH, Pmode, offset)));
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (LO_SUM, Pmode, reg, offset)));
+ emit_insn (gen_rtx (USE, VOIDmode,
+ gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM)));
+
+ orig = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, reg);
+#endif
+#endif
+ return orig;
+ }
+
+ ptr_ref = gen_rtx (SYMBOL_REF, Pmode,
+ machopic_non_lazy_ptr_name (name));
+
+ ptr_ref = gen_rtx_MEM (Pmode, ptr_ref);
+ RTX_UNCHANGING_P (ptr_ref) = 1;
+
+ return ptr_ref;
+ }
+ else if (GET_CODE (orig) == CONST)
+ {
+ rtx base, result;
+
+ /* legitimize both operands of the PLUS */
+ if (GET_CODE (XEXP (orig, 0)) == PLUS)
+ {
+ base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
+ reg);
+ orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
+ (base == reg ? 0 : reg));
+ }
+ else
+ return orig;
+
+ if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
+ {
+ result = plus_constant_for_output (base, INTVAL (orig));
+ }
+ else
+ {
+ result = gen_rtx (PLUS, Pmode, base, orig);
+ }
+
+ if (RTX_UNCHANGING_P (base) && RTX_UNCHANGING_P (orig))
+ RTX_UNCHANGING_P (result) = 1;
+
+ if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
+ {
+ if (reg)
+ {
+ emit_move_insn (reg, result);
+ result = reg;
+ }
+ else
+ {
+ result = force_reg (GET_MODE (result), result);
+ }
+ }
+
+ return result;
+
+ }
+ else if (GET_CODE (orig) == MEM)
+ XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
+ /* When the target is i386, this code prevents crashes due to the
+ compiler's ignorance on how to move the PIC base register to
+ other registers. (The reload phase sometimes introduces such
+ insns.) */
+ else if (GET_CODE (orig) == PLUS
+ && GET_CODE (XEXP (orig, 0)) == REG
+ && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
+#ifdef I386
+ /* Prevent the same register from being erroneously used
+ as both the base and index registers. */
+ && GET_CODE (XEXP (orig, 1)) == CONST
+#endif
+ && reg)
+ {
+ emit_move_insn (reg, XEXP (orig, 0));
+ XEXP (ptr_ref, 0) = reg;
+ }
+ return ptr_ref;
+}
+
+/* For MACHOPIC_INDIRECT_CALL_TARGET below, we need to beware of:
+
+ extern "C" { int f(); }
+ struct X { int f(); int g(); };
+ int X::f() { ::f(); }
+ int X::g() { ::f(); f();}
+
+ This is hairy. Both calls to "::f()" need to be indirect (i.e., to
+ appropriate symbol stubs), but since MACHOPIC_NAME_DEFINED_P calls
+ GET_IDENTIFIER which treats "f" as "X::f", and "X::f" is indeed (being)
+ defined somewhere in "X"'s inheritance hierarchy, MACHOPIC_NAME_DEFINED_P
+ returns TRUE when called with "f", which means that
+ MACHOPIC_INDIRECT_CALL_TARGET uses an "internal" call instead of an
+ indirect one as it should.
+
+ Our quick-n-dirty solution to this is to call the following
+ FUNC_NAME_MAYBE_SCOPED routine which (only for C++) checks whether
+ FNAME -- the name of the function which we're calling -- is NOT a
+ mangled C++ name, AND if the current function being compiled is a
+ method, and if so, use an "external" or "indirect" call.
+
+ Note that this function will be called ONLY when MACHOPIC_INDIRECT_TARGET_P
+ has already indicated that the target is NOT indirect.
+
+ This conservative solution will sometimes make indirect calls where
+ it might have been possible to make direct ones.
+
+ FUNC_NAME_MAYBE_SCOPED returns 1 to indicate a "C" name (not scoped),
+ which in turns means we should create a stub for an indirect call.
+ */
+
+static int is_cplusplus = -1;
+
+static int
+func_name_maybe_scoped (fname)
+ const char *fname;
+{
+
+ if (is_cplusplus < 0)
+ is_cplusplus = (strcmp (lang_identify (), "cplusplus") == 0);
+
+ if (is_cplusplus)
+ {
+ /* If we have a method, then check whether the function we're trying to
+ call is a "C" function. If so, we should use an indirect call.
+
+ It turns out to be hard to tell whether "we have a method", since
+ static member functions have a TREE_CODE of FUNCTION_TYPE, as do
+ namespace-level non-member functions. So here, we always look for
+ an extern-"C"-like name, and make stubs for them no matter the
+ calling context. This is temporary, and leaves nagging suspicion
+ that improvements should be possible here. (I.e., I suspect that
+ it can still sometimes make stubs where it needn't.) */
+
+ /* if (1 || TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) */
+ {
+ /* If fname is of the form "f__1X" or "f__Fv", it's C++. */
+ while (*fname == '_') ++fname; /* skip leading underscores */
+ while (*fname != 0)
+ {
+ if (fname[0] == '_' && fname[1] == '_'
+ && (fname[2] == 'F' || (fname[2] >= '0' && fname[2] <= '9')))
+ return 0;
+ ++fname;
+ }
+ /* Not a C++ mangled name: must be "C", in which case play safe. */
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Transform TARGET (a MEM), which is a function call target, to the
+ corresponding symbol_stub if necessary. Return a new MEM. */
+
+rtx
+machopic_indirect_call_target (target)
+ rtx target;
+{
+ if (GET_CODE (target) != MEM)
+ return target;
+
+ if (MACHOPIC_INDIRECT && GET_CODE (XEXP (target, 0)) == SYMBOL_REF)
+ {
+ enum machine_mode mode = GET_MODE (XEXP (target, 0));
+ const char *name = XSTR (XEXP (target, 0), 0);
+
+ if (!machopic_name_defined_p (name) || func_name_maybe_scoped (name))
+ {
+ const char *stub_name = machopic_stub_name (name);
+
+ XEXP (target, 0) = gen_rtx (SYMBOL_REF, mode, stub_name);
+ RTX_UNCHANGING_P (target) = 1;
+ }
+ }
+
+ return target;
+}
+
+rtx
+machopic_legitimize_pic_address (orig, mode, reg)
+ rtx orig, reg;
+ enum machine_mode mode;
+{
+ rtx pic_ref = orig;
+
+ if (! MACHOPIC_PURE)
+ return orig;
+
+ /* First handle a simple SYMBOL_REF or LABEL_REF */
+ if (GET_CODE (orig) == LABEL_REF
+ || (GET_CODE (orig) == SYMBOL_REF
+ ))
+ {
+ /* addr(foo) = &func+(foo-func) */
+ rtx pic_base;
+
+ orig = machopic_indirect_data_reference (orig, reg);
+
+ if (GET_CODE (orig) == PLUS
+ && GET_CODE (XEXP (orig, 0)) == REG)
+ {
+ if (reg == 0)
+ return force_reg (mode, orig);
+
+ emit_move_insn (reg, orig);
+ return reg;
+ }
+
+ pic_base = gen_rtx (SYMBOL_REF, Pmode, machopic_function_base_name ());
+
+ if (GET_CODE (orig) == MEM)
+ {
+ if (reg == 0)
+ {
+ if (reload_in_progress)
+ abort ();
+ else
+ reg = gen_reg_rtx (Pmode);
+ }
+
+#ifdef HAVE_lo_sum
+ if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
+ || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
+ {
+ rtx offset = gen_rtx (CONST, Pmode,
+ gen_rtx (MINUS, Pmode,
+ XEXP (orig, 0), pic_base));
+#if defined (TARGET_TOC) /* i.e., PowerPC */
+ /* Generating a new reg may expose opportunities for
+ common subexpression elimination. */
+ rtx hi_sum_reg =
+ (reload_in_progress ? reg : gen_reg_rtx (SImode));
+
+ emit_insn (gen_rtx (SET, Pmode, hi_sum_reg,
+ gen_rtx (PLUS, Pmode,
+ pic_offset_table_rtx,
+ gen_rtx (HIGH, Pmode, offset))));
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (MEM, GET_MODE (orig),
+ gen_rtx (LO_SUM, Pmode,
+ hi_sum_reg, offset))));
+ pic_ref = reg;
+
+#else
+ emit_insn (gen_rtx (USE, VOIDmode,
+ gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM)));
+
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (HIGH, Pmode,
+ gen_rtx (CONST, Pmode, offset))));
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (LO_SUM, Pmode, reg,
+ gen_rtx (CONST, Pmode, offset))));
+ pic_ref = gen_rtx (PLUS, Pmode,
+ pic_offset_table_rtx, reg);
+#endif
+ }
+ else
+#endif /* HAVE_lo_sum */
+ {
+ rtx pic = pic_offset_table_rtx;
+ if (GET_CODE (pic) != REG)
+ {
+ emit_move_insn (reg, pic);
+ pic = reg;
+ }
+#if 0
+ emit_insn (gen_rtx (USE, VOIDmode,
+ gen_rtx (REG, Pmode, PIC_OFFSET_TABLE_REGNUM)));
+#endif
+
+ pic_ref = gen_rtx (PLUS, Pmode,
+ pic,
+ gen_rtx (CONST, Pmode,
+ gen_rtx (MINUS, Pmode,
+ XEXP (orig, 0),
+ pic_base)));
+ }
+
+#if !defined (TARGET_TOC)
+ RTX_UNCHANGING_P (pic_ref) = 1;
+ emit_move_insn (reg, pic_ref);
+ pic_ref = gen_rtx (MEM, GET_MODE (orig), reg);
+#endif
+ }
+ else
+ {
+
+#ifdef HAVE_lo_sum
+ if (GET_CODE (orig) == SYMBOL_REF
+ || GET_CODE (orig) == LABEL_REF)
+ {
+ rtx offset = gen_rtx (CONST, Pmode,
+ gen_rtx (MINUS, Pmode, orig, pic_base));
+#if defined (TARGET_TOC) /* i.e., PowerPC */
+ rtx hi_sum_reg;
+
+ if (reg == 0)
+ {
+ if (reload_in_progress)
+ abort ();
+ else
+ reg = gen_reg_rtx (SImode);
+ }
+
+ hi_sum_reg = reg;
+
+ emit_insn (gen_rtx (SET, Pmode, hi_sum_reg,
+ gen_rtx (PLUS, Pmode,
+ pic_offset_table_rtx,
+ gen_rtx (HIGH, Pmode, offset))));
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (LO_SUM, Pmode,
+ hi_sum_reg, offset)));
+ pic_ref = reg;
+#else
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (HIGH, Pmode, offset)));
+ emit_insn (gen_rtx (SET, VOIDmode, reg,
+ gen_rtx (LO_SUM, Pmode, reg, offset)));
+ pic_ref = gen_rtx (PLUS, Pmode,
+ pic_offset_table_rtx, reg);
+#endif
+ }
+ else
+#endif /* HAVE_lo_sum */
+ {
+ if (GET_CODE (orig) == REG)
+ {
+ return orig;
+ }
+ else
+ {
+ rtx pic = pic_offset_table_rtx;
+ if (GET_CODE (pic) != REG)
+ {
+ emit_move_insn (reg, pic);
+ pic = reg;
+ }
+#if 0
+ emit_insn (gen_rtx (USE, VOIDmode,
+ pic_offset_table_rtx));
+#endif
+ pic_ref = gen_rtx (PLUS, Pmode,
+ pic,
+ gen_rtx (CONST, Pmode,
+ gen_rtx (MINUS, Pmode,
+ orig, pic_base)));
+ }
+ }
+ }
+
+ RTX_UNCHANGING_P (pic_ref) = 1;
+
+ if (GET_CODE (pic_ref) != REG)
+ {
+ if (reg != 0)
+ {
+ emit_move_insn (reg, pic_ref);
+ return reg;
+ }
+ else
+ {
+ return force_reg (mode, pic_ref);
+ }
+ }
+ else
+ {
+ return pic_ref;
+ }
+ }
+
+ else if (GET_CODE (orig) == SYMBOL_REF)
+ return orig;
+
+ else if (GET_CODE (orig) == PLUS
+ && (GET_CODE (XEXP (orig, 0)) == MEM
+ || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
+ || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
+ && XEXP (orig, 0) != pic_offset_table_rtx
+ && GET_CODE (XEXP (orig, 1)) != REG)
+
+ {
+ rtx base;
+ int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
+
+ base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
+ orig = machopic_legitimize_pic_address (XEXP (orig, 1),
+ Pmode, (base == reg ? 0 : reg));
+ if (GET_CODE (orig) == CONST_INT)
+ {
+ pic_ref = plus_constant_for_output (base, INTVAL (orig));
+ is_complex = 1;
+ }
+ else
+ {
+ pic_ref = gen_rtx (PLUS, Pmode, base, orig);
+ }
+
+ if (RTX_UNCHANGING_P (base) && RTX_UNCHANGING_P (orig))
+ RTX_UNCHANGING_P (pic_ref) = 1;
+
+ if (reg && is_complex)
+ {
+ emit_move_insn (reg, pic_ref);
+ pic_ref = reg;
+ }
+ /* Likewise, should we set special REG_NOTEs here? */
+ }
+
+ else if (GET_CODE (orig) == CONST)
+ {
+ return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
+ }
+
+ else if (GET_CODE (orig) == MEM
+ && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
+ {
+ rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
+
+ addr = gen_rtx (MEM, GET_MODE (orig), addr);
+ RTX_UNCHANGING_P (addr) = RTX_UNCHANGING_P (orig);
+ emit_move_insn (reg, addr);
+ pic_ref = reg;
+ }
+
+ return pic_ref;
+}
+
+
+void
+machopic_finish (asm_out_file)
+ FILE *asm_out_file;
+{
+ tree temp;
+
+ for (temp = machopic_stubs;
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ {
+ char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ char *stub_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+ char *sym;
+ char *stub;
+ tree decl = lookup_name_darwin (TREE_VALUE (temp));
+
+ if (! TREE_USED (temp))
+ continue;
+
+ /* Don't emit stubs for static inline functions which have not
+ been compiled. */
+ if (decl
+ && TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_INLINE (decl)
+ && ! TREE_PUBLIC (decl)
+ && ! TREE_ASM_WRITTEN (decl))
+ continue;
+
+ sym = alloca (strlen (sym_name) + 2);
+ if (sym_name[0] == '*' || sym_name[0] == '&')
+ strcpy (sym, sym_name + 1);
+ else if (sym_name[0] == '-' || sym_name[0] == '+')
+ strcpy (sym, sym_name);
+ else
+ sym[0] = '_', strcpy (sym + 1, sym_name);
+
+ stub = alloca (strlen (stub_name) + 2);
+ if (stub_name[0] == '*' || stub_name[0] == '&')
+ strcpy (stub, stub_name + 1);
+ else
+ stub[0] = '_', strcpy (stub + 1, stub_name);
+
+ machopic_output_stub (asm_out_file, sym, stub);
+ }
+
+ for (temp = machopic_non_lazy_pointers;
+ temp != NULL_TREE;
+ temp = TREE_CHAIN (temp))
+ {
+ char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ char *lazy_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+#if 0
+ tree decl = lookup_name_darwin (TREE_VALUE (temp));
+#endif
+
+ if (! TREE_USED (temp))
+ continue;
+
+ if (machopic_ident_defined_p (TREE_VALUE (temp))
+#if 0 /* add back when we have private externs */
+ || (decl && DECL_PRIVATE_EXTERN (decl))
+#endif
+ )
+ {
+ data_section ();
+ assemble_align (UNITS_PER_WORD * BITS_PER_UNIT);
+ assemble_label (lazy_name);
+ assemble_integer (gen_rtx (SYMBOL_REF, Pmode, sym_name),
+ GET_MODE_SIZE (Pmode), 1);
+ }
+ else
+ {
+ machopic_nl_symbol_ptr_section ();
+ assemble_name (asm_out_file, lazy_name);
+ fprintf (asm_out_file, ":\n");
+
+ fprintf (asm_out_file, "\t.indirect_symbol ");
+ assemble_name (asm_out_file, sym_name);
+ fprintf (asm_out_file, "\n");
+
+ assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode), 1);
+ }
+ }
+}
+
+int
+machopic_operand_p (op)
+ rtx op;
+{
+ if (MACHOPIC_JUST_INDIRECT)
+ {
+ while (GET_CODE (op) == CONST)
+ op = XEXP (op, 0);
+
+ if (GET_CODE (op) == SYMBOL_REF)
+ return machopic_name_defined_p (XSTR (op, 0));
+ else
+ return 0;
+ }
+
+ while (GET_CODE (op) == CONST)
+ op = XEXP (op, 0);
+
+ if (GET_CODE (op) == MINUS
+ && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+ && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
+ && machopic_name_defined_p (XSTR (XEXP (op, 0), 0))
+ && machopic_name_defined_p (XSTR (XEXP (op, 1), 0)))
+ return 1;
+
+#if 0 /*def TARGET_TOC*/ /* i.e., PowerPC */
+ /* Without this statement, the compiler crashes while compiling enquire.c
+ when targetting PowerPC. It is not known why this code is not needed
+ when targetting other processors. */
+ else if (GET_CODE (op) == SYMBOL_REF
+ && (machopic_classify_name (XSTR (op, 0))
+ == MACHOPIC_DEFINED_FUNCTION))
+ {
+ return 1;
+ }
+#endif
+
+ return 0;
+}
--- /dev/null
+/* Target definitions for Darwin (Mac OS X) systems.
+ Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001
+ Free Software Foundation, Inc.
+ Contributed by Apple Computer 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* The definitions in this file are common to all processor types
+ running Darwin, which is the kernel for Mac OS X. Darwin is
+ basically a BSD user layer laid over a Mach kernel, then evolved
+ for many years (at NeXT) in parallel with other Unix systems. So
+ while the runtime is a somewhat idiosyncratic Mach-based thing,
+ other definitions look like they would for a BSD variant. */
+
+/* Although NeXT ran on many different architectures, as of Jan 2001
+ the only supported Darwin targets are PowerPC and x86. */
+
+/* Make the compiler look here for standard stuff. */
+
+#undef STANDARD_EXEC_PREFIX
+#define STANDARD_EXEC_PREFIX "/usr/libexec/"
+
+/* Name of the command that invokes the compiler - used in g++.c. */
+
+#undef GCC_NAME
+#define GCC_NAME "cc"
+
+/* Never try linking with -lm - used in g++.c. */
+
+#define NO_MATH_LIBRARY
+
+/* We have atexit. */
+
+#define HAVE_ATEXIT
+
+/* Define an empty body for the function do_global_dtors() in libgcc2.c. */
+
+#define DO_GLOBAL_DTORS_BODY
+
+/* The string value for __SIZE_TYPE__. */
+
+#ifndef SIZE_TYPE
+#define SIZE_TYPE "long unsigned int"
+#endif
+
+/* Type used for ptrdiff_t, as a string used in a declaration. */
+
+#undef PTRDIFF_TYPE
+#define PTRDIFF_TYPE "int"
+
+/* wchar_t is int. */
+
+#undef WCHAR_TYPE
+#define WCHAR_TYPE "int"
+#undef WCHAR_TYPE_SIZE
+#define WCHAR_TYPE_SIZE 32
+
+/* 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
+
+/* Don't warn about MacOS-style 'APPL' four-char-constants. */
+
+#undef WARN_FOUR_CHAR_CONSTANTS
+#define WARN_FOUR_CHAR_CONSTANTS 0
+
+/* Machine dependent cpp options. */
+
+/* The sequence here allows us to get a more specific version number
+ glued into __APPLE_CC__. Normally this number would be updated as
+ part of submitting to a release engineering organization. */
+
+#ifndef APPLE_CC
+#define APPLE_CC 999
+#endif
+
+#define STRINGIFY_THIS(x) # x
+#define REALLY_STRINGIFY(x) STRINGIFY_THIS(x)
+
+#undef CPP_SPEC
+#define CPP_SPEC "-D__APPLE_CC__=" REALLY_STRINGIFY(APPLE_CC) " \
+ %{static:-D__STATIC__}%{!static:-D__DYNAMIC__}"
+
+/* Machine dependent libraries. */
+
+#undef LIB_SPEC
+#define LIB_SPEC \
+ "%{!static:%{!pg:-framework System}%{pg:-framework System,_profile}}"
+
+#undef LIBGCC_SPEC
+#define LIBGCC_SPEC "%{!shared:%{static:-lcc} \
+ %{!static:-lcc_dynamic}}"
+
+/* We specify crt0.o as -lcrt0.o so that ld will search the library path. */
+
+#undef STARTFILE_SPEC
+#define STARTFILE_SPEC \
+ "%{pg:%{static:-lgcrt0.o}%{!static:-lgcrt1.o}} \
+ %{!pg:%{static:-lcrt0.o}%{!static:-lcrt1.o}}"
+
+#undef DOLLARS_IN_IDENTIFIERS
+#define DOLLARS_IN_IDENTIFIERS 2
+
+/* Allow #sccs (but don't do anything). */
+
+#define SCCS_DIRECTIVE
+
+/* We use Dbx symbol format. */
+
+#define DBX_DEBUGGING_INFO
+
+/* When generating stabs debugging, use N_BINCL entries. */
+
+#define DBX_USE_BINCL
+
+/* There is no limit to the length of stabs strings. */
+
+#define DBX_CONTIN_LENGTH 0
+
+/* 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) \
+do { text_section (); \
+ fprintf (FILE, \
+ "\t.stabs \"%s\",%d,0,0,Letext\nLetext:\n", "" , N_SO); \
+ } while (0)
+
+/* Our profiling scheme doesn't LP labels and counter words. */
+
+#define NO_PROFILE_COUNTERS
+
+/* 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 { if (flag_pic) \
+ mod_init_section (); \
+ else \
+ constructor_section (); \
+ ASM_OUTPUT_ALIGN (FILE, 1); \
+ fprintf (FILE, "\t.long "); \
+ assemble_name (FILE, NAME); \
+ fprintf (FILE, "\n"); \
+ if (!flag_pic) \
+ fprintf (FILE, ".reference .constructors_used\n"); \
+ } while (0)
+
+#undef ASM_OUTPUT_DESTRUCTOR
+#define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
+ do { if (flag_pic) \
+ mod_term_section (); \
+ else \
+ destructor_section (); \
+ ASM_OUTPUT_ALIGN (FILE, 1); \
+ fprintf (FILE, "\t.long "); \
+ assemble_name (FILE, NAME); \
+ fprintf (FILE, "\n"); \
+ if (!flag_pic) \
+ fprintf (FILE, ".reference .destructors_used\n"); \
+ } while (0)
+
+
+/* Don't output a .file directive. That is only used by the assembler for
+ error reporting. */
+
+#undef ASM_FILE_START
+#define ASM_FILE_START(FILE)
+
+#undef ASM_FILE_END
+#define ASM_FILE_END(FILE) \
+ do { \
+ extern const char *language_string; \
+ machopic_finish (asm_out_file); \
+ if (strcmp (language_string, "GNU C++") == 0) \
+ { \
+ constructor_section (); \
+ destructor_section (); \
+ ASM_OUTPUT_ALIGN (FILE, 1); \
+ } \
+ } while (0)
+
+/* Give ObjcC methods pretty symbol names. */
+
+#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)
+
+/* The RTTI data (e.g., __ti4name) is common and public (and static),
+ but it does need to be referenced via indirect PIC data pointers.
+ The machopic_define_name calls are telling the machopic subsystem
+ that the name *is* defined in this module, so it doesn't need to
+ make them indirect. */
+
+#undef ASM_DECLARE_OBJECT_NAME
+#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \
+ do { \
+ char *xname = NAME; \
+ if (GET_CODE (XEXP (DECL_RTL (DECL), 0)) != SYMBOL_REF) \
+ xname = IDENTIFIER_POINTER (DECL_NAME (DECL)); \
+ if ((TREE_STATIC (DECL) \
+ && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL))) \
+ || DECL_INITIAL (DECL)) \
+ machopic_define_name (xname); \
+ ASM_OUTPUT_LABEL (FILE, xname); \
+ } 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] == '&') \
+ { \
+ int len = strlen (NAME); \
+ if (len > 6 && !strcmp ("$stub", NAME + len - 5)) \
+ machopic_validate_stub_or_non_lazy_ptr (NAME, 1); \
+ else if (len > 7 && !strcmp ("$stub\"", NAME + len - 6)) \
+ machopic_validate_stub_or_non_lazy_ptr (NAME, 1); \
+ else if (len > 14 && !strcmp ("$non_lazy_ptr", NAME + len - 13)) \
+ machopic_validate_stub_or_non_lazy_ptr (NAME, 0); \
+ fputs (&NAME[1], FILE); \
+ } \
+ else 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_DECL_LOCAL
+#define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \
+ do { \
+ fputs (".lcomm ", (FILE)); \
+ assemble_name ((FILE), (NAME)); \
+ fprintf ((FILE), ",%u,%u\n", (SIZE), floor_log2 ((ALIGN) / BITS_PER_UNIT)); \
+ if ((DECL) && ((TREE_STATIC (DECL) \
+ && (!DECL_COMMON (DECL) || !TREE_PUBLIC (DECL))) \
+ || DECL_INITIAL (DECL))) \
+ machopic_define_name (NAME); \
+ } while (0)
+
+/* Output nothing for #ident. */
+
+#undef ASM_OUTPUT_IDENT
+#define ASM_OUTPUT_IDENT(FILE, NAME)
+
+/* The maximum alignment which the object file format can support.
+ For Mach-O, 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 (); \
+ data_section (); \
+ if (asm_out_file) \
+ fprintf (asm_out_file, "%s\n", DIRECTIVE); \
+ in_section = SECTION; \
+ } \
+} \
+
+#define ALIAS_SECTION(enum_value, alias_name) \
+do { if (!strcmp (alias_name, name)) \
+ section_alias[enum_value] = (alias ? get_identifier (alias) : 0); \
+ } while (0)
+
+/* Darwin uses many types of special sections. */
+
+#undef EXTRA_SECTIONS
+#define EXTRA_SECTIONS \
+ in_const, in_const_data, in_cstring, in_literal4, in_literal8, \
+ in_constructor, in_destructor, in_mod_init, in_mod_term, \
+ 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_selector_fixup, \
+ in_objc_symbols, in_objc_module_info, \
+ in_objc_protocol, in_objc_string_object, \
+ in_objc_constant_string_object, \
+ in_objc_class_names, in_objc_meth_var_names, \
+ in_objc_meth_var_types, in_objc_cls_refs, \
+ in_machopic_nl_symbol_ptr, \
+ in_machopic_lazy_symbol_ptr, \
+ in_machopic_symbol_stub, \
+ in_machopic_picsymbol_stub, \
+ num_sections
+
+#undef EXTRA_SECTION_FUNCTIONS
+#define EXTRA_SECTION_FUNCTIONS \
+SECTION_FUNCTION (const_section, \
+ in_const, \
+ ".const", 1, 0) \
+SECTION_FUNCTION (const_data_section, \
+ in_const_data, \
+ ".const_data", 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 (mod_init_section, \
+ in_mod_init, \
+ ".mod_init_func", 0, 0) \
+SECTION_FUNCTION (mod_term_section, \
+ in_mod_term, \
+ ".mod_term_func", 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_selector_fixup_section, \
+ in_objc_selector_fixup, \
+ ".section __OBJC, __sel_fixup", 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_constant_string_object_section, \
+ in_objc_constant_string_object, \
+ ".section __OBJC, __cstring_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) \
+ \
+SECTION_FUNCTION (machopic_lazy_symbol_ptr_section, \
+ in_machopic_lazy_symbol_ptr, \
+ ".lazy_symbol_pointer", 0, 0) \
+SECTION_FUNCTION (machopic_nl_symbol_ptr_section, \
+ in_machopic_nl_symbol_ptr, \
+ ".non_lazy_symbol_pointer", 0, 0) \
+SECTION_FUNCTION (machopic_symbol_stub_section, \
+ in_machopic_symbol_stub, \
+ ".symbol_stub", 0, 0) \
+SECTION_FUNCTION (machopic_picsymbol_stub_section, \
+ in_machopic_picsymbol_stub, \
+ ".picsymbol_stub", 0, 0) \
+ \
+void \
+objc_section_init () \
+{ \
+ static int been_here = 0; \
+ \
+ if (been_here == 0) \
+ { \
+ been_here = 1; \
+ /* written, cold -> hot */ \
+ objc_cat_cls_meth_section (); \
+ objc_cat_inst_meth_section (); \
+ objc_string_object_section (); \
+ objc_constant_string_object_section (); \
+ objc_selector_refs_section (); \
+ objc_selector_fixup_section (); \
+ objc_cls_refs_section (); \
+ objc_class_section (); \
+ objc_meta_class_section (); \
+ /* shared, hot -> cold */ \
+ objc_cls_meth_section (); \
+ objc_inst_meth_section (); \
+ objc_protocol_section (); \
+ objc_class_names_section (); \
+ objc_meth_var_types_section (); \
+ objc_meth_var_names_section (); \
+ objc_category_section (); \
+ objc_class_vars_section (); \
+ objc_instance_vars_section (); \
+ objc_module_info_section (); \
+ objc_symbols_section (); \
+ } \
+} \
+static tree section_alias[(int) num_sections]; \
+void try_section_alias () \
+{ \
+ if (section_alias[in_section] && asm_out_file) \
+ fprintf (asm_out_file, "%s\n", \
+ IDENTIFIER_POINTER (section_alias[in_section])); \
+} \
+void alias_section (name, alias) \
+ char *name, *alias; \
+{ \
+ ALIAS_SECTION (in_data, "data"); \
+ ALIAS_SECTION (in_text, "text"); \
+ ALIAS_SECTION (in_const, "const"); \
+ ALIAS_SECTION (in_const_data, "const_data"); \
+ ALIAS_SECTION (in_cstring, "cstring"); \
+ ALIAS_SECTION (in_literal4, "literal4"); \
+ ALIAS_SECTION (in_literal8, "literal8"); \
+}
+
+#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 name = TYPE_NAME (TREE_TYPE (exp)); \
+ if (TREE_CODE (name) == TYPE_DECL) \
+ name = DECL_NAME (name); \
+ if (!strcmp (IDENTIFIER_POINTER (name), "NSConstantString")) \
+ objc_constant_string_object_section (); \
+ else if (!strcmp (IDENTIFIER_POINTER (name), "NXConstantString")) \
+ objc_string_object_section (); \
+ else if (TREE_READONLY (exp) || TREE_CONSTANT (exp)) \
+ { \
+ if (TREE_SIDE_EFFECTS (exp) || flag_pic && reloc) \
+ const_data_section (); \
+ else \
+ 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_SELECTOR_FIXUP", 20)) \
+ objc_selector_fixup_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)) \
+ { if (flag_pic && reloc ) const_data_section (); \
+ else readonly_data_section (); } \
+ else \
+ data_section (); \
+ } \
+ else if (TREE_READONLY (exp) || TREE_CONSTANT (exp)) \
+ { \
+ if (TREE_SIDE_EFFECTS (exp) || flag_pic && reloc) \
+ const_data_section (); \
+ else \
+ readonly_data_section (); \
+ } \
+ else \
+ data_section (); \
+ try_section_alias (); \
+ } \
+ 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)
+
+#define DECLARE_UNRESOLVED_REFERENCE(NAME) \
+ do { extern FILE* asm_out_file; \
+ if (asm_out_file) { \
+ if (flag_pic) \
+ fprintf (asm_out_file, "\t.lazy_reference "); \
+ else \
+ fprintf (asm_out_file, "\t.reference "); \
+ assemble_name (asm_out_file, NAME); \
+ fprintf (asm_out_file, "\n"); \
+ } \
+ } while (0)
+
+#define DECLARE_CLASS_REFERENCE(NAME) \
+ do { extern FILE* asm_out_file; \
+ if (asm_out_file) { \
+ fprintf (asm_out_file, "\t"); \
+ assemble_name (asm_out_file, NAME); \
+ fprintf (asm_out_file, "=0\n"); \
+ assemble_global (NAME); \
+ } \
+ } while (0)
+
+#undef ASM_GLOBALIZE_LABEL
+#define ASM_GLOBALIZE_LABEL(FILE,NAME) \
+ do { const char* _x = (NAME); if (!!strncmp (_x, "_OBJC_", 6)) { \
+ (fputs (".globl ", FILE), assemble_name (FILE, _x), fputs ("\n", FILE)); \
+ }} while (0)
+
+#undef ASM_GENERATE_INTERNAL_LABEL
+#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
+ sprintf (LABEL, "*%s%d", PREFIX, NUM)
+
+/* This is how to output an internal numbered label where PREFIX is
+ the class of label and NUM is the number within the class. */
+
+#undef ASM_OUTPUT_INTERNAL_LABEL
+#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
+ fprintf (FILE, "%s%d:\n", PREFIX, NUM)
+
+/* Since we have a separate readonly data section, define this so that
+ jump tables end up in text rather than data. */
+
+#ifndef JUMP_TABLES_IN_TEXT_SECTION
+#define JUMP_TABLES_IN_TEXT_SECTION 1
+#endif
+
+/* Symbolic names for various things we might know about a symbol. */
+
+enum machopic_addr_class {
+ MACHOPIC_UNDEFINED,
+ MACHOPIC_DEFINED_DATA,
+ MACHOPIC_UNDEFINED_DATA,
+ MACHOPIC_DEFINED_FUNCTION,
+ MACHOPIC_UNDEFINED_FUNCTION
+};
+
+/* Macros defining the various PIC cases. */
+
+#define MACHOPIC_INDIRECT (flag_pic)
+#define MACHOPIC_JUST_INDIRECT (flag_pic == 1)
+#define MACHOPIC_PURE (flag_pic == 2)
+
+#define GEN_BINDER_NAME_FOR_STUB(BUF,STUB,STUB_LENGTH) \
+ do { \
+ const char *stub_ = (STUB); \
+ char *buffer_ = (BUF); \
+ strcpy (buffer_, stub_); \
+ if (stub_[0] == '"') \
+ { \
+ strcpy (buffer_ + (STUB_LENGTH) - 1, "_binder\""); \
+ } \
+ else \
+ { \
+ strcpy (buffer_ + (STUB_LENGTH), "_binder"); \
+ } \
+ } while (0)
+
+#define GEN_SYMBOL_NAME_FOR_SYMBOL(BUF,SYMBOL,SYMBOL_LENGTH) \
+ do { \
+ const char *symbol_ = (SYMBOL); \
+ char *buffer_ = (BUF); \
+ if (name_needs_quotes (symbol_) && symbol_[0] != '"') \
+ { \
+ sprintf (buffer_, "\"%s\"", symbol_); \
+ } \
+ else \
+ { \
+ strcpy (buffer_, symbol_); \
+ } \
+ } while (0)
+
+/* Given a symbol name string, create the lazy pointer version
+ of the symbol name. */
+
+#define GEN_LAZY_PTR_NAME_FOR_SYMBOL(BUF,SYMBOL,SYMBOL_LENGTH) \
+ do { \
+ const char *symbol_ = (SYMBOL); \
+ char *buffer_ = (BUF); \
+ if (symbol_[0] == '"') \
+ { \
+ strcpy (buffer_, "\"L"); \
+ strcpy (buffer_ + 2, symbol_ + 1); \
+ strcpy (buffer_ + (SYMBOL_LENGTH), "$lazy_ptr\""); \
+ } \
+ else if (name_needs_quotes (symbol_)) \
+ { \
+ strcpy (buffer_, "\"L"); \
+ strcpy (buffer_ + 2, symbol_); \
+ strcpy (buffer_ + (SYMBOL_LENGTH) + 2, "$lazy_ptr\""); \
+ } \
+ else \
+ { \
+ strcpy (buffer_, "L"); \
+ strcpy (buffer_ + 1, symbol_); \
+ strcpy (buffer_ + (SYMBOL_LENGTH) + 1, "$lazy_ptr"); \
+ } \
+ } while (0)
+
--- /dev/null
+/* Target definitions for PowerPC running Darwin (Mac OS X).
+ Copyright (C) 1997, 2000, 2001 Free Software Foundation, Inc.
+ Contributed by Apple Computer 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* The "Darwin ABI" is mostly like AIX, but with some key differences. */
+
+#define DEFAULT_ABI ABI_DARWIN
+
+/* The object file format is Mach-O. */
+
+#define TARGET_OBJECT_FORMAT OBJECT_MACHO
+
+/* We're not ever going to do TOCs. */
+
+#define TARGET_TOC 0
+#define TARGET_NO_TOC 1
+
+#define CPP_PREDEFINES "-D__ppc__ -D__NATURAL_ALIGNMENT__ -D__MACH__ -D__BIG_ENDIAN__ -D__APPLE__"
+
+/* We want -fPIC by default, unless we're using -static to compile for
+ the kernel or some such. */
+
+#define CC1_SPEC "%{!static:-fPIC}"
+
+#define FIXED_R13 0
+
+#undef TARGET_DEFAULT
+#define TARGET_DEFAULT (MASK_POWERPC | MASK_MULTIPLE | MASK_NEW_MNEMONICS \
+ | MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC)
+
+/* Base register for access to local variables of the function. */
+
+#undef FRAME_POINTER_REGNUM
+#define FRAME_POINTER_REGNUM 30
+
+#undef PIC_OFFSET_TABLE_REGNUM
+#define PIC_OFFSET_TABLE_REGNUM 31
+
+#undef STACK_BOUNDARY
+#define STACK_BOUNDARY 128
+
+/* Pad the outgoing args area to 16 bytes instead of the usual 8. */
+
+#undef STARTING_FRAME_OFFSET
+#define STARTING_FRAME_OFFSET \
+ (RS6000_ALIGN (current_function_outgoing_args_size, 16) \
+ + RS6000_VARARGS_AREA \
+ + RS6000_SAVE_AREA)
+
+#undef STACK_DYNAMIC_OFFSET
+#define STACK_DYNAMIC_OFFSET(FUNDECL) \
+ (RS6000_ALIGN (current_function_outgoing_args_size, 16) \
+ + (STACK_POINTER_OFFSET))
+
+/* Define cutoff for using external functions to save floating point.
+ Currently on Darwin, always use inline stores. */
+
+#undef FP_SAVE_INLINE
+#define FP_SAVE_INLINE(FIRST_REG) ((FIRST_REG) < 64)
+
+/* Always use the "debug" register names, they're what the assembler
+ wants to see. */
+
+#undef REGISTER_NAMES
+#define REGISTER_NAMES DEBUG_REGISTER_NAMES
+
+/* This outputs NAME to FILE. */
+
+#undef RS6000_OUTPUT_BASENAME
+#define RS6000_OUTPUT_BASENAME(FILE, NAME) \
+ assemble_name (FILE, NAME);
+
+/* Output before instructions. */
+/* 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. */
+
+#define ASM_OUTPUT_LABEL(FILE,NAME) \
+ do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
+
+/* This is how to output a command to make the user-level label named NAME
+ defined for reference from other files. */
+
+#undef ASM_GLOBALIZE_LABEL
+#define ASM_GLOBALIZE_LABEL(FILE,NAME) \
+ do { fputs ("\t.globl ", FILE); \
+ RS6000_OUTPUT_BASENAME (FILE, NAME); putc ('\n', FILE);} while (0)
+
+/* This is how to output an internal label prefix. rs6000.c uses this
+ when generating traceback tables. */
+/* Not really used for Darwin? */
+
+#undef ASM_OUTPUT_INTERNAL_LABEL_PREFIX
+#define ASM_OUTPUT_INTERNAL_LABEL_PREFIX(FILE,PREFIX) \
+ fprintf (FILE, "%s", PREFIX)
+
+#undef TEXT_SECTION_ASM_OP
+#define TEXT_SECTION_ASM_OP ".text"
+
+/* Output before writable data. */
+
+#undef DATA_SECTION_ASM_OP
+#define DATA_SECTION_ASM_OP ".data"
+
+/* This says how to output an assembler line to define a global common
+ symbol. */
+/* ? */
+#undef ASM_OUTPUT_ALIGNED_COMMON
+#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
+ do { fputs (".comm ", (FILE)); \
+ RS6000_OUTPUT_BASENAME ((FILE), (NAME)); \
+ fprintf ((FILE), ",%d\n", (SIZE)); } while (0)
+
+#define ASM_OUTPUT_SKIP(FILE,SIZE) \
+ fprintf (FILE, "\t.space %d\n", SIZE)
+
+/* FP save and restore routines. */
+#define SAVE_FP_PREFIX "._savef"
+#define SAVE_FP_SUFFIX ""
+#define RESTORE_FP_PREFIX "._restf"
+#define RESTORE_FP_SUFFIX ""
+
+/* Generate insns to call the profiler. */
+
+#define PROFILE_HOOK(LABEL) output_profile_hook (LABEL)
+
+/* Function name to call to do profiling. */
+
+#define RS6000_MCOUNT "*mcount"
+
+/* Since Darwin doesn't do TOCs, stub this out. */
+
+#define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE) 0
+
+/* Given an rtx X being reloaded into a reg required to be
+ in class CLASS, return the class of reg to actually use.
+ In general this is just CLASS; but on some machines
+ in some cases it is preferable to use a more restrictive class.
+
+ On the RS/6000, we have to return NO_REGS when we want to reload a
+ floating-point CONST_DOUBLE to force it to be copied to memory.
+
+ Don't allow R0 when loading the address of, or otherwise furtling with,
+ a SYMBOL_REF. */
+
+#undef PREFERRED_RELOAD_CLASS
+#define PREFERRED_RELOAD_CLASS(X,CLASS) \
+ (((GET_CODE (X) == CONST_DOUBLE \
+ && GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT) \
+ ? NO_REGS \
+ : (GET_MODE_CLASS (GET_MODE (X)) == MODE_INT \
+ && (CLASS) == NON_SPECIAL_REGS) \
+ ? GENERAL_REGS \
+ : (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == HIGH) \
+ ? BASE_REGS \
+ : (CLASS)))
+
+/* Fix for emit_group_load (): force large constants to be pushed via regs. */
+#define ALWAYS_PUSH_CONSTS_USING_REGS_P 1
extern void rs6000_emit_move PARAMS ((rtx, rtx, enum machine_mode));
extern rtx rs6000_legitimize_address PARAMS ((rtx, rtx, enum machine_mode));
extern void rs6000_select_rtx_section PARAMS ((enum machine_mode, rtx));
+
extern rtx rs6000_return_addr PARAMS ((int, rtx));
extern void rs6000_output_symbol_ref PARAMS ((FILE*, rtx));
+
+extern rtx rs6000_machopic_legitimize_pic_address PARAMS ((rtx orig, enum machine_mode mode, rtx reg));
+
#endif /* RTX_CODE */
#ifdef TREE_CODE
/* expr.h defines ARGS_SIZE_RTX and `enum direction' */
extern enum direction function_arg_padding PARAMS ((enum machine_mode, tree));
#endif /* ARGS_SIZE_RTX */
+
#endif /* TREE_CODE */
extern void optimization_options PARAMS ((int, int));
extern void rs6000_aix_emit_builtin_unwind_init PARAMS ((void));
extern void rs6000_emit_epilogue PARAMS ((int));
extern void debug_stack_info PARAMS ((rs6000_stack_t *));
+
+extern void machopic_output_stub PARAMS ((FILE *, const char *, const char *));
emit_insn (gen_elf_high (reg, (x)));
return gen_rtx_LO_SUM (Pmode, reg, (x));
}
+ else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
+ && ! flag_pic
+ && GET_CODE (x) != CONST_INT
+ && GET_CODE (x) != CONST_DOUBLE
+ && CONSTANT_P (x)
+ && (TARGET_HARD_FLOAT || mode != DFmode)
+ && mode != DImode
+ && mode != TImode)
+ {
+ rtx reg = gen_reg_rtx (Pmode);
+ emit_insn (gen_macho_high (reg, (x)));
+ return gen_rtx_LO_SUM (Pmode, reg, (x));
+ }
else if (TARGET_TOC
&& CONSTANT_POOL_EXPR_P (x)
&& ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
return;
}
- if (TARGET_ELF && TARGET_NO_TOC && ! flag_pic
+ if ((TARGET_ELF || DEFAULT_ABI == ABI_DARWIN)
+ && TARGET_NO_TOC && ! flag_pic
&& mode == Pmode
&& CONSTANT_P (operands[1])
&& GET_CODE (operands[1]) != HIGH
operands[1] = new_ref;
}
+ if (DEFAULT_ABI == ABI_DARWIN)
+ {
+ emit_insn (gen_macho_high (target, operands[1]));
+ emit_insn (gen_macho_low (operands[0], target, operands[1]));
+ return;
+ }
+
emit_insn (gen_elf_high (target, operands[1]));
emit_insn (gen_elf_low (operands[0], target, operands[1]));
return;
if (GET_CODE (operands[1]) != LABEL_REF)
emit_insn (gen_rtx_USE (VOIDmode, operands[1]));
+ /* Darwin uses a special PIC legitimizer. */
+ if (DEFAULT_ABI == ABI_DARWIN && flag_pic)
+ {
+ rtx temp_reg = ((reload_in_progress || reload_completed)
+ ? operands[0] : NULL);
+
+#if TARGET_MACHO
+ operands[1] =
+ rs6000_machopic_legitimize_pic_address (operands[1], mode,
+ temp_reg);
+#endif
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ return;
+ }
+
/* If we are to limit the number of things we put in the TOC and
this is a symbol plus a constant we can add in one insn,
just put the symbol in the TOC and add the constant. Don't do
case ABI_V4:
case ABI_AIX_NODESC:
case ABI_SOLARIS:
+ case ABI_DARWIN:
break;
}
}
if (regs_ever_live[first_reg]
&& (! call_used_regs[first_reg]
|| (first_reg == PIC_OFFSET_TABLE_REGNUM
- && (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
- && flag_pic == 1)))
+ && (((DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
+ && flag_pic == 1)
+ || (DEFAULT_ABI == ABI_DARWIN
+ && flag_pic)))))
break;
if (profile_flag)
before/after the .__mcount call plus an additional register
for the static chain, if needed; use registers from 30 down to 22
to do this. */
- if (DEFAULT_ABI == ABI_AIX)
+ if (DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
{
int last_parm_reg, profile_first_reg;
Skip reg 31 which may contain the frame pointer. */
profile_first_reg = (33 - last_parm_reg
- (current_function_needs_context ? 1 : 0));
+#if TARGET_MACHO
+ /* Need to skip another reg to account for R31 being PICBASE
+ (when flag_pic is set) or R30 being used as the frame
+ pointer (when flag_pic is not set). */
+ --profile_first_reg;
+#endif
/* Do not save frame pointer if no parameters needs to be saved. */
if (profile_first_reg == 31)
profile_first_reg = 32;
}
}
+#if TARGET_MACHO
+ if (flag_pic && current_function_uses_pic_offset_table &&
+ (first_reg > PIC_OFFSET_TABLE_REGNUM))
+ return PIC_OFFSET_TABLE_REGNUM;
+#endif
+
return first_reg;
}
complicated by having two separate calling sequences, the AIX calling
sequence and the V.4 calling sequence.
- AIX stack frames look like:
+ AIX (and Darwin/Mac OS) stack frames look like:
32-bit 64-bit
SP----> +---------------------------------------+
| back chain to caller | 0 0
info_ptr->first_gp_reg_save = first_reg_to_save ();
/* Assume that we will have to save PIC_OFFSET_TABLE_REGNUM,
even if it currently looks like we won't. */
- if (flag_pic == 1
- && (abi == ABI_V4 || abi == ABI_SOLARIS)
+ if (((flag_pic == 1
+ && (abi == ABI_V4 || abi == ABI_SOLARIS))
+ || (flag_pic &&
+ abi == ABI_DARWIN))
&& info_ptr->first_gp_reg_save > PIC_OFFSET_TABLE_REGNUM)
info_ptr->gp_size = reg_size * (32 - PIC_OFFSET_TABLE_REGNUM);
else
&& !FP_SAVE_INLINE (info_ptr->first_fp_reg_save))
|| (abi == ABI_V4 && current_function_calls_alloca)
|| (abi == ABI_SOLARIS && current_function_calls_alloca)
+ || (DEFAULT_ABI == ABI_DARWIN && flag_pic && current_function_uses_pic_offset_table)
|| info_ptr->calls_p)
{
info_ptr->lr_save_p = 1;
+ info_ptr->cr_size
+ info_ptr->lr_size
+ info_ptr->toc_size, 8);
+ if (DEFAULT_ABI == ABI_DARWIN)
+ info_ptr->save_size = RS6000_ALIGN (info_ptr->save_size, 16);
/* Calculate the offsets */
switch (abi)
case ABI_AIX:
case ABI_AIX_NODESC:
+ case ABI_DARWIN:
info_ptr->fp_save_offset = - info_ptr->fp_size;
info_ptr->gp_save_offset = info_ptr->fp_save_offset - info_ptr->gp_size;
info_ptr->ehrd_offset = info_ptr->gp_save_offset - ehrd_size;
else
info_ptr->push_p = (frame_pointer_needed
- || write_symbols != NO_DEBUG
+ || (abi != ABI_DARWIN && write_symbols != NO_DEBUG)
|| ((total_raw_size - info_ptr->fixed_size)
> (TARGET_32BIT ? 220 : 288)));
case ABI_NONE: abi_string = "NONE"; break;
case ABI_AIX: abi_string = "AIX"; break;
case ABI_AIX_NODESC: abi_string = "AIX"; break;
+ case ABI_DARWIN: abi_string = "Darwin"; break;
case ABI_V4: abi_string = "V.4"; break;
case ABI_SOLARIS: abi_string = "Solaris"; break;
}
if ((regs_ever_live[info->first_gp_reg_save+i]
&& ! call_used_regs[info->first_gp_reg_save+i])
|| (i+info->first_gp_reg_save == PIC_OFFSET_TABLE_REGNUM
- && (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
- && flag_pic == 1))
+ && (((DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
+ && flag_pic == 1)
+ || (DEFAULT_ABI == ABI_DARWIN
+ && flag_pic))))
{
rtx addr, reg, mem;
reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
emit_move_insn (gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM),
gen_rtx_REG (Pmode, 11));
}
+
+ if (DEFAULT_ABI == ABI_DARWIN
+ && flag_pic && current_function_uses_pic_offset_table)
+ {
+ rtx dest = gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM);
+
+ rs6000_maybe_dead (emit_insn (gen_load_macho_picbase (dest)));
+
+ rs6000_maybe_dead (
+ emit_move_insn (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM),
+ gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM)));
+ }
}
if ((regs_ever_live[info->first_gp_reg_save+i]
&& ! call_used_regs[info->first_gp_reg_save+i])
|| (i+info->first_gp_reg_save == PIC_OFFSET_TABLE_REGNUM
- && (DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
- && flag_pic == 1))
+ && (((DEFAULT_ABI == ABI_V4 || DEFAULT_ABI == ABI_SOLARIS)
+ && flag_pic == 1)
+ || (DEFAULT_ABI == ABI_DARWIN
+ && flag_pic))))
{
rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
GEN_INT (info->gp_save_offset
if (flag_pic) fputs ("@plt", file);
putc ('\n', file);
break;
+
+#if TARGET_MACHO
+ case ABI_DARWIN:
+ fprintf (file, "\tb %s", prefix);
+ if (flag_pic && !machopic_name_defined_p (fname))
+ assemble_name (file, machopic_stub_name (fname));
+ else
+ assemble_name (file, fname);
+ putc ('\n', file);
+ break;
+#endif
}
}
}
emit_library_call (init_one_libfunc (RS6000_MCOUNT), 0, VOIDmode, 1,
fun, Pmode);
}
+ else if (DEFAULT_ABI == ABI_DARWIN)
+ {
+ char *mcount_name = RS6000_MCOUNT;
+ int caller_addr_regno = LINK_REGISTER_REGNUM;
+
+ /* Be conservative and always set this, at least for now. */
+ current_function_uses_pic_offset_table = 1;
+
+#if TARGET_MACHO
+ /* For PIC code, set up a stub and collect the caller's address
+ from r0, which is where the prologue puts it. */
+ if (flag_pic)
+ {
+ mcount_name = machopic_stub_name (mcount_name);
+ if (current_function_uses_pic_offset_table)
+ caller_addr_regno = 0;
+ }
+#endif
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, mcount_name),
+ 0, VOIDmode, 1,
+ gen_rtx_REG (Pmode, caller_addr_regno), Pmode);
+ }
}
/* Write function profiler code. */
break;
case ABI_AIX:
+ case ABI_DARWIN:
/* Don't do anything, done in output_profile_hook (). */
break;
toc_hash_table = htab_create (1021, toc_hash_function, toc_hash_eq, NULL);
ggc_add_root (&toc_hash_table, 1, sizeof (toc_hash_table),
toc_hash_mark_table);
+
+#if TARGET_MACHO
+ machopic_add_gc_roots ();
+#endif
+}
+
+#if TARGET_MACHO
+
+#if 0
+/* Returns 1 if OP is either a symbol reference or a sum of a symbol
+ reference and a constant. */
+
+int
+symbolic_operand (op)
+ register rtx op;
+{
+ switch (GET_CODE (op))
+ {
+ case SYMBOL_REF:
+ case LABEL_REF:
+ return 1;
+ case CONST:
+ op = XEXP (op, 0);
+ return (GET_CODE (op) == SYMBOL_REF ||
+ (GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+ || GET_CODE (XEXP (op, 0)) == LABEL_REF)
+ && GET_CODE (XEXP (op, 1)) == CONST_INT);
+ default:
+ return 0;
+ }
}
+#endif
+
+#ifdef RS6000_LONG_BRANCH
+
+static tree stub_list = 0;
+
+/* ADD_COMPILER_STUB adds the compiler generated stub for handling
+ procedure calls to the linked list. */
+
+void
+add_compiler_stub (label_name, function_name, line_number)
+ tree label_name;
+ tree function_name;
+ int line_number;
+{
+ tree stub = build_tree_list (function_name, label_name);
+ TREE_TYPE (stub) = build_int_2 (line_number, 0);
+ TREE_CHAIN (stub) = stub_list;
+ stub_list = stub;
+}
+
+#define STUB_LABEL_NAME(STUB) TREE_VALUE (STUB)
+#define STUB_FUNCTION_NAME(STUB) TREE_PURPOSE (STUB)
+#define STUB_LINE_NUMBER(STUB) TREE_INT_CST_LOW (TREE_TYPE (STUB))
+
+/* OUTPUT_COMPILER_STUB outputs the compiler generated stub for handling
+ procedure calls from the linked list and initializes the linked list. */
+
+void output_compiler_stub ()
+{
+ char tmp_buf[256];
+ char label_buf[256];
+ char *label;
+ tree tmp_stub, stub;
+
+ if (!flag_pic)
+ for (stub = stub_list; stub; stub = TREE_CHAIN (stub))
+ {
+ fprintf (asm_out_file,
+ "%s:\n", IDENTIFIER_POINTER(STUB_LABEL_NAME(stub)));
+
+#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
+ if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
+ fprintf (asm_out_file, "\t.stabd 68,0,%d\n", STUB_LINE_NUMBER(stub));
+#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
+
+ if (IDENTIFIER_POINTER (STUB_FUNCTION_NAME (stub))[0] == '*')
+ strcpy (label_buf,
+ IDENTIFIER_POINTER (STUB_FUNCTION_NAME (stub))+1);
+ else
+ {
+ label_buf[0] = '_';
+ strcpy (label_buf+1,
+ IDENTIFIER_POINTER (STUB_FUNCTION_NAME (stub)));
+ }
+
+ strcpy (tmp_buf, "lis r12,hi16(");
+ strcat (tmp_buf, label_buf);
+ strcat (tmp_buf, ")\n\tori r12,r12,lo16(");
+ strcat (tmp_buf, label_buf);
+ strcat (tmp_buf, ")\n\tmtctr r12\n\tbctr");
+ output_asm_insn (tmp_buf, 0);
+
+#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
+ if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
+ fprintf(asm_out_file, "\t.stabd 68,0,%d\n", STUB_LINE_NUMBER (stub));
+#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
+ }
+
+ stub_list = 0;
+}
+
+/* NO_PREVIOUS_DEF checks in the link list whether the function name is
+ already there or not. */
+
+int no_previous_def (function_name)
+ tree function_name;
+{
+ tree stub;
+ for (stub = stub_list; stub; stub = TREE_CHAIN (stub))
+ if (function_name == STUB_FUNCTION_NAME (stub))
+ return 0;
+ return 1;
+}
+
+/* GET_PREV_LABEL gets the label name from the previous definition of
+ the function. */
+
+tree get_prev_label (function_name)
+ tree function_name;
+{
+ tree stub;
+ for (stub = stub_list; stub; stub = TREE_CHAIN (stub))
+ if (function_name == STUB_FUNCTION_NAME (stub))
+ return STUB_LABEL_NAME (stub);
+ return 0;
+}
+
+/* INSN is either a function call or a millicode call. It may have an
+ unconditional jump in its delay slot.
+
+ CALL_DEST is the routine we are calling. */
+
+char *
+output_call (insn, call_dest, operand_number)
+ rtx insn;
+ rtx call_dest;
+ int operand_number;
+{
+ static char buf[256];
+ if (GET_CODE (call_dest) == SYMBOL_REF && TARGET_LONG_BRANCH && !flag_pic)
+ {
+ tree labelname;
+ tree funname = get_identifier (XSTR (call_dest, 0));
+
+ if (no_previous_def (funname))
+ {
+ int line_number;
+ rtx label_rtx = gen_label_rtx ();
+ char *label_buf, temp_buf[256];
+ ASM_GENERATE_INTERNAL_LABEL (temp_buf, "L",
+ CODE_LABEL_NUMBER (label_rtx));
+ label_buf = temp_buf[0] == '*' ? temp_buf + 1 : temp_buf;
+ labelname = get_identifier (label_buf);
+ for (; insn && GET_CODE (insn) != NOTE; insn = PREV_INSN (insn));
+ if (insn)
+ line_number = NOTE_LINE_NUMBER (insn);
+ add_compiler_stub (labelname, funname, line_number);
+ }
+ else
+ labelname = get_prev_label (funname);
+
+ sprintf (buf, "jbsr %%z%d,%.246s",
+ operand_number, IDENTIFIER_POINTER (labelname));
+ return buf;
+ }
+ else
+ {
+ sprintf (buf, "bl %%z%d", operand_number);
+ return buf;
+ }
+}
+
+#endif /* RS6000_LONG_BRANCH */
+
+#define GEN_LOCAL_LABEL_FOR_SYMBOL(BUF,SYMBOL,LENGTH,N) \
+ do { \
+ const char *symbol_ = (SYMBOL); \
+ char *buffer_ = (BUF); \
+ if (symbol_[0] == '"') \
+ { \
+ sprintf(buffer_, "\"L%d$%s", (N), symbol_+1); \
+ } \
+ else if (name_needs_quotes(symbol_)) \
+ { \
+ sprintf(buffer_, "\"L%d$%s\"", (N), symbol_); \
+ } \
+ else \
+ { \
+ sprintf(buffer_, "L%d$%s", (N), symbol_); \
+ } \
+ } while (0)
+
+
+/* Generate PIC and indirect symbol stubs. */
+
+void
+machopic_output_stub (file, symb, stub)
+ FILE *file;
+ const char *symb, *stub;
+{
+ unsigned int length;
+ char *binder_name, *symbol_name, *lazy_ptr_name;
+ char *local_label_0, *local_label_1, *local_label_2;
+ static int label = 0;
+
+ label += 1;
+
+ length = strlen (stub);
+ binder_name = alloca (length + 32);
+ GEN_BINDER_NAME_FOR_STUB (binder_name, stub, length);
+
+ length = strlen (symb);
+ symbol_name = alloca (length + 32);
+ GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
+
+ lazy_ptr_name = alloca (length + 32);
+ GEN_LAZY_PTR_NAME_FOR_SYMBOL (lazy_ptr_name, symb, length);
+
+ local_label_0 = alloca (length + 32);
+ GEN_LOCAL_LABEL_FOR_SYMBOL (local_label_0, symb, length, 0);
+
+ local_label_1 = alloca (length + 32);
+ GEN_LOCAL_LABEL_FOR_SYMBOL (local_label_1, symb, length, 1);
+
+ local_label_2 = alloca (length + 32);
+ GEN_LOCAL_LABEL_FOR_SYMBOL (local_label_2, symb, length, 2);
+
+ if (flag_pic == 2)
+ machopic_picsymbol_stub_section ();
+ else
+ machopic_symbol_stub_section ();
+
+ fprintf (file, "%s:\n", stub);
+ fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
+
+ if (flag_pic == 2)
+ {
+ fprintf (file, "\tmflr r0\n");
+ fprintf (file, "\tbcl 20,31,%s\n", local_label_0);
+ fprintf (file, "%s:\n\tmflr r11\n", local_label_0);
+ fprintf (file, "\taddis r11,r11,ha16(%s-%s)\n",
+ lazy_ptr_name, local_label_0);
+ fprintf (file, "\tmtlr r0\n");
+ fprintf (file, "\tlwz r12,lo16(%s-%s)(r11)\n",
+ lazy_ptr_name, local_label_0);
+ fprintf (file, "\tmtctr r12\n");
+ fprintf (file, "\taddi r11,r11,lo16(%s-%s)\n",
+ lazy_ptr_name, local_label_0);
+ fprintf (file, "\tbctr\n");
+ }
+ else
+ fprintf (file, "non-pure not supported\n");
+
+ machopic_lazy_symbol_ptr_section ();
+ fprintf (file, "%s:\n", lazy_ptr_name);
+ fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
+ fprintf (file, "\t.long dyld_stub_binding_helper\n");
+}
+
+/* Legitimize PIC addresses. If the address is already
+ position-independent, we return ORIG. Newly generated
+ position-independent addresses go into a reg. This is REG if non
+ zero, otherwise we allocate register(s) as necessary. */
+
+#define SMALL_INT(X) ((unsigned) (INTVAL(X) + 0x4000) < 0x8000)
+
+rtx
+rs6000_machopic_legitimize_pic_address (orig, mode, reg)
+ rtx orig;
+ enum machine_mode mode;
+ rtx reg;
+{
+ rtx base, offset;
+
+ if (reg == NULL && ! reload_in_progress && ! reload_completed)
+ reg = gen_reg_rtx (Pmode);
+
+ if (GET_CODE (orig) == CONST)
+ {
+ if (GET_CODE (XEXP (orig, 0)) == PLUS
+ && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
+ return orig;
+
+ if (GET_CODE (XEXP (orig, 0)) == PLUS)
+ {
+ base = rs6000_machopic_legitimize_pic_address (XEXP (XEXP (orig, 0), 0),
+ Pmode, reg);
+ offset = rs6000_machopic_legitimize_pic_address (XEXP (XEXP (orig, 0), 1),
+ Pmode, reg);
+ }
+ else
+ abort ();
+
+ if (GET_CODE (offset) == CONST_INT)
+ {
+ if (SMALL_INT (offset))
+ return plus_constant_for_output (base, INTVAL (offset));
+ else if (! reload_in_progress && ! reload_completed)
+ offset = force_reg (Pmode, offset);
+ else
+ abort ();
+ }
+ return gen_rtx (PLUS, Pmode, base, offset);
+ }
+
+ /* Fall back on generic machopic code. */
+ return machopic_legitimize_pic_address (orig, mode, reg);
+}
+
+/* This is just a placeholder to make linking work without having to
+ add this to the generic Darwin EXTRA_SECTIONS. If -mcall-aix is
+ ever needed for Darwin (not too likely!) this would have to get a
+ real definition. */
+
+void
+toc_section ()
+{
+}
+
+#endif /* TARGET_MACHO */
#define OBJECT_XCOFF 1
#define OBJECT_ELF 2
#define OBJECT_PEF 3
+#define OBJECT_MACHO 4
#define TARGET_ELF (TARGET_OBJECT_FORMAT == OBJECT_ELF)
#define TARGET_AIX (TARGET_OBJECT_FORMAT == OBJECT_XCOFF)
#define TARGET_MACOS (TARGET_OBJECT_FORMAT == OBJECT_PEF)
+#define TARGET_MACHO (TARGET_OBJECT_FORMAT == OBJECT_MACHO)
/* Print subsidiary information on the compiler version in use. */
#define TARGET_VERSION ;
&& flag_pic == 1) \
fixed_regs[PIC_OFFSET_TABLE_REGNUM] \
= call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \
+ if (DEFAULT_ABI == ABI_DARWIN && flag_pic) \
+ global_regs[PIC_OFFSET_TABLE_REGNUM] \
+ = fixed_regs[PIC_OFFSET_TABLE_REGNUM] \
+ = call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \
}
/* Specify the registers used for certain standard purposes.
ABI_AIX, /* IBM's AIX */
ABI_AIX_NODESC, /* AIX calling sequence minus function descriptors */
ABI_V4, /* System V.4/eabi */
- ABI_SOLARIS /* Solaris */
+ ABI_SOLARIS, /* Solaris */
+ ABI_DARWIN /* Apple's Darwin (OS X kernel) */
};
extern enum rs6000_abi rs6000_current_abi; /* available for use by subtarget */
/* Size of the outgoing register save area */
#define RS6000_REG_SAVE ((DEFAULT_ABI == ABI_AIX \
- || DEFAULT_ABI == ABI_AIX_NODESC) \
+ || DEFAULT_ABI == ABI_AIX_NODESC \
+ || DEFAULT_ABI == ABI_DARWIN) \
? (TARGET_64BIT ? 64 : 32) \
: 0)
/* Size of the fixed area on the stack */
#define RS6000_SAVE_AREA \
- (((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_AIX_NODESC) ? 24 : 8) \
+ (((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_DARWIN) ? 24 : 8) \
<< (TARGET_64BIT ? 1 : 0))
/* MEM representing address to save the TOC register */
#define FP_ARG_AIX_MAX_REG 45
#define FP_ARG_V4_MAX_REG 40
#define FP_ARG_MAX_REG ((DEFAULT_ABI == ABI_AIX \
- || DEFAULT_ABI == ABI_AIX_NODESC) \
+ || DEFAULT_ABI == ABI_AIX_NODESC \
+ || DEFAULT_ABI == ABI_DARWIN) \
? FP_ARG_AIX_MAX_REG : FP_ARG_V4_MAX_REG)
#define FP_ARG_NUM_REG (FP_ARG_MAX_REG - FP_ARG_MIN_REG + 1)
abi's store the return address. */
#define RETURN_ADDRESS_OFFSET \
((DEFAULT_ABI == ABI_AIX \
+ || DEFAULT_ABI == ABI_DARWIN \
|| DEFAULT_ABI == ABI_AIX_NODESC) ? (TARGET_32BIT ? 8 : 16) : \
(DEFAULT_ABI == ABI_V4 \
|| DEFAULT_ABI == ABI_SOLARIS) ? (TARGET_32BIT ? 4 : 8) : \
{cau|addis} %0,%1,%v2"
[(set_attr "length" "4,4,4,4")])
+(define_insn "addsi3_high"
+ [(set (match_operand:SI 0 "gpc_reg_operand" "=b")
+ (plus:SI (match_operand:SI 1 "gpc_reg_operand" "b")
+ (high:SI (match_operand 2 "" ""))))]
+ "TARGET_MACHO && !TARGET_64BIT"
+ "{cau|addis} %0,%1,ha16(%2)"
+ [(set_attr "length" "4")])
+
(define_insn "*addsi3_internal2"
[(set (match_operand:CC 0 "cc_reg_operand" "=x,x,?y,?y")
(compare:CC (plus:SI (match_operand:SI 1 "gpc_reg_operand" "%r,r,r,r")
{cal|la} %0,%2@l(%1)
{ai|addic} %0,%1,%K2")
+;; Mach-O PIC trickery.
+(define_insn "macho_high"
+ [(set (match_operand:SI 0 "gpc_reg_operand" "=b*r")
+ (high:SI (match_operand 1 "" "")))]
+ "TARGET_MACHO && ! TARGET_64BIT"
+ "{liu|lis} %0,ha16(%1)")
+
+(define_insn "macho_low"
+ [(set (match_operand:SI 0 "gpc_reg_operand" "=r,r")
+ (lo_sum:SI (match_operand:SI 1 "gpc_reg_operand" "b,!*r")
+ (match_operand 2 "" "")))]
+ "TARGET_MACHO && ! TARGET_64BIT"
+ "@
+ {cal %0,%a2@l(%1)|la %0,lo16(%2)(%1)}
+ {cal %0,%a2@l(%1)|addic %0,%1,lo16(%2)}")
+
;; Set up a register with a value from the GOT table
(define_expand "movsi_got"
""
"{ rs6000_emit_move (operands[0], operands[1], SImode); DONE; }")
+(define_insn "movsi_low"
+ [(set (match_operand:SI 0 "gpc_reg_operand" "=r")
+ (mem:SI (lo_sum:SI (match_operand:SI 1 "register_operand" "b")
+ (match_operand 2 "" ""))))]
+ "TARGET_MACHO && ! TARGET_64BIT"
+ "{l|lwz} %0,lo16(%2)(%1)"
+ [(set_attr "type" "load")
+ (set_attr "length" "4")])
+
(define_insn "*movsi_internal1"
[(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,m,r,r,r,r,r,*q,*c*l,*h")
(match_operand:SI 1 "input_operand" "r,U,m,r,I,L,n,R,*h,r,r,0"))]
"{l|lwz} %0,%2-%3(%1)"
[(set_attr "type" "load")])
+(define_insn "load_macho_picbase"
+ [(set (match_operand:SI 0 "register_operand" "=l")
+ (unspec:SI [(const_int 0)] 15))]
+ "(DEFAULT_ABI == ABI_DARWIN) && flag_pic"
+ "*
+{
+#if TARGET_MACHO
+ char *picbase = machopic_function_base_name ();
+ operands[1] = gen_rtx_SYMBOL_REF (Pmode, ggc_alloc_string (picbase, -1));
+#endif
+ return \"bcl 20,31,%1\\n%1:\";
+}"
+ [(set_attr "type" "branch")
+ (set_attr "length" "4")])
+
;; If the TOC is shared over a translation unit, as happens with all
;; the kinds of PIC that we support, we need to restore the TOC
;; pointer only when jumping over units of translation.
""
"
{
+#if TARGET_MACHO
+ if (flag_pic)
+ operands[0] = machopic_indirect_call_target (operands[0]);
+#endif
+
if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
abort ();
if (DEFAULT_ABI == ABI_V4
|| DEFAULT_ABI == ABI_AIX_NODESC
+ || DEFAULT_ABI == ABI_DARWIN
|| DEFAULT_ABI == ABI_SOLARIS)
operands[0] = force_reg (Pmode, operands[0]);
""
"
{
+#if TARGET_MACHO
+ if (flag_pic)
+ operands[1] = machopic_indirect_call_target (operands[1]);
+#endif
+
if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
abort ();
if (DEFAULT_ABI == ABI_V4
|| DEFAULT_ABI == ABI_AIX_NODESC
+ || DEFAULT_ABI == ABI_DARWIN
|| DEFAULT_ABI == ABI_SOLARIS)
operands[0] = force_reg (Pmode, operands[0]);
(clobber (match_scratch:SI 3 "=l,l,l,l"))]
"DEFAULT_ABI == ABI_AIX_NODESC
|| DEFAULT_ABI == ABI_V4
+ || DEFAULT_ABI == ABI_DARWIN
|| DEFAULT_ABI == ABI_SOLARIS"
"*
{
(clobber (match_scratch:SI 4 "=l,l,l,l"))]
"DEFAULT_ABI == ABI_AIX_NODESC
|| DEFAULT_ABI == ABI_V4
+ || DEFAULT_ABI == ABI_DARWIN
|| DEFAULT_ABI == ABI_SOLARIS"
"*
{
--- /dev/null
+# Do not build libgcc1.
+LIBGCC1 =
+CROSS_LIBGCC1 =
+
+# We want fine grained libraries, so use the new code to build the
+# floating point emulation libraries.
+FPBIT = fp-bit.c
+DPBIT = dp-bit.c
+
+dp-bit.c: $(srcdir)/config/fp-bit.c
+ cat $(srcdir)/config/fp-bit.c > dp-bit.c
+
+fp-bit.c: $(srcdir)/config/fp-bit.c
+ echo '#define FLOAT' > fp-bit.c
+ cat $(srcdir)/config/fp-bit.c >> fp-bit.c
+
+darwin.o: $(srcdir)/config/darwin.c
+ $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/darwin.c
+
+# Build the libraries for both hard and soft floating point
+
+MULTILIB_OPTIONS = msoft-float
+MULTILIB_DIRNAMES = soft-float
+
+LIBGCC = stmp-multilib
+INSTALL_LIBGCC = install-multilib
#ifndef __WCHAR_T
#ifndef _WCHAR_T_
#ifndef _BSD_WCHAR_T_
+#ifndef _BSD_WCHAR_T_DEFINED_ /* Darwin */
#ifndef _WCHAR_T_DEFINED_
#ifndef _WCHAR_T_DEFINED
#ifndef _WCHAR_T_H
#endif
#endif
#endif
+#endif
#endif /* __wchar_t__ */
#undef __need_wchar_t
#endif /* _STDDEF_H or __need_wchar_t. */
projects / platform / upstream / linaro-gcc.git / commitdiff