/* Functions for generic Darwin as target machine for GNU C compiler.
- Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001
+ Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
Contributed by Apple Computer Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
+along with GCC; 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 "coretypes.h"
+#include "tm.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "reload.h"
#include "function.h"
#include "ggc.h"
+#include "langhooks.h"
+#include "tm_p.h"
+#include "errors.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 *));
-static void update_non_lazy_ptrs PARAMS ((const char *));
-static void update_stubs PARAMS ((const char *));
+static int machopic_data_defined_p (const char *);
+static void update_non_lazy_ptrs (const char *);
+static void update_stubs (const char *);
+static const char *machopic_non_lazy_ptr_name (const char*);
int
-name_needs_quotes (name)
- const char *name;
+name_needs_quotes (const char *name)
{
int c;
while ((c = *name++) != '\0')
- if (!isalnum (c) && c != '_')
+ if (! ISIDNUM (c) && 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;
+static GTY(()) tree machopic_defined_list;
enum machopic_addr_class
-machopic_classify_ident (ident)
- tree ident;
+machopic_classify_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[0] == '_'
+ && name[1] == 'O'
+ && name[2] == 'B'
&& name[3] == 'J'
&& name[4] == 'C'
&& name[5] == '_'));
tree temp;
+ /* The PIC base symbol is always defined. */
+ if (! strcmp (name, "<pic base>"))
+ return MACHOPIC_DEFINED_DATA;
+
if (name[0] != '!')
{
/* Here if no special encoding to be found. */
else if (name[1] == 'T')
return MACHOPIC_DEFINED_FUNCTION;
+ /* It is possible that someone is holding a "stale" name, which has
+ since been defined. See if there is a "defined" name (i.e,
+ different from NAME only in having a '!D_' or a '!T_' instead of
+ a '!d_' or '!t_' prefix) in the identifier hash tables. If so, say
+ that this identifier is defined. */
+ else if (name[1] == 'd' || name[1] == 't')
+ {
+ char *new_name;
+ new_name = (char *)alloca (strlen (name) + 1);
+ strcpy (new_name, name);
+ new_name[1] = (name[1] == 'd') ? 'D' : 'T';
+ if (maybe_get_identifier (new_name) != NULL)
+ return (name[1] == 'd') ? MACHOPIC_DEFINED_DATA
+ : MACHOPIC_DEFINED_FUNCTION;
+ }
+
for (temp = machopic_defined_list; temp != NULL_TREE; temp = TREE_CHAIN (temp))
{
if (ident == TREE_VALUE (temp))
return MACHOPIC_DEFINED_DATA;
}
}
-
+
if (name[1] == 't' || name[1] == 'T')
{
if (lprefix)
}
}
-
+
enum machopic_addr_class
-machopic_classify_name (name)
- const char *name;
+machopic_classify_name (const char *name)
{
return machopic_classify_ident (get_identifier (name));
}
int
-machopic_ident_defined_p (ident)
- tree ident;
+machopic_ident_defined_p (tree ident)
{
switch (machopic_classify_ident (ident))
{
}
static int
-machopic_data_defined_p (name)
- const char *name;
+machopic_data_defined_p (const char *name)
{
switch (machopic_classify_ident (get_identifier (name)))
{
}
int
-machopic_name_defined_p (name)
- const char *name;
+machopic_name_defined_p (const char *name)
{
return machopic_ident_defined_p (get_identifier (name));
}
void
-machopic_define_ident (ident)
- tree ident;
+machopic_define_ident (tree ident)
{
if (!machopic_ident_defined_p (ident))
- machopic_defined_list =
+ machopic_defined_list =
tree_cons (NULL_TREE, ident, machopic_defined_list);
}
void
-machopic_define_name (name)
- const char *name;
+machopic_define_name (const char *name)
{
machopic_define_ident (get_identifier (name));
}
-/* This is a static to make inline functions work. The rtx
- representing the PIC base symbol always points to here. */
+static GTY(()) char * function_base;
-static char function_base[32];
+const char *
+machopic_function_base_name (void)
+{
+ /* if dynamic-no-pic is on, we should not get here */
+ if (MACHO_DYNAMIC_NO_PIC_P)
+ abort ();
-static int current_pic_label_num;
+ if (function_base == NULL)
+ function_base =
+ (char *) ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
-char *
-machopic_function_base_name ()
-{
- static char *name = NULL;
- static const char *current_name;
+ current_function_uses_pic_offset_table = 1;
- current_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
+ return function_base;
+}
- if (name != current_name)
- {
- current_function_uses_pic_offset_table = 1;
+static GTY(()) const char * function_base_func_name;
+static GTY(()) int current_pic_label_num;
- /* 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. */
-
+void
+machopic_output_function_base_name (FILE *file)
+{
+ const char *current_name;
+
+ /* If dynamic-no-pic is on, we should not get here. */
+ if (MACHO_DYNAMIC_NO_PIC_P)
+ abort ();
+ current_name =
+ IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
+ if (function_base_func_name != current_name)
+ {
++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;
+ function_base_func_name = current_name;
}
-
- return function_base;
+ fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
}
-static tree machopic_non_lazy_pointers = NULL;
+static GTY(()) tree machopic_non_lazy_pointers;
/* 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;
+static const char *
+machopic_non_lazy_ptr_name (const char *name)
{
- char *temp_name;
+ const char *temp_name;
tree temp, ident = get_identifier (name);
-
+
for (temp = machopic_non_lazy_pointers;
- temp != NULL_TREE;
+ temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
if (ident == TREE_VALUE (temp))
return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
}
- STRIP_NAME_ENCODING (name, name);
+ name = darwin_strip_name_encoding (name);
/* Try again, but comparing names this time. */
for (temp = machopic_non_lazy_pointers;
- temp != NULL_TREE;
+ temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
if (TREE_VALUE (temp))
{
temp_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
- STRIP_NAME_ENCODING (temp_name, temp_name);
+ temp_name = darwin_strip_name_encoding (temp_name);
if (strcmp (name, temp_name) == 0)
return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
}
{
char *buffer;
+ int namelen = strlen (name);
+ int bufferlen = 0;
tree ptr_name;
- buffer = alloca (strlen (name) + 20);
+ buffer = alloca (namelen + strlen("$non_lazy_ptr") + 5);
strcpy (buffer, "&L");
+ bufferlen = 2;
if (name[0] == '*')
- strcat (buffer, name+1);
+ {
+ memcpy (buffer + bufferlen, name+1, namelen-1+1);
+ bufferlen += namelen-1;
+ }
else
{
- strcat (buffer, "_");
- strcat (buffer, name);
+ buffer[bufferlen] = '_';
+ memcpy (buffer + bufferlen +1, name, namelen+1);
+ bufferlen += namelen +1;
}
-
- strcat (buffer, "$non_lazy_ptr");
+
+ memcpy (buffer + bufferlen, "$non_lazy_ptr", strlen("$non_lazy_ptr")+1);
+ bufferlen += strlen("$non_lazy_ptr");
ptr_name = get_identifier (buffer);
- machopic_non_lazy_pointers
+ machopic_non_lazy_pointers
= tree_cons (ptr_name, ident, machopic_non_lazy_pointers);
TREE_USED (machopic_non_lazy_pointers) = 0;
}
}
-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);
-}
+static GTY(()) tree machopic_stubs;
/* 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;
+const char *
+machopic_stub_name (const char *name)
{
tree temp, ident = get_identifier (name);
-
+ const char *tname;
+
for (temp = machopic_stubs;
- temp != NULL_TREE;
+ temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
if (ident == TREE_VALUE (temp))
return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
- if (strcmp (name, IDENTIFIER_POINTER (TREE_VALUE (temp))) == 0)
+ tname = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ if (strcmp (name, tname) == 0)
+ return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+ /* A library call name might not be section-encoded yet, so try
+ it against a stripped name. */
+ if (name[0] != '!'
+ && tname[0] == '!'
+ && strcmp (name, tname + 4) == 0)
return IDENTIFIER_POINTER (TREE_PURPOSE (temp));
}
- STRIP_NAME_ENCODING (name, name);
+ name = darwin_strip_name_encoding (name);
{
char *buffer;
+ int bufferlen = 0;
+ int namelen = strlen (name);
tree ptr_name;
int needs_quotes = name_needs_quotes (name);
- buffer = alloca (strlen (name) + 20);
+ buffer = alloca (namelen + 20);
if (needs_quotes)
- strcpy (buffer, "&\"L");
+ {
+ strcpy (buffer, "&\"L");
+ bufferlen = strlen("&\"L");
+ }
else
- strcpy (buffer, "&L");
+ {
+ strcpy (buffer, "&L");
+ bufferlen = strlen("&L");
+ }
+
if (name[0] == '*')
{
- strcat (buffer, name+1);
+ memcpy (buffer + bufferlen, name+1, namelen - 1 +1);
+ bufferlen += namelen - 1;
}
else
{
- strcat (buffer, "_");
- strcat (buffer, name);
+ buffer[bufferlen] = '_';
+ memcpy (buffer + bufferlen +1, name, namelen+1);
+ bufferlen += namelen +1;
}
if (needs_quotes)
- strcat (buffer, "$stub\"");
+ {
+ memcpy (buffer + bufferlen, "$stub\"", strlen("$stub\"")+1);
+ bufferlen += strlen("$stub\"");
+ }
else
- strcat (buffer, "$stub");
+ {
+ memcpy (buffer + bufferlen, "$stub", strlen("$stub")+1);
+ bufferlen += strlen("$stub");
+ }
ptr_name = get_identifier (buffer);
machopic_stubs = tree_cons (ptr_name, ident, machopic_stubs);
}
void
-machopic_validate_stub_or_non_lazy_ptr (name, validate_stub)
- const char *name;
- int validate_stub;
+machopic_validate_stub_or_non_lazy_ptr (const char *name, int validate_stub)
{
- char *real_name;
+ const char *real_name;
tree temp, ident = get_identifier (name), id2;
for (temp = (validate_stub ? machopic_stubs : machopic_non_lazy_pointers);
original symbol as being referenced. */
TREE_USED (temp) = 1;
if (TREE_CODE (TREE_VALUE (temp)) == IDENTIFIER_NODE)
- TREE_SYMBOL_REFERENCED (TREE_VALUE (temp)) = 1;
- STRIP_NAME_ENCODING (real_name, IDENTIFIER_POINTER (TREE_VALUE (temp)));
+ mark_referenced (TREE_VALUE (temp));
+ real_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ real_name = darwin_strip_name_encoding (real_name);
id2 = maybe_get_identifier (real_name);
if (id2)
- TREE_SYMBOL_REFERENCED (id2) = 1;
+ mark_referenced (id2);
}
}
source using indirections. */
rtx
-machopic_indirect_data_reference (orig, reg)
- rtx orig, reg;
+machopic_indirect_data_reference (rtx orig, rtx reg)
{
rtx ptr_ref = orig;
-
+
if (! MACHOPIC_INDIRECT)
return orig;
if (GET_CODE (orig) == SYMBOL_REF)
{
const char *name = XSTR (orig, 0);
+ int defined = machopic_data_defined_p (name);
- if (machopic_data_defined_p (name))
+ if (defined && MACHO_DYNAMIC_NO_PIC_P)
+ {
+#if defined (TARGET_TOC)
+ emit_insn (gen_macho_high (reg, orig));
+ emit_insn (gen_macho_low (reg, reg, orig));
+#else
+ /* some other cpu -- writeme! */
+ abort ();
+#endif
+ return reg;
+ }
+ else if (defined)
{
- 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) || defined (HAVE_lo_sum)
+ 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));
+#endif
#if defined (TARGET_TOC) /* i.e., PowerPC */
- rtx hi_sum_reg = reg;
+ rtx hi_sum_reg = (no_new_pseudos ? reg : gen_reg_rtx (Pmode));
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)));
+ 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)));
+ 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, pic_offset_table_rtx));
- orig = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, reg);
+ 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_SYMBOL_REF (Pmode,
+ machopic_non_lazy_ptr_name (name));
+
+ SYMBOL_REF_DECL (ptr_ref) = SYMBOL_REF_DECL (orig);
ptr_ref = gen_rtx_MEM (Pmode, ptr_ref);
RTX_UNCHANGING_P (ptr_ref) = 1;
orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
(base == reg ? 0 : reg));
}
- else
+ else
return orig;
if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
result = plus_constant (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;
+ result = gen_rtx_PLUS (Pmode, base, orig);
if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
{
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;
+machopic_indirect_call_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))
+ /* If the name is already defined, we need do nothing. */
+ if (name[0] == '!' && name[1] == 'T')
+ return target;
+
+ if (!machopic_name_defined_p (name))
{
const char *stub_name = machopic_stub_name (name);
+ tree decl = SYMBOL_REF_DECL (XEXP (target, 0));
- XEXP (target, 0) = gen_rtx (SYMBOL_REF, mode, stub_name);
+ XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
+ SYMBOL_REF_DECL (XEXP (target, 0)) = decl;
RTX_UNCHANGING_P (target) = 1;
- }
+ }
}
return target;
}
rtx
-machopic_legitimize_pic_address (orig, mode, reg)
- rtx orig, reg;
- enum machine_mode mode;
+machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
{
rtx pic_ref = orig;
- if (! MACHOPIC_PURE)
+ if (! MACHOPIC_INDIRECT)
return orig;
/* First handle a simple SYMBOL_REF or LABEL_REF */
orig = machopic_indirect_data_reference (orig, reg);
- if (GET_CODE (orig) == PLUS
+ if (GET_CODE (orig) == PLUS
&& GET_CODE (XEXP (orig, 0)) == REG)
{
if (reg == 0)
emit_move_insn (reg, orig);
return reg;
- }
+ }
- pic_base = gen_rtx (SYMBOL_REF, Pmode, machopic_function_base_name ());
+ /* if dynamic-no-pic then use 0 as the pic base */
+ if (MACHO_DYNAMIC_NO_PIC_P)
+ pic_base = CONST0_RTX (Pmode);
+ else
+ pic_base = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
if (GET_CODE (orig) == MEM)
{
else
reg = gen_reg_rtx (Pmode);
}
-
+
#ifdef HAVE_lo_sum
- if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
+ if (MACHO_DYNAMIC_NO_PIC_P
+ && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
+ || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
+ {
+#if defined (TARGET_TOC) /* ppc */
+ rtx temp_reg = (no_new_pseudos) ? reg : gen_reg_rtx (Pmode);
+ rtx asym = XEXP (orig, 0);
+ rtx mem;
+
+ emit_insn (gen_macho_high (temp_reg, asym));
+ mem = gen_rtx_MEM (GET_MODE (orig),
+ gen_rtx_LO_SUM (Pmode, temp_reg, asym));
+ RTX_UNCHANGING_P (mem) = 1;
+ emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+#else
+ /* Some other CPU -- WriteMe! but right now there are no other platform that can use dynamic-no-pic */
+ abort ();
+#endif
+ pic_ref = reg;
+ }
+ else
+ 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));
+ 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;
+ rtx hi_sum_reg = no_new_pseudos ? reg : gen_reg_rtx (SImode);
+ rtx mem;
+ rtx insn;
+ rtx sum;
+
+ sum = gen_rtx_HIGH (Pmode, offset);
+ if (! MACHO_DYNAMIC_NO_PIC_P)
+ sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
+
+ emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
+
+ mem = gen_rtx_MEM (GET_MODE (orig),
+ gen_rtx_LO_SUM (Pmode,
+ hi_sum_reg, offset));
+ RTX_UNCHANGING_P (mem) = 1;
+ insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, pic_ref,
+ REG_NOTES (insn));
+ 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);
+ 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
pic = reg;
}
#if 0
- emit_insn (gen_rtx (USE, VOIDmode,
- gen_rtx (REG, Pmode, PIC_OFFSET_TABLE_REGNUM)));
+ 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)));
+ 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);
+ pic_ref = gen_rtx_MEM (GET_MODE (orig), reg);
#endif
+ RTX_UNCHANGING_P (pic_ref) = 1;
}
else
{
#ifdef HAVE_lo_sum
- if (GET_CODE (orig) == SYMBOL_REF
+ if (GET_CODE (orig) == SYMBOL_REF
|| GET_CODE (orig) == LABEL_REF)
{
- rtx offset = gen_rtx (CONST, Pmode,
- gen_rtx (MINUS, Pmode, orig, pic_base));
+ rtx offset = gen_rtx_CONST (Pmode,
+ gen_rtx_MINUS (Pmode,
+ orig, pic_base));
#if defined (TARGET_TOC) /* i.e., PowerPC */
rtx hi_sum_reg;
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)));
+ emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
+ (MACHO_DYNAMIC_NO_PIC_P)
+ ? gen_rtx_HIGH (Pmode, offset)
+ : 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;
+ RTX_UNCHANGING_P (pic_ref) = 1;
#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);
+ 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);
+ RTX_UNCHANGING_P (pic_ref) = 1;
#endif
}
else
pic = reg;
}
#if 0
- emit_insn (gen_rtx (USE, VOIDmode,
- pic_offset_table_rtx));
+ 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)));
+ 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)
|| 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);
is_complex = 1;
}
else
- pic_ref = gen_rtx (PLUS, Pmode, base, orig);
+ pic_ref = gen_rtx_PLUS (Pmode, base, orig);
if (RTX_UNCHANGING_P (base) && RTX_UNCHANGING_P (orig))
RTX_UNCHANGING_P (pic_ref) = 1;
{
rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
- addr = gen_rtx (MEM, GET_MODE (orig), addr);
+ addr = gen_rtx_MEM (GET_MODE (orig), addr);
RTX_UNCHANGING_P (addr) = RTX_UNCHANGING_P (orig);
emit_move_insn (reg, addr);
pic_ref = reg;
void
-machopic_finish (asm_out_file)
- FILE *asm_out_file;
+machopic_finish (FILE *asm_out_file)
{
tree temp;
temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
- char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
- char *stub_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
+ const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ const char *stub_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
char *sym;
char *stub;
if (! TREE_USED (temp))
continue;
- STRIP_NAME_ENCODING (sym_name, sym_name);
+ sym_name = darwin_strip_name_encoding (sym_name);
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);
+ strcpy (sym, sym_name);
else
sym[0] = '_', strcpy (sym + 1, sym_name);
}
for (temp = machopic_non_lazy_pointers;
- temp != NULL_TREE;
+ 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
+ const char *const sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ const char *const lazy_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp));
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
- )
+ if (machopic_ident_defined_p (TREE_VALUE (temp)))
{
data_section ();
- assemble_align (UNITS_PER_WORD * BITS_PER_UNIT);
+ assemble_align (GET_MODE_ALIGNMENT (Pmode));
assemble_label (lazy_name);
- assemble_integer (gen_rtx (SYMBOL_REF, Pmode, sym_name),
- GET_MODE_SIZE (Pmode), 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
+ GET_MODE_SIZE (Pmode),
+ GET_MODE_ALIGNMENT (Pmode), 1);
}
else
{
machopic_nl_symbol_ptr_section ();
- assemble_name (asm_out_file, lazy_name);
+ 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);
+ assemble_name (asm_out_file, sym_name);
fprintf (asm_out_file, "\n");
- assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode), 1);
+ assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode),
+ GET_MODE_ALIGNMENT (Pmode), 1);
}
}
}
-int
-machopic_operand_p (op)
- rtx op;
+int
+machopic_operand_p (rtx op)
{
if (MACHOPIC_JUST_INDIRECT)
{
&& 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;
}
use later. */
void
-darwin_encode_section_info (decl)
- tree decl;
+darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
{
char code = '\0';
int defined = 0;
rtx sym_ref;
- char *orig_str, *new_str;
+ const char *orig_str;
+ char *new_str;
size_t len, new_len;
+ /* Do the standard encoding things first. */
+ default_encode_section_info (decl, rtl, first);
+
+ /* With the introduction of symbol_ref flags, some of the following
+ code has become redundant and should be removed at some point. */
+
if ((TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL)
&& !DECL_EXTERNAL (decl)
+ && (!TREE_PUBLIC (decl) || (!DECL_ONE_ONLY (decl) && !DECL_WEAK (decl)))
&& ((TREE_STATIC (decl)
&& (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
- || DECL_INITIAL (decl)))
+ || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
+ && DECL_INITIAL (decl) != error_mark_node)))
defined = 1;
if (TREE_CODE (decl) == FUNCTION_DECL)
if (code == '\0')
return;
- sym_ref = XEXP (DECL_RTL (decl), 0);
+ sym_ref = XEXP (rtl, 0);
orig_str = XSTR (sym_ref, 0);
len = strlen (orig_str) + 1;
}
/* The non-lazy pointer list may have captured references to the
old encoded name, change them. */
- update_non_lazy_ptrs (XSTR (sym_ref, 0));
- update_stubs (XSTR (sym_ref, 0));
+ if (TREE_CODE (decl) == VAR_DECL)
+ update_non_lazy_ptrs (XSTR (sym_ref, 0));
+ else
+ update_stubs (XSTR (sym_ref, 0));
+}
+
+/* Undo the effects of the above. */
+
+const char *
+darwin_strip_name_encoding (const char *str)
+{
+ return str[0] == '!' ? str + 4 : str;
}
/* Scan the list of non-lazy pointers and update any recorded names whose
stripped name matches the argument. */
static void
-update_non_lazy_ptrs (name)
- const char *name;
+update_non_lazy_ptrs (const char *name)
{
- char *name1, *name2;
+ const char *name1, *name2;
tree temp;
- STRIP_NAME_ENCODING (name1, name);
+ name1 = darwin_strip_name_encoding (name);
for (temp = machopic_non_lazy_pointers;
- temp != NULL_TREE;
+ temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
- char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
if (*sym_name == '!')
{
- STRIP_NAME_ENCODING (name2, sym_name);
+ name2 = darwin_strip_name_encoding (sym_name);
if (strcmp (name1, name2) == 0)
{
- IDENTIFIER_POINTER (TREE_VALUE (temp)) = name;
+ /* FIXME: This breaks the identifier hash table. */
+ IDENTIFIER_NODE_CHECK (TREE_VALUE (temp))->identifier.id.str
+ = (unsigned char *) name;
break;
}
}
}
}
-
/* Scan the list of stubs and update any recorded names whose
stripped name matches the argument. */
static void
-update_stubs (name)
- const char *name;
+update_stubs (const char *name)
{
- char *name1, *name2;
+ const char *name1, *name2;
tree temp;
- STRIP_NAME_ENCODING (name1, name);
+ name1 = darwin_strip_name_encoding (name);
for (temp = machopic_stubs;
- temp != NULL_TREE;
+ temp != NULL_TREE;
temp = TREE_CHAIN (temp))
{
- char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
+ const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp));
if (*sym_name == '!')
{
- STRIP_NAME_ENCODING (name2, sym_name);
+ name2 = darwin_strip_name_encoding (sym_name);
if (strcmp (name1, name2) == 0)
{
- IDENTIFIER_POINTER (TREE_VALUE (temp)) = name;
+ /* FIXME: This breaks the identifier hash table. */
+ IDENTIFIER_NODE_CHECK (TREE_VALUE (temp))->identifier.id.str
+ = (unsigned char *) name;
break;
}
}
}
void
-machopic_asm_out_constructor (symbol, priority)
- rtx symbol;
- int priority ATTRIBUTE_UNUSED;
+darwin_make_decl_one_only (tree decl)
{
- if (flag_pic)
+ static const char *text_section = "__TEXT,__textcoal_nt,coalesced,no_toc";
+ static const char *data_section = "__DATA,__datacoal_nt,coalesced,no_toc";
+
+ const char *sec = TREE_CODE (decl) == FUNCTION_DECL
+ ? text_section
+ : data_section;
+ TREE_PUBLIC (decl) = 1;
+ DECL_ONE_ONLY (decl) = 1;
+ DECL_SECTION_NAME (decl) = build_string (strlen (sec), sec);
+}
+
+void
+machopic_select_section (tree exp, int reloc,
+ unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
+{
+ void (*base_function)(void);
+
+ if (decl_readonly_section_1 (exp, reloc, MACHOPIC_INDIRECT))
+ base_function = readonly_data_section;
+ else if (TREE_READONLY (exp) || TREE_CONSTANT (exp))
+ base_function = const_data_section;
+ else
+ base_function = data_section;
+
+ if (TREE_CODE (exp) == STRING_CST
+ && ((size_t) TREE_STRING_LENGTH (exp)
+ == strlen (TREE_STRING_POINTER (exp)) + 1))
+ cstring_section ();
+ else if ((TREE_CODE (exp) == INTEGER_CST || TREE_CODE (exp) == REAL_CST)
+ && flag_merge_constants)
+ {
+ 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
+ base_function ();
+ }
+ 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
+ base_function ();
+ }
+ 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_IMAGE_INFO", 16))
+ objc_image_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
+ base_function ();
+ }
+ else
+ base_function ();
+}
+
+/* This can be called with address expressions as "rtx".
+ They must go in "const". */
+
+void
+machopic_select_rtx_section (enum machine_mode mode, rtx x,
+ unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
+{
+ if (GET_MODE_SIZE (mode) == 8)
+ literal8_section ();
+ else if (GET_MODE_SIZE (mode) == 4
+ && (GET_CODE (x) == CONST_INT
+ || GET_CODE (x) == CONST_DOUBLE))
+ literal4_section ();
+ else if (MACHOPIC_INDIRECT
+ && (GET_CODE (x) == SYMBOL_REF
+ || GET_CODE (x) == CONST
+ || GET_CODE (x) == LABEL_REF))
+ const_data_section ();
+ else
+ const_section ();
+}
+
+void
+machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
+{
+ if (MACHOPIC_INDIRECT)
mod_init_section ();
else
constructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
- if (!flag_pic)
+ if (! MACHOPIC_INDIRECT)
fprintf (asm_out_file, ".reference .constructors_used\n");
}
void
-machopic_asm_out_destructor (symbol, priority)
- rtx symbol;
- int priority ATTRIBUTE_UNUSED;
+machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
{
- if (flag_pic)
+ if (MACHOPIC_INDIRECT)
mod_term_section ();
else
destructor_section ();
- assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
+ assemble_align (POINTER_SIZE);
+ assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
- if (!flag_pic)
+ if (! MACHOPIC_INDIRECT)
fprintf (asm_out_file, ".reference .destructors_used\n");
}
+
+void
+darwin_globalize_label (FILE *stream, const char *name)
+{
+ if (!!strncmp (name, "_OBJC_", 6))
+ default_globalize_label (stream, name);
+}
+
+void
+darwin_asm_named_section (const char *name, unsigned int flags ATTRIBUTE_UNUSED)
+{
+ if (flag_reorder_blocks_and_partition)
+ fprintf (asm_out_file, SECTION_FORMAT_STRING, name);
+ else
+ fprintf (asm_out_file, ".section %s\n", name);
+}
+
+unsigned int
+darwin_section_type_flags (tree decl, const char *name, int reloc)
+{
+ unsigned int flags = default_section_type_flags (decl, name, reloc);
+
+ /* Weak or linkonce variables live in a writable section. */
+ if (decl != 0 && TREE_CODE (decl) != FUNCTION_DECL
+ && (DECL_WEAK (decl) || DECL_ONE_ONLY (decl)))
+ flags |= SECTION_WRITE;
+
+ return flags;
+}
+
+void
+darwin_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED)
+{
+ /* Darwin does not use unique sections. However, the target's
+ unique_section hook is called for linkonce symbols. We need
+ to set an appropriate section for such symbols. */
+ if (DECL_ONE_ONLY (decl) && !DECL_SECTION_NAME (decl))
+ darwin_make_decl_one_only (decl);
+}
+
+/* Emit a label for an FDE, making it global and/or weak if appropriate.
+ The third parameter is nonzero if this is for exception handling.
+ The fourth parameter is nonzero if this is just a placeholder for an
+ FDE that we are omitting. */
+
+void
+darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
+{
+ tree id = DECL_ASSEMBLER_NAME (decl)
+ ? DECL_ASSEMBLER_NAME (decl)
+ : DECL_NAME (decl);
+
+ const char *prefix = "_";
+ const int prefix_len = 1;
+
+ const char *base = IDENTIFIER_POINTER (id);
+ unsigned int base_len = IDENTIFIER_LENGTH (id);
+
+ const char *suffix = ".eh";
+
+ int need_quotes = name_needs_quotes (base);
+ int quotes_len = need_quotes ? 2 : 0;
+ char *lab;
+
+ if (! for_eh)
+ suffix = ".eh1";
+
+ lab = xmalloc (prefix_len + base_len + strlen (suffix) + quotes_len + 1);
+ lab[0] = '\0';
+
+ if (need_quotes)
+ strcat(lab, "\"");
+ strcat(lab, prefix);
+ strcat(lab, base);
+ strcat(lab, suffix);
+ if (need_quotes)
+ strcat(lab, "\"");
+
+ if (TREE_PUBLIC (decl))
+ fprintf (file, "%s %s\n",
+ (DECL_VISIBILITY (decl) != VISIBILITY_HIDDEN
+ ? ".globl"
+ : ".private_extern"),
+ lab);
+
+ if (DECL_ONE_ONLY (decl) && TREE_PUBLIC (decl))
+ fprintf (file, ".weak_definition %s\n", lab);
+
+ if (empty)
+ fprintf (file, "%s = 0\n", lab);
+ else
+ fprintf (file, "%s:\n", lab);
+
+ free (lab);
+}
+
+/* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
+
+void
+darwin_non_lazy_pcrel (FILE *file, rtx addr)
+{
+ const char *str;
+ const char *nlp_name;
+
+ if (GET_CODE (addr) != SYMBOL_REF)
+ abort ();
+
+ str = darwin_strip_name_encoding (XSTR (addr, 0));
+ nlp_name = machopic_non_lazy_ptr_name (str);
+ fputs ("\t.long\t", file);
+ ASM_OUTPUT_LABELREF (file, nlp_name);
+ fputs ("-.", file);
+}
+
+/* Emit an assembler directive to set visibility for a symbol. The
+ only supported visibilities are VISIBILITY_DEFAULT and
+ VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
+ extern". There is no MACH-O equivalent of ELF's
+ VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
+
+void
+darwin_assemble_visibility (tree decl, int vis)
+{
+ if (vis == VISIBILITY_DEFAULT)
+ ;
+ else if (vis == VISIBILITY_HIDDEN)
+ {
+ fputs ("\t.private_extern ", asm_out_file);
+ assemble_name (asm_out_file,
+ (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
+ fputs ("\n", asm_out_file);
+ }
+ else
+ warning ("internal and protected visibility attributes not supported"
+ "in this configuration; ignored");
+}
+
+/* Output a difference of two labels that will be an assembly time
+ constant if the two labels are local. (.long lab1-lab2 will be
+ very different if lab1 is at the boundary between two sections; it
+ will be relocated according to the second section, not the first,
+ so one ends up with a difference between labels in different
+ sections, which is bad in the dwarf2 eh context for instance.) */
+
+static int darwin_dwarf_label_counter;
+
+void
+darwin_asm_output_dwarf_delta (FILE *file, int size ATTRIBUTE_UNUSED,
+ const char *lab1, const char *lab2)
+{
+ int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
+ && lab2[0] == '*' && lab2[1] == 'L');
+
+ if (islocaldiff)
+ fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
+ else
+ fprintf (file, "\t%s\t", ".long");
+ assemble_name (file, lab1);
+ fprintf (file, "-");
+ assemble_name (file, lab2);
+ if (islocaldiff)
+ fprintf (file, "\n\t.long L$set$%d", darwin_dwarf_label_counter++);
+}
+
+void
+darwin_file_end (void)
+{
+ machopic_finish (asm_out_file);
+ if (strcmp (lang_hooks.name, "GNU C++") == 0)
+ {
+ constructor_section ();
+ destructor_section ();
+ ASM_OUTPUT_ALIGN (asm_out_file, 1);
+ }
+}
+
+#include "gt-darwin.h"