1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
4 Free Software Foundation, Inc.
5 Contributed by Apple Computer Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
35 #include "insn-attr.h"
42 #include "langhooks.h"
50 /* Darwin supports a feature called fix-and-continue, which is used
51 for rapid turn around debugging. When code is compiled with the
52 -mfix-and-continue flag, two changes are made to the generated code
53 that allow the system to do things that it would normally not be
54 able to do easily. These changes allow gdb to load in
55 recompilation of a translation unit that has been changed into a
56 running program and replace existing functions and methods of that
57 translation unit with versions of those functions and methods
58 from the newly compiled translation unit. The new functions access
59 the existing static symbols from the old translation unit, if the
60 symbol existed in the unit to be replaced, and from the new
61 translation unit, otherwise.
63 The changes are to insert 5 nops at the beginning of all functions
64 and to use indirection to get at static symbols. The 5 nops
65 are required by consumers of the generated code. Currently, gdb
66 uses this to patch in a jump to the overriding function, this
67 allows all uses of the old name to forward to the replacement,
68 including existing function pointers and virtual methods. See
69 rs6000_emit_prologue for the code that handles the nop insertions.
71 The added indirection allows gdb to redirect accesses to static
72 symbols from the newly loaded translation unit to the existing
73 symbol, if any. @code{static} symbols are special and are handled by
74 setting the second word in the .non_lazy_symbol_pointer data
75 structure to symbol. See indirect_data for the code that handles
76 the extra indirection, and machopic_output_indirection and its use
77 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
78 symbol indirection. */
81 section * darwin_sections[NUM_DARWIN_SECTIONS];
83 /* True if we're setting __attribute__ ((ms_struct)). */
84 int darwin_ms_struct = false;
86 /* A get_unnamed_section callback used to switch to an ObjC section.
87 DIRECTIVE is as for output_section_asm_op. */
90 output_objc_section_asm_op (const void *directive)
92 static bool been_here = false;
96 static const enum darwin_section_enum tomark[] =
98 /* written, cold -> hot */
99 objc_cat_cls_meth_section,
100 objc_cat_inst_meth_section,
101 objc_string_object_section,
102 objc_constant_string_object_section,
103 objc_selector_refs_section,
104 objc_selector_fixup_section,
105 objc_cls_refs_section,
107 objc_meta_class_section,
108 /* shared, hot -> cold */
109 objc_cls_meth_section,
110 objc_inst_meth_section,
111 objc_protocol_section,
112 objc_class_names_section,
113 objc_meth_var_types_section,
114 objc_meth_var_names_section,
115 objc_category_section,
116 objc_class_vars_section,
117 objc_instance_vars_section,
118 objc_module_info_section,
124 for (i = 0; i < ARRAY_SIZE (tomark); i++)
125 switch_to_section (darwin_sections[tomark[i]]);
127 output_section_asm_op (directive);
130 /* Implement TARGET_ASM_INIT_SECTIONS. */
133 darwin_init_sections (void)
135 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
136 darwin_sections[NAME] = \
137 get_unnamed_section (FLAGS, (OBJC \
138 ? output_objc_section_asm_op \
139 : output_section_asm_op), \
141 #include "config/darwin-sections.def"
144 readonly_data_section = darwin_sections[const_section];
145 exception_section = darwin_sections[darwin_exception_section];
146 eh_frame_section = darwin_sections[darwin_eh_frame_section];
150 name_needs_quotes (const char *name)
153 while ((c = *name++) != '\0')
154 if (! ISIDNUM (c) && c != '.' && c != '$')
159 /* Return true if SYM_REF can be used without an indirection. */
161 machopic_symbol_defined_p (rtx sym_ref)
163 if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
166 /* If a symbol references local and is not an extern to this
167 file, then the symbol might be able to declared as defined. */
168 if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
170 /* If the symbol references a variable and the variable is a
171 common symbol, then this symbol is not defined. */
172 if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
174 tree decl = SYMBOL_REF_DECL (sym_ref);
177 if (DECL_COMMON (decl))
185 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
186 reference, which will not be changed. */
188 enum machopic_addr_class
189 machopic_classify_symbol (rtx sym_ref)
194 flags = SYMBOL_REF_FLAGS (sym_ref);
195 function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
196 if (machopic_symbol_defined_p (sym_ref))
198 ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
201 ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
204 #ifndef TARGET_FIX_AND_CONTINUE
205 #define TARGET_FIX_AND_CONTINUE 0
208 /* Indicate when fix-and-continue style code generation is being used
209 and when a reference to data should be indirected so that it can be
210 rebound in a new translation unit to reference the original instance
211 of that data. Symbol names that are for code generation local to
212 the translation unit are bound to the new translation unit;
213 currently this means symbols that begin with L or _OBJC_;
214 otherwise, we indicate that an indirect reference should be made to
215 permit the runtime to rebind new instances of the translation unit
216 to the original instance of the data. */
219 indirect_data (rtx sym_ref)
224 /* If we aren't generating fix-and-continue code, don't do anything
226 if (TARGET_FIX_AND_CONTINUE == 0)
229 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
230 are indirected. Symbols that begin with L and _OBJC_ are always
231 bound to the current translation unit as they are used for
232 generated local data of the translation unit. */
234 name = XSTR (sym_ref, 0);
236 lprefix = (((name[0] == '*' || name[0] == '&')
237 && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
238 || (strncmp (name, "_OBJC_", 6) == 0));
245 machopic_data_defined_p (rtx sym_ref)
247 if (indirect_data (sym_ref))
250 switch (machopic_classify_symbol (sym_ref))
252 case MACHOPIC_DEFINED_DATA:
253 case MACHOPIC_DEFINED_FUNCTION:
261 machopic_define_symbol (rtx mem)
265 gcc_assert (GET_CODE (mem) == MEM);
266 sym_ref = XEXP (mem, 0);
267 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
270 static GTY(()) const char * function_base;
273 machopic_function_base_name (void)
275 /* if dynamic-no-pic is on, we should not get here */
276 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
278 if (function_base == NULL)
279 function_base = ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
281 current_function_uses_pic_offset_table = 1;
283 return function_base;
286 /* Return a SYMBOL_REF for the PIC function base. */
289 machopic_function_base_sym (void)
293 sym_ref = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
294 SYMBOL_REF_FLAGS (sym_ref)
295 |= (MACHO_SYMBOL_FLAG_VARIABLE | MACHO_SYMBOL_FLAG_DEFINED);
299 /* Return either ORIG or (const:P (minus:P ORIG PIC_BASE)), depending
300 on whether pic_base is NULL or not. */
302 gen_pic_offset (rtx orig, rtx pic_base)
307 return gen_rtx_CONST (Pmode, gen_rtx_MINUS (Pmode, orig, pic_base));
310 static GTY(()) const char * function_base_func_name;
311 static GTY(()) int current_pic_label_num;
314 machopic_output_function_base_name (FILE *file)
316 const char *current_name;
318 /* If dynamic-no-pic is on, we should not get here. */
319 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
321 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
322 if (function_base_func_name != current_name)
324 ++current_pic_label_num;
325 function_base_func_name = current_name;
327 fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
330 /* The suffix attached to non-lazy pointer symbols. */
331 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
332 /* The suffix attached to stub symbols. */
333 #define STUB_SUFFIX "$stub"
335 typedef struct machopic_indirection GTY (())
337 /* The SYMBOL_REF for the entity referenced. */
339 /* The name of the stub or non-lazy pointer. */
340 const char * ptr_name;
341 /* True iff this entry is for a stub (as opposed to a non-lazy
344 /* True iff this stub or pointer pointer has been referenced. */
346 } machopic_indirection;
348 /* A table mapping stub names and non-lazy pointer names to
349 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
351 static GTY ((param_is (struct machopic_indirection))) htab_t
352 machopic_indirections;
354 /* Return a hash value for a SLOT in the indirections hash table. */
357 machopic_indirection_hash (const void *slot)
359 const machopic_indirection *p = (const machopic_indirection *) slot;
360 return htab_hash_string (p->ptr_name);
363 /* Returns true if the KEY is the same as that associated with
367 machopic_indirection_eq (const void *slot, const void *key)
369 return strcmp (((const machopic_indirection *) slot)->ptr_name, key) == 0;
372 /* Return the name of the non-lazy pointer (if STUB_P is false) or
373 stub (if STUB_B is true) corresponding to the given name. */
376 machopic_indirection_name (rtx sym_ref, bool stub_p)
379 const char *name = XSTR (sym_ref, 0);
380 size_t namelen = strlen (name);
381 machopic_indirection *p;
383 bool saw_star = false;
386 const char *prefix = user_label_prefix;
387 const char *quote = "";
390 id = maybe_get_identifier (name);
395 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
396 id = TREE_CHAIN (id);
399 name = IDENTIFIER_POINTER (id);
400 namelen = strlen (name);
412 needs_quotes = name_needs_quotes (name);
419 suffix = STUB_SUFFIX;
421 suffix = NON_LAZY_POINTER_SUFFIX;
423 buffer = alloca (strlen ("&L")
430 /* Construct the name of the non-lazy pointer or stub. */
431 sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
433 if (!machopic_indirections)
434 machopic_indirections = htab_create_ggc (37,
435 machopic_indirection_hash,
436 machopic_indirection_eq,
439 slot = htab_find_slot_with_hash (machopic_indirections, buffer,
440 htab_hash_string (buffer), INSERT);
443 p = (machopic_indirection *) *slot;
447 p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
449 p->ptr_name = xstrdup (buffer);
458 /* Return the name of the stub for the mcount function. */
461 machopic_mcount_stub_name (void)
463 rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
464 return machopic_indirection_name (symbol, /*stub_p=*/true);
467 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
468 or non-lazy pointer as used -- and mark the object to which the
469 pointer/stub refers as used as well, since the pointer/stub will
470 emit a reference to it. */
473 machopic_validate_stub_or_non_lazy_ptr (const char *name)
475 machopic_indirection *p;
477 p = ((machopic_indirection *)
478 (htab_find_with_hash (machopic_indirections, name,
479 htab_hash_string (name))));
482 const char *real_name;
487 /* Do what output_addr_const will do when we actually call it. */
488 if (SYMBOL_REF_DECL (p->symbol))
489 mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
491 real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
493 id = maybe_get_identifier (real_name);
495 mark_referenced (id);
499 /* Transform ORIG, which may be any data source, to the corresponding
500 source using indirections. */
503 machopic_indirect_data_reference (rtx orig, rtx reg)
507 if (! MACHOPIC_INDIRECT)
510 if (GET_CODE (orig) == SYMBOL_REF)
512 int defined = machopic_data_defined_p (orig);
514 if (defined && MACHO_DYNAMIC_NO_PIC_P)
516 #if defined (TARGET_TOC)
517 /* Create a new register for CSE opportunities. */
518 rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));
519 emit_insn (gen_macho_high (hi_reg, orig));
520 emit_insn (gen_macho_low (reg, hi_reg, orig));
522 /* some other cpu -- writeme! */
529 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
530 rtx pic_base = machopic_function_base_sym ();
531 rtx offset = gen_pic_offset (orig, pic_base);
534 #if defined (TARGET_TOC) /* i.e., PowerPC */
535 rtx hi_sum_reg = (!can_create_pseudo_p ()
537 : gen_reg_rtx (Pmode));
541 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
542 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
543 gen_rtx_HIGH (Pmode, offset))));
544 emit_insn (gen_rtx_SET (Pmode, reg,
545 gen_rtx_LO_SUM (Pmode, hi_sum_reg,
546 copy_rtx (offset))));
550 #if defined (HAVE_lo_sum)
553 emit_insn (gen_rtx_SET (VOIDmode, reg,
554 gen_rtx_HIGH (Pmode, offset)));
555 emit_insn (gen_rtx_SET (VOIDmode, reg,
556 gen_rtx_LO_SUM (Pmode, reg,
557 copy_rtx (offset))));
558 emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
560 orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
566 ptr_ref = (gen_rtx_SYMBOL_REF
568 machopic_indirection_name (orig, /*stub_p=*/false)));
570 SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
572 ptr_ref = gen_const_mem (Pmode, ptr_ref);
573 machopic_define_symbol (ptr_ref);
577 else if (GET_CODE (orig) == CONST)
581 /* legitimize both operands of the PLUS */
582 if (GET_CODE (XEXP (orig, 0)) == PLUS)
584 base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
586 orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
587 (base == reg ? 0 : reg));
592 if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
593 result = plus_constant (base, INTVAL (orig));
595 result = gen_rtx_PLUS (Pmode, base, orig);
597 if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
601 emit_move_insn (reg, result);
606 result = force_reg (GET_MODE (result), result);
613 else if (GET_CODE (orig) == MEM)
614 XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
615 /* When the target is i386, this code prevents crashes due to the
616 compiler's ignorance on how to move the PIC base register to
617 other registers. (The reload phase sometimes introduces such
619 else if (GET_CODE (orig) == PLUS
620 && GET_CODE (XEXP (orig, 0)) == REG
621 && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
623 /* Prevent the same register from being erroneously used
624 as both the base and index registers. */
625 && GET_CODE (XEXP (orig, 1)) == CONST
629 emit_move_insn (reg, XEXP (orig, 0));
630 XEXP (ptr_ref, 0) = reg;
635 /* Transform TARGET (a MEM), which is a function call target, to the
636 corresponding symbol_stub if necessary. Return a new MEM. */
639 machopic_indirect_call_target (rtx target)
641 if (GET_CODE (target) != MEM)
644 if (MACHOPIC_INDIRECT
645 && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
646 && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
647 & MACHO_SYMBOL_FLAG_DEFINED))
649 rtx sym_ref = XEXP (target, 0);
650 const char *stub_name = machopic_indirection_name (sym_ref,
652 enum machine_mode mode = GET_MODE (sym_ref);
654 XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
655 SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
656 MEM_READONLY_P (target) = 1;
657 MEM_NOTRAP_P (target) = 1;
664 machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
668 if (! MACHOPIC_INDIRECT)
671 /* First handle a simple SYMBOL_REF or LABEL_REF */
672 if (GET_CODE (orig) == LABEL_REF
673 || (GET_CODE (orig) == SYMBOL_REF
676 /* addr(foo) = &func+(foo-func) */
679 orig = machopic_indirect_data_reference (orig, reg);
681 if (GET_CODE (orig) == PLUS
682 && GET_CODE (XEXP (orig, 0)) == REG)
685 return force_reg (mode, orig);
687 emit_move_insn (reg, orig);
691 /* if dynamic-no-pic we don't have a pic base */
692 if (MACHO_DYNAMIC_NO_PIC_P)
695 pic_base = machopic_function_base_sym ();
697 if (GET_CODE (orig) == MEM)
701 gcc_assert (!reload_in_progress);
702 reg = gen_reg_rtx (Pmode);
706 if (MACHO_DYNAMIC_NO_PIC_P
707 && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
708 || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
710 #if defined (TARGET_TOC) /* ppc */
711 rtx temp_reg = (!can_create_pseudo_p ()
713 gen_reg_rtx (Pmode));
714 rtx asym = XEXP (orig, 0);
717 emit_insn (gen_macho_high (temp_reg, asym));
718 mem = gen_const_mem (GET_MODE (orig),
719 gen_rtx_LO_SUM (Pmode, temp_reg,
721 emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
723 /* Some other CPU -- WriteMe! but right now there are no other
724 platforms that can use dynamic-no-pic */
730 if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
731 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
733 rtx offset = gen_pic_offset (XEXP (orig, 0), pic_base);
734 #if defined (TARGET_TOC) /* i.e., PowerPC */
735 /* Generating a new reg may expose opportunities for
736 common subexpression elimination. */
737 rtx hi_sum_reg = (!can_create_pseudo_p ()
739 : gen_reg_rtx (Pmode));
744 sum = gen_rtx_HIGH (Pmode, offset);
745 if (! MACHO_DYNAMIC_NO_PIC_P)
746 sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
748 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
750 mem = gen_const_mem (GET_MODE (orig),
751 gen_rtx_LO_SUM (Pmode,
754 insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
755 set_unique_reg_note (insn, REG_EQUAL, pic_ref);
759 emit_insn (gen_rtx_USE (VOIDmode,
761 PIC_OFFSET_TABLE_REGNUM)));
763 emit_insn (gen_rtx_SET (VOIDmode, reg,
765 gen_rtx_CONST (Pmode,
767 emit_insn (gen_rtx_SET (VOIDmode, reg,
768 gen_rtx_LO_SUM (Pmode, reg,
769 gen_rtx_CONST (Pmode,
770 copy_rtx (offset)))));
771 pic_ref = gen_rtx_PLUS (Pmode,
772 pic_offset_table_rtx, reg);
776 #endif /* HAVE_lo_sum */
778 rtx pic = pic_offset_table_rtx;
779 if (GET_CODE (pic) != REG)
781 emit_move_insn (reg, pic);
785 emit_insn (gen_rtx_USE (VOIDmode,
787 PIC_OFFSET_TABLE_REGNUM)));
790 if (reload_in_progress)
791 df_set_regs_ever_live (REGNO (pic), true);
792 pic_ref = gen_rtx_PLUS (Pmode, pic,
793 gen_pic_offset (XEXP (orig, 0),
797 #if !defined (TARGET_TOC)
798 emit_move_insn (reg, pic_ref);
799 pic_ref = gen_const_mem (GET_MODE (orig), reg);
806 if (GET_CODE (orig) == SYMBOL_REF
807 || GET_CODE (orig) == LABEL_REF)
809 rtx offset = gen_pic_offset (orig, pic_base);
810 #if defined (TARGET_TOC) /* i.e., PowerPC */
815 gcc_assert (!reload_in_progress);
816 reg = gen_reg_rtx (Pmode);
821 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
822 (MACHO_DYNAMIC_NO_PIC_P)
823 ? gen_rtx_HIGH (Pmode, offset)
824 : gen_rtx_PLUS (Pmode,
825 pic_offset_table_rtx,
828 emit_insn (gen_rtx_SET (VOIDmode, reg,
829 gen_rtx_LO_SUM (Pmode,
831 copy_rtx (offset))));
834 emit_insn (gen_rtx_SET (VOIDmode, reg,
835 gen_rtx_HIGH (Pmode, offset)));
836 emit_insn (gen_rtx_SET (VOIDmode, reg,
837 gen_rtx_LO_SUM (Pmode, reg,
838 copy_rtx (offset))));
839 pic_ref = gen_rtx_PLUS (Pmode,
840 pic_offset_table_rtx, reg);
844 #endif /* HAVE_lo_sum */
847 || GET_CODE (orig) == SUBREG)
853 rtx pic = pic_offset_table_rtx;
854 if (GET_CODE (pic) != REG)
856 emit_move_insn (reg, pic);
860 emit_insn (gen_rtx_USE (VOIDmode,
861 pic_offset_table_rtx));
863 if (reload_in_progress)
864 df_set_regs_ever_live (REGNO (pic), true);
865 pic_ref = gen_rtx_PLUS (Pmode,
867 gen_pic_offset (orig, pic_base));
872 if (GET_CODE (pic_ref) != REG)
876 emit_move_insn (reg, pic_ref);
881 return force_reg (mode, pic_ref);
890 else if (GET_CODE (orig) == SYMBOL_REF)
893 else if (GET_CODE (orig) == PLUS
894 && (GET_CODE (XEXP (orig, 0)) == MEM
895 || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
896 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
897 && XEXP (orig, 0) != pic_offset_table_rtx
898 && GET_CODE (XEXP (orig, 1)) != REG)
902 int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
904 base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
905 orig = machopic_legitimize_pic_address (XEXP (orig, 1),
906 Pmode, (base == reg ? 0 : reg));
907 if (GET_CODE (orig) == CONST_INT)
909 pic_ref = plus_constant (base, INTVAL (orig));
913 pic_ref = gen_rtx_PLUS (Pmode, base, orig);
915 if (reg && is_complex)
917 emit_move_insn (reg, pic_ref);
920 /* Likewise, should we set special REG_NOTEs here? */
923 else if (GET_CODE (orig) == CONST)
925 return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
928 else if (GET_CODE (orig) == MEM
929 && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
931 rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
932 addr = replace_equiv_address (orig, addr);
933 emit_move_insn (reg, addr);
940 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
941 DATA is the FILE* for assembly output. Called from
945 machopic_output_indirection (void **slot, void *data)
947 machopic_indirection *p = *((machopic_indirection **) slot);
948 FILE *asm_out_file = (FILE *) data;
950 const char *sym_name;
951 const char *ptr_name;
957 sym_name = XSTR (symbol, 0);
958 ptr_name = p->ptr_name;
966 id = maybe_get_identifier (sym_name);
971 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
972 id = TREE_CHAIN (id);
974 sym_name = IDENTIFIER_POINTER (id);
977 sym = alloca (strlen (sym_name) + 2);
978 if (sym_name[0] == '*' || sym_name[0] == '&')
979 strcpy (sym, sym_name + 1);
980 else if (sym_name[0] == '-' || sym_name[0] == '+')
981 strcpy (sym, sym_name);
983 sprintf (sym, "%s%s", user_label_prefix, sym_name);
985 stub = alloca (strlen (ptr_name) + 2);
986 if (ptr_name[0] == '*' || ptr_name[0] == '&')
987 strcpy (stub, ptr_name + 1);
989 sprintf (stub, "%s%s", user_label_prefix, ptr_name);
991 machopic_output_stub (asm_out_file, sym, stub);
993 else if (! indirect_data (symbol)
994 && (machopic_symbol_defined_p (symbol)
995 || SYMBOL_REF_LOCAL_P (symbol)))
997 switch_to_section (data_section);
998 assemble_align (GET_MODE_ALIGNMENT (Pmode));
999 assemble_label (ptr_name);
1000 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
1001 GET_MODE_SIZE (Pmode),
1002 GET_MODE_ALIGNMENT (Pmode), 1);
1006 rtx init = const0_rtx;
1008 switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
1009 assemble_name (asm_out_file, ptr_name);
1010 fprintf (asm_out_file, ":\n");
1012 fprintf (asm_out_file, "\t.indirect_symbol ");
1013 assemble_name (asm_out_file, sym_name);
1014 fprintf (asm_out_file, "\n");
1016 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1017 have their symbol name instead of 0 in the second entry of
1018 the non-lazy symbol pointer data structure when they are
1019 defined. This allows the runtime to rebind newer instances
1020 of the translation unit with the original instance of the
1023 if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
1024 && machopic_symbol_defined_p (symbol))
1025 init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
1027 assemble_integer (init, GET_MODE_SIZE (Pmode),
1028 GET_MODE_ALIGNMENT (Pmode), 1);
1035 machopic_finish (FILE *asm_out_file)
1037 if (machopic_indirections)
1038 htab_traverse_noresize (machopic_indirections,
1039 machopic_output_indirection,
1044 machopic_operand_p (rtx op)
1046 if (MACHOPIC_JUST_INDIRECT)
1048 while (GET_CODE (op) == CONST)
1051 if (GET_CODE (op) == SYMBOL_REF)
1052 return machopic_symbol_defined_p (op);
1057 while (GET_CODE (op) == CONST)
1060 if (GET_CODE (op) == MINUS
1061 && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
1062 && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
1063 && machopic_symbol_defined_p (XEXP (op, 0))
1064 && machopic_symbol_defined_p (XEXP (op, 1)))
1070 /* This function records whether a given name corresponds to a defined
1071 or undefined function or variable, for machopic_classify_ident to
1075 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
1079 /* Do the standard encoding things first. */
1080 default_encode_section_info (decl, rtl, first);
1082 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
1085 sym_ref = XEXP (rtl, 0);
1086 if (TREE_CODE (decl) == VAR_DECL)
1087 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
1089 if (!DECL_EXTERNAL (decl)
1090 && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
1091 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
1092 && ((TREE_STATIC (decl)
1093 && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
1094 || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
1095 && DECL_INITIAL (decl) != error_mark_node)))
1096 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
1098 if (! TREE_PUBLIC (decl))
1099 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
1103 darwin_mark_decl_preserved (const char *name)
1105 fprintf (asm_out_file, ".no_dead_strip ");
1106 assemble_name (asm_out_file, name);
1107 fputc ('\n', asm_out_file);
1111 darwin_text_section (int reloc, int weak)
1115 ? darwin_sections[text_unlikely_coal_section]
1116 : unlikely_text_section ());
1119 ? darwin_sections[text_coal_section]
1124 darwin_rodata_section (int weak)
1127 ? darwin_sections[const_coal_section]
1128 : darwin_sections[const_section]);
1132 darwin_mergeable_string_section (tree exp,
1133 unsigned HOST_WIDE_INT align)
1135 if (flag_merge_constants
1136 && TREE_CODE (exp) == STRING_CST
1137 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1139 && (int_size_in_bytes (TREE_TYPE (exp))
1140 == TREE_STRING_LENGTH (exp))
1141 && ((size_t) TREE_STRING_LENGTH (exp)
1142 == strlen (TREE_STRING_POINTER (exp)) + 1))
1143 return darwin_sections[cstring_section];
1145 return readonly_data_section;
1148 #ifndef HAVE_GAS_LITERAL16
1149 #define HAVE_GAS_LITERAL16 0
1153 darwin_mergeable_constant_section (tree exp,
1154 unsigned HOST_WIDE_INT align)
1156 enum machine_mode mode = DECL_MODE (exp);
1157 unsigned int modesize = GET_MODE_BITSIZE (mode);
1159 if (flag_merge_constants
1162 && modesize <= align
1165 && (align & (align -1)) == 0)
1167 tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1169 if (TREE_CODE (size) == INTEGER_CST
1170 && TREE_INT_CST_LOW (size) == 4
1171 && TREE_INT_CST_HIGH (size) == 0)
1172 return darwin_sections[literal4_section];
1173 else if (TREE_CODE (size) == INTEGER_CST
1174 && TREE_INT_CST_LOW (size) == 8
1175 && TREE_INT_CST_HIGH (size) == 0)
1176 return darwin_sections[literal8_section];
1177 else if (HAVE_GAS_LITERAL16
1179 && TREE_CODE (size) == INTEGER_CST
1180 && TREE_INT_CST_LOW (size) == 16
1181 && TREE_INT_CST_HIGH (size) == 0)
1182 return darwin_sections[literal16_section];
1184 return readonly_data_section;
1187 return readonly_data_section;
1191 machopic_reloc_rw_mask (void)
1193 return MACHOPIC_INDIRECT ? 3 : 0;
1197 machopic_select_section (tree decl,
1199 unsigned HOST_WIDE_INT align)
1201 bool weak = (DECL_P (decl)
1203 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
1204 || ! lookup_attribute ("weak_import",
1205 DECL_ATTRIBUTES (decl))));
1206 section *base_section;
1208 switch (categorize_decl_for_section (decl, reloc))
1211 base_section = darwin_text_section (reloc, weak);
1215 case SECCAT_SRODATA:
1216 base_section = darwin_rodata_section (weak);
1219 case SECCAT_RODATA_MERGE_STR:
1220 base_section = darwin_mergeable_string_section (decl, align);
1223 case SECCAT_RODATA_MERGE_STR_INIT:
1224 base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1227 case SECCAT_RODATA_MERGE_CONST:
1228 base_section = darwin_mergeable_constant_section (decl, align);
1232 case SECCAT_DATA_REL:
1233 case SECCAT_DATA_REL_LOCAL:
1234 case SECCAT_DATA_REL_RO:
1235 case SECCAT_DATA_REL_RO_LOCAL:
1241 if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1242 base_section = weak ? darwin_sections[const_data_coal_section]
1243 : darwin_sections[const_data_section];
1245 base_section = weak ? darwin_sections[data_coal_section] : data_section;
1252 /* Darwin weird special cases. */
1253 if (TREE_CODE (decl) == CONSTRUCTOR
1255 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1256 && TYPE_NAME (TREE_TYPE (decl)))
1258 tree name = TYPE_NAME (TREE_TYPE (decl));
1259 if (TREE_CODE (name) == TYPE_DECL)
1260 name = DECL_NAME (name);
1262 if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1264 if (flag_next_runtime)
1265 return darwin_sections[objc_constant_string_object_section];
1267 return darwin_sections[objc_string_object_section];
1270 return base_section;
1272 else if (TREE_CODE (decl) == VAR_DECL
1274 && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1275 && IDENTIFIER_POINTER (DECL_NAME (decl))
1276 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1278 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1280 if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1281 return darwin_sections[objc_cls_meth_section];
1282 else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1283 return darwin_sections[objc_inst_meth_section];
1284 else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1285 return darwin_sections[objc_cat_cls_meth_section];
1286 else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1287 return darwin_sections[objc_cat_inst_meth_section];
1288 else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1289 return darwin_sections[objc_class_vars_section];
1290 else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1291 return darwin_sections[objc_instance_vars_section];
1292 else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1293 return darwin_sections[objc_cat_cls_meth_section];
1294 else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1295 return darwin_sections[objc_class_names_section];
1296 else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1297 return darwin_sections[objc_meth_var_names_section];
1298 else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1299 return darwin_sections[objc_meth_var_types_section];
1300 else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1301 return darwin_sections[objc_cls_refs_section];
1302 else if (!strncmp (name, "_OBJC_CLASS_", 12))
1303 return darwin_sections[objc_class_section];
1304 else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1305 return darwin_sections[objc_meta_class_section];
1306 else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1307 return darwin_sections[objc_category_section];
1308 else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1309 return darwin_sections[objc_selector_refs_section];
1310 else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1311 return darwin_sections[objc_selector_fixup_section];
1312 else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1313 return darwin_sections[objc_symbols_section];
1314 else if (!strncmp (name, "_OBJC_MODULES", 13))
1315 return darwin_sections[objc_module_info_section];
1316 else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1317 return darwin_sections[objc_image_info_section];
1318 else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1319 return darwin_sections[objc_cat_inst_meth_section];
1320 else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1321 return darwin_sections[objc_cat_cls_meth_section];
1322 else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1323 return darwin_sections[objc_cat_cls_meth_section];
1324 else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1325 return darwin_sections[objc_protocol_section];
1327 return base_section;
1330 return base_section;
1333 /* This can be called with address expressions as "rtx".
1334 They must go in "const". */
1337 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1338 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1340 if (GET_MODE_SIZE (mode) == 8
1341 && (GET_CODE (x) == CONST_INT
1342 || GET_CODE (x) == CONST_DOUBLE))
1343 return darwin_sections[literal8_section];
1344 else if (GET_MODE_SIZE (mode) == 4
1345 && (GET_CODE (x) == CONST_INT
1346 || GET_CODE (x) == CONST_DOUBLE))
1347 return darwin_sections[literal4_section];
1348 else if (HAVE_GAS_LITERAL16
1350 && GET_MODE_SIZE (mode) == 16
1351 && (GET_CODE (x) == CONST_INT
1352 || GET_CODE (x) == CONST_DOUBLE
1353 || GET_CODE (x) == CONST_VECTOR))
1354 return darwin_sections[literal16_section];
1355 else if (MACHOPIC_INDIRECT
1356 && (GET_CODE (x) == SYMBOL_REF
1357 || GET_CODE (x) == CONST
1358 || GET_CODE (x) == LABEL_REF))
1359 return darwin_sections[const_data_section];
1361 return darwin_sections[const_section];
1365 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1367 if (MACHOPIC_INDIRECT)
1368 switch_to_section (darwin_sections[mod_init_section]);
1370 switch_to_section (darwin_sections[constructor_section]);
1371 assemble_align (POINTER_SIZE);
1372 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1374 if (! MACHOPIC_INDIRECT)
1375 fprintf (asm_out_file, ".reference .constructors_used\n");
1379 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1381 if (MACHOPIC_INDIRECT)
1382 switch_to_section (darwin_sections[mod_term_section]);
1384 switch_to_section (darwin_sections[destructor_section]);
1385 assemble_align (POINTER_SIZE);
1386 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1388 if (! MACHOPIC_INDIRECT)
1389 fprintf (asm_out_file, ".reference .destructors_used\n");
1393 darwin_globalize_label (FILE *stream, const char *name)
1395 if (!!strncmp (name, "_OBJC_", 6))
1396 default_globalize_label (stream, name);
1400 darwin_asm_named_section (const char *name,
1401 unsigned int flags ATTRIBUTE_UNUSED,
1402 tree decl ATTRIBUTE_UNUSED)
1404 fprintf (asm_out_file, "\t.section %s\n", name);
1408 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1410 /* Darwin does not use unique sections. */
1413 /* Handle __attribute__ ((apple_kext_compatibility)).
1414 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1415 vtable for classes with this attribute (and their descendants) by not
1416 outputting the new 3.0 nondeleting destructor. This means that such
1417 objects CANNOT be allocated on the stack or as globals UNLESS they have
1418 a completely empty `operator delete'.
1419 Luckily, this fits in with the Darwin kext model.
1421 This attribute also disables gcc3's potential overlaying of derived
1422 class data members on the padding at the end of the base class. */
1425 darwin_handle_kext_attribute (tree *node, tree name,
1426 tree args ATTRIBUTE_UNUSED,
1427 int flags ATTRIBUTE_UNUSED,
1430 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1431 if (! TARGET_KEXTABI)
1433 warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1434 "only when compiling a kext", IDENTIFIER_POINTER (name));
1436 *no_add_attrs = true;
1438 else if (TREE_CODE (*node) != RECORD_TYPE)
1440 warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1441 "only to C++ classes", IDENTIFIER_POINTER (name));
1443 *no_add_attrs = true;
1449 /* Handle a "weak_import" attribute; arguments as in
1450 struct attribute_spec.handler. */
1453 darwin_handle_weak_import_attribute (tree *node, tree name,
1454 tree ARG_UNUSED (args),
1455 int ARG_UNUSED (flags),
1456 bool * no_add_attrs)
1458 if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1460 warning (OPT_Wattributes, "%qs attribute ignored",
1461 IDENTIFIER_POINTER (name));
1462 *no_add_attrs = true;
1465 declare_weak (*node);
1470 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1471 The third parameter is nonzero if this is for exception handling.
1472 The fourth parameter is nonzero if this is just a placeholder for an
1473 FDE that we are omitting. */
1476 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1483 lab = concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), ".eh", NULL);
1485 if (TREE_PUBLIC (decl))
1487 targetm.asm_out.globalize_label (file, lab);
1488 if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN)
1490 fputs ("\t.private_extern ", file);
1491 assemble_name (file, lab);
1496 if (DECL_WEAK (decl))
1498 fputs ("\t.weak_definition ", file);
1499 assemble_name (file, lab);
1503 assemble_name (file, lab);
1506 fputs (" = 0\n", file);
1508 /* Mark the absolute .eh and .eh1 style labels as needed to
1509 ensure that we don't dead code strip them and keep such
1510 labels from another instantiation point until we can fix this
1511 properly with group comdat support. */
1512 darwin_mark_decl_preserved (lab);
1515 fputs (":\n", file);
1520 static GTY(()) unsigned long except_table_label_num;
1523 darwin_emit_except_table_label (FILE *file)
1525 char section_start_label[30];
1527 ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1528 except_table_label_num++);
1529 ASM_OUTPUT_LABEL (file, section_start_label);
1531 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1534 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1536 const char *nlp_name;
1538 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1540 nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1541 fputs ("\t.long\t", file);
1542 ASM_OUTPUT_LABELREF (file, nlp_name);
1546 /* Emit an assembler directive to set visibility for a symbol. The
1547 only supported visibilities are VISIBILITY_DEFAULT and
1548 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1549 extern". There is no MACH-O equivalent of ELF's
1550 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1553 darwin_assemble_visibility (tree decl, int vis)
1555 if (vis == VISIBILITY_DEFAULT)
1557 else if (vis == VISIBILITY_HIDDEN)
1559 fputs ("\t.private_extern ", asm_out_file);
1560 assemble_name (asm_out_file,
1561 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1562 fputs ("\n", asm_out_file);
1565 warning (OPT_Wattributes, "internal and protected visibility attributes "
1566 "not supported in this configuration; ignored");
1569 /* Output a difference of two labels that will be an assembly time
1570 constant if the two labels are local. (.long lab1-lab2 will be
1571 very different if lab1 is at the boundary between two sections; it
1572 will be relocated according to the second section, not the first,
1573 so one ends up with a difference between labels in different
1574 sections, which is bad in the dwarf2 eh context for instance.) */
1576 static int darwin_dwarf_label_counter;
1579 darwin_asm_output_dwarf_delta (FILE *file, int size,
1580 const char *lab1, const char *lab2)
1582 int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1583 && lab2[0] == '*' && lab2[1] == 'L');
1584 const char *directive = (size == 8 ? ".quad" : ".long");
1587 fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1589 fprintf (file, "\t%s\t", directive);
1590 assemble_name_raw (file, lab1);
1591 fprintf (file, "-");
1592 assemble_name_raw (file, lab2);
1594 fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1597 /* Output labels for the start of the DWARF sections if necessary. */
1599 darwin_file_start (void)
1601 if (write_symbols == DWARF2_DEBUG)
1603 static const char * const debugnames[] =
1605 DEBUG_FRAME_SECTION,
1607 DEBUG_ABBREV_SECTION,
1608 DEBUG_ARANGES_SECTION,
1609 DEBUG_MACINFO_SECTION,
1612 DEBUG_PUBNAMES_SECTION,
1613 DEBUG_PUBTYPES_SECTION,
1615 DEBUG_RANGES_SECTION
1619 for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1623 switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1625 gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1626 gcc_assert (strchr (debugnames[i] + 8, ','));
1628 namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1629 fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1634 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
1635 offsets are not represented using relocs in .o files; either the
1636 section never leaves the .o file, or the linker or other tool is
1637 responsible for parsing the DWARF and updating the offsets. */
1640 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1646 gcc_assert (base->common.flags & SECTION_NAMED);
1647 gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1648 gcc_assert (strchr (base->named.name + 8, ','));
1650 namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1651 sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1652 darwin_asm_output_dwarf_delta (file, size, lab, sname);
1656 darwin_file_end (void)
1658 machopic_finish (asm_out_file);
1659 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1661 switch_to_section (darwin_sections[constructor_section]);
1662 switch_to_section (darwin_sections[destructor_section]);
1663 ASM_OUTPUT_ALIGN (asm_out_file, 1);
1665 fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1668 /* TODO: Add a language hook for identifying if a decl is a vtable. */
1669 #define DARWIN_VTABLE_P(DECL) 0
1671 /* Cross-module name binding. Darwin does not support overriding
1672 functions at dynamic-link time, except for vtables in kexts. */
1675 darwin_binds_local_p (const_tree decl)
1677 return default_binds_local_p_1 (decl,
1678 TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
1682 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet. */
1683 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
1684 anchor relative to ".", the current section position. We cannot use
1685 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
1688 darwin_asm_output_anchor (rtx symbol)
1690 fprintf (asm_out_file, "\t.set\t");
1691 assemble_name (asm_out_file, XSTR (symbol, 0));
1692 fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1693 SYMBOL_REF_BLOCK_OFFSET (symbol));
1697 /* Set the darwin specific attributes on TYPE. */
1699 darwin_set_default_type_attributes (tree type)
1701 if (darwin_ms_struct
1702 && TREE_CODE (type) == RECORD_TYPE)
1703 TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1705 TYPE_ATTRIBUTES (type));
1708 /* True, iff we're generating code for loadable kernel extensions. */
1711 darwin_kextabi_p (void) {
1712 return flag_apple_kext;
1716 darwin_override_options (void)
1718 if (flag_mkernel || flag_apple_kext)
1720 /* -mkernel implies -fapple-kext for C++ */
1721 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1722 flag_apple_kext = 1;
1726 /* No EH in kexts. */
1727 flag_exceptions = 0;
1728 /* No -fnon-call-exceptions data in kexts. */
1729 flag_non_call_exceptions = 0;
1731 if (flag_var_tracking
1732 && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1733 && debug_info_level >= DINFO_LEVEL_NORMAL
1734 && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
1735 flag_var_tracking_uninit = 1;
1738 /* Add $LDBL128 suffix to long double builtins. */
1741 darwin_patch_builtin (int fncode)
1743 tree fn = built_in_decls[fncode];
1750 sym = DECL_ASSEMBLER_NAME (fn);
1751 newname = ACONCAT (("_", IDENTIFIER_POINTER (sym), "$LDBL128", NULL));
1753 set_user_assembler_name (fn, newname);
1755 fn = implicit_built_in_decls[fncode];
1757 set_user_assembler_name (fn, newname);
1761 darwin_patch_builtins (void)
1763 if (LONG_DOUBLE_TYPE_SIZE != 128)
1766 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
1767 #define PATCH_BUILTIN_NO64(fncode) \
1768 if (!TARGET_64BIT) \
1769 darwin_patch_builtin (fncode);
1770 #define PATCH_BUILTIN_VARIADIC(fncode) \
1772 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
1773 darwin_patch_builtin (fncode);
1774 #include "darwin-ppc-ldouble-patch.def"
1775 #undef PATCH_BUILTIN
1776 #undef PATCH_BUILTIN_NO64
1777 #undef PATCH_BUILTIN_VARIADIC
1781 #include "gt-darwin.h"