diff options
Diffstat (limited to 'gcc/config/darwin.c')
| -rw-r--r-- | gcc/config/darwin.c | 475 |
1 files changed, 451 insertions, 24 deletions
diff --git a/gcc/config/darwin.c b/gcc/config/darwin.c index 858d150d45e..cc213a49388 100644 --- a/gcc/config/darwin.c +++ b/gcc/config/darwin.c @@ -46,7 +46,57 @@ Boston, MA 02111-1307, USA. */ 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*); +const char *machopic_non_lazy_ptr_name (const char*); + +/* APPLE LOCAL prototypes */ +static tree machopic_non_lazy_ptr_list_entry PARAMS ((const char*, int)); +static tree machopic_stub_list_entry PARAMS ((const char *)); + +/* APPLE LOCAL begin coalescing */ +void +make_decl_coalesced (decl, private_extern_p) + tree decl; + int private_extern_p; /* 0 for global, 1 for private extern */ +{ + int no_toc_p = 1; /* Don't add to table of contents */ +#if 0 + const char *decl_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); +#endif + static const char *const names[4] = { + "__TEXT,__textcoal,coalesced", + "__TEXT,__textcoal_nt,coalesced,no_toc", + "__DATA,__datacoal,coalesced", + "__DATA,__datacoal_nt,coalesced,no_toc", + }; + const char *sec; + int idx; + + /* Do nothing if coalescing is disabled. */ + if (!COALESCING_ENABLED_P()) + return; + + /* We *do* need to mark these *INTERNAL* functions coalesced: though + these pseudo-functions themselves will never appear, their cloned + descendants need to be marked coalesced too. */ +#if 0 + /* Don't touch anything with " *INTERNAL" in its name. */ + if (strstr (decl_name, " *INTERNAL") != NULL) + return; +#endif + + DECL_COALESCED (decl) = 1; + if (private_extern_p) + DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; + TREE_PUBLIC (decl) = 1; + + idx = 0; + if (TREE_CODE (decl) != FUNCTION_DECL) + idx = 2; + sec = names[idx + (no_toc_p ? 1 : 0)]; + + DECL_SECTION_NAME (decl) = build_string (strlen (sec), sec); +} +/* APPLE LOCAL end coalescing */ int name_needs_quotes (const char *name) @@ -187,6 +237,14 @@ machopic_ident_defined_p (tree ident) static int machopic_data_defined_p (const char *name) { + /* APPLE LOCAL BEGIN fix-and-continue mrs */ +#ifndef TARGET_INDIRECT_ALL_DATA +#define TARGET_INDIRECT_ALL_DATA 0 +#endif + if (TARGET_INDIRECT_ALL_DATA) + return 0; + /* APPLE LOCAL END fix-and-continue mrs */ + switch (machopic_classify_ident (get_identifier (name))) { case MACHOPIC_DEFINED_DATA: @@ -264,18 +322,19 @@ static GTY(()) tree machopic_non_lazy_pointers; either by finding it in our list of pointer names, or by generating a new one. */ -static const char * -machopic_non_lazy_ptr_name (const char *name) +/* APPLE LOCAL weak import */ +/* machopic_non_lazy_ptr_list_entry separated from machopic_non_lazy_ptr_name */ +static tree +machopic_non_lazy_ptr_list_entry (const char *name, int create_p) { - const char *temp_name; - tree temp, ident = get_identifier (name); - + tree temp, ident = (create_p) ? get_identifier (name) : NULL; + for (temp = machopic_non_lazy_pointers; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { if (ident == TREE_VALUE (temp)) - return IDENTIFIER_POINTER (TREE_PURPOSE (temp)); + return temp; } name = darwin_strip_name_encoding (name); @@ -287,14 +346,14 @@ machopic_non_lazy_ptr_name (const char *name) { if (TREE_VALUE (temp)) { - temp_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); + const char *temp_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); temp_name = darwin_strip_name_encoding (temp_name); if (strcmp (name, temp_name) == 0) - return IDENTIFIER_POINTER (TREE_PURPOSE (temp)); + return temp; } } - { + if (create_p) { char *buffer; int namelen = strlen (name); int bufferlen = 0; @@ -325,17 +384,41 @@ machopic_non_lazy_ptr_name (const char *name) TREE_USED (machopic_non_lazy_pointers) = 0; - return IDENTIFIER_POINTER (ptr_name); + return machopic_non_lazy_pointers; } + + return NULL; } +/* APPLE LOCAL begin coalescing */ +/* Was the variable NAME ever referenced? */ +int +machopic_var_referred_to_p (name) + const char *name; +{ + return (machopic_non_lazy_ptr_list_entry (name, /*create:*/ 0) != NULL); +} +/* APPLE LOCAL end coalescing */ + +/* APPLE LOCAL begin weak import */ +const char * +machopic_non_lazy_ptr_name (name) + const char *name; +{ + return IDENTIFIER_POINTER (TREE_PURPOSE + (machopic_non_lazy_ptr_list_entry (name, /*create:*/ 1))); +} +/* APPLE LOCAL end weak import */ + static GTY(()) tree machopic_stubs; /* Return the name of the stub corresponding to the given name, generating a new stub name if necessary. */ -const char * -machopic_stub_name (const char *name) +/* APPLE LOCAL begin weak import */ +/* machopic_stub_list_entry separated from machopic_stub_name */ +static tree +machopic_stub_list_entry (const char *name) { tree temp, ident = get_identifier (name); const char *tname; @@ -345,16 +428,22 @@ machopic_stub_name (const char *name) temp = TREE_CHAIN (temp)) { if (ident == TREE_VALUE (temp)) - return IDENTIFIER_POINTER (TREE_PURPOSE (temp)); + return temp; tname = IDENTIFIER_POINTER (TREE_VALUE (temp)); if (strcmp (name, tname) == 0) - return IDENTIFIER_POINTER (TREE_PURPOSE (temp)); + return temp; + + /* APPLE LOCAL Stripped encodings ('!T_' and '!t_') should match. */ + if (name [0] == '!' && tname[0] == '!' + && strcmp (name + 4, tname + 4) == 0) + return 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)); + return temp; } name = darwin_strip_name_encoding (name); @@ -406,10 +495,18 @@ machopic_stub_name (const char *name) machopic_stubs = tree_cons (ptr_name, ident, machopic_stubs); TREE_USED (machopic_stubs) = 0; - return IDENTIFIER_POINTER (ptr_name); + return machopic_stubs; } } +const char * +machopic_stub_name (name) + const char *name; +{ + return IDENTIFIER_POINTER (TREE_PURPOSE (machopic_stub_list_entry (name))); +} +/* APPLE LOCAL end weak import */ + void machopic_validate_stub_or_non_lazy_ptr (const char *name, int validate_stub) { @@ -448,6 +545,8 @@ machopic_indirect_data_reference (rtx orig, rtx reg) if (GET_CODE (orig) == SYMBOL_REF) { const char *name = XSTR (orig, 0); + /* APPLE LOCAL weak import */ + tree sym; int defined = machopic_data_defined_p (name); if (defined && MACHO_DYNAMIC_NO_PIC_P) @@ -499,8 +598,14 @@ machopic_indirect_data_reference (rtx orig, rtx reg) return orig; } + /* APPLE LOCAL weak import */ + sym = machopic_non_lazy_ptr_list_entry (name, /*create:*/ 1); + IDENTIFIER_WEAK_IMPORT (TREE_PURPOSE (sym)) = + IDENTIFIER_WEAK_IMPORT (TREE_VALUE (sym)) = + SYMBOL_REF_WEAK_IMPORT (orig); + ptr_ref = gen_rtx_SYMBOL_REF (Pmode, - machopic_non_lazy_ptr_name (name)); + IDENTIFIER_POINTER (TREE_PURPOSE (sym))); ptr_ref = gen_rtx_MEM (Pmode, ptr_ref); RTX_UNCHANGING_P (ptr_ref) = 1; @@ -585,9 +690,14 @@ machopic_indirect_call_target (rtx target) if (!machopic_name_defined_p (name)) { - const char *stub_name = machopic_stub_name (name); - - XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name); + /* APPLE LOCAL weak import */ + tree stub = machopic_stub_list_entry (name); + IDENTIFIER_WEAK_IMPORT (TREE_PURPOSE (stub)) = + IDENTIFIER_WEAK_IMPORT (TREE_VALUE (stub)) = + SYMBOL_REF_WEAK_IMPORT (XEXP (target, 0)); + + XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, + IDENTIFIER_POINTER (TREE_PURPOSE (stub))); RTX_UNCHANGING_P (target) = 1; } } @@ -855,6 +965,43 @@ machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg) if (RTX_UNCHANGING_P (base) && RTX_UNCHANGING_P (orig)) RTX_UNCHANGING_P (pic_ref) = 1; + /* APPLE LOCAL begin gen ADD */ +#ifdef MASK_80387 + { + rtx mem, other; + + if (GET_CODE (orig) == MEM) { + mem = orig; other = base; + /* Swap the kids only if there is only one MEM, and it's on the right. */ + if (GET_CODE (base) != MEM) { + XEXP (pic_ref, 0) = orig; + XEXP (pic_ref, 1) = base; + } + } + else if (GET_CODE (base) == MEM) { + mem = base; other = orig; + } else + mem = other = NULL_RTX; + + /* Both kids are MEMs. */ + if (other && GET_CODE (other) == MEM) + other = force_reg (GET_MODE (other), other); + + /* The x86 can't post-index a MEM; emit an ADD instruction to handle this. */ + if (mem && GET_CODE (mem) == MEM) { + if ( ! reload_in_progress) { + rtx set = gen_rtx_SET (VOIDmode, reg, pic_ref); + rtx clobber_cc = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG)); + pic_ref = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber_cc)); + emit_insn (pic_ref); + pic_ref = reg; + is_complex = 0; + } + } + } +#endif + /* APPLE LOCAL end gen ADD */ + if (reg && is_complex) { emit_move_insn (reg, pic_ref); @@ -871,7 +1018,12 @@ machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx 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); + /* APPLE LOCAL use new pseudo for temp; reusing reg confuses PRE */ + rtx tempreg = reg; + rtx addr; + if ( !no_new_pseudos ) + tempreg = gen_reg_rtx (Pmode); + addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, tempreg); addr = gen_rtx_MEM (GET_MODE (orig), addr); RTX_UNCHANGING_P (addr) = RTX_UNCHANGING_P (orig); @@ -916,6 +1068,14 @@ machopic_finish (FILE *asm_out_file) else stub[0] = '_', strcpy (stub + 1, stub_name); + /* APPLE LOCAL weak import */ + if ( IDENTIFIER_WEAK_IMPORT (TREE_VALUE (temp))) + { + fprintf (asm_out_file, "\t.weak_reference "); + assemble_name (asm_out_file, sym_name); + fprintf (asm_out_file, "\n"); + } + machopic_output_stub (asm_out_file, sym, stub); } @@ -929,7 +1089,11 @@ machopic_finish (FILE *asm_out_file) if (! TREE_USED (temp)) continue; - if (machopic_ident_defined_p (TREE_VALUE (temp))) + /* APPLE LOCAL fix-and-continue mrs */ + if (! TARGET_INDIRECT_ALL_DATA + && (machopic_ident_defined_p (TREE_VALUE (temp)) + /* APPLE LOCAL private extern */ + || (sym_name[0] == '!' && sym_name[2] == 'p'))) { data_section (); assemble_align (GET_MODE_ALIGNMENT (Pmode)); @@ -940,6 +1104,17 @@ machopic_finish (FILE *asm_out_file) } else { + /* APPLE LOCAL fix-and-continue mrs */ + rtx init = const0_rtx; + + /* APPLE LOCAL weak import */ + if ( IDENTIFIER_WEAK_IMPORT (TREE_VALUE (temp))) + { + fprintf (asm_out_file, "\t.weak_reference "); + assemble_name (asm_out_file, sym_name); + fprintf (asm_out_file, "\n"); + } + machopic_nl_symbol_ptr_section (); assemble_name (asm_out_file, lazy_name); fprintf (asm_out_file, ":\n"); @@ -948,8 +1123,14 @@ machopic_finish (FILE *asm_out_file) assemble_name (asm_out_file, sym_name); fprintf (asm_out_file, "\n"); - assemble_integer (const0_rtx, GET_MODE_SIZE (Pmode), + /* APPLE LOCAL BEGIN fix-and-continue mrs */ + if (sym_name[3] == 's' + && machopic_ident_defined_p (TREE_VALUE (temp))) + init = gen_rtx_SYMBOL_REF (Pmode, sym_name); + + assemble_integer (init, GET_MODE_SIZE (Pmode), GET_MODE_ALIGNMENT (Pmode), 1); + /* APPLE LOCAL END fix-and-continue mrs */ } } } @@ -1004,11 +1185,28 @@ darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED) if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) && !DECL_EXTERNAL (decl) + /* APPLE LOCAL coalescing */ +#ifdef DECL_IS_COALESCED_OR_WEAK + && ! DECL_IS_COALESCED_OR_WEAK (decl) +#endif && ((TREE_STATIC (decl) && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl))) || (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node))) defined = 1; + /* APPLE LOCAL fix OBJC codegen */ + if (TREE_CODE (decl) == VAR_DECL) + { + sym_ref = XEXP (DECL_RTL (decl), 0); + orig_str = XSTR (sym_ref, 0); + if ( orig_str[0] == '_' + && orig_str[1] == 'O' + && orig_str[2] == 'B' + && orig_str[3] == 'J' + && orig_str[4] == 'C' + && orig_str[5] == '_') + defined = 1; + } if (TREE_CODE (decl) == FUNCTION_DECL) code = (defined ? 'T' : 't'); @@ -1041,7 +1239,15 @@ darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED) new_str[0] = '!'; new_str[1] = code; new_str[2] = '_'; + /* APPLE LOCAL private extern */ + if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN) + new_str[2] = 'p'; new_str[3] = '_'; + /* APPLE LOCAL BEGIN fix-and-continue mrs */ + if (TARGET_INDIRECT_ALL_DATA + && TREE_CODE (decl) == VAR_DECL && ! TREE_PUBLIC (decl)) + new_str[3] = 's'; + /* APPLE LOCAL END fix-and-continue mrs */ memcpy (new_str + 4, orig_str, len); XSTR (sym_ref, 0) = ggc_alloc_string (new_str, new_len); } @@ -1161,9 +1367,24 @@ machopic_select_section (tree exp, int reloc, && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE && TYPE_NAME (TREE_TYPE (exp))) { + /* APPLE LOCAL begin constant strings */ + extern int flag_next_runtime; + extern const char *constant_string_class_name; + /* APPLE LOCAL end constant strings */ tree name = TYPE_NAME (TREE_TYPE (exp)); if (TREE_CODE (name) == TYPE_DECL) name = DECL_NAME (name); + /* APPLE LOCAL begin constant strings */ + if (constant_string_class_name + && !strcmp (IDENTIFIER_POINTER (name), + constant_string_class_name)) + { + if (flag_next_runtime) + objc_constant_string_object_section (); + else + objc_string_object_section (); + } + /* APPLE LOCAL end constant strings */ if (!strcmp (IDENTIFIER_POINTER (name), "NSConstantString")) objc_constant_string_object_section (); else if (!strcmp (IDENTIFIER_POINTER (name), "NXConstantString")) @@ -1171,6 +1392,26 @@ machopic_select_section (tree exp, int reloc, else base_function (); } + /* APPLE LOCAL begin constant cfstrings */ + else if (TREE_CODE (exp) == CONSTRUCTOR + && TREE_TYPE (exp) + && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE + && TREE_OPERAND (exp, 0)) + { + tree name = TREE_OPERAND (exp, 0); + if (TREE_CODE (name) == TREE_LIST && TREE_VALUE (name) + && TREE_CODE (TREE_VALUE (name)) == NOP_EXPR + && TREE_OPERAND (TREE_VALUE (name), 0) + && TREE_OPERAND (TREE_OPERAND (TREE_VALUE (name), 0), 0)) + name = TREE_OPERAND (TREE_OPERAND (TREE_VALUE (name), 0), 0); + if (TREE_CODE (name) == VAR_DECL + && !strcmp (IDENTIFIER_POINTER (DECL_NAME (name)), + "__CFConstantStringClassReference")) + cfstring_constant_object_section (); + else + base_function (); + } + /* APPLE LOCAL end constant cfstrings */ else if (TREE_CODE (exp) == VAR_DECL && DECL_NAME (exp) && TREE_CODE (DECL_NAME (exp)) == IDENTIFIER_NODE && @@ -1228,6 +1469,10 @@ machopic_select_section (tree exp, int reloc, else base_function (); } + /* APPLE LOCAL begin darwin_set_section_for_var_p */ + else if (darwin_set_section_for_var_p (exp, reloc, align)) + ; + /* APPLE LOCAL end darwin_set_section_for_var_p */ else base_function (); } @@ -1289,6 +1534,188 @@ darwin_globalize_label (FILE *stream, const char *name) default_globalize_label (stream, name); } +/* APPLE LOCAL begin assembly "abort" directive */ +/* This can be called instead of EXIT. It will emit a '.abort' directive + into any existing assembly file, causing assembly to immediately abort, + thus preventing the assembler from spewing out numerous, irrelevant + error messages. */ + +void +abort_assembly_and_exit (status) + int status; +{ + /* If we're aborting, get the assembler to abort, too. */ + if (status == FATAL_EXIT_CODE && asm_out_file != 0) + fprintf (asm_out_file, "\n.abort\n"); + + exit (status); +} +/* APPLE LOCAL end assembly "abort" directive */ + +/* APPLE LOCAL coalescing */ +void +darwin_asm_named_section (name, flags) + const char *name; + unsigned int flags ATTRIBUTE_UNUSED; +{ + fprintf (asm_out_file, ".section %s\n", name); +} + +unsigned int +darwin_section_type_flags (decl, name, reloc) + tree decl; + const char *name; + int reloc; +{ + unsigned int flags = default_section_type_flags (decl, name, reloc); + + /* Weak or coalesced variables live in a writable section. */ + if (decl != 0 && TREE_CODE (decl) != FUNCTION_DECL + && DECL_IS_COALESCED_OR_WEAK (decl)) + flags |= SECTION_WRITE; + + return flags; +} +/* APPLE LOCAL end coalescing */ + +/* APPLE LOCAL begin double destructor turly 20020214 */ +#include "c-common.h" + +/* Handle __attribute__ ((apple_kext_compatibility)). + This only applies to darwin kexts for 295 compatibility -- it shrinks the + vtable for classes with this attribute (and their descendants) by not + outputting the new 3.0 nondeleting destructor. This means that such + objects CANNOT be allocated on the stack or as globals UNLESS they have + a completely empty `operator delete'. + Luckily, this fits in with the Darwin kext model. + + This attribute also disables gcc3's potential overlaying of derived + class data members on the padding at the end of the base class. */ + +tree +darwin_handle_odd_attribute (node, name, args, flags, no_add_attrs) + tree *node; + tree name; + tree args ATTRIBUTE_UNUSED; + int flags ATTRIBUTE_UNUSED; + bool *no_add_attrs; +{ + if (! POSSIBLY_COMPILING_APPLE_KEXT_P ()) + { + warning ("`%s' 2.95 vtable-compatability attribute applies " + "only when compiling a kext", IDENTIFIER_POINTER (name)); + + *no_add_attrs = true; + } + else if (TREE_CODE (*node) != RECORD_TYPE) + { + warning ("`%s' 2.95 vtable-compatability attribute applies " + "only to C++ classes", IDENTIFIER_POINTER (name)); + + *no_add_attrs = true; + } + + return NULL_TREE; +} +/* APPLE LOCAL end double destructor turly 20020214 */ + +/* APPLE LOCAL begin darwin_set_section_for_var_p turly 20020226 */ + +/* This is specifically for any initialised static class constants + which may be output by the C++ front end at the end of compilation. + SELECT_SECTION () macro won't do because these are VAR_DECLs, not + STRING_CSTs or INTEGER_CSTs. And by putting 'em in appropriate + sections, we save space. */ + +extern void cstring_section (void), + literal4_section (void), literal8_section (void); +int +darwin_set_section_for_var_p (exp, reloc, align) + tree exp; + int reloc; + int align; +{ + if (!reloc && TREE_CODE (exp) == VAR_DECL + && DECL_ALIGN (exp) == align + && TREE_READONLY (exp) && DECL_INITIAL (exp)) + { + /* Put constant string vars in ".cstring" section. */ + + if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE + && TREE_CODE (TREE_TYPE (TREE_TYPE (exp))) == INTEGER_TYPE + && integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (exp)))) + && TREE_CODE (DECL_INITIAL (exp)) == STRING_CST) + { + + /* Compare string length with actual number of characters + the compiler will write out (which is not necessarily + TREE_STRING_LENGTH, in the case of a constant array of + characters that is not null-terminated). Select appropriate + section accordingly. */ + + if (MIN ( TREE_STRING_LENGTH (DECL_INITIAL(exp)), + int_size_in_bytes (TREE_TYPE (exp))) + == (long) strlen (TREE_STRING_POINTER (DECL_INITIAL (exp))) + 1) + { + cstring_section (); + return 1; + } + else + { + const_section (); + return 1; + } + } + else + if (TREE_READONLY (TREE_TYPE (exp)) + && ((TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE + && TREE_CODE (DECL_INITIAL (exp)) == INTEGER_CST) + || (TREE_CODE (TREE_TYPE (exp)) == REAL_TYPE + && TREE_CODE (DECL_INITIAL (exp)) == REAL_CST)) + && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (DECL_INITIAL (exp)))) + == INTEGER_CST) + { + tree size = TYPE_SIZE_UNIT (TREE_TYPE (DECL_INITIAL (exp))); + if (TREE_INT_CST_HIGH (size) != 0) + return 0; + + /* Put integer and float consts in the literal4|8 sections. */ + + if (TREE_INT_CST_LOW (size) == 4) + { + literal4_section (); + return 1; + } + else if (TREE_INT_CST_LOW (size) == 8) + { + literal8_section (); + return 1; + } + } + } + return 0; +} +/* APPLE LOCAL end darwin_set_section_for_var_p turly 20020226 */ + +/* APPLE LOCAL begin C++ EH */ +/* 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); +} +/* APPLE LOCAL end C++ EH */ + /* 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 |