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,
3 2005, 2006, 2007, 2008, 2009
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 /* Return either ORIG or:
272 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
274 depending on MACHO_DYNAMIC_NO_PIC_P. */
276 machopic_gen_offset (rtx orig)
278 if (MACHO_DYNAMIC_NO_PIC_P)
282 /* Play games to avoid marking the function as needing pic if we
283 are being called as part of the cost-estimation process. */
284 if (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)
285 crtl->uses_pic_offset_table = 1;
286 orig = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig),
287 UNSPEC_MACHOPIC_OFFSET);
288 return gen_rtx_CONST (Pmode, orig);
292 static GTY(()) const char * function_base_func_name;
293 static GTY(()) int current_pic_label_num;
296 machopic_output_function_base_name (FILE *file)
298 const char *current_name;
300 /* If dynamic-no-pic is on, we should not get here. */
301 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
303 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
304 if (function_base_func_name != current_name)
306 ++current_pic_label_num;
307 function_base_func_name = current_name;
309 fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
312 /* The suffix attached to non-lazy pointer symbols. */
313 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
314 /* The suffix attached to stub symbols. */
315 #define STUB_SUFFIX "$stub"
317 typedef struct GTY (()) machopic_indirection
319 /* The SYMBOL_REF for the entity referenced. */
321 /* The name of the stub or non-lazy pointer. */
322 const char * ptr_name;
323 /* True iff this entry is for a stub (as opposed to a non-lazy
326 /* True iff this stub or pointer pointer has been referenced. */
328 } machopic_indirection;
330 /* A table mapping stub names and non-lazy pointer names to
331 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
333 static GTY ((param_is (struct machopic_indirection))) htab_t
334 machopic_indirections;
336 /* Return a hash value for a SLOT in the indirections hash table. */
339 machopic_indirection_hash (const void *slot)
341 const machopic_indirection *p = (const machopic_indirection *) slot;
342 return htab_hash_string (p->ptr_name);
345 /* Returns true if the KEY is the same as that associated with
349 machopic_indirection_eq (const void *slot, const void *key)
351 return strcmp (((const machopic_indirection *) slot)->ptr_name,
352 (const char *) key) == 0;
355 /* Return the name of the non-lazy pointer (if STUB_P is false) or
356 stub (if STUB_B is true) corresponding to the given name. */
359 machopic_indirection_name (rtx sym_ref, bool stub_p)
362 const char *name = XSTR (sym_ref, 0);
363 size_t namelen = strlen (name);
364 machopic_indirection *p;
366 bool saw_star = false;
369 const char *prefix = user_label_prefix;
370 const char *quote = "";
373 id = maybe_get_identifier (name);
378 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
379 id = TREE_CHAIN (id);
382 name = IDENTIFIER_POINTER (id);
383 namelen = strlen (name);
395 needs_quotes = name_needs_quotes (name);
402 suffix = STUB_SUFFIX;
404 suffix = NON_LAZY_POINTER_SUFFIX;
406 buffer = XALLOCAVEC (char, strlen ("&L")
413 /* Construct the name of the non-lazy pointer or stub. */
414 sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
416 if (!machopic_indirections)
417 machopic_indirections = htab_create_ggc (37,
418 machopic_indirection_hash,
419 machopic_indirection_eq,
422 slot = htab_find_slot_with_hash (machopic_indirections, buffer,
423 htab_hash_string (buffer), INSERT);
426 p = (machopic_indirection *) *slot;
430 p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
432 p->ptr_name = xstrdup (buffer);
441 /* Return the name of the stub for the mcount function. */
444 machopic_mcount_stub_name (void)
446 rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
447 return machopic_indirection_name (symbol, /*stub_p=*/true);
450 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
451 or non-lazy pointer as used -- and mark the object to which the
452 pointer/stub refers as used as well, since the pointer/stub will
453 emit a reference to it. */
456 machopic_validate_stub_or_non_lazy_ptr (const char *name)
458 machopic_indirection *p;
460 p = ((machopic_indirection *)
461 (htab_find_with_hash (machopic_indirections, name,
462 htab_hash_string (name))));
465 const char *real_name;
470 /* Do what output_addr_const will do when we actually call it. */
471 if (SYMBOL_REF_DECL (p->symbol))
472 mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
474 real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
476 id = maybe_get_identifier (real_name);
478 mark_referenced (id);
482 /* Transform ORIG, which may be any data source, to the corresponding
483 source using indirections. */
486 machopic_indirect_data_reference (rtx orig, rtx reg)
490 if (! MACHOPIC_INDIRECT)
493 if (GET_CODE (orig) == SYMBOL_REF)
495 int defined = machopic_data_defined_p (orig);
497 if (defined && MACHO_DYNAMIC_NO_PIC_P)
499 #if defined (TARGET_TOC)
500 /* Create a new register for CSE opportunities. */
501 rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));
502 emit_insn (gen_macho_high (hi_reg, orig));
503 emit_insn (gen_macho_low (reg, hi_reg, orig));
505 /* some other cpu -- writeme! */
512 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
513 rtx offset = machopic_gen_offset (orig);
516 #if defined (TARGET_TOC) /* i.e., PowerPC */
517 rtx hi_sum_reg = (!can_create_pseudo_p ()
519 : gen_reg_rtx (Pmode));
523 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
524 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
525 gen_rtx_HIGH (Pmode, offset))));
526 emit_insn (gen_rtx_SET (Pmode, reg,
527 gen_rtx_LO_SUM (Pmode, hi_sum_reg,
528 copy_rtx (offset))));
532 #if defined (HAVE_lo_sum)
535 emit_insn (gen_rtx_SET (VOIDmode, reg,
536 gen_rtx_HIGH (Pmode, offset)));
537 emit_insn (gen_rtx_SET (VOIDmode, reg,
538 gen_rtx_LO_SUM (Pmode, reg,
539 copy_rtx (offset))));
540 emit_use (pic_offset_table_rtx);
542 orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
548 ptr_ref = (gen_rtx_SYMBOL_REF
550 machopic_indirection_name (orig, /*stub_p=*/false)));
552 SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
554 ptr_ref = gen_const_mem (Pmode, ptr_ref);
555 machopic_define_symbol (ptr_ref);
559 else if (GET_CODE (orig) == CONST)
563 /* legitimize both operands of the PLUS */
564 if (GET_CODE (XEXP (orig, 0)) == PLUS)
566 base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
568 orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
569 (base == reg ? 0 : reg));
574 if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
575 result = plus_constant (base, INTVAL (orig));
577 result = gen_rtx_PLUS (Pmode, base, orig);
579 if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
583 emit_move_insn (reg, result);
588 result = force_reg (GET_MODE (result), result);
595 else if (GET_CODE (orig) == MEM)
596 XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
597 /* When the target is i386, this code prevents crashes due to the
598 compiler's ignorance on how to move the PIC base register to
599 other registers. (The reload phase sometimes introduces such
601 else if (GET_CODE (orig) == PLUS
602 && GET_CODE (XEXP (orig, 0)) == REG
603 && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
605 /* Prevent the same register from being erroneously used
606 as both the base and index registers. */
607 && GET_CODE (XEXP (orig, 1)) == CONST
611 emit_move_insn (reg, XEXP (orig, 0));
612 XEXP (ptr_ref, 0) = reg;
617 /* Transform TARGET (a MEM), which is a function call target, to the
618 corresponding symbol_stub if necessary. Return a new MEM. */
621 machopic_indirect_call_target (rtx target)
623 if (GET_CODE (target) != MEM)
626 if (MACHOPIC_INDIRECT
627 && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
628 && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
629 & MACHO_SYMBOL_FLAG_DEFINED))
631 rtx sym_ref = XEXP (target, 0);
632 const char *stub_name = machopic_indirection_name (sym_ref,
634 enum machine_mode mode = GET_MODE (sym_ref);
636 XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
637 SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
638 MEM_READONLY_P (target) = 1;
639 MEM_NOTRAP_P (target) = 1;
646 machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
650 if (! MACHOPIC_INDIRECT)
653 /* First handle a simple SYMBOL_REF or LABEL_REF */
654 if (GET_CODE (orig) == LABEL_REF
655 || (GET_CODE (orig) == SYMBOL_REF
658 /* addr(foo) = &func+(foo-func) */
659 orig = machopic_indirect_data_reference (orig, reg);
661 if (GET_CODE (orig) == PLUS
662 && GET_CODE (XEXP (orig, 0)) == REG)
665 return force_reg (mode, orig);
667 emit_move_insn (reg, orig);
671 if (GET_CODE (orig) == MEM)
675 gcc_assert (!reload_in_progress);
676 reg = gen_reg_rtx (Pmode);
680 if (MACHO_DYNAMIC_NO_PIC_P
681 && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
682 || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
684 #if defined (TARGET_TOC) /* ppc */
685 rtx temp_reg = (!can_create_pseudo_p ()
687 gen_reg_rtx (Pmode));
688 rtx asym = XEXP (orig, 0);
691 emit_insn (gen_macho_high (temp_reg, asym));
692 mem = gen_const_mem (GET_MODE (orig),
693 gen_rtx_LO_SUM (Pmode, temp_reg,
695 emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
697 /* Some other CPU -- WriteMe! but right now there are no other
698 platforms that can use dynamic-no-pic */
704 if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
705 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
707 rtx offset = machopic_gen_offset (XEXP (orig, 0));
708 #if defined (TARGET_TOC) /* i.e., PowerPC */
709 /* Generating a new reg may expose opportunities for
710 common subexpression elimination. */
711 rtx hi_sum_reg = (!can_create_pseudo_p ()
713 : gen_reg_rtx (Pmode));
718 sum = gen_rtx_HIGH (Pmode, offset);
719 if (! MACHO_DYNAMIC_NO_PIC_P)
720 sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
722 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
724 mem = gen_const_mem (GET_MODE (orig),
725 gen_rtx_LO_SUM (Pmode,
728 insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
729 set_unique_reg_note (insn, REG_EQUAL, pic_ref);
733 emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
735 emit_insn (gen_rtx_SET (VOIDmode, reg,
737 gen_rtx_CONST (Pmode,
739 emit_insn (gen_rtx_SET (VOIDmode, reg,
740 gen_rtx_LO_SUM (Pmode, reg,
741 gen_rtx_CONST (Pmode,
742 copy_rtx (offset)))));
743 pic_ref = gen_rtx_PLUS (Pmode,
744 pic_offset_table_rtx, reg);
748 #endif /* HAVE_lo_sum */
750 rtx pic = pic_offset_table_rtx;
751 if (GET_CODE (pic) != REG)
753 emit_move_insn (reg, pic);
757 emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
760 if (reload_in_progress)
761 df_set_regs_ever_live (REGNO (pic), true);
762 pic_ref = gen_rtx_PLUS (Pmode, pic,
763 machopic_gen_offset (XEXP (orig, 0)));
766 #if !defined (TARGET_TOC)
767 emit_move_insn (reg, pic_ref);
768 pic_ref = gen_const_mem (GET_MODE (orig), reg);
775 if (GET_CODE (orig) == SYMBOL_REF
776 || GET_CODE (orig) == LABEL_REF)
778 rtx offset = machopic_gen_offset (orig);
779 #if defined (TARGET_TOC) /* i.e., PowerPC */
784 gcc_assert (!reload_in_progress);
785 reg = gen_reg_rtx (Pmode);
790 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
791 (MACHO_DYNAMIC_NO_PIC_P)
792 ? gen_rtx_HIGH (Pmode, offset)
793 : gen_rtx_PLUS (Pmode,
794 pic_offset_table_rtx,
797 emit_insn (gen_rtx_SET (VOIDmode, reg,
798 gen_rtx_LO_SUM (Pmode,
800 copy_rtx (offset))));
803 emit_insn (gen_rtx_SET (VOIDmode, reg,
804 gen_rtx_HIGH (Pmode, offset)));
805 emit_insn (gen_rtx_SET (VOIDmode, reg,
806 gen_rtx_LO_SUM (Pmode, reg,
807 copy_rtx (offset))));
808 pic_ref = gen_rtx_PLUS (Pmode,
809 pic_offset_table_rtx, reg);
813 #endif /* HAVE_lo_sum */
816 || GET_CODE (orig) == SUBREG)
822 rtx pic = pic_offset_table_rtx;
823 if (GET_CODE (pic) != REG)
825 emit_move_insn (reg, pic);
829 emit_use (pic_offset_table_rtx);
831 if (reload_in_progress)
832 df_set_regs_ever_live (REGNO (pic), true);
833 pic_ref = gen_rtx_PLUS (Pmode,
835 machopic_gen_offset (orig));
840 if (GET_CODE (pic_ref) != REG)
844 emit_move_insn (reg, pic_ref);
849 return force_reg (mode, pic_ref);
858 else if (GET_CODE (orig) == SYMBOL_REF)
861 else if (GET_CODE (orig) == PLUS
862 && (GET_CODE (XEXP (orig, 0)) == MEM
863 || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
864 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
865 && XEXP (orig, 0) != pic_offset_table_rtx
866 && GET_CODE (XEXP (orig, 1)) != REG)
870 int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
872 base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
873 orig = machopic_legitimize_pic_address (XEXP (orig, 1),
874 Pmode, (base == reg ? 0 : reg));
875 if (GET_CODE (orig) == CONST_INT)
877 pic_ref = plus_constant (base, INTVAL (orig));
881 pic_ref = gen_rtx_PLUS (Pmode, base, orig);
883 if (reg && is_complex)
885 emit_move_insn (reg, pic_ref);
888 /* Likewise, should we set special REG_NOTEs here? */
891 else if (GET_CODE (orig) == CONST)
893 return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
896 else if (GET_CODE (orig) == MEM
897 && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
899 rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
900 addr = replace_equiv_address (orig, addr);
901 emit_move_insn (reg, addr);
908 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
909 DATA is the FILE* for assembly output. Called from
913 machopic_output_indirection (void **slot, void *data)
915 machopic_indirection *p = *((machopic_indirection **) slot);
916 FILE *asm_out_file = (FILE *) data;
918 const char *sym_name;
919 const char *ptr_name;
925 sym_name = XSTR (symbol, 0);
926 ptr_name = p->ptr_name;
934 id = maybe_get_identifier (sym_name);
939 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
940 id = TREE_CHAIN (id);
942 sym_name = IDENTIFIER_POINTER (id);
945 sym = XALLOCAVEC (char, strlen (sym_name) + 2);
946 if (sym_name[0] == '*' || sym_name[0] == '&')
947 strcpy (sym, sym_name + 1);
948 else if (sym_name[0] == '-' || sym_name[0] == '+')
949 strcpy (sym, sym_name);
951 sprintf (sym, "%s%s", user_label_prefix, sym_name);
953 stub = XALLOCAVEC (char, strlen (ptr_name) + 2);
954 if (ptr_name[0] == '*' || ptr_name[0] == '&')
955 strcpy (stub, ptr_name + 1);
957 sprintf (stub, "%s%s", user_label_prefix, ptr_name);
959 machopic_output_stub (asm_out_file, sym, stub);
961 else if (! indirect_data (symbol)
962 && (machopic_symbol_defined_p (symbol)
963 || SYMBOL_REF_LOCAL_P (symbol)))
965 switch_to_section (data_section);
966 assemble_align (GET_MODE_ALIGNMENT (Pmode));
967 assemble_label (ptr_name);
968 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
969 GET_MODE_SIZE (Pmode),
970 GET_MODE_ALIGNMENT (Pmode), 1);
974 rtx init = const0_rtx;
976 switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
978 /* Mach-O symbols are passed around in code through indirect
979 references and the original symbol_ref hasn't passed through
980 the generic handling and reference-catching in
981 output_operand, so we need to manually mark weak references
983 if (SYMBOL_REF_WEAK (symbol))
985 tree decl = SYMBOL_REF_DECL (symbol);
986 gcc_assert (DECL_P (decl));
988 if (decl != NULL_TREE
989 && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
990 /* Handle only actual external-only definitions, not
991 e.g. extern inline code or variables for which
992 storage has been allocated. */
993 && !TREE_STATIC (decl))
995 fputs ("\t.weak_reference ", asm_out_file);
996 assemble_name (asm_out_file, sym_name);
997 fputc ('\n', asm_out_file);
1001 assemble_name (asm_out_file, ptr_name);
1002 fprintf (asm_out_file, ":\n");
1004 fprintf (asm_out_file, "\t.indirect_symbol ");
1005 assemble_name (asm_out_file, sym_name);
1006 fprintf (asm_out_file, "\n");
1008 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1009 have their symbol name instead of 0 in the second entry of
1010 the non-lazy symbol pointer data structure when they are
1011 defined. This allows the runtime to rebind newer instances
1012 of the translation unit with the original instance of the
1015 if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
1016 && machopic_symbol_defined_p (symbol))
1017 init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
1019 assemble_integer (init, GET_MODE_SIZE (Pmode),
1020 GET_MODE_ALIGNMENT (Pmode), 1);
1027 machopic_finish (FILE *asm_out_file)
1029 if (machopic_indirections)
1030 htab_traverse_noresize (machopic_indirections,
1031 machopic_output_indirection,
1036 machopic_operand_p (rtx op)
1038 if (MACHOPIC_JUST_INDIRECT)
1039 return (GET_CODE (op) == SYMBOL_REF
1040 && machopic_symbol_defined_p (op));
1042 return (GET_CODE (op) == CONST
1043 && GET_CODE (XEXP (op, 0)) == UNSPEC
1044 && XINT (XEXP (op, 0), 1) == UNSPEC_MACHOPIC_OFFSET);
1047 /* This function records whether a given name corresponds to a defined
1048 or undefined function or variable, for machopic_classify_ident to
1052 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
1056 /* Do the standard encoding things first. */
1057 default_encode_section_info (decl, rtl, first);
1059 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
1062 sym_ref = XEXP (rtl, 0);
1063 if (TREE_CODE (decl) == VAR_DECL)
1064 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
1066 if (!DECL_EXTERNAL (decl)
1067 && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
1068 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
1069 && ((TREE_STATIC (decl)
1070 && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
1071 || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
1072 && DECL_INITIAL (decl) != error_mark_node)))
1073 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
1075 if (! TREE_PUBLIC (decl))
1076 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
1080 darwin_mark_decl_preserved (const char *name)
1082 fprintf (asm_out_file, ".no_dead_strip ");
1083 assemble_name (asm_out_file, name);
1084 fputc ('\n', asm_out_file);
1088 darwin_text_section (int reloc, int weak)
1092 ? darwin_sections[text_unlikely_coal_section]
1093 : unlikely_text_section ());
1096 ? darwin_sections[text_coal_section]
1101 darwin_rodata_section (int weak)
1104 ? darwin_sections[const_coal_section]
1105 : darwin_sections[const_section]);
1109 darwin_mergeable_string_section (tree exp,
1110 unsigned HOST_WIDE_INT align)
1112 if (flag_merge_constants
1113 && TREE_CODE (exp) == STRING_CST
1114 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1116 && (int_size_in_bytes (TREE_TYPE (exp))
1117 == TREE_STRING_LENGTH (exp))
1118 && ((size_t) TREE_STRING_LENGTH (exp)
1119 == strlen (TREE_STRING_POINTER (exp)) + 1))
1120 return darwin_sections[cstring_section];
1122 return readonly_data_section;
1125 #ifndef HAVE_GAS_LITERAL16
1126 #define HAVE_GAS_LITERAL16 0
1130 darwin_mergeable_constant_section (tree exp,
1131 unsigned HOST_WIDE_INT align)
1133 enum machine_mode mode = DECL_MODE (exp);
1134 unsigned int modesize = GET_MODE_BITSIZE (mode);
1136 if (flag_merge_constants
1139 && modesize <= align
1142 && (align & (align -1)) == 0)
1144 tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1146 if (TREE_CODE (size) == INTEGER_CST
1147 && TREE_INT_CST_LOW (size) == 4
1148 && TREE_INT_CST_HIGH (size) == 0)
1149 return darwin_sections[literal4_section];
1150 else if (TREE_CODE (size) == INTEGER_CST
1151 && TREE_INT_CST_LOW (size) == 8
1152 && TREE_INT_CST_HIGH (size) == 0)
1153 return darwin_sections[literal8_section];
1154 else if (HAVE_GAS_LITERAL16
1156 && TREE_CODE (size) == INTEGER_CST
1157 && TREE_INT_CST_LOW (size) == 16
1158 && TREE_INT_CST_HIGH (size) == 0)
1159 return darwin_sections[literal16_section];
1161 return readonly_data_section;
1164 return readonly_data_section;
1168 machopic_reloc_rw_mask (void)
1170 return MACHOPIC_INDIRECT ? 3 : 0;
1174 machopic_select_section (tree decl,
1176 unsigned HOST_WIDE_INT align)
1178 bool weak = (DECL_P (decl)
1180 && !lookup_attribute ("weak_import",
1181 DECL_ATTRIBUTES (decl)));
1182 section *base_section;
1184 switch (categorize_decl_for_section (decl, reloc))
1187 base_section = darwin_text_section (reloc, weak);
1191 case SECCAT_SRODATA:
1192 base_section = darwin_rodata_section (weak);
1195 case SECCAT_RODATA_MERGE_STR:
1196 base_section = darwin_mergeable_string_section (decl, align);
1199 case SECCAT_RODATA_MERGE_STR_INIT:
1200 base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1203 case SECCAT_RODATA_MERGE_CONST:
1204 base_section = darwin_mergeable_constant_section (decl, align);
1208 case SECCAT_DATA_REL:
1209 case SECCAT_DATA_REL_LOCAL:
1210 case SECCAT_DATA_REL_RO:
1211 case SECCAT_DATA_REL_RO_LOCAL:
1217 if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1218 base_section = weak ? darwin_sections[const_data_coal_section]
1219 : darwin_sections[const_data_section];
1221 base_section = weak ? darwin_sections[data_coal_section] : data_section;
1228 /* Darwin weird special cases. */
1229 if (TREE_CODE (decl) == CONSTRUCTOR
1231 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1232 && TYPE_NAME (TREE_TYPE (decl)))
1234 tree name = TYPE_NAME (TREE_TYPE (decl));
1235 if (TREE_CODE (name) == TYPE_DECL)
1236 name = DECL_NAME (name);
1238 if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1240 if (flag_next_runtime)
1241 return darwin_sections[objc_constant_string_object_section];
1243 return darwin_sections[objc_string_object_section];
1246 return base_section;
1248 else if (TREE_CODE (decl) == VAR_DECL
1250 && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1251 && IDENTIFIER_POINTER (DECL_NAME (decl))
1252 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1254 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1256 if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1257 return darwin_sections[objc_cls_meth_section];
1258 else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1259 return darwin_sections[objc_inst_meth_section];
1260 else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1261 return darwin_sections[objc_cat_cls_meth_section];
1262 else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1263 return darwin_sections[objc_cat_inst_meth_section];
1264 else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1265 return darwin_sections[objc_class_vars_section];
1266 else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1267 return darwin_sections[objc_instance_vars_section];
1268 else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1269 return darwin_sections[objc_cat_cls_meth_section];
1270 else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1271 return darwin_sections[objc_class_names_section];
1272 else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1273 return darwin_sections[objc_meth_var_names_section];
1274 else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1275 return darwin_sections[objc_meth_var_types_section];
1276 else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1277 return darwin_sections[objc_cls_refs_section];
1278 else if (!strncmp (name, "_OBJC_CLASS_", 12))
1279 return darwin_sections[objc_class_section];
1280 else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1281 return darwin_sections[objc_meta_class_section];
1282 else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1283 return darwin_sections[objc_category_section];
1284 else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1285 return darwin_sections[objc_selector_refs_section];
1286 else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1287 return darwin_sections[objc_selector_fixup_section];
1288 else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1289 return darwin_sections[objc_symbols_section];
1290 else if (!strncmp (name, "_OBJC_MODULES", 13))
1291 return darwin_sections[objc_module_info_section];
1292 else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1293 return darwin_sections[objc_image_info_section];
1294 else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1295 return darwin_sections[objc_cat_inst_meth_section];
1296 else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1297 return darwin_sections[objc_cat_cls_meth_section];
1298 else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1299 return darwin_sections[objc_cat_cls_meth_section];
1300 else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1301 return darwin_sections[objc_protocol_section];
1303 return base_section;
1306 return base_section;
1309 /* This can be called with address expressions as "rtx".
1310 They must go in "const". */
1313 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1314 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1316 if (GET_MODE_SIZE (mode) == 8
1317 && (GET_CODE (x) == CONST_INT
1318 || GET_CODE (x) == CONST_DOUBLE))
1319 return darwin_sections[literal8_section];
1320 else if (GET_MODE_SIZE (mode) == 4
1321 && (GET_CODE (x) == CONST_INT
1322 || GET_CODE (x) == CONST_DOUBLE))
1323 return darwin_sections[literal4_section];
1324 else if (HAVE_GAS_LITERAL16
1326 && GET_MODE_SIZE (mode) == 16
1327 && (GET_CODE (x) == CONST_INT
1328 || GET_CODE (x) == CONST_DOUBLE
1329 || GET_CODE (x) == CONST_VECTOR))
1330 return darwin_sections[literal16_section];
1331 else if (MACHOPIC_INDIRECT
1332 && (GET_CODE (x) == SYMBOL_REF
1333 || GET_CODE (x) == CONST
1334 || GET_CODE (x) == LABEL_REF))
1335 return darwin_sections[const_data_section];
1337 return darwin_sections[const_section];
1341 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1343 if (MACHOPIC_INDIRECT)
1344 switch_to_section (darwin_sections[mod_init_section]);
1346 switch_to_section (darwin_sections[constructor_section]);
1347 assemble_align (POINTER_SIZE);
1348 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1350 if (! MACHOPIC_INDIRECT)
1351 fprintf (asm_out_file, ".reference .constructors_used\n");
1355 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1357 if (MACHOPIC_INDIRECT)
1358 switch_to_section (darwin_sections[mod_term_section]);
1360 switch_to_section (darwin_sections[destructor_section]);
1361 assemble_align (POINTER_SIZE);
1362 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1364 if (! MACHOPIC_INDIRECT)
1365 fprintf (asm_out_file, ".reference .destructors_used\n");
1369 darwin_globalize_label (FILE *stream, const char *name)
1371 if (!!strncmp (name, "_OBJC_", 6))
1372 default_globalize_label (stream, name);
1375 /* This routine returns non-zero if 'name' starts with the special objective-c
1376 anonymous file-scope static name. It accommodates c++'s mangling of such
1377 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1380 darwin_label_is_anonymous_local_objc_name (const char *name)
1382 const unsigned char *p = (const unsigned char *) name;
1385 if (p[1] == 'Z' && p[2] == 'L')
1388 while (*p >= '0' && *p <= '9')
1391 return (!strncmp ((const char *)p, "_OBJC_", 6));
1395 darwin_asm_named_section (const char *name,
1396 unsigned int flags ATTRIBUTE_UNUSED,
1397 tree decl ATTRIBUTE_UNUSED)
1399 fprintf (asm_out_file, "\t.section %s\n", name);
1403 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1405 /* Darwin does not use unique sections. */
1408 /* Handle __attribute__ ((apple_kext_compatibility)).
1409 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1410 vtable for classes with this attribute (and their descendants) by not
1411 outputting the new 3.0 nondeleting destructor. This means that such
1412 objects CANNOT be allocated on the stack or as globals UNLESS they have
1413 a completely empty `operator delete'.
1414 Luckily, this fits in with the Darwin kext model.
1416 This attribute also disables gcc3's potential overlaying of derived
1417 class data members on the padding at the end of the base class. */
1420 darwin_handle_kext_attribute (tree *node, tree name,
1421 tree args ATTRIBUTE_UNUSED,
1422 int flags ATTRIBUTE_UNUSED,
1425 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1426 if (! TARGET_KEXTABI)
1428 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1429 "only when compiling a kext", name);
1431 *no_add_attrs = true;
1433 else if (TREE_CODE (*node) != RECORD_TYPE)
1435 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1436 "only to C++ classes", name);
1438 *no_add_attrs = true;
1444 /* Handle a "weak_import" attribute; arguments as in
1445 struct attribute_spec.handler. */
1448 darwin_handle_weak_import_attribute (tree *node, tree name,
1449 tree ARG_UNUSED (args),
1450 int ARG_UNUSED (flags),
1451 bool * no_add_attrs)
1453 if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1455 warning (OPT_Wattributes, "%qE attribute ignored",
1457 *no_add_attrs = true;
1460 declare_weak (*node);
1465 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1466 The third parameter is nonzero if this is for exception handling.
1467 The fourth parameter is nonzero if this is just a placeholder for an
1468 FDE that we are omitting. */
1471 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1478 lab = concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), ".eh", NULL);
1480 if (TREE_PUBLIC (decl))
1482 targetm.asm_out.globalize_label (file, lab);
1483 if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN)
1485 fputs ("\t.private_extern ", file);
1486 assemble_name (file, lab);
1491 if (DECL_WEAK (decl))
1493 fputs ("\t.weak_definition ", file);
1494 assemble_name (file, lab);
1498 assemble_name (file, lab);
1501 fputs (" = 0\n", file);
1503 /* Mark the absolute .eh and .eh1 style labels as needed to
1504 ensure that we don't dead code strip them and keep such
1505 labels from another instantiation point until we can fix this
1506 properly with group comdat support. */
1507 darwin_mark_decl_preserved (lab);
1510 fputs (":\n", file);
1515 static GTY(()) unsigned long except_table_label_num;
1518 darwin_emit_except_table_label (FILE *file)
1520 char section_start_label[30];
1522 ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1523 except_table_label_num++);
1524 ASM_OUTPUT_LABEL (file, section_start_label);
1526 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1529 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1531 const char *nlp_name;
1533 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1535 nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1536 fputs ("\t.long\t", file);
1537 ASM_OUTPUT_LABELREF (file, nlp_name);
1541 /* Emit an assembler directive to set visibility for a symbol. The
1542 only supported visibilities are VISIBILITY_DEFAULT and
1543 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1544 extern". There is no MACH-O equivalent of ELF's
1545 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1548 darwin_assemble_visibility (tree decl, int vis)
1550 if (vis == VISIBILITY_DEFAULT)
1552 else if (vis == VISIBILITY_HIDDEN)
1554 fputs ("\t.private_extern ", asm_out_file);
1555 assemble_name (asm_out_file,
1556 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1557 fputs ("\n", asm_out_file);
1560 warning (OPT_Wattributes, "internal and protected visibility attributes "
1561 "not supported in this configuration; ignored");
1564 /* Output a difference of two labels that will be an assembly time
1565 constant if the two labels are local. (.long lab1-lab2 will be
1566 very different if lab1 is at the boundary between two sections; it
1567 will be relocated according to the second section, not the first,
1568 so one ends up with a difference between labels in different
1569 sections, which is bad in the dwarf2 eh context for instance.) */
1571 static int darwin_dwarf_label_counter;
1574 darwin_asm_output_dwarf_delta (FILE *file, int size,
1575 const char *lab1, const char *lab2)
1577 int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1578 && lab2[0] == '*' && lab2[1] == 'L');
1579 const char *directive = (size == 8 ? ".quad" : ".long");
1582 fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1584 fprintf (file, "\t%s\t", directive);
1585 assemble_name_raw (file, lab1);
1586 fprintf (file, "-");
1587 assemble_name_raw (file, lab2);
1589 fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1592 /* Output labels for the start of the DWARF sections if necessary. */
1594 darwin_file_start (void)
1596 if (write_symbols == DWARF2_DEBUG)
1598 static const char * const debugnames[] =
1600 DEBUG_FRAME_SECTION,
1602 DEBUG_ABBREV_SECTION,
1603 DEBUG_ARANGES_SECTION,
1604 DEBUG_MACINFO_SECTION,
1607 DEBUG_PUBNAMES_SECTION,
1608 DEBUG_PUBTYPES_SECTION,
1610 DEBUG_RANGES_SECTION
1614 for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1618 switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1620 gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1621 gcc_assert (strchr (debugnames[i] + 8, ','));
1623 namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1624 fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1629 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
1630 offsets are not represented using relocs in .o files; either the
1631 section never leaves the .o file, or the linker or other tool is
1632 responsible for parsing the DWARF and updating the offsets. */
1635 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1641 gcc_assert (base->common.flags & SECTION_NAMED);
1642 gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1643 gcc_assert (strchr (base->named.name + 8, ','));
1645 namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1646 sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1647 darwin_asm_output_dwarf_delta (file, size, lab, sname);
1651 darwin_file_end (void)
1653 machopic_finish (asm_out_file);
1654 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1656 switch_to_section (darwin_sections[constructor_section]);
1657 switch_to_section (darwin_sections[destructor_section]);
1658 ASM_OUTPUT_ALIGN (asm_out_file, 1);
1660 fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1663 /* TODO: Add a language hook for identifying if a decl is a vtable. */
1664 #define DARWIN_VTABLE_P(DECL) 0
1666 /* Cross-module name binding. Darwin does not support overriding
1667 functions at dynamic-link time, except for vtables in kexts. */
1670 darwin_binds_local_p (const_tree decl)
1672 return default_binds_local_p_1 (decl,
1673 TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
1677 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet. */
1678 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
1679 anchor relative to ".", the current section position. We cannot use
1680 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
1683 darwin_asm_output_anchor (rtx symbol)
1685 fprintf (asm_out_file, "\t.set\t");
1686 assemble_name (asm_out_file, XSTR (symbol, 0));
1687 fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1688 SYMBOL_REF_BLOCK_OFFSET (symbol));
1692 /* Set the darwin specific attributes on TYPE. */
1694 darwin_set_default_type_attributes (tree type)
1696 if (darwin_ms_struct
1697 && TREE_CODE (type) == RECORD_TYPE)
1698 TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1700 TYPE_ATTRIBUTES (type));
1703 /* True, iff we're generating code for loadable kernel extensions. */
1706 darwin_kextabi_p (void) {
1707 return flag_apple_kext;
1711 darwin_override_options (void)
1713 /* Don't emit DWARF3/4 unless specifically selected. This is a
1714 workaround for tool bugs. */
1715 if (dwarf_strict < 0)
1718 /* Disable -freorder-blocks-and-partition for darwin_emit_unwind_label. */
1719 if (flag_reorder_blocks_and_partition
1720 && (targetm.asm_out.unwind_label == darwin_emit_unwind_label))
1722 inform (input_location,
1723 "-freorder-blocks-and-partition does not work with exceptions "
1724 "on this architecture");
1725 flag_reorder_blocks_and_partition = 0;
1726 flag_reorder_blocks = 1;
1729 if (flag_mkernel || flag_apple_kext)
1731 /* -mkernel implies -fapple-kext for C++ */
1732 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1733 flag_apple_kext = 1;
1737 /* No EH in kexts. */
1738 flag_exceptions = 0;
1739 /* No -fnon-call-exceptions data in kexts. */
1740 flag_non_call_exceptions = 0;
1742 if (flag_var_tracking
1743 && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1744 && debug_info_level >= DINFO_LEVEL_NORMAL
1745 && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
1746 flag_var_tracking_uninit = 1;
1749 /* Add $LDBL128 suffix to long double builtins. */
1752 darwin_patch_builtin (int fncode)
1754 tree fn = built_in_decls[fncode];
1761 sym = DECL_ASSEMBLER_NAME (fn);
1762 newname = ACONCAT (("_", IDENTIFIER_POINTER (sym), "$LDBL128", NULL));
1764 set_user_assembler_name (fn, newname);
1766 fn = implicit_built_in_decls[fncode];
1768 set_user_assembler_name (fn, newname);
1772 darwin_patch_builtins (void)
1774 if (LONG_DOUBLE_TYPE_SIZE != 128)
1777 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
1778 #define PATCH_BUILTIN_NO64(fncode) \
1779 if (!TARGET_64BIT) \
1780 darwin_patch_builtin (fncode);
1781 #define PATCH_BUILTIN_VARIADIC(fncode) \
1783 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
1784 darwin_patch_builtin (fncode);
1785 #include "darwin-ppc-ldouble-patch.def"
1786 #undef PATCH_BUILTIN
1787 #undef PATCH_BUILTIN_NO64
1788 #undef PATCH_BUILTIN_VARIADIC
1792 #include "gt-darwin.h"