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, 2010
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"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
34 #include "insn-attr.h"
41 #include "langhooks.h"
49 #include "lto-streamer.h"
51 /* Darwin supports a feature called fix-and-continue, which is used
52 for rapid turn around debugging. When code is compiled with the
53 -mfix-and-continue flag, two changes are made to the generated code
54 that allow the system to do things that it would normally not be
55 able to do easily. These changes allow gdb to load in
56 recompilation of a translation unit that has been changed into a
57 running program and replace existing functions and methods of that
58 translation unit with versions of those functions and methods
59 from the newly compiled translation unit. The new functions access
60 the existing static symbols from the old translation unit, if the
61 symbol existed in the unit to be replaced, and from the new
62 translation unit, otherwise.
64 The changes are to insert 5 nops at the beginning of all functions
65 and to use indirection to get at static symbols. The 5 nops
66 are required by consumers of the generated code. Currently, gdb
67 uses this to patch in a jump to the overriding function, this
68 allows all uses of the old name to forward to the replacement,
69 including existing function pointers and virtual methods. See
70 rs6000_emit_prologue for the code that handles the nop insertions.
72 The added indirection allows gdb to redirect accesses to static
73 symbols from the newly loaded translation unit to the existing
74 symbol, if any. @code{static} symbols are special and are handled by
75 setting the second word in the .non_lazy_symbol_pointer data
76 structure to symbol. See indirect_data for the code that handles
77 the extra indirection, and machopic_output_indirection and its use
78 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
79 symbol indirection. */
82 section * darwin_sections[NUM_DARWIN_SECTIONS];
84 /* True if we're setting __attribute__ ((ms_struct)). */
85 int darwin_ms_struct = false;
87 /* A get_unnamed_section callback used to switch to an ObjC section.
88 DIRECTIVE is as for output_section_asm_op. */
91 output_objc_section_asm_op (const void *directive)
93 static bool been_here = false;
97 static const enum darwin_section_enum tomark[] =
99 /* written, cold -> hot */
100 objc_cat_cls_meth_section,
101 objc_cat_inst_meth_section,
102 objc_string_object_section,
103 objc_constant_string_object_section,
104 objc_selector_refs_section,
105 objc_selector_fixup_section,
106 objc_cls_refs_section,
108 objc_meta_class_section,
109 /* shared, hot -> cold */
110 objc_cls_meth_section,
111 objc_inst_meth_section,
112 objc_protocol_section,
113 objc_class_names_section,
114 objc_meth_var_types_section,
115 objc_meth_var_names_section,
116 objc_category_section,
117 objc_class_vars_section,
118 objc_instance_vars_section,
119 objc_module_info_section,
125 for (i = 0; i < ARRAY_SIZE (tomark); i++)
126 switch_to_section (darwin_sections[tomark[i]]);
128 output_section_asm_op (directive);
131 /* Implement TARGET_ASM_INIT_SECTIONS. */
134 darwin_init_sections (void)
136 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
137 darwin_sections[NAME] = \
138 get_unnamed_section (FLAGS, (OBJC \
139 ? output_objc_section_asm_op \
140 : output_section_asm_op), \
142 #include "config/darwin-sections.def"
145 readonly_data_section = darwin_sections[const_section];
146 exception_section = darwin_sections[darwin_exception_section];
147 eh_frame_section = darwin_sections[darwin_eh_frame_section];
151 name_needs_quotes (const char *name)
154 while ((c = *name++) != '\0')
155 if (! ISIDNUM (c) && c != '.' && c != '$')
160 /* Return true if SYM_REF can be used without an indirection. */
162 machopic_symbol_defined_p (rtx sym_ref)
164 if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
167 /* If a symbol references local and is not an extern to this
168 file, then the symbol might be able to declared as defined. */
169 if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
171 /* If the symbol references a variable and the variable is a
172 common symbol, then this symbol is not defined. */
173 if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
175 tree decl = SYMBOL_REF_DECL (sym_ref);
178 if (DECL_COMMON (decl))
186 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
187 reference, which will not be changed. */
189 enum machopic_addr_class
190 machopic_classify_symbol (rtx sym_ref)
194 function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
195 if (machopic_symbol_defined_p (sym_ref))
197 ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
200 ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
203 #ifndef TARGET_FIX_AND_CONTINUE
204 #define TARGET_FIX_AND_CONTINUE 0
207 /* Indicate when fix-and-continue style code generation is being used
208 and when a reference to data should be indirected so that it can be
209 rebound in a new translation unit to reference the original instance
210 of that data. Symbol names that are for code generation local to
211 the translation unit are bound to the new translation unit;
212 currently this means symbols that begin with L or _OBJC_;
213 otherwise, we indicate that an indirect reference should be made to
214 permit the runtime to rebind new instances of the translation unit
215 to the original instance of the data. */
218 indirect_data (rtx sym_ref)
223 /* If we aren't generating fix-and-continue code, don't do anything
225 if (TARGET_FIX_AND_CONTINUE == 0)
228 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
229 are indirected. Symbols that begin with L and _OBJC_ are always
230 bound to the current translation unit as they are used for
231 generated local data of the translation unit. */
233 name = XSTR (sym_ref, 0);
235 lprefix = (((name[0] == '*' || name[0] == '&')
236 && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
237 || (strncmp (name, "_OBJC_", 6) == 0));
244 machopic_data_defined_p (rtx sym_ref)
246 if (indirect_data (sym_ref))
249 switch (machopic_classify_symbol (sym_ref))
251 case MACHOPIC_DEFINED_DATA:
252 case MACHOPIC_DEFINED_FUNCTION:
260 machopic_define_symbol (rtx mem)
264 gcc_assert (GET_CODE (mem) == MEM);
265 sym_ref = XEXP (mem, 0);
266 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
269 /* Return either ORIG or:
271 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
273 depending on MACHO_DYNAMIC_NO_PIC_P. */
275 machopic_gen_offset (rtx orig)
277 if (MACHO_DYNAMIC_NO_PIC_P)
281 /* Play games to avoid marking the function as needing pic if we
282 are being called as part of the cost-estimation process. */
283 if (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)
284 crtl->uses_pic_offset_table = 1;
285 orig = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig),
286 UNSPEC_MACHOPIC_OFFSET);
287 return gen_rtx_CONST (Pmode, orig);
291 static GTY(()) const char * function_base_func_name;
292 static GTY(()) int current_pic_label_num;
295 machopic_output_function_base_name (FILE *file)
297 const char *current_name;
299 /* If dynamic-no-pic is on, we should not get here. */
300 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
302 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
303 if (function_base_func_name != current_name)
305 ++current_pic_label_num;
306 function_base_func_name = current_name;
308 fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
311 /* The suffix attached to non-lazy pointer symbols. */
312 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
313 /* The suffix attached to stub symbols. */
314 #define STUB_SUFFIX "$stub"
316 typedef struct GTY (()) machopic_indirection
318 /* The SYMBOL_REF for the entity referenced. */
320 /* The name of the stub or non-lazy pointer. */
321 const char * ptr_name;
322 /* True iff this entry is for a stub (as opposed to a non-lazy
325 /* True iff this stub or pointer pointer has been referenced. */
327 } machopic_indirection;
329 /* A table mapping stub names and non-lazy pointer names to
330 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
332 static GTY ((param_is (struct machopic_indirection))) htab_t
333 machopic_indirections;
335 /* Return a hash value for a SLOT in the indirections hash table. */
338 machopic_indirection_hash (const void *slot)
340 const machopic_indirection *p = (const machopic_indirection *) slot;
341 return htab_hash_string (p->ptr_name);
344 /* Returns true if the KEY is the same as that associated with
348 machopic_indirection_eq (const void *slot, const void *key)
350 return strcmp (((const machopic_indirection *) slot)->ptr_name,
351 (const char *) key) == 0;
354 /* Return the name of the non-lazy pointer (if STUB_P is false) or
355 stub (if STUB_B is true) corresponding to the given name. */
358 machopic_indirection_name (rtx sym_ref, bool stub_p)
361 const char *name = XSTR (sym_ref, 0);
362 size_t namelen = strlen (name);
363 machopic_indirection *p;
367 const char *prefix = user_label_prefix;
368 const char *quote = "";
371 id = maybe_get_identifier (name);
376 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
377 id = TREE_CHAIN (id);
380 name = IDENTIFIER_POINTER (id);
381 namelen = strlen (name);
392 needs_quotes = name_needs_quotes (name);
399 suffix = STUB_SUFFIX;
401 suffix = NON_LAZY_POINTER_SUFFIX;
403 buffer = XALLOCAVEC (char, strlen ("&L")
410 /* Construct the name of the non-lazy pointer or stub. */
411 sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
413 if (!machopic_indirections)
414 machopic_indirections = htab_create_ggc (37,
415 machopic_indirection_hash,
416 machopic_indirection_eq,
419 slot = htab_find_slot_with_hash (machopic_indirections, buffer,
420 htab_hash_string (buffer), INSERT);
423 p = (machopic_indirection *) *slot;
427 p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
429 p->ptr_name = xstrdup (buffer);
438 /* Return the name of the stub for the mcount function. */
441 machopic_mcount_stub_name (void)
443 rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
444 return machopic_indirection_name (symbol, /*stub_p=*/true);
447 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
448 or non-lazy pointer as used -- and mark the object to which the
449 pointer/stub refers as used as well, since the pointer/stub will
450 emit a reference to it. */
453 machopic_validate_stub_or_non_lazy_ptr (const char *name)
455 machopic_indirection *p;
457 p = ((machopic_indirection *)
458 (htab_find_with_hash (machopic_indirections, name,
459 htab_hash_string (name))));
462 const char *real_name;
467 /* Do what output_addr_const will do when we actually call it. */
468 if (SYMBOL_REF_DECL (p->symbol))
469 mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
471 real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
473 id = maybe_get_identifier (real_name);
475 mark_referenced (id);
479 /* Transform ORIG, which may be any data source, to the corresponding
480 source using indirections. */
483 machopic_indirect_data_reference (rtx orig, rtx reg)
487 if (! MACHOPIC_INDIRECT)
490 if (GET_CODE (orig) == SYMBOL_REF)
492 int defined = machopic_data_defined_p (orig);
494 if (defined && MACHO_DYNAMIC_NO_PIC_P)
496 #if defined (TARGET_TOC)
497 /* Create a new register for CSE opportunities. */
498 rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));
499 emit_insn (gen_macho_high (hi_reg, orig));
500 emit_insn (gen_macho_low (reg, hi_reg, orig));
502 /* some other cpu -- writeme! */
509 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
510 rtx offset = machopic_gen_offset (orig);
513 #if defined (TARGET_TOC) /* i.e., PowerPC */
514 rtx hi_sum_reg = (!can_create_pseudo_p ()
516 : gen_reg_rtx (Pmode));
520 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
521 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
522 gen_rtx_HIGH (Pmode, offset))));
523 emit_insn (gen_rtx_SET (Pmode, reg,
524 gen_rtx_LO_SUM (Pmode, hi_sum_reg,
525 copy_rtx (offset))));
529 #if defined (HAVE_lo_sum)
532 emit_insn (gen_rtx_SET (VOIDmode, reg,
533 gen_rtx_HIGH (Pmode, offset)));
534 emit_insn (gen_rtx_SET (VOIDmode, reg,
535 gen_rtx_LO_SUM (Pmode, reg,
536 copy_rtx (offset))));
537 emit_use (pic_offset_table_rtx);
539 orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
545 ptr_ref = (gen_rtx_SYMBOL_REF
547 machopic_indirection_name (orig, /*stub_p=*/false)));
549 SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
551 ptr_ref = gen_const_mem (Pmode, ptr_ref);
552 machopic_define_symbol (ptr_ref);
556 else if (GET_CODE (orig) == CONST)
560 /* legitimize both operands of the PLUS */
561 if (GET_CODE (XEXP (orig, 0)) == PLUS)
563 base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
565 orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
566 (base == reg ? 0 : reg));
571 if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
572 result = plus_constant (base, INTVAL (orig));
574 result = gen_rtx_PLUS (Pmode, base, orig);
576 if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
580 emit_move_insn (reg, result);
585 result = force_reg (GET_MODE (result), result);
592 else if (GET_CODE (orig) == MEM)
593 XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
594 /* When the target is i386, this code prevents crashes due to the
595 compiler's ignorance on how to move the PIC base register to
596 other registers. (The reload phase sometimes introduces such
598 else if (GET_CODE (orig) == PLUS
599 && GET_CODE (XEXP (orig, 0)) == REG
600 && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
602 /* Prevent the same register from being erroneously used
603 as both the base and index registers. */
604 && GET_CODE (XEXP (orig, 1)) == CONST
608 emit_move_insn (reg, XEXP (orig, 0));
609 XEXP (ptr_ref, 0) = reg;
614 /* Transform TARGET (a MEM), which is a function call target, to the
615 corresponding symbol_stub if necessary. Return a new MEM. */
618 machopic_indirect_call_target (rtx target)
620 if (GET_CODE (target) != MEM)
623 if (MACHOPIC_INDIRECT
624 && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
625 && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
626 & MACHO_SYMBOL_FLAG_DEFINED))
628 rtx sym_ref = XEXP (target, 0);
629 const char *stub_name = machopic_indirection_name (sym_ref,
631 enum machine_mode mode = GET_MODE (sym_ref);
633 XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
634 SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
635 MEM_READONLY_P (target) = 1;
636 MEM_NOTRAP_P (target) = 1;
643 machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
647 if (! MACHOPIC_INDIRECT)
650 /* First handle a simple SYMBOL_REF or LABEL_REF */
651 if (GET_CODE (orig) == LABEL_REF
652 || (GET_CODE (orig) == SYMBOL_REF
655 /* addr(foo) = &func+(foo-func) */
656 orig = machopic_indirect_data_reference (orig, reg);
658 if (GET_CODE (orig) == PLUS
659 && GET_CODE (XEXP (orig, 0)) == REG)
662 return force_reg (mode, orig);
664 emit_move_insn (reg, orig);
668 if (GET_CODE (orig) == MEM)
672 gcc_assert (!reload_in_progress);
673 reg = gen_reg_rtx (Pmode);
677 if (MACHO_DYNAMIC_NO_PIC_P
678 && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
679 || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
681 #if defined (TARGET_TOC) /* ppc */
682 rtx temp_reg = (!can_create_pseudo_p ()
684 gen_reg_rtx (Pmode));
685 rtx asym = XEXP (orig, 0);
688 emit_insn (gen_macho_high (temp_reg, asym));
689 mem = gen_const_mem (GET_MODE (orig),
690 gen_rtx_LO_SUM (Pmode, temp_reg,
692 emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
694 /* Some other CPU -- WriteMe! but right now there are no other
695 platforms that can use dynamic-no-pic */
701 if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
702 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
704 rtx offset = machopic_gen_offset (XEXP (orig, 0));
705 #if defined (TARGET_TOC) /* i.e., PowerPC */
706 /* Generating a new reg may expose opportunities for
707 common subexpression elimination. */
708 rtx hi_sum_reg = (!can_create_pseudo_p ()
710 : gen_reg_rtx (Pmode));
715 sum = gen_rtx_HIGH (Pmode, offset);
716 if (! MACHO_DYNAMIC_NO_PIC_P)
717 sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
719 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
721 mem = gen_const_mem (GET_MODE (orig),
722 gen_rtx_LO_SUM (Pmode,
725 insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
726 set_unique_reg_note (insn, REG_EQUAL, pic_ref);
730 emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
732 emit_insn (gen_rtx_SET (VOIDmode, reg,
734 gen_rtx_CONST (Pmode,
736 emit_insn (gen_rtx_SET (VOIDmode, reg,
737 gen_rtx_LO_SUM (Pmode, reg,
738 gen_rtx_CONST (Pmode,
739 copy_rtx (offset)))));
740 pic_ref = gen_rtx_PLUS (Pmode,
741 pic_offset_table_rtx, reg);
745 #endif /* HAVE_lo_sum */
747 rtx pic = pic_offset_table_rtx;
748 if (GET_CODE (pic) != REG)
750 emit_move_insn (reg, pic);
754 emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
757 if (reload_in_progress)
758 df_set_regs_ever_live (REGNO (pic), true);
759 pic_ref = gen_rtx_PLUS (Pmode, pic,
760 machopic_gen_offset (XEXP (orig, 0)));
763 #if !defined (TARGET_TOC)
764 emit_move_insn (reg, pic_ref);
765 pic_ref = gen_const_mem (GET_MODE (orig), reg);
772 if (GET_CODE (orig) == SYMBOL_REF
773 || GET_CODE (orig) == LABEL_REF)
775 rtx offset = machopic_gen_offset (orig);
776 #if defined (TARGET_TOC) /* i.e., PowerPC */
781 gcc_assert (!reload_in_progress);
782 reg = gen_reg_rtx (Pmode);
787 emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
788 (MACHO_DYNAMIC_NO_PIC_P)
789 ? gen_rtx_HIGH (Pmode, offset)
790 : gen_rtx_PLUS (Pmode,
791 pic_offset_table_rtx,
794 emit_insn (gen_rtx_SET (VOIDmode, reg,
795 gen_rtx_LO_SUM (Pmode,
797 copy_rtx (offset))));
800 emit_insn (gen_rtx_SET (VOIDmode, reg,
801 gen_rtx_HIGH (Pmode, offset)));
802 emit_insn (gen_rtx_SET (VOIDmode, reg,
803 gen_rtx_LO_SUM (Pmode, reg,
804 copy_rtx (offset))));
805 pic_ref = gen_rtx_PLUS (Pmode,
806 pic_offset_table_rtx, reg);
810 #endif /* HAVE_lo_sum */
813 || GET_CODE (orig) == SUBREG)
819 rtx pic = pic_offset_table_rtx;
820 if (GET_CODE (pic) != REG)
822 emit_move_insn (reg, pic);
826 emit_use (pic_offset_table_rtx);
828 if (reload_in_progress)
829 df_set_regs_ever_live (REGNO (pic), true);
830 pic_ref = gen_rtx_PLUS (Pmode,
832 machopic_gen_offset (orig));
837 if (GET_CODE (pic_ref) != REG)
841 emit_move_insn (reg, pic_ref);
846 return force_reg (mode, pic_ref);
855 else if (GET_CODE (orig) == SYMBOL_REF)
858 else if (GET_CODE (orig) == PLUS
859 && (GET_CODE (XEXP (orig, 0)) == MEM
860 || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
861 || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
862 && XEXP (orig, 0) != pic_offset_table_rtx
863 && GET_CODE (XEXP (orig, 1)) != REG)
867 int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
869 base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
870 orig = machopic_legitimize_pic_address (XEXP (orig, 1),
871 Pmode, (base == reg ? 0 : reg));
872 if (GET_CODE (orig) == CONST_INT)
874 pic_ref = plus_constant (base, INTVAL (orig));
878 pic_ref = gen_rtx_PLUS (Pmode, base, orig);
880 if (reg && is_complex)
882 emit_move_insn (reg, pic_ref);
885 /* Likewise, should we set special REG_NOTEs here? */
888 else if (GET_CODE (orig) == CONST)
890 return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
893 else if (GET_CODE (orig) == MEM
894 && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
896 rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
897 addr = replace_equiv_address (orig, addr);
898 emit_move_insn (reg, addr);
905 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
906 DATA is the FILE* for assembly output. Called from
910 machopic_output_indirection (void **slot, void *data)
912 machopic_indirection *p = *((machopic_indirection **) slot);
913 FILE *asm_out_file = (FILE *) data;
915 const char *sym_name;
916 const char *ptr_name;
922 sym_name = XSTR (symbol, 0);
923 ptr_name = p->ptr_name;
931 id = maybe_get_identifier (sym_name);
936 while (IDENTIFIER_TRANSPARENT_ALIAS (id))
937 id = TREE_CHAIN (id);
939 sym_name = IDENTIFIER_POINTER (id);
942 sym = XALLOCAVEC (char, strlen (sym_name) + 2);
943 if (sym_name[0] == '*' || sym_name[0] == '&')
944 strcpy (sym, sym_name + 1);
945 else if (sym_name[0] == '-' || sym_name[0] == '+')
946 strcpy (sym, sym_name);
948 sprintf (sym, "%s%s", user_label_prefix, sym_name);
950 stub = XALLOCAVEC (char, strlen (ptr_name) + 2);
951 if (ptr_name[0] == '*' || ptr_name[0] == '&')
952 strcpy (stub, ptr_name + 1);
954 sprintf (stub, "%s%s", user_label_prefix, ptr_name);
956 machopic_output_stub (asm_out_file, sym, stub);
958 else if (! indirect_data (symbol)
959 && (machopic_symbol_defined_p (symbol)
960 || SYMBOL_REF_LOCAL_P (symbol)))
962 switch_to_section (data_section);
963 assemble_align (GET_MODE_ALIGNMENT (Pmode));
964 assemble_label (ptr_name);
965 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
966 GET_MODE_SIZE (Pmode),
967 GET_MODE_ALIGNMENT (Pmode), 1);
971 rtx init = const0_rtx;
973 switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
975 /* Mach-O symbols are passed around in code through indirect
976 references and the original symbol_ref hasn't passed through
977 the generic handling and reference-catching in
978 output_operand, so we need to manually mark weak references
980 if (SYMBOL_REF_WEAK (symbol))
982 tree decl = SYMBOL_REF_DECL (symbol);
983 gcc_assert (DECL_P (decl));
985 if (decl != NULL_TREE
986 && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
987 /* Handle only actual external-only definitions, not
988 e.g. extern inline code or variables for which
989 storage has been allocated. */
990 && !TREE_STATIC (decl))
992 fputs ("\t.weak_reference ", asm_out_file);
993 assemble_name (asm_out_file, sym_name);
994 fputc ('\n', asm_out_file);
998 assemble_name (asm_out_file, ptr_name);
999 fprintf (asm_out_file, ":\n");
1001 fprintf (asm_out_file, "\t.indirect_symbol ");
1002 assemble_name (asm_out_file, sym_name);
1003 fprintf (asm_out_file, "\n");
1005 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1006 have their symbol name instead of 0 in the second entry of
1007 the non-lazy symbol pointer data structure when they are
1008 defined. This allows the runtime to rebind newer instances
1009 of the translation unit with the original instance of the
1012 if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
1013 && machopic_symbol_defined_p (symbol))
1014 init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
1016 assemble_integer (init, GET_MODE_SIZE (Pmode),
1017 GET_MODE_ALIGNMENT (Pmode), 1);
1024 machopic_finish (FILE *asm_out_file)
1026 if (machopic_indirections)
1027 htab_traverse_noresize (machopic_indirections,
1028 machopic_output_indirection,
1033 machopic_operand_p (rtx op)
1035 if (MACHOPIC_JUST_INDIRECT)
1036 return (GET_CODE (op) == SYMBOL_REF
1037 && machopic_symbol_defined_p (op));
1039 return (GET_CODE (op) == CONST
1040 && GET_CODE (XEXP (op, 0)) == UNSPEC
1041 && XINT (XEXP (op, 0), 1) == UNSPEC_MACHOPIC_OFFSET);
1044 /* This function records whether a given name corresponds to a defined
1045 or undefined function or variable, for machopic_classify_ident to
1049 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
1053 /* Do the standard encoding things first. */
1054 default_encode_section_info (decl, rtl, first);
1056 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
1059 sym_ref = XEXP (rtl, 0);
1060 if (TREE_CODE (decl) == VAR_DECL)
1061 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
1063 if (!DECL_EXTERNAL (decl)
1064 && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
1065 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
1066 && ((TREE_STATIC (decl)
1067 && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
1068 || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
1069 && DECL_INITIAL (decl) != error_mark_node)))
1070 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
1072 if (! TREE_PUBLIC (decl))
1073 SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
1077 darwin_mark_decl_preserved (const char *name)
1079 fprintf (asm_out_file, ".no_dead_strip ");
1080 assemble_name (asm_out_file, name);
1081 fputc ('\n', asm_out_file);
1085 darwin_text_section (int reloc, int weak)
1089 ? darwin_sections[text_unlikely_coal_section]
1090 : unlikely_text_section ());
1093 ? darwin_sections[text_coal_section]
1098 darwin_rodata_section (int weak)
1101 ? darwin_sections[const_coal_section]
1102 : darwin_sections[const_section]);
1106 darwin_mergeable_string_section (tree exp,
1107 unsigned HOST_WIDE_INT align)
1109 if (flag_merge_constants
1110 && TREE_CODE (exp) == STRING_CST
1111 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1113 && (int_size_in_bytes (TREE_TYPE (exp))
1114 == TREE_STRING_LENGTH (exp))
1115 && ((size_t) TREE_STRING_LENGTH (exp)
1116 == strlen (TREE_STRING_POINTER (exp)) + 1))
1117 return darwin_sections[cstring_section];
1119 return readonly_data_section;
1122 #ifndef HAVE_GAS_LITERAL16
1123 #define HAVE_GAS_LITERAL16 0
1127 darwin_mergeable_constant_section (tree exp,
1128 unsigned HOST_WIDE_INT align)
1130 enum machine_mode mode = DECL_MODE (exp);
1131 unsigned int modesize = GET_MODE_BITSIZE (mode);
1133 if (flag_merge_constants
1136 && modesize <= align
1139 && (align & (align -1)) == 0)
1141 tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1143 if (TREE_CODE (size) == INTEGER_CST
1144 && TREE_INT_CST_LOW (size) == 4
1145 && TREE_INT_CST_HIGH (size) == 0)
1146 return darwin_sections[literal4_section];
1147 else if (TREE_CODE (size) == INTEGER_CST
1148 && TREE_INT_CST_LOW (size) == 8
1149 && TREE_INT_CST_HIGH (size) == 0)
1150 return darwin_sections[literal8_section];
1151 else if (HAVE_GAS_LITERAL16
1153 && TREE_CODE (size) == INTEGER_CST
1154 && TREE_INT_CST_LOW (size) == 16
1155 && TREE_INT_CST_HIGH (size) == 0)
1156 return darwin_sections[literal16_section];
1158 return readonly_data_section;
1161 return readonly_data_section;
1165 machopic_reloc_rw_mask (void)
1167 return MACHOPIC_INDIRECT ? 3 : 0;
1171 machopic_select_section (tree decl,
1173 unsigned HOST_WIDE_INT align)
1175 bool weak = (DECL_P (decl)
1177 && !lookup_attribute ("weak_import",
1178 DECL_ATTRIBUTES (decl)));
1179 section *base_section;
1181 switch (categorize_decl_for_section (decl, reloc))
1184 base_section = darwin_text_section (reloc, weak);
1188 case SECCAT_SRODATA:
1189 base_section = darwin_rodata_section (weak);
1192 case SECCAT_RODATA_MERGE_STR:
1193 base_section = darwin_mergeable_string_section (decl, align);
1196 case SECCAT_RODATA_MERGE_STR_INIT:
1197 base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1200 case SECCAT_RODATA_MERGE_CONST:
1201 base_section = darwin_mergeable_constant_section (decl, align);
1205 case SECCAT_DATA_REL:
1206 case SECCAT_DATA_REL_LOCAL:
1207 case SECCAT_DATA_REL_RO:
1208 case SECCAT_DATA_REL_RO_LOCAL:
1214 if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1215 base_section = weak ? darwin_sections[const_data_coal_section]
1216 : darwin_sections[const_data_section];
1218 base_section = weak ? darwin_sections[data_coal_section] : data_section;
1225 /* Darwin weird special cases. */
1226 if (TREE_CODE (decl) == CONSTRUCTOR
1228 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1229 && TYPE_NAME (TREE_TYPE (decl)))
1231 tree name = TYPE_NAME (TREE_TYPE (decl));
1232 if (TREE_CODE (name) == TYPE_DECL)
1233 name = DECL_NAME (name);
1235 if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1237 if (flag_next_runtime)
1238 return darwin_sections[objc_constant_string_object_section];
1240 return darwin_sections[objc_string_object_section];
1243 return base_section;
1245 else if (TREE_CODE (decl) == VAR_DECL
1247 && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1248 && IDENTIFIER_POINTER (DECL_NAME (decl))
1249 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1251 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1253 if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1254 return darwin_sections[objc_cls_meth_section];
1255 else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1256 return darwin_sections[objc_inst_meth_section];
1257 else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1258 return darwin_sections[objc_cat_cls_meth_section];
1259 else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1260 return darwin_sections[objc_cat_inst_meth_section];
1261 else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1262 return darwin_sections[objc_class_vars_section];
1263 else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1264 return darwin_sections[objc_instance_vars_section];
1265 else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1266 return darwin_sections[objc_cat_cls_meth_section];
1267 else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1268 return darwin_sections[objc_class_names_section];
1269 else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1270 return darwin_sections[objc_meth_var_names_section];
1271 else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1272 return darwin_sections[objc_meth_var_types_section];
1273 else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1274 return darwin_sections[objc_cls_refs_section];
1275 else if (!strncmp (name, "_OBJC_CLASS_", 12))
1276 return darwin_sections[objc_class_section];
1277 else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1278 return darwin_sections[objc_meta_class_section];
1279 else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1280 return darwin_sections[objc_category_section];
1281 else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1282 return darwin_sections[objc_selector_refs_section];
1283 else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1284 return darwin_sections[objc_selector_fixup_section];
1285 else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1286 return darwin_sections[objc_symbols_section];
1287 else if (!strncmp (name, "_OBJC_MODULES", 13))
1288 return darwin_sections[objc_module_info_section];
1289 else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1290 return darwin_sections[objc_image_info_section];
1291 else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1292 return darwin_sections[objc_cat_inst_meth_section];
1293 else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1294 return darwin_sections[objc_cat_cls_meth_section];
1295 else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1296 return darwin_sections[objc_cat_cls_meth_section];
1297 else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1298 return darwin_sections[objc_protocol_section];
1300 return base_section;
1303 return base_section;
1306 /* This can be called with address expressions as "rtx".
1307 They must go in "const". */
1310 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1311 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1313 if (GET_MODE_SIZE (mode) == 8
1314 && (GET_CODE (x) == CONST_INT
1315 || GET_CODE (x) == CONST_DOUBLE))
1316 return darwin_sections[literal8_section];
1317 else if (GET_MODE_SIZE (mode) == 4
1318 && (GET_CODE (x) == CONST_INT
1319 || GET_CODE (x) == CONST_DOUBLE))
1320 return darwin_sections[literal4_section];
1321 else if (HAVE_GAS_LITERAL16
1323 && GET_MODE_SIZE (mode) == 16
1324 && (GET_CODE (x) == CONST_INT
1325 || GET_CODE (x) == CONST_DOUBLE
1326 || GET_CODE (x) == CONST_VECTOR))
1327 return darwin_sections[literal16_section];
1328 else if (MACHOPIC_INDIRECT
1329 && (GET_CODE (x) == SYMBOL_REF
1330 || GET_CODE (x) == CONST
1331 || GET_CODE (x) == LABEL_REF))
1332 return darwin_sections[const_data_section];
1334 return darwin_sections[const_section];
1338 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1340 if (MACHOPIC_INDIRECT)
1341 switch_to_section (darwin_sections[mod_init_section]);
1343 switch_to_section (darwin_sections[constructor_section]);
1344 assemble_align (POINTER_SIZE);
1345 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1347 if (! MACHOPIC_INDIRECT)
1348 fprintf (asm_out_file, ".reference .constructors_used\n");
1352 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1354 if (MACHOPIC_INDIRECT)
1355 switch_to_section (darwin_sections[mod_term_section]);
1357 switch_to_section (darwin_sections[destructor_section]);
1358 assemble_align (POINTER_SIZE);
1359 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1361 if (! MACHOPIC_INDIRECT)
1362 fprintf (asm_out_file, ".reference .destructors_used\n");
1366 darwin_globalize_label (FILE *stream, const char *name)
1368 if (!!strncmp (name, "_OBJC_", 6))
1369 default_globalize_label (stream, name);
1372 /* This routine returns non-zero if 'name' starts with the special objective-c
1373 anonymous file-scope static name. It accommodates c++'s mangling of such
1374 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1377 darwin_label_is_anonymous_local_objc_name (const char *name)
1379 const unsigned char *p = (const unsigned char *) name;
1382 if (p[1] == 'Z' && p[2] == 'L')
1385 while (*p >= '0' && *p <= '9')
1388 return (!strncmp ((const char *)p, "_OBJC_", 6));
1391 /* LTO support for Mach-O. */
1393 /* Section names for LTO sections. */
1394 static unsigned int lto_section_names_offset = 0;
1396 /* This is the obstack which we use to allocate the many strings. */
1397 static struct obstack lto_section_names_obstack;
1399 /* Segment name for LTO sections. */
1400 #define LTO_SEGMENT_NAME "__GNU_LTO"
1402 /* Section name for LTO section names section. */
1403 #define LTO_NAMES_SECTION "__section_names"
1405 /* File to temporarily store LTO data. This is appended to asm_out_file
1406 in darwin_end_file. */
1407 static FILE *lto_asm_out_file, *saved_asm_out_file;
1408 static char *lto_asm_out_name;
1410 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
1411 asm_out_file and switching to an alternative output file. */
1413 darwin_asm_lto_start (void)
1415 gcc_assert (! saved_asm_out_file);
1416 saved_asm_out_file = asm_out_file;
1417 if (! lto_asm_out_name)
1418 lto_asm_out_name = make_temp_file (".lto.s");
1419 lto_asm_out_file = fopen (lto_asm_out_name, "a");
1420 if (lto_asm_out_file == NULL)
1421 fatal_error ("failed to open temporary file %s for LTO output",
1423 asm_out_file = lto_asm_out_file;
1426 /* Restore asm_out_file. */
1428 darwin_asm_lto_end (void)
1430 gcc_assert (saved_asm_out_file);
1431 fclose (lto_asm_out_file);
1432 asm_out_file = saved_asm_out_file;
1433 saved_asm_out_file = NULL;
1437 darwin_asm_named_section (const char *name,
1439 tree decl ATTRIBUTE_UNUSED)
1441 /* LTO sections go in a special segment __GNU_LTO. We want to replace the
1442 section name with something we can use to represent arbitrary-length
1443 names (section names in Mach-O are at most 16 characters long). */
1444 if (strncmp (name, LTO_SECTION_NAME_PREFIX,
1445 strlen (LTO_SECTION_NAME_PREFIX)) == 0)
1447 /* We expect certain flags to be set... */
1448 gcc_assert ((flags & (SECTION_DEBUG | SECTION_NAMED))
1449 == (SECTION_DEBUG | SECTION_NAMED));
1451 /* Add the section name to the things to output when we end the
1452 current assembler output file.
1453 This is all not very efficient, but that doesn't matter -- this
1454 shouldn't be a hot path in the compiler... */
1455 obstack_1grow (<o_section_names_obstack, '\t');
1456 obstack_grow (<o_section_names_obstack, ".ascii ", 7);
1457 obstack_1grow (<o_section_names_obstack, '"');
1458 obstack_grow (<o_section_names_obstack, name, strlen (name));
1459 obstack_grow (<o_section_names_obstack, "\\0\"\n", 4);
1461 /* Output the dummy section name. */
1462 fprintf (asm_out_file, "\t# %s\n", name);
1463 fprintf (asm_out_file, "\t.section %s,__%08X,regular,debug\n",
1464 LTO_SEGMENT_NAME, lto_section_names_offset);
1466 /* Update the offset for the next section name. Make sure we stay
1467 within reasonable length. */
1468 lto_section_names_offset += strlen (name) + 1;
1469 gcc_assert (lto_section_names_offset > 0
1470 && lto_section_names_offset < ((unsigned) 1 << 31));
1473 fprintf (asm_out_file, "\t.section %s\n", name);
1477 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1479 /* Darwin does not use unique sections. */
1482 /* Handle __attribute__ ((apple_kext_compatibility)).
1483 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1484 vtable for classes with this attribute (and their descendants) by not
1485 outputting the new 3.0 nondeleting destructor. This means that such
1486 objects CANNOT be allocated on the stack or as globals UNLESS they have
1487 a completely empty `operator delete'.
1488 Luckily, this fits in with the Darwin kext model.
1490 This attribute also disables gcc3's potential overlaying of derived
1491 class data members on the padding at the end of the base class. */
1494 darwin_handle_kext_attribute (tree *node, tree name,
1495 tree args ATTRIBUTE_UNUSED,
1496 int flags ATTRIBUTE_UNUSED,
1499 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1500 if (! TARGET_KEXTABI)
1502 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1503 "only when compiling a kext", name);
1505 *no_add_attrs = true;
1507 else if (TREE_CODE (*node) != RECORD_TYPE)
1509 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1510 "only to C++ classes", name);
1512 *no_add_attrs = true;
1518 /* Handle a "weak_import" attribute; arguments as in
1519 struct attribute_spec.handler. */
1522 darwin_handle_weak_import_attribute (tree *node, tree name,
1523 tree ARG_UNUSED (args),
1524 int ARG_UNUSED (flags),
1525 bool * no_add_attrs)
1527 if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1529 warning (OPT_Wattributes, "%qE attribute ignored",
1531 *no_add_attrs = true;
1534 declare_weak (*node);
1539 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1540 The third parameter is nonzero if this is for exception handling.
1541 The fourth parameter is nonzero if this is just a placeholder for an
1542 FDE that we are omitting. */
1545 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1552 lab = concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), ".eh", NULL);
1554 if (TREE_PUBLIC (decl))
1556 targetm.asm_out.globalize_label (file, lab);
1557 if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN)
1559 fputs ("\t.private_extern ", file);
1560 assemble_name (file, lab);
1565 if (DECL_WEAK (decl))
1567 fputs ("\t.weak_definition ", file);
1568 assemble_name (file, lab);
1572 assemble_name (file, lab);
1575 fputs (" = 0\n", file);
1577 /* Mark the absolute .eh and .eh1 style labels as needed to
1578 ensure that we don't dead code strip them and keep such
1579 labels from another instantiation point until we can fix this
1580 properly with group comdat support. */
1581 darwin_mark_decl_preserved (lab);
1584 fputs (":\n", file);
1589 static GTY(()) unsigned long except_table_label_num;
1592 darwin_emit_except_table_label (FILE *file)
1594 char section_start_label[30];
1596 ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1597 except_table_label_num++);
1598 ASM_OUTPUT_LABEL (file, section_start_label);
1600 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1603 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1605 const char *nlp_name;
1607 gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1609 nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1610 fputs ("\t.long\t", file);
1611 ASM_OUTPUT_LABELREF (file, nlp_name);
1615 /* Emit an assembler directive to set visibility for a symbol. The
1616 only supported visibilities are VISIBILITY_DEFAULT and
1617 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1618 extern". There is no MACH-O equivalent of ELF's
1619 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1622 darwin_assemble_visibility (tree decl, int vis)
1624 if (vis == VISIBILITY_DEFAULT)
1626 else if (vis == VISIBILITY_HIDDEN)
1628 fputs ("\t.private_extern ", asm_out_file);
1629 assemble_name (asm_out_file,
1630 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1631 fputs ("\n", asm_out_file);
1634 warning (OPT_Wattributes, "internal and protected visibility attributes "
1635 "not supported in this configuration; ignored");
1638 /* Output a difference of two labels that will be an assembly time
1639 constant if the two labels are local. (.long lab1-lab2 will be
1640 very different if lab1 is at the boundary between two sections; it
1641 will be relocated according to the second section, not the first,
1642 so one ends up with a difference between labels in different
1643 sections, which is bad in the dwarf2 eh context for instance.) */
1645 static int darwin_dwarf_label_counter;
1648 darwin_asm_output_dwarf_delta (FILE *file, int size,
1649 const char *lab1, const char *lab2)
1651 int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1652 && lab2[0] == '*' && lab2[1] == 'L');
1653 const char *directive = (size == 8 ? ".quad" : ".long");
1656 fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1658 fprintf (file, "\t%s\t", directive);
1659 assemble_name_raw (file, lab1);
1660 fprintf (file, "-");
1661 assemble_name_raw (file, lab2);
1663 fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1666 /* Output labels for the start of the DWARF sections if necessary.
1667 Initialize the stuff we need for LTO long section names support. */
1669 darwin_file_start (void)
1671 if (write_symbols == DWARF2_DEBUG)
1673 static const char * const debugnames[] =
1675 DEBUG_FRAME_SECTION,
1677 DEBUG_ABBREV_SECTION,
1678 DEBUG_ARANGES_SECTION,
1679 DEBUG_MACINFO_SECTION,
1682 DEBUG_PUBNAMES_SECTION,
1683 DEBUG_PUBTYPES_SECTION,
1685 DEBUG_RANGES_SECTION
1689 for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1693 switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1695 gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1696 gcc_assert (strchr (debugnames[i] + 8, ','));
1698 namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1699 fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1703 /* We fill this obstack with the complete section text for the lto section
1704 names to write in darwin_file_end. */
1705 obstack_init (<o_section_names_obstack);
1706 lto_section_names_offset = 0;
1709 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
1710 offsets are not represented using relocs in .o files; either the
1711 section never leaves the .o file, or the linker or other tool is
1712 responsible for parsing the DWARF and updating the offsets. */
1715 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1721 gcc_assert (base->common.flags & SECTION_NAMED);
1722 gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1723 gcc_assert (strchr (base->named.name + 8, ','));
1725 namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1726 sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1727 darwin_asm_output_dwarf_delta (file, size, lab, sname);
1731 darwin_file_end (void)
1733 const char *lto_section_names;
1735 machopic_finish (asm_out_file);
1736 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1738 switch_to_section (darwin_sections[constructor_section]);
1739 switch_to_section (darwin_sections[destructor_section]);
1740 ASM_OUTPUT_ALIGN (asm_out_file, 1);
1743 /* If there was LTO assembler output, append it to asm_out_file. */
1744 if (lto_asm_out_name)
1747 char *buf, *lto_asm_txt;
1749 /* Shouldn't be here if we failed to switch back. */
1750 gcc_assert (! saved_asm_out_file);
1752 lto_asm_out_file = fopen (lto_asm_out_name, "r");
1753 if (lto_asm_out_file == NULL)
1754 fatal_error ("failed to open temporary file %s with LTO output",
1756 fseek (lto_asm_out_file, 0, SEEK_END);
1757 n = ftell (lto_asm_out_file);
1760 fseek (lto_asm_out_file, 0, SEEK_SET);
1761 lto_asm_txt = buf = (char *) xmalloc (n + 1);
1762 while (fgets (lto_asm_txt, n, lto_asm_out_file))
1763 fputs (lto_asm_txt, asm_out_file);
1766 /* Remove the temporary file. */
1767 fclose (lto_asm_out_file);
1768 unlink_if_ordinary (lto_asm_out_name);
1769 free (lto_asm_out_name);
1772 /* Finish the LTO section names obstack. Don't output anything if
1773 there are no recorded section names. */
1774 obstack_1grow (<o_section_names_obstack, '\0');
1775 lto_section_names = XOBFINISH (<o_section_names_obstack, const char *);
1776 if (strlen (lto_section_names) > 0)
1778 fprintf (asm_out_file,
1779 "\t.section %s,%s,regular,debug\n",
1780 LTO_SEGMENT_NAME, LTO_NAMES_SECTION);
1781 fprintf (asm_out_file,
1782 "\t# Section names in %s are offsets into this table\n",
1784 fprintf (asm_out_file, "%s\n", lto_section_names);
1786 obstack_free (<o_section_names_obstack, NULL);
1788 fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1791 /* TODO: Add a language hook for identifying if a decl is a vtable. */
1792 #define DARWIN_VTABLE_P(DECL) 0
1794 /* Cross-module name binding. Darwin does not support overriding
1795 functions at dynamic-link time, except for vtables in kexts. */
1798 darwin_binds_local_p (const_tree decl)
1800 return default_binds_local_p_1 (decl,
1801 TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
1805 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet. */
1806 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
1807 anchor relative to ".", the current section position. We cannot use
1808 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
1811 darwin_asm_output_anchor (rtx symbol)
1813 fprintf (asm_out_file, "\t.set\t");
1814 assemble_name (asm_out_file, XSTR (symbol, 0));
1815 fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1816 SYMBOL_REF_BLOCK_OFFSET (symbol));
1820 /* Set the darwin specific attributes on TYPE. */
1822 darwin_set_default_type_attributes (tree type)
1824 if (darwin_ms_struct
1825 && TREE_CODE (type) == RECORD_TYPE)
1826 TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1828 TYPE_ATTRIBUTES (type));
1831 /* True, iff we're generating code for loadable kernel extensions. */
1834 darwin_kextabi_p (void) {
1835 return flag_apple_kext;
1839 darwin_override_options (void)
1841 /* Don't emit DWARF3/4 unless specifically selected. This is a
1842 workaround for tool bugs. */
1843 if (dwarf_strict < 0)
1846 /* Disable -freorder-blocks-and-partition for darwin_emit_unwind_label. */
1847 if (flag_reorder_blocks_and_partition
1848 && (targetm.asm_out.unwind_label == darwin_emit_unwind_label))
1850 inform (input_location,
1851 "-freorder-blocks-and-partition does not work with exceptions "
1852 "on this architecture");
1853 flag_reorder_blocks_and_partition = 0;
1854 flag_reorder_blocks = 1;
1857 if (flag_mkernel || flag_apple_kext)
1859 /* -mkernel implies -fapple-kext for C++ */
1860 if (strcmp (lang_hooks.name, "GNU C++") == 0)
1861 flag_apple_kext = 1;
1865 /* No EH in kexts. */
1866 flag_exceptions = 0;
1867 /* No -fnon-call-exceptions data in kexts. */
1868 flag_non_call_exceptions = 0;
1870 if (flag_var_tracking
1871 && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1872 && debug_info_level >= DINFO_LEVEL_NORMAL
1873 && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
1874 flag_var_tracking_uninit = 1;
1877 /* Add $LDBL128 suffix to long double builtins. */
1880 darwin_patch_builtin (int fncode)
1882 tree fn = built_in_decls[fncode];
1889 sym = DECL_ASSEMBLER_NAME (fn);
1890 newname = ACONCAT (("_", IDENTIFIER_POINTER (sym), "$LDBL128", NULL));
1892 set_user_assembler_name (fn, newname);
1894 fn = implicit_built_in_decls[fncode];
1896 set_user_assembler_name (fn, newname);
1900 darwin_patch_builtins (void)
1902 if (LONG_DOUBLE_TYPE_SIZE != 128)
1905 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
1906 #define PATCH_BUILTIN_NO64(fncode) \
1907 if (!TARGET_64BIT) \
1908 darwin_patch_builtin (fncode);
1909 #define PATCH_BUILTIN_VARIADIC(fncode) \
1911 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
1912 darwin_patch_builtin (fncode);
1913 #include "darwin-ppc-ldouble-patch.def"
1914 #undef PATCH_BUILTIN
1915 #undef PATCH_BUILTIN_NO64
1916 #undef PATCH_BUILTIN_VARIADIC
1920 #include "gt-darwin.h"