1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
4 Free Software Foundation, Inc.
5 Contributed by Apple Computer Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
35 #include "insn-attr.h"
42 #include "langhooks.h"
50 /* Darwin supports a feature called fix-and-continue, which is used
51 for rapid turn around debugging. When code is compiled with the
52 -mfix-and-continue flag, two changes are made to the generated code
53 that allow the system to do things that it would normally not be
54 able to do easily. These changes allow gdb to load in
55 recompilation of a translation unit that has been changed into a
56 running program and replace existing functions and methods of that
57 translation unit with versions of those functions and methods
58 from the newly compiled translation unit. The new functions access
59 the existing static symbols from the old translation unit, if the
60 symbol existed in the unit to be replaced, and from the new
61 translation unit, otherwise.
63 The changes are to insert 5 nops at the beginning of all functions
64 and to use indirection to get at static symbols. The 5 nops
65 are required by consumers of the generated code. Currently, gdb
66 uses this to patch in a jump to the overriding function, this
67 allows all uses of the old name to forward to the replacement,
68 including existing function pointers and virtual methods. See
69 rs6000_emit_prologue for the code that handles the nop insertions.
71 The added indirection allows gdb to redirect accesses to static
72 symbols from the newly loaded translation unit to the existing
73 symbol, if any. @code{static} symbols are special and are handled by
74 setting the second word in the .non_lazy_symbol_pointer data
75 structure to symbol. See indirect_data for the code that handles
76 the extra indirection, and machopic_output_indirection and its use
77 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
78 symbol indirection. */
81 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
83 /* True if we're setting __attribute__ ((ms_struct)). */
84 int darwin_ms_struct
= false;
86 /* A get_unnamed_section callback used to switch to an ObjC section.
87 DIRECTIVE is as for output_section_asm_op. */
90 output_objc_section_asm_op (const void *directive
)
92 static bool been_here
= false;
96 static const enum darwin_section_enum tomark
[] =
98 /* written, cold -> hot */
99 objc_cat_cls_meth_section
,
100 objc_cat_inst_meth_section
,
101 objc_string_object_section
,
102 objc_constant_string_object_section
,
103 objc_selector_refs_section
,
104 objc_selector_fixup_section
,
105 objc_cls_refs_section
,
107 objc_meta_class_section
,
108 /* shared, hot -> cold */
109 objc_cls_meth_section
,
110 objc_inst_meth_section
,
111 objc_protocol_section
,
112 objc_class_names_section
,
113 objc_meth_var_types_section
,
114 objc_meth_var_names_section
,
115 objc_category_section
,
116 objc_class_vars_section
,
117 objc_instance_vars_section
,
118 objc_module_info_section
,
124 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
125 switch_to_section (darwin_sections
[tomark
[i
]]);
127 output_section_asm_op (directive
);
130 /* Implement TARGET_ASM_INIT_SECTIONS. */
133 darwin_init_sections (void)
135 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
136 darwin_sections[NAME] = \
137 get_unnamed_section (FLAGS, (OBJC \
138 ? output_objc_section_asm_op \
139 : output_section_asm_op), \
141 #include "config/darwin-sections.def"
144 readonly_data_section
= darwin_sections
[const_section
];
145 exception_section
= darwin_sections
[darwin_exception_section
];
146 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
150 name_needs_quotes (const char *name
)
153 while ((c
= *name
++) != '\0')
154 if (! ISIDNUM (c
) && c
!= '.' && c
!= '$')
159 /* Return true if SYM_REF can be used without an indirection. */
161 machopic_symbol_defined_p (rtx sym_ref
)
163 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
166 /* If a symbol references local and is not an extern to this
167 file, then the symbol might be able to declared as defined. */
168 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
170 /* If the symbol references a variable and the variable is a
171 common symbol, then this symbol is not defined. */
172 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
174 tree decl
= SYMBOL_REF_DECL (sym_ref
);
177 if (DECL_COMMON (decl
))
185 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
186 reference, which will not be changed. */
188 enum machopic_addr_class
189 machopic_classify_symbol (rtx sym_ref
)
194 flags
= SYMBOL_REF_FLAGS (sym_ref
);
195 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
196 if (machopic_symbol_defined_p (sym_ref
))
198 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
201 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
204 #ifndef TARGET_FIX_AND_CONTINUE
205 #define TARGET_FIX_AND_CONTINUE 0
208 /* Indicate when fix-and-continue style code generation is being used
209 and when a reference to data should be indirected so that it can be
210 rebound in a new translation unit to reference the original instance
211 of that data. Symbol names that are for code generation local to
212 the translation unit are bound to the new translation unit;
213 currently this means symbols that begin with L or _OBJC_;
214 otherwise, we indicate that an indirect reference should be made to
215 permit the runtime to rebind new instances of the translation unit
216 to the original instance of the data. */
219 indirect_data (rtx sym_ref
)
224 /* If we aren't generating fix-and-continue code, don't do anything
226 if (TARGET_FIX_AND_CONTINUE
== 0)
229 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
230 are indirected. Symbols that begin with L and _OBJC_ are always
231 bound to the current translation unit as they are used for
232 generated local data of the translation unit. */
234 name
= XSTR (sym_ref
, 0);
236 lprefix
= (((name
[0] == '*' || name
[0] == '&')
237 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
238 || (strncmp (name
, "_OBJC_", 6) == 0));
245 machopic_data_defined_p (rtx sym_ref
)
247 if (indirect_data (sym_ref
))
250 switch (machopic_classify_symbol (sym_ref
))
252 case MACHOPIC_DEFINED_DATA
:
253 case MACHOPIC_DEFINED_FUNCTION
:
261 machopic_define_symbol (rtx mem
)
265 gcc_assert (GET_CODE (mem
) == MEM
);
266 sym_ref
= XEXP (mem
, 0);
267 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
270 static GTY(()) const char * function_base
;
273 machopic_function_base_name (void)
275 /* if dynamic-no-pic is on, we should not get here */
276 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
278 if (function_base
== NULL
)
279 function_base
= ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
281 crtl
->uses_pic_offset_table
= 1;
283 return function_base
;
286 /* Return a SYMBOL_REF for the PIC function base. */
289 machopic_function_base_sym (void)
293 sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, machopic_function_base_name ());
294 SYMBOL_REF_FLAGS (sym_ref
)
295 |= (MACHO_SYMBOL_FLAG_VARIABLE
| MACHO_SYMBOL_FLAG_DEFINED
);
299 /* Return either ORIG or (const:P (minus:P ORIG PIC_BASE)), depending
300 on whether pic_base is NULL or not. */
302 gen_pic_offset (rtx orig
, rtx pic_base
)
307 return gen_rtx_CONST (Pmode
, gen_rtx_MINUS (Pmode
, orig
, pic_base
));
310 static GTY(()) const char * function_base_func_name
;
311 static GTY(()) int current_pic_label_num
;
314 machopic_output_function_base_name (FILE *file
)
316 const char *current_name
;
318 /* If dynamic-no-pic is on, we should not get here. */
319 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
321 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
322 if (function_base_func_name
!= current_name
)
324 ++current_pic_label_num
;
325 function_base_func_name
= current_name
;
327 fprintf (file
, "\"L%011d$pb\"", current_pic_label_num
);
330 /* The suffix attached to non-lazy pointer symbols. */
331 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
332 /* The suffix attached to stub symbols. */
333 #define STUB_SUFFIX "$stub"
335 typedef struct machopic_indirection
GTY (())
337 /* The SYMBOL_REF for the entity referenced. */
339 /* The name of the stub or non-lazy pointer. */
340 const char * ptr_name
;
341 /* True iff this entry is for a stub (as opposed to a non-lazy
344 /* True iff this stub or pointer pointer has been referenced. */
346 } machopic_indirection
;
348 /* A table mapping stub names and non-lazy pointer names to
349 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
351 static GTY ((param_is (struct machopic_indirection
))) htab_t
352 machopic_indirections
;
354 /* Return a hash value for a SLOT in the indirections hash table. */
357 machopic_indirection_hash (const void *slot
)
359 const machopic_indirection
*p
= (const machopic_indirection
*) slot
;
360 return htab_hash_string (p
->ptr_name
);
363 /* Returns true if the KEY is the same as that associated with
367 machopic_indirection_eq (const void *slot
, const void *key
)
369 return strcmp (((const machopic_indirection
*) slot
)->ptr_name
,
370 (const char *) key
) == 0;
373 /* Return the name of the non-lazy pointer (if STUB_P is false) or
374 stub (if STUB_B is true) corresponding to the given name. */
377 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
380 const char *name
= XSTR (sym_ref
, 0);
381 size_t namelen
= strlen (name
);
382 machopic_indirection
*p
;
384 bool saw_star
= false;
387 const char *prefix
= user_label_prefix
;
388 const char *quote
= "";
391 id
= maybe_get_identifier (name
);
396 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
397 id
= TREE_CHAIN (id
);
400 name
= IDENTIFIER_POINTER (id
);
401 namelen
= strlen (name
);
413 needs_quotes
= name_needs_quotes (name
);
420 suffix
= STUB_SUFFIX
;
422 suffix
= NON_LAZY_POINTER_SUFFIX
;
424 buffer
= XALLOCAVEC (char, strlen ("&L")
431 /* Construct the name of the non-lazy pointer or stub. */
432 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
434 if (!machopic_indirections
)
435 machopic_indirections
= htab_create_ggc (37,
436 machopic_indirection_hash
,
437 machopic_indirection_eq
,
440 slot
= htab_find_slot_with_hash (machopic_indirections
, buffer
,
441 htab_hash_string (buffer
), INSERT
);
444 p
= (machopic_indirection
*) *slot
;
448 p
= (machopic_indirection
*) ggc_alloc (sizeof (machopic_indirection
));
450 p
->ptr_name
= xstrdup (buffer
);
459 /* Return the name of the stub for the mcount function. */
462 machopic_mcount_stub_name (void)
464 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
465 return machopic_indirection_name (symbol
, /*stub_p=*/true);
468 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
469 or non-lazy pointer as used -- and mark the object to which the
470 pointer/stub refers as used as well, since the pointer/stub will
471 emit a reference to it. */
474 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
476 machopic_indirection
*p
;
478 p
= ((machopic_indirection
*)
479 (htab_find_with_hash (machopic_indirections
, name
,
480 htab_hash_string (name
))));
483 const char *real_name
;
488 /* Do what output_addr_const will do when we actually call it. */
489 if (SYMBOL_REF_DECL (p
->symbol
))
490 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
492 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
494 id
= maybe_get_identifier (real_name
);
496 mark_referenced (id
);
500 /* Transform ORIG, which may be any data source, to the corresponding
501 source using indirections. */
504 machopic_indirect_data_reference (rtx orig
, rtx reg
)
508 if (! MACHOPIC_INDIRECT
)
511 if (GET_CODE (orig
) == SYMBOL_REF
)
513 int defined
= machopic_data_defined_p (orig
);
515 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
517 #if defined (TARGET_TOC)
518 /* Create a new register for CSE opportunities. */
519 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
520 emit_insn (gen_macho_high (hi_reg
, orig
));
521 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
523 /* some other cpu -- writeme! */
530 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
531 rtx pic_base
= machopic_function_base_sym ();
532 rtx offset
= gen_pic_offset (orig
, pic_base
);
535 #if defined (TARGET_TOC) /* i.e., PowerPC */
536 rtx hi_sum_reg
= (!can_create_pseudo_p ()
538 : gen_reg_rtx (Pmode
));
542 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
543 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
544 gen_rtx_HIGH (Pmode
, offset
))));
545 emit_insn (gen_rtx_SET (Pmode
, reg
,
546 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
547 copy_rtx (offset
))));
551 #if defined (HAVE_lo_sum)
554 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
555 gen_rtx_HIGH (Pmode
, offset
)));
556 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
557 gen_rtx_LO_SUM (Pmode
, reg
,
558 copy_rtx (offset
))));
559 emit_use (pic_offset_table_rtx
);
561 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
567 ptr_ref
= (gen_rtx_SYMBOL_REF
569 machopic_indirection_name (orig
, /*stub_p=*/false)));
571 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
573 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
574 machopic_define_symbol (ptr_ref
);
578 else if (GET_CODE (orig
) == CONST
)
582 /* legitimize both operands of the PLUS */
583 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
585 base
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 0),
587 orig
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 1),
588 (base
== reg
? 0 : reg
));
593 if (MACHOPIC_PURE
&& GET_CODE (orig
) == CONST_INT
)
594 result
= plus_constant (base
, INTVAL (orig
));
596 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
598 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
602 emit_move_insn (reg
, result
);
607 result
= force_reg (GET_MODE (result
), result
);
614 else if (GET_CODE (orig
) == MEM
)
615 XEXP (ptr_ref
, 0) = machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
616 /* When the target is i386, this code prevents crashes due to the
617 compiler's ignorance on how to move the PIC base register to
618 other registers. (The reload phase sometimes introduces such
620 else if (GET_CODE (orig
) == PLUS
621 && GET_CODE (XEXP (orig
, 0)) == REG
622 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
624 /* Prevent the same register from being erroneously used
625 as both the base and index registers. */
626 && GET_CODE (XEXP (orig
, 1)) == CONST
630 emit_move_insn (reg
, XEXP (orig
, 0));
631 XEXP (ptr_ref
, 0) = reg
;
636 /* Transform TARGET (a MEM), which is a function call target, to the
637 corresponding symbol_stub if necessary. Return a new MEM. */
640 machopic_indirect_call_target (rtx target
)
642 if (GET_CODE (target
) != MEM
)
645 if (MACHOPIC_INDIRECT
646 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
647 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
648 & MACHO_SYMBOL_FLAG_DEFINED
))
650 rtx sym_ref
= XEXP (target
, 0);
651 const char *stub_name
= machopic_indirection_name (sym_ref
,
653 enum machine_mode mode
= GET_MODE (sym_ref
);
655 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
656 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
657 MEM_READONLY_P (target
) = 1;
658 MEM_NOTRAP_P (target
) = 1;
665 machopic_legitimize_pic_address (rtx orig
, enum machine_mode mode
, rtx reg
)
669 if (! MACHOPIC_INDIRECT
)
672 /* First handle a simple SYMBOL_REF or LABEL_REF */
673 if (GET_CODE (orig
) == LABEL_REF
674 || (GET_CODE (orig
) == SYMBOL_REF
677 /* addr(foo) = &func+(foo-func) */
680 orig
= machopic_indirect_data_reference (orig
, reg
);
682 if (GET_CODE (orig
) == PLUS
683 && GET_CODE (XEXP (orig
, 0)) == REG
)
686 return force_reg (mode
, orig
);
688 emit_move_insn (reg
, orig
);
692 /* if dynamic-no-pic we don't have a pic base */
693 if (MACHO_DYNAMIC_NO_PIC_P
)
696 pic_base
= machopic_function_base_sym ();
698 if (GET_CODE (orig
) == MEM
)
702 gcc_assert (!reload_in_progress
);
703 reg
= gen_reg_rtx (Pmode
);
707 if (MACHO_DYNAMIC_NO_PIC_P
708 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
709 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
711 #if defined (TARGET_TOC) /* ppc */
712 rtx temp_reg
= (!can_create_pseudo_p ()
714 gen_reg_rtx (Pmode
));
715 rtx asym
= XEXP (orig
, 0);
718 emit_insn (gen_macho_high (temp_reg
, asym
));
719 mem
= gen_const_mem (GET_MODE (orig
),
720 gen_rtx_LO_SUM (Pmode
, temp_reg
,
722 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
724 /* Some other CPU -- WriteMe! but right now there are no other
725 platforms that can use dynamic-no-pic */
731 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
732 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
734 rtx offset
= gen_pic_offset (XEXP (orig
, 0), pic_base
);
735 #if defined (TARGET_TOC) /* i.e., PowerPC */
736 /* Generating a new reg may expose opportunities for
737 common subexpression elimination. */
738 rtx hi_sum_reg
= (!can_create_pseudo_p ()
740 : gen_reg_rtx (Pmode
));
745 sum
= gen_rtx_HIGH (Pmode
, offset
);
746 if (! MACHO_DYNAMIC_NO_PIC_P
)
747 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
749 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
751 mem
= gen_const_mem (GET_MODE (orig
),
752 gen_rtx_LO_SUM (Pmode
,
755 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
756 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
760 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
762 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
764 gen_rtx_CONST (Pmode
,
766 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
767 gen_rtx_LO_SUM (Pmode
, reg
,
768 gen_rtx_CONST (Pmode
,
769 copy_rtx (offset
)))));
770 pic_ref
= gen_rtx_PLUS (Pmode
,
771 pic_offset_table_rtx
, reg
);
775 #endif /* HAVE_lo_sum */
777 rtx pic
= pic_offset_table_rtx
;
778 if (GET_CODE (pic
) != REG
)
780 emit_move_insn (reg
, pic
);
784 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
787 if (reload_in_progress
)
788 df_set_regs_ever_live (REGNO (pic
), true);
789 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
790 gen_pic_offset (XEXP (orig
, 0),
794 #if !defined (TARGET_TOC)
795 emit_move_insn (reg
, pic_ref
);
796 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
803 if (GET_CODE (orig
) == SYMBOL_REF
804 || GET_CODE (orig
) == LABEL_REF
)
806 rtx offset
= gen_pic_offset (orig
, pic_base
);
807 #if defined (TARGET_TOC) /* i.e., PowerPC */
812 gcc_assert (!reload_in_progress
);
813 reg
= gen_reg_rtx (Pmode
);
818 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
819 (MACHO_DYNAMIC_NO_PIC_P
)
820 ? gen_rtx_HIGH (Pmode
, offset
)
821 : gen_rtx_PLUS (Pmode
,
822 pic_offset_table_rtx
,
825 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
826 gen_rtx_LO_SUM (Pmode
,
828 copy_rtx (offset
))));
831 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
832 gen_rtx_HIGH (Pmode
, offset
)));
833 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
834 gen_rtx_LO_SUM (Pmode
, reg
,
835 copy_rtx (offset
))));
836 pic_ref
= gen_rtx_PLUS (Pmode
,
837 pic_offset_table_rtx
, reg
);
841 #endif /* HAVE_lo_sum */
844 || GET_CODE (orig
) == SUBREG
)
850 rtx pic
= pic_offset_table_rtx
;
851 if (GET_CODE (pic
) != REG
)
853 emit_move_insn (reg
, pic
);
857 emit_use (pic_offset_table_rtx
);
859 if (reload_in_progress
)
860 df_set_regs_ever_live (REGNO (pic
), true);
861 pic_ref
= gen_rtx_PLUS (Pmode
,
863 gen_pic_offset (orig
, pic_base
));
868 if (GET_CODE (pic_ref
) != REG
)
872 emit_move_insn (reg
, pic_ref
);
877 return force_reg (mode
, pic_ref
);
886 else if (GET_CODE (orig
) == SYMBOL_REF
)
889 else if (GET_CODE (orig
) == PLUS
890 && (GET_CODE (XEXP (orig
, 0)) == MEM
891 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
892 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
893 && XEXP (orig
, 0) != pic_offset_table_rtx
894 && GET_CODE (XEXP (orig
, 1)) != REG
)
898 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
900 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
901 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
902 Pmode
, (base
== reg
? 0 : reg
));
903 if (GET_CODE (orig
) == CONST_INT
)
905 pic_ref
= plus_constant (base
, INTVAL (orig
));
909 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
911 if (reg
&& is_complex
)
913 emit_move_insn (reg
, pic_ref
);
916 /* Likewise, should we set special REG_NOTEs here? */
919 else if (GET_CODE (orig
) == CONST
)
921 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
924 else if (GET_CODE (orig
) == MEM
925 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
927 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
928 addr
= replace_equiv_address (orig
, addr
);
929 emit_move_insn (reg
, addr
);
936 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
937 DATA is the FILE* for assembly output. Called from
941 machopic_output_indirection (void **slot
, void *data
)
943 machopic_indirection
*p
= *((machopic_indirection
**) slot
);
944 FILE *asm_out_file
= (FILE *) data
;
946 const char *sym_name
;
947 const char *ptr_name
;
953 sym_name
= XSTR (symbol
, 0);
954 ptr_name
= p
->ptr_name
;
962 id
= maybe_get_identifier (sym_name
);
967 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
968 id
= TREE_CHAIN (id
);
970 sym_name
= IDENTIFIER_POINTER (id
);
973 sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
974 if (sym_name
[0] == '*' || sym_name
[0] == '&')
975 strcpy (sym
, sym_name
+ 1);
976 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
977 strcpy (sym
, sym_name
);
979 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
981 stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
982 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
983 strcpy (stub
, ptr_name
+ 1);
985 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
987 machopic_output_stub (asm_out_file
, sym
, stub
);
989 else if (! indirect_data (symbol
)
990 && (machopic_symbol_defined_p (symbol
)
991 || SYMBOL_REF_LOCAL_P (symbol
)))
993 switch_to_section (data_section
);
994 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
995 assemble_label (ptr_name
);
996 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
997 GET_MODE_SIZE (Pmode
),
998 GET_MODE_ALIGNMENT (Pmode
), 1);
1002 rtx init
= const0_rtx
;
1004 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1005 assemble_name (asm_out_file
, ptr_name
);
1006 fprintf (asm_out_file
, ":\n");
1008 fprintf (asm_out_file
, "\t.indirect_symbol ");
1009 assemble_name (asm_out_file
, sym_name
);
1010 fprintf (asm_out_file
, "\n");
1012 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1013 have their symbol name instead of 0 in the second entry of
1014 the non-lazy symbol pointer data structure when they are
1015 defined. This allows the runtime to rebind newer instances
1016 of the translation unit with the original instance of the
1019 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1020 && machopic_symbol_defined_p (symbol
))
1021 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1023 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1024 GET_MODE_ALIGNMENT (Pmode
), 1);
1031 machopic_finish (FILE *asm_out_file
)
1033 if (machopic_indirections
)
1034 htab_traverse_noresize (machopic_indirections
,
1035 machopic_output_indirection
,
1040 machopic_operand_p (rtx op
)
1042 if (MACHOPIC_JUST_INDIRECT
)
1044 while (GET_CODE (op
) == CONST
)
1047 if (GET_CODE (op
) == SYMBOL_REF
)
1048 return machopic_symbol_defined_p (op
);
1053 while (GET_CODE (op
) == CONST
)
1056 if (GET_CODE (op
) == MINUS
1057 && GET_CODE (XEXP (op
, 0)) == SYMBOL_REF
1058 && GET_CODE (XEXP (op
, 1)) == SYMBOL_REF
1059 && machopic_symbol_defined_p (XEXP (op
, 0))
1060 && machopic_symbol_defined_p (XEXP (op
, 1)))
1066 /* This function records whether a given name corresponds to a defined
1067 or undefined function or variable, for machopic_classify_ident to
1071 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1075 /* Do the standard encoding things first. */
1076 default_encode_section_info (decl
, rtl
, first
);
1078 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1081 sym_ref
= XEXP (rtl
, 0);
1082 if (TREE_CODE (decl
) == VAR_DECL
)
1083 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1085 if (!DECL_EXTERNAL (decl
)
1086 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1087 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1088 && ((TREE_STATIC (decl
)
1089 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1090 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1091 && DECL_INITIAL (decl
) != error_mark_node
)))
1092 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1094 if (! TREE_PUBLIC (decl
))
1095 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1099 darwin_mark_decl_preserved (const char *name
)
1101 fprintf (asm_out_file
, ".no_dead_strip ");
1102 assemble_name (asm_out_file
, name
);
1103 fputc ('\n', asm_out_file
);
1107 darwin_text_section (int reloc
, int weak
)
1111 ? darwin_sections
[text_unlikely_coal_section
]
1112 : unlikely_text_section ());
1115 ? darwin_sections
[text_coal_section
]
1120 darwin_rodata_section (int weak
)
1123 ? darwin_sections
[const_coal_section
]
1124 : darwin_sections
[const_section
]);
1128 darwin_mergeable_string_section (tree exp
,
1129 unsigned HOST_WIDE_INT align
)
1131 if (flag_merge_constants
1132 && TREE_CODE (exp
) == STRING_CST
1133 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1135 && (int_size_in_bytes (TREE_TYPE (exp
))
1136 == TREE_STRING_LENGTH (exp
))
1137 && ((size_t) TREE_STRING_LENGTH (exp
)
1138 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1139 return darwin_sections
[cstring_section
];
1141 return readonly_data_section
;
1144 #ifndef HAVE_GAS_LITERAL16
1145 #define HAVE_GAS_LITERAL16 0
1149 darwin_mergeable_constant_section (tree exp
,
1150 unsigned HOST_WIDE_INT align
)
1152 enum machine_mode mode
= DECL_MODE (exp
);
1153 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1155 if (flag_merge_constants
1158 && modesize
<= align
1161 && (align
& (align
-1)) == 0)
1163 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1165 if (TREE_CODE (size
) == INTEGER_CST
1166 && TREE_INT_CST_LOW (size
) == 4
1167 && TREE_INT_CST_HIGH (size
) == 0)
1168 return darwin_sections
[literal4_section
];
1169 else if (TREE_CODE (size
) == INTEGER_CST
1170 && TREE_INT_CST_LOW (size
) == 8
1171 && TREE_INT_CST_HIGH (size
) == 0)
1172 return darwin_sections
[literal8_section
];
1173 else if (HAVE_GAS_LITERAL16
1175 && TREE_CODE (size
) == INTEGER_CST
1176 && TREE_INT_CST_LOW (size
) == 16
1177 && TREE_INT_CST_HIGH (size
) == 0)
1178 return darwin_sections
[literal16_section
];
1180 return readonly_data_section
;
1183 return readonly_data_section
;
1187 machopic_reloc_rw_mask (void)
1189 return MACHOPIC_INDIRECT
? 3 : 0;
1193 machopic_select_section (tree decl
,
1195 unsigned HOST_WIDE_INT align
)
1197 bool weak
= (DECL_P (decl
)
1199 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
1200 || ! lookup_attribute ("weak_import",
1201 DECL_ATTRIBUTES (decl
))));
1202 section
*base_section
;
1204 switch (categorize_decl_for_section (decl
, reloc
))
1207 base_section
= darwin_text_section (reloc
, weak
);
1211 case SECCAT_SRODATA
:
1212 base_section
= darwin_rodata_section (weak
);
1215 case SECCAT_RODATA_MERGE_STR
:
1216 base_section
= darwin_mergeable_string_section (decl
, align
);
1219 case SECCAT_RODATA_MERGE_STR_INIT
:
1220 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1223 case SECCAT_RODATA_MERGE_CONST
:
1224 base_section
= darwin_mergeable_constant_section (decl
, align
);
1228 case SECCAT_DATA_REL
:
1229 case SECCAT_DATA_REL_LOCAL
:
1230 case SECCAT_DATA_REL_RO
:
1231 case SECCAT_DATA_REL_RO_LOCAL
:
1237 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
1238 base_section
= weak
? darwin_sections
[const_data_coal_section
]
1239 : darwin_sections
[const_data_section
];
1241 base_section
= weak
? darwin_sections
[data_coal_section
] : data_section
;
1248 /* Darwin weird special cases. */
1249 if (TREE_CODE (decl
) == CONSTRUCTOR
1251 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1252 && TYPE_NAME (TREE_TYPE (decl
)))
1254 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1255 if (TREE_CODE (name
) == TYPE_DECL
)
1256 name
= DECL_NAME (name
);
1258 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1260 if (flag_next_runtime
)
1261 return darwin_sections
[objc_constant_string_object_section
];
1263 return darwin_sections
[objc_string_object_section
];
1266 return base_section
;
1268 else if (TREE_CODE (decl
) == VAR_DECL
1270 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1271 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1272 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1274 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1276 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1277 return darwin_sections
[objc_cls_meth_section
];
1278 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1279 return darwin_sections
[objc_inst_meth_section
];
1280 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1281 return darwin_sections
[objc_cat_cls_meth_section
];
1282 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1283 return darwin_sections
[objc_cat_inst_meth_section
];
1284 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1285 return darwin_sections
[objc_class_vars_section
];
1286 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1287 return darwin_sections
[objc_instance_vars_section
];
1288 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1289 return darwin_sections
[objc_cat_cls_meth_section
];
1290 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1291 return darwin_sections
[objc_class_names_section
];
1292 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1293 return darwin_sections
[objc_meth_var_names_section
];
1294 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1295 return darwin_sections
[objc_meth_var_types_section
];
1296 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1297 return darwin_sections
[objc_cls_refs_section
];
1298 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1299 return darwin_sections
[objc_class_section
];
1300 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1301 return darwin_sections
[objc_meta_class_section
];
1302 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1303 return darwin_sections
[objc_category_section
];
1304 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1305 return darwin_sections
[objc_selector_refs_section
];
1306 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1307 return darwin_sections
[objc_selector_fixup_section
];
1308 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1309 return darwin_sections
[objc_symbols_section
];
1310 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1311 return darwin_sections
[objc_module_info_section
];
1312 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1313 return darwin_sections
[objc_image_info_section
];
1314 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1315 return darwin_sections
[objc_cat_inst_meth_section
];
1316 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1317 return darwin_sections
[objc_cat_cls_meth_section
];
1318 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1319 return darwin_sections
[objc_cat_cls_meth_section
];
1320 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1321 return darwin_sections
[objc_protocol_section
];
1323 return base_section
;
1326 return base_section
;
1329 /* This can be called with address expressions as "rtx".
1330 They must go in "const". */
1333 machopic_select_rtx_section (enum machine_mode mode
, rtx x
,
1334 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1336 if (GET_MODE_SIZE (mode
) == 8
1337 && (GET_CODE (x
) == CONST_INT
1338 || GET_CODE (x
) == CONST_DOUBLE
))
1339 return darwin_sections
[literal8_section
];
1340 else if (GET_MODE_SIZE (mode
) == 4
1341 && (GET_CODE (x
) == CONST_INT
1342 || GET_CODE (x
) == CONST_DOUBLE
))
1343 return darwin_sections
[literal4_section
];
1344 else if (HAVE_GAS_LITERAL16
1346 && GET_MODE_SIZE (mode
) == 16
1347 && (GET_CODE (x
) == CONST_INT
1348 || GET_CODE (x
) == CONST_DOUBLE
1349 || GET_CODE (x
) == CONST_VECTOR
))
1350 return darwin_sections
[literal16_section
];
1351 else if (MACHOPIC_INDIRECT
1352 && (GET_CODE (x
) == SYMBOL_REF
1353 || GET_CODE (x
) == CONST
1354 || GET_CODE (x
) == LABEL_REF
))
1355 return darwin_sections
[const_data_section
];
1357 return darwin_sections
[const_section
];
1361 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1363 if (MACHOPIC_INDIRECT
)
1364 switch_to_section (darwin_sections
[mod_init_section
]);
1366 switch_to_section (darwin_sections
[constructor_section
]);
1367 assemble_align (POINTER_SIZE
);
1368 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1370 if (! MACHOPIC_INDIRECT
)
1371 fprintf (asm_out_file
, ".reference .constructors_used\n");
1375 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1377 if (MACHOPIC_INDIRECT
)
1378 switch_to_section (darwin_sections
[mod_term_section
]);
1380 switch_to_section (darwin_sections
[destructor_section
]);
1381 assemble_align (POINTER_SIZE
);
1382 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1384 if (! MACHOPIC_INDIRECT
)
1385 fprintf (asm_out_file
, ".reference .destructors_used\n");
1389 darwin_globalize_label (FILE *stream
, const char *name
)
1391 if (!!strncmp (name
, "_OBJC_", 6))
1392 default_globalize_label (stream
, name
);
1396 darwin_asm_named_section (const char *name
,
1397 unsigned int flags ATTRIBUTE_UNUSED
,
1398 tree decl ATTRIBUTE_UNUSED
)
1400 fprintf (asm_out_file
, "\t.section %s\n", name
);
1404 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
1406 /* Darwin does not use unique sections. */
1409 /* Handle __attribute__ ((apple_kext_compatibility)).
1410 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1411 vtable for classes with this attribute (and their descendants) by not
1412 outputting the new 3.0 nondeleting destructor. This means that such
1413 objects CANNOT be allocated on the stack or as globals UNLESS they have
1414 a completely empty `operator delete'.
1415 Luckily, this fits in with the Darwin kext model.
1417 This attribute also disables gcc3's potential overlaying of derived
1418 class data members on the padding at the end of the base class. */
1421 darwin_handle_kext_attribute (tree
*node
, tree name
,
1422 tree args ATTRIBUTE_UNUSED
,
1423 int flags ATTRIBUTE_UNUSED
,
1426 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1427 if (! TARGET_KEXTABI
)
1429 warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1430 "only when compiling a kext", IDENTIFIER_POINTER (name
));
1432 *no_add_attrs
= true;
1434 else if (TREE_CODE (*node
) != RECORD_TYPE
)
1436 warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1437 "only to C++ classes", IDENTIFIER_POINTER (name
));
1439 *no_add_attrs
= true;
1445 /* Handle a "weak_import" attribute; arguments as in
1446 struct attribute_spec.handler. */
1449 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
1450 tree
ARG_UNUSED (args
),
1451 int ARG_UNUSED (flags
),
1452 bool * no_add_attrs
)
1454 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
1456 warning (OPT_Wattributes
, "%qs attribute ignored",
1457 IDENTIFIER_POINTER (name
));
1458 *no_add_attrs
= true;
1461 declare_weak (*node
);
1466 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1467 The third parameter is nonzero if this is for exception handling.
1468 The fourth parameter is nonzero if this is just a placeholder for an
1469 FDE that we are omitting. */
1472 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
1479 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), ".eh", NULL
);
1481 if (TREE_PUBLIC (decl
))
1483 targetm
.asm_out
.globalize_label (file
, lab
);
1484 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
1486 fputs ("\t.private_extern ", file
);
1487 assemble_name (file
, lab
);
1492 if (DECL_WEAK (decl
))
1494 fputs ("\t.weak_definition ", file
);
1495 assemble_name (file
, lab
);
1499 assemble_name (file
, lab
);
1502 fputs (" = 0\n", file
);
1504 /* Mark the absolute .eh and .eh1 style labels as needed to
1505 ensure that we don't dead code strip them and keep such
1506 labels from another instantiation point until we can fix this
1507 properly with group comdat support. */
1508 darwin_mark_decl_preserved (lab
);
1511 fputs (":\n", file
);
1516 static GTY(()) unsigned long except_table_label_num
;
1519 darwin_emit_except_table_label (FILE *file
)
1521 char section_start_label
[30];
1523 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
1524 except_table_label_num
++);
1525 ASM_OUTPUT_LABEL (file
, section_start_label
);
1527 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1530 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
1532 const char *nlp_name
;
1534 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
1536 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
1537 fputs ("\t.long\t", file
);
1538 ASM_OUTPUT_LABELREF (file
, nlp_name
);
1542 /* Emit an assembler directive to set visibility for a symbol. The
1543 only supported visibilities are VISIBILITY_DEFAULT and
1544 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1545 extern". There is no MACH-O equivalent of ELF's
1546 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1549 darwin_assemble_visibility (tree decl
, int vis
)
1551 if (vis
== VISIBILITY_DEFAULT
)
1553 else if (vis
== VISIBILITY_HIDDEN
)
1555 fputs ("\t.private_extern ", asm_out_file
);
1556 assemble_name (asm_out_file
,
1557 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
1558 fputs ("\n", asm_out_file
);
1561 warning (OPT_Wattributes
, "internal and protected visibility attributes "
1562 "not supported in this configuration; ignored");
1565 /* Output a difference of two labels that will be an assembly time
1566 constant if the two labels are local. (.long lab1-lab2 will be
1567 very different if lab1 is at the boundary between two sections; it
1568 will be relocated according to the second section, not the first,
1569 so one ends up with a difference between labels in different
1570 sections, which is bad in the dwarf2 eh context for instance.) */
1572 static int darwin_dwarf_label_counter
;
1575 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
1576 const char *lab1
, const char *lab2
)
1578 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
1579 && lab2
[0] == '*' && lab2
[1] == 'L');
1580 const char *directive
= (size
== 8 ? ".quad" : ".long");
1583 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
1585 fprintf (file
, "\t%s\t", directive
);
1586 assemble_name_raw (file
, lab1
);
1587 fprintf (file
, "-");
1588 assemble_name_raw (file
, lab2
);
1590 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
1593 /* Output labels for the start of the DWARF sections if necessary. */
1595 darwin_file_start (void)
1597 if (write_symbols
== DWARF2_DEBUG
)
1599 static const char * const debugnames
[] =
1601 DEBUG_FRAME_SECTION
,
1603 DEBUG_ABBREV_SECTION
,
1604 DEBUG_ARANGES_SECTION
,
1605 DEBUG_MACINFO_SECTION
,
1608 DEBUG_PUBNAMES_SECTION
,
1609 DEBUG_PUBTYPES_SECTION
,
1611 DEBUG_RANGES_SECTION
1615 for (i
= 0; i
< ARRAY_SIZE (debugnames
); i
++)
1619 switch_to_section (get_section (debugnames
[i
], SECTION_DEBUG
, NULL
));
1621 gcc_assert (strncmp (debugnames
[i
], "__DWARF,", 8) == 0);
1622 gcc_assert (strchr (debugnames
[i
] + 8, ','));
1624 namelen
= strchr (debugnames
[i
] + 8, ',') - (debugnames
[i
] + 8);
1625 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, debugnames
[i
] + 8);
1630 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
1631 offsets are not represented using relocs in .o files; either the
1632 section never leaves the .o file, or the linker or other tool is
1633 responsible for parsing the DWARF and updating the offsets. */
1636 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
1642 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
1643 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
1644 gcc_assert (strchr (base
->named
.name
+ 8, ','));
1646 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
1647 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
1648 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
1652 darwin_file_end (void)
1654 machopic_finish (asm_out_file
);
1655 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
1657 switch_to_section (darwin_sections
[constructor_section
]);
1658 switch_to_section (darwin_sections
[destructor_section
]);
1659 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
1661 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
1664 /* TODO: Add a language hook for identifying if a decl is a vtable. */
1665 #define DARWIN_VTABLE_P(DECL) 0
1667 /* Cross-module name binding. Darwin does not support overriding
1668 functions at dynamic-link time, except for vtables in kexts. */
1671 darwin_binds_local_p (const_tree decl
)
1673 return default_binds_local_p_1 (decl
,
1674 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
1678 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet. */
1679 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
1680 anchor relative to ".", the current section position. We cannot use
1681 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
1684 darwin_asm_output_anchor (rtx symbol
)
1686 fprintf (asm_out_file
, "\t.set\t");
1687 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1688 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
1689 SYMBOL_REF_BLOCK_OFFSET (symbol
));
1693 /* Set the darwin specific attributes on TYPE. */
1695 darwin_set_default_type_attributes (tree type
)
1697 if (darwin_ms_struct
1698 && TREE_CODE (type
) == RECORD_TYPE
)
1699 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
1701 TYPE_ATTRIBUTES (type
));
1704 /* True, iff we're generating code for loadable kernel extensions. */
1707 darwin_kextabi_p (void) {
1708 return flag_apple_kext
;
1712 darwin_override_options (void)
1714 if (flag_mkernel
|| flag_apple_kext
)
1716 /* -mkernel implies -fapple-kext for C++ */
1717 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
1718 flag_apple_kext
= 1;
1722 /* No EH in kexts. */
1723 flag_exceptions
= 0;
1724 /* No -fnon-call-exceptions data in kexts. */
1725 flag_non_call_exceptions
= 0;
1727 if (flag_var_tracking
1728 && strverscmp (darwin_macosx_version_min
, "10.5") >= 0
1729 && debug_info_level
>= DINFO_LEVEL_NORMAL
1730 && debug_hooks
->var_location
!= do_nothing_debug_hooks
.var_location
)
1731 flag_var_tracking_uninit
= 1;
1734 /* Add $LDBL128 suffix to long double builtins. */
1737 darwin_patch_builtin (int fncode
)
1739 tree fn
= built_in_decls
[fncode
];
1746 sym
= DECL_ASSEMBLER_NAME (fn
);
1747 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
1749 set_user_assembler_name (fn
, newname
);
1751 fn
= implicit_built_in_decls
[fncode
];
1753 set_user_assembler_name (fn
, newname
);
1757 darwin_patch_builtins (void)
1759 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
1762 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
1763 #define PATCH_BUILTIN_NO64(fncode) \
1764 if (!TARGET_64BIT) \
1765 darwin_patch_builtin (fncode);
1766 #define PATCH_BUILTIN_VARIADIC(fncode) \
1768 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
1769 darwin_patch_builtin (fncode);
1770 #include "darwin-ppc-ldouble-patch.def"
1771 #undef PATCH_BUILTIN
1772 #undef PATCH_BUILTIN_NO64
1773 #undef PATCH_BUILTIN_VARIADIC
1777 #include "gt-darwin.h"