/* 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" #include "function.h" #include "ggc.h" #include "langhooks.h" #include "darwin-protos.h" /* APPLE LOCAL PFE */ #ifdef PFE #include "pfe/pfe.h" #include "pfe/pfe-header.h" struct darwin_pfe_additions_t { tree machopic_non_lazy_pointers; tree machopic_stubs; char *function_base; int flag_pic; int dynamic_no_pic; }; #endif /* PFE */ /* APPLE LOCAL C++ EH */ rtx personality_libfunc_used = 0; extern void machopic_output_stub PARAMS ((FILE *, const char *, const char *)); static int machopic_data_defined_p PARAMS ((const char *)); static void update_non_lazy_ptrs PARAMS ((const char *)); static void update_stubs PARAMS ((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_PRIVATE_EXTERN (decl) = 1; 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 (name) const char *name; { int c; while ((c = *name++) != '\0') /* APPLE LOCAL Objective-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; 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; if (name[0] != '!') { /* Here if no special encoding to be found. */ 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; } else if (name[1] == 'D') return MACHOPIC_DEFINED_DATA; 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)) { if (name[1] == 'T') return MACHOPIC_DEFINED_FUNCTION; else return MACHOPIC_DEFINED_DATA; } } if (name[1] == 't' || name[1] == 'T') { 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)); } /* This is a static to make inline functions work. The rtx representing the PIC base symbol always points to here. */ /* APPLE LOCAL begin PFE */ #ifdef PFE /* The function_base is specially treated by PFE_SAVESTRING (actually by it calling darwin_pfe_maybe_savestring()) so that we always use the same buffer. There are rtl references to this buffer that expect that when the buffer changes all those references will point to the new value in the buffer. */ static char *function_base = NULL; #else static char function_base[32]; #endif /* APPLE LOCAL end PFE */ static int current_pic_label_num; const char * machopic_function_base_name () { static const char *name = NULL; static const char *current_name; /* APPLE LOCAL begin PFE */ #ifdef PFE if (function_base == NULL) function_base = (char *)PFE_MALLOC (32, PFE_ALLOC_FUNCTION_BASE); #endif /* APPLE LOCAL end PFE */ /* APPLE LOCAL dynamic-no-pic */ if (MACHO_DYNAMIC_NO_PIC_P ()) abort (); 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. */ /* 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 (name, create_p) const char *name; int create_p; { 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 temp; } STRIP_NAME_ENCODING (name, name); /* Try again, but comparing names this time. */ for (temp = machopic_non_lazy_pointers; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { if (TREE_VALUE (temp)) { const char *temp_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); STRIP_NAME_ENCODING (temp_name, temp_name); if (strcmp (name, temp_name) == 0) return temp; } } if (create_p) { 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"); /* APPLE LOCAL PFE */ #ifdef PFE buffer = (char *) PFE_SAVESTRING (buffer); #endif 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 machopic_non_lazy_pointers; } return NULL; } /* 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); } 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))); } 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. */ /* APPLE LOCAL weak import */ /* machopic_stub_list_entry separated from machopic_stub_name */ static tree machopic_stub_list_entry (name) const char *name; { tree temp, ident = get_identifier (name); const char *tname; for (temp = machopic_stubs; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { if (ident == TREE_VALUE (temp)) return temp; tname = IDENTIFIER_POINTER (TREE_VALUE (temp)); if (strcmp (name, tname) == 0) 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 temp; } STRIP_NAME_ENCODING (name, name); { 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 machopic_stubs; } } const char * machopic_stub_name (name) const char *name; { return IDENTIFIER_POINTER (TREE_PURPOSE (machopic_stub_list_entry (name))); } void machopic_validate_stub_or_non_lazy_ptr (name, validate_stub) const char *name; int validate_stub; { const char *real_name; tree temp, ident = get_identifier (name), id2; 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; STRIP_NAME_ENCODING (real_name, IDENTIFIER_POINTER (TREE_VALUE (temp))); id2 = maybe_get_identifier (real_name); if (id2) TREE_SYMBOL_REFERENCED (id2) = 1; } } /* Transform ORIG, which may be any data source, to the corresponding source using indirections. */ /* APPLE LOCAL darwin native */ 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); /* APPLE LOCAL dynamic-no-pic */ int defined = machopic_data_defined_p (name); /* APPLE LOCAL weak import */ tree sym; 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) { /* APPLE LOCAL PFE */ /* Use MACHOPIC_FUNCTION_BASE_NAME instead of machopic_function_base_name. It is a macro to redirect the string in PFE memory for the PFE usage. */ 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; } /* 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, IDENTIFIER_POINTER (TREE_PURPOSE (sym))); 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 (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; } /* 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 the name is already defined, we need do nothing. */ if (name[0] == '!' && name[1] == 'T') return target; if (!machopic_name_defined_p (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; } } return target; } rtx machopic_legitimize_pic_address (orig, mode, reg) rtx orig, reg; enum machine_mode mode; { rtx pic_ref = orig; /* APPLE LOCAL dynamic-no-pic */ if (! MACHOPIC_INDIRECT) 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; } /* APPLE LOCAL dynamic-no-pic */ if (MACHO_DYNAMIC_NO_PIC_P ()) pic_base = CONST0_RTX (Pmode); else /* APPLE LOCAL PFE */ /* Use MACHOPIC_FUNCTION_BASE_NAME instead of machopic_function_base_name. It is a macro to redirect the string in PFE memory for the PFE usage. */ 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 /* APPLE LOCAL dynamic-no-pic */ 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! */ 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)); #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)); rtx mem; /* dbj */ rtx insn; /* dbj */ emit_insn (gen_rtx (SET, Pmode, hi_sum_reg, /* APPLE LOCAL dynamic-no-pic */ (MACHO_DYNAMIC_NO_PIC_P ()) ? gen_rtx (HIGH, Pmode, offset) : gen_rtx (PLUS, Pmode, pic_offset_table_rtx, gen_rtx (HIGH, Pmode, offset)))); /* APPLE LOCAL dbj */ 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)); /* end APPLE LOCAL dbj */ 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, /* APPLE LOCAL dynamic-no-pic */ (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; #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 (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)) { 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 = 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] == '+' || sym_name[0] == '"' || name_needs_quotes (sym_name)) 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); /* 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); } for (temp = machopic_non_lazy_pointers; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); const char *lazy_name = IDENTIFIER_POINTER (TREE_PURPOSE (temp)); if (! TREE_USED (temp)) continue; if (machopic_ident_defined_p (TREE_VALUE (temp)) || (sym_name[0] == '!' && sym_name[2] == 'p')) { data_section (); assemble_align (GET_MODE_ALIGNMENT (Pmode)); assemble_label (lazy_name); assemble_integer (gen_rtx (SYMBOL_REF, Pmode, sym_name), GET_MODE_SIZE (Pmode), GET_MODE_ALIGNMENT (Pmode), 1); } else { /* 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"); 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), GET_MODE_ALIGNMENT (Pmode), 1); } } /* APPLE LOCAL begin C++ EH */ /* Output a ".reference __gxx_personality_v0" to keep linking semantics the same (we used to make a direct reference to this symbol, but now it's encoded so that the __eh_frame section can live in __TEXT.) */ /*** temporarily disabled ("0 &&") for compatibility with -all_load ***/ if ( 0 && personality_libfunc_used) { const char *str = XSTR (personality_libfunc_used, 0); STRIP_NAME_ENCODING (str, str); fprintf (asm_out_file, ".reference _%s\n", str); } /* APPLE LOCAL end C++ EH */ } 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; } /* This function records whether a given name corresponds to a defined or undefined function or variable, for machopic_classify_ident to use later. */ void darwin_encode_section_info (decl) tree decl; { char code = '\0'; int defined = 0; rtx sym_ref; const char *orig_str; char *new_str; size_t len, new_len; 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'); else if (TREE_CODE (decl) == VAR_DECL) code = (defined ? 'D' : 'd'); if (code == '\0') return; sym_ref = XEXP (DECL_RTL (decl), 0); orig_str = XSTR (sym_ref, 0); len = strlen (orig_str) + 1; if (orig_str[0] == '!') { /* Already encoded; see if we need to change it. */ if (code == orig_str[1]) return; /* Yes, tweak a copy of the name and put it in a new string. */ new_str = alloca (len); memcpy (new_str, orig_str, len); new_str[1] = code; XSTR (sym_ref, 0) = ggc_alloc_string (new_str, len); } else { /* Add the encoding. */ new_len = len + 4; new_str = alloca (new_len); new_str[0] = '!'; new_str[1] = code; new_str[2] = '_'; /* APPLE LOCAL private extern */ if (DECL_PRIVATE_EXTERN (decl)) new_str[2] = 'p'; new_str[3] = '_'; memcpy (new_str + 4, orig_str, len); XSTR (sym_ref, 0) = ggc_alloc_string (new_str, new_len); } /* The non-lazy pointer list may have captured references to the old encoded name, change them. */ if (TREE_CODE (decl) == VAR_DECL) update_non_lazy_ptrs (XSTR (sym_ref, 0)); else update_stubs (XSTR (sym_ref, 0)); } /* 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; { const char *name1, *name2; tree temp; STRIP_NAME_ENCODING (name1, name); for (temp = machopic_non_lazy_pointers; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); if (*sym_name == '!') { STRIP_NAME_ENCODING (name2, sym_name); if (strcmp (name1, name2) == 0) { IDENTIFIER_POINTER (TREE_VALUE (temp)) = 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; { const char *name1, *name2; tree temp; STRIP_NAME_ENCODING (name1, name); for (temp = machopic_stubs; temp != NULL_TREE; temp = TREE_CHAIN (temp)) { const char *sym_name = IDENTIFIER_POINTER (TREE_VALUE (temp)); if (*sym_name == '!') { STRIP_NAME_ENCODING (name2, sym_name); if (strcmp (name1, name2) == 0) { IDENTIFIER_POINTER (TREE_VALUE (temp)) = name; break; } } } } void machopic_asm_out_constructor (symbol, priority) rtx symbol; int priority ATTRIBUTE_UNUSED; { /* APPLE LOCAL dynamic-no-pic */ if (MACHOPIC_INDIRECT) mod_init_section (); else constructor_section (); assemble_align (POINTER_SIZE); assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); /* APPLE LOCAL dynamic-no-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; { /* APPLE LOCAL dynamic-no-pic */ if (MACHOPIC_INDIRECT) mod_term_section (); else destructor_section (); assemble_align (POINTER_SIZE); assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); /* APPLE LOCAL dynamic-no-pic */ if (! MACHOPIC_INDIRECT) fprintf (asm_out_file, ".reference .destructors_used\n"); } static int dwarf_label_counter; void darwin_asm_output_dwarf_delta (file, size, lab1, lab2, force_reloc) FILE *file; int size ATTRIBUTE_UNUSED; const char *lab1, *lab2; int force_reloc; { const char *p = lab1 + (lab1[0] == '*'); int islocaldiff = p[0] == 'L' && !force_reloc; if (islocaldiff) fprintf (file, "\t.set L$set$%d,", dwarf_label_counter); else fprintf (file, "\t%s\t", ".long"/*unaligned_integer_asm_op (size)*/); assemble_name (file, lab1); fprintf (file, "-"); assemble_name (file, lab2); if (islocaldiff) fprintf (file, "\n\t%s L$set$%d", ".long"/*unaligned_integer_asm_op (size)*/, dwarf_label_counter++); } /* 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 PFE */ /*-------------------------------------------------------------------*/ #ifdef PFE /* This is called to allocate or freeze/thaw target-specific additions to the pfe header. The argument is a pointer to a target-defined field in the pfe header. When the value in the field is NULL then, by definition, this is for creating the dump file. The function should allocate space for any data (using pfe_malloc or pfe_calloc), do any appropriate initialization to this space, and save the pointer in *pp. If the argument is not NULL the function is expected to freeze/thaw (depending on pfe_operation) the data pointed to by the argument as well as *pp itself (*pp is never NULL in this case). Of course during thawing *pp will be the pointer set when the function was originally called with a NULL argument. */ void darwin_pfe_freeze_thaw_target_additions (pp) void *pp; { struct darwin_pfe_additions_t *hdr; /* If *pp is NULL then we are initializing for a load and called from pfe_init() to allocate the space in the pfe header field pointed to by pp. */ if (*(struct darwin_pfe_additions_t **)pp == NULL) { *(struct darwin_pfe_additions_t **)pp = PFE_CALLOC (1, sizeof (struct darwin_pfe_additions_t), PFE_ALLOC_TARGET_ADDITIONS); return; } /* If freeze/thawing then *pp is not NULL and points to the space we previously allocated above. By copying anonymous pointer pp into a "struct darwin_pfe_additions_t *" typed pointer named "hdr" we can use the usual freeze/thaw macros to make life a little easier. Note, at this point we know that this is the second call and thus must be from pfe_freeze_thaw_compiler_state(). We cannot use PFE_FREEZE_THAW_PTR to freeze/thaw pp since we will always get NULL when thawing when PFE_NO_THAW_LOAD is 1. And we know that pfe_freeze_thaw_compiler_state() will not call this routine if *pp is NULL so we don't need to use PFE_FREEZE_THAW_PTR anyhow. */ hdr = (struct darwin_pfe_additions_t *)pfe_freeze_thaw_ptr_fp (pp); PFE_GLOBAL_TO_HDR_IF_FREEZING (machopic_non_lazy_pointers); PFE_FREEZE_THAW_WALK(hdr->machopic_non_lazy_pointers); PFE_HDR_TO_GLOBAL_IF_THAWING (machopic_non_lazy_pointers); PFE_GLOBAL_TO_HDR_IF_FREEZING (machopic_stubs); PFE_FREEZE_THAW_WALK(hdr->machopic_stubs); PFE_HDR_TO_GLOBAL_IF_THAWING (machopic_stubs); PFE_GLOBAL_TO_HDR_IF_FREEZING (function_base); pfe_freeze_thaw_ptr_fp (&hdr->function_base); PFE_HDR_TO_GLOBAL_IF_THAWING (function_base); /* The following must be be consistent when loading a pfe file and thus only saved when dumping the file. */ if (PFE_FREEZING) { hdr->flag_pic = flag_pic; hdr->dynamic_no_pic = MACHO_DYNAMIC_NO_PIC_P (); } } /* This is called only by pfe_savestring() for dumping when the macro PFE_TARGET_MAYBE_SAVESTRING is defined (which it is for darwin). This imposes an addtional condition on whether we allocate strings in PFE memory with pfe_savestring(). For the function_base we must only allocate a single stirng buffer and never make copies. That buffer is allocated (in PFE memory) by machopic_function_base_name(). It needs to be a fixed buffer because there are rtl references to it which assume that when the buffer's contents change all the rtl references will reflect that change. */ int darwin_pfe_maybe_savestring (s) char *s; { return (s != function_base); } /* Called to check for consistent target-specific switches in pfe files. */ void darwin_pfe_check_target_settings () { struct darwin_pfe_additions_t *hdr = (struct darwin_pfe_additions_t *)pfe_compiler_state_ptr->pfe_target_additions; if (hdr->dynamic_no_pic != MACHO_DYNAMIC_NO_PIC_P ()) fatal_error ("Inconsistent setting of -mdynamic-no-pic on pre-compiled header dump and load."); if (hdr->flag_pic != flag_pic) fatal_error ("Inconsistent setting of -fPIC on pre-compiled header dump and load."); } #endif /* PFE */ /* APPLE LOCAL begin double destructor turly 20020214 */ #include "c-common.h" extern int warning (const char *, ...); /* 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 (! flag_writable_strings && 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 && (unsigned) TREE_STRING_LENGTH (DECL_INITIAL (exp)) == strlen (TREE_STRING_POINTER (DECL_INITIAL (exp))) + 1) { cstring_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 */ /* 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 (); STRIP_NAME_ENCODING (str, XSTR (addr, 0)); nlp_name = machopic_non_lazy_ptr_name (str); fputs("\t.long\t", file); ASM_OUTPUT_LABELREF(file, nlp_name); fputs ("-.", file); }