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 2, 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 COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "coretypes.h"
30 #include "hard-reg-set.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "insn-flags.h"
36 #include "insn-attr.h"
43 #include "langhooks.h"
49 /* Darwin supports a feature called fix-and-continue, which is used
50 for rapid turn around debugging. When code is compiled with the
51 -mfix-and-continue flag, two changes are made to the generated code
52 that allow the system to do things that it would normally not be
53 able to do easily. These changes allow gdb to load in
54 recompilation of a translation unit that has been changed into a
55 running program and replace existing functions and methods of that
56 translation unit with versions of those functions and methods
57 from the newly compiled translation unit. The new functions access
58 the existing static symbols from the old translation unit, if the
59 symbol existed in the unit to be replaced, and from the new
60 translation unit, otherwise.
62 The changes are to insert 5 nops at the beginning of all functions
63 and to use indirection to get at static symbols. The 5 nops
64 are required by consumers of the generated code. Currently, gdb
65 uses this to patch in a jump to the overriding function, this
66 allows all uses of the old name to forward to the replacement,
67 including existing function pointers and virtual methods. See
68 rs6000_emit_prologue for the code that handles the nop insertions.
70 The added indirection allows gdb to redirect accesses to static
71 symbols from the newly loaded translation unit to the existing
72 symbol, if any. @code{static} symbols are special and are handled by
73 setting the second word in the .non_lazy_symbol_pointer data
74 structure to symbol. See indirect_data for the code that handles
75 the extra indirection, and machopic_output_indirection and its use
76 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
77 symbol indirection. */
80 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
82 /* True if we're setting __attribute__ ((ms_struct)). */
83 int darwin_ms_struct
= false;
85 /* A get_unnamed_section callback used to switch to an ObjC section.
86 DIRECTIVE is as for output_section_asm_op. */
89 output_objc_section_asm_op (const void *directive
)
91 static bool been_here
= false;
95 static const enum darwin_section_enum tomark
[] =
97 /* written, cold -> hot */
98 objc_cat_cls_meth_section
,
99 objc_cat_inst_meth_section
,
100 objc_string_object_section
,
101 objc_constant_string_object_section
,
102 objc_selector_refs_section
,
103 objc_selector_fixup_section
,
104 objc_cls_refs_section
,
106 objc_meta_class_section
,
107 /* shared, hot -> cold */
108 objc_cls_meth_section
,
109 objc_inst_meth_section
,
110 objc_protocol_section
,
111 objc_class_names_section
,
112 objc_meth_var_types_section
,
113 objc_meth_var_names_section
,
114 objc_category_section
,
115 objc_class_vars_section
,
116 objc_instance_vars_section
,
117 objc_module_info_section
,
123 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
124 switch_to_section (darwin_sections
[tomark
[i
]]);
126 output_section_asm_op (directive
);
129 /* Implement TARGET_ASM_INIT_SECTIONS. */
132 darwin_init_sections (void)
134 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
135 darwin_sections[NAME] = \
136 get_unnamed_section (FLAGS, (OBJC \
137 ? output_objc_section_asm_op \
138 : output_section_asm_op), \
140 #include "config/darwin-sections.def"
143 readonly_data_section
= darwin_sections
[const_section
];
144 exception_section
= darwin_sections
[darwin_exception_section
];
145 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
149 name_needs_quotes (const char *name
)
152 while ((c
= *name
++) != '\0')
153 if (! ISIDNUM (c
) && c
!= '.' && c
!= '$')
158 /* Return true if SYM_REF can be used without an indirection. */
160 machopic_symbol_defined_p (rtx sym_ref
)
162 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
165 /* If a symbol references local and is not an extern to this
166 file, then the symbol might be able to declared as defined. */
167 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
169 /* If the symbol references a variable and the variable is a
170 common symbol, then this symbol is not defined. */
171 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
173 tree decl
= SYMBOL_REF_DECL (sym_ref
);
176 if (DECL_COMMON (decl
))
184 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
185 reference, which will not be changed. */
187 enum machopic_addr_class
188 machopic_classify_symbol (rtx sym_ref
)
193 flags
= SYMBOL_REF_FLAGS (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 static GTY(()) char * function_base
;
272 machopic_function_base_name (void)
274 /* if dynamic-no-pic is on, we should not get here */
275 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
277 if (function_base
== NULL
)
279 (char *) ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
281 current_function_uses_pic_offset_table
= 1;
283 return function_base
;
286 /* Return a SYMBOL_REF for the PIC function base. */
289 machopic_function_base_sym (void)
293 sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, machopic_function_base_name ());
294 SYMBOL_REF_FLAGS (sym_ref
)
295 |= (MACHO_SYMBOL_FLAG_VARIABLE
| MACHO_SYMBOL_FLAG_DEFINED
);
299 /* Return either ORIG or (const:P (minus:P ORIG PIC_BASE)), depending
300 on whether pic_base is NULL or not. */
302 gen_pic_offset (rtx orig
, rtx pic_base
)
307 return gen_rtx_CONST (Pmode
, gen_rtx_MINUS (Pmode
, orig
, pic_base
));
310 static GTY(()) const char * function_base_func_name
;
311 static GTY(()) int current_pic_label_num
;
314 machopic_output_function_base_name (FILE *file
)
316 const char *current_name
;
318 /* If dynamic-no-pic is on, we should not get here. */
319 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
321 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
322 if (function_base_func_name
!= current_name
)
324 ++current_pic_label_num
;
325 function_base_func_name
= current_name
;
327 fprintf (file
, "\"L%011d$pb\"", current_pic_label_num
);
330 /* The suffix attached to non-lazy pointer symbols. */
331 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
332 /* The suffix attached to stub symbols. */
333 #define STUB_SUFFIX "$stub"
335 typedef struct machopic_indirection
GTY (())
337 /* The SYMBOL_REF for the entity referenced. */
339 /* The name of the stub or non-lazy pointer. */
340 const char * ptr_name
;
341 /* True iff this entry is for a stub (as opposed to a non-lazy
344 /* True iff this stub or pointer pointer has been referenced. */
346 } machopic_indirection
;
348 /* A table mapping stub names and non-lazy pointer names to
349 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
351 static GTY ((param_is (struct machopic_indirection
))) htab_t
352 machopic_indirections
;
354 /* Return a hash value for a SLOT in the indirections hash table. */
357 machopic_indirection_hash (const void *slot
)
359 const machopic_indirection
*p
= (const machopic_indirection
*) slot
;
360 return htab_hash_string (p
->ptr_name
);
363 /* Returns true if the KEY is the same as that associated with
367 machopic_indirection_eq (const void *slot
, const void *key
)
369 return strcmp (((const machopic_indirection
*) slot
)->ptr_name
, key
) == 0;
372 /* Return the name of the non-lazy pointer (if STUB_P is false) or
373 stub (if STUB_B is true) corresponding to the given name. */
376 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
379 const char *name
= XSTR (sym_ref
, 0);
380 size_t namelen
= strlen (name
);
381 machopic_indirection
*p
;
383 bool saw_star
= false;
386 const char *prefix
= user_label_prefix
;
387 const char *quote
= "";
390 id
= maybe_get_identifier (name
);
395 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
396 id
= TREE_CHAIN (id
);
399 name
= IDENTIFIER_POINTER (id
);
400 namelen
= strlen (name
);
412 needs_quotes
= name_needs_quotes (name
);
419 suffix
= STUB_SUFFIX
;
421 suffix
= NON_LAZY_POINTER_SUFFIX
;
423 buffer
= alloca (strlen ("&L")
430 /* Construct the name of the non-lazy pointer or stub. */
431 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
433 if (!machopic_indirections
)
434 machopic_indirections
= htab_create_ggc (37,
435 machopic_indirection_hash
,
436 machopic_indirection_eq
,
439 slot
= htab_find_slot_with_hash (machopic_indirections
, buffer
,
440 htab_hash_string (buffer
), INSERT
);
443 p
= (machopic_indirection
*) *slot
;
447 p
= (machopic_indirection
*) ggc_alloc (sizeof (machopic_indirection
));
449 p
->ptr_name
= xstrdup (buffer
);
458 /* Return the name of the stub for the mcount function. */
461 machopic_mcount_stub_name (void)
463 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
464 return machopic_indirection_name (symbol
, /*stub_p=*/true);
467 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
468 or non-lazy pointer as used -- and mark the object to which the
469 pointer/stub refers as used as well, since the pointer/stub will
470 emit a reference to it. */
473 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
475 machopic_indirection
*p
;
477 p
= ((machopic_indirection
*)
478 (htab_find_with_hash (machopic_indirections
, name
,
479 htab_hash_string (name
))));
482 const char *real_name
;
487 /* Do what output_addr_const will do when we actually call it. */
488 if (SYMBOL_REF_DECL (p
->symbol
))
489 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
491 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
493 id
= maybe_get_identifier (real_name
);
495 mark_referenced (id
);
499 /* Transform ORIG, which may be any data source, to the corresponding
500 source using indirections. */
503 machopic_indirect_data_reference (rtx orig
, rtx reg
)
507 if (! MACHOPIC_INDIRECT
)
510 if (GET_CODE (orig
) == SYMBOL_REF
)
512 int defined
= machopic_data_defined_p (orig
);
514 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
516 #if defined (TARGET_TOC)
517 /* Create a new register for CSE opportunities. */
518 rtx hi_reg
= (no_new_pseudos
? reg
: gen_reg_rtx (Pmode
));
519 emit_insn (gen_macho_high (hi_reg
, orig
));
520 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
522 /* some other cpu -- writeme! */
529 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
530 rtx pic_base
= machopic_function_base_sym ();
531 rtx offset
= gen_pic_offset (orig
, pic_base
);
534 #if defined (TARGET_TOC) /* i.e., PowerPC */
535 rtx hi_sum_reg
= (no_new_pseudos
? reg
: gen_reg_rtx (Pmode
));
539 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
540 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
541 gen_rtx_HIGH (Pmode
, offset
))));
542 emit_insn (gen_rtx_SET (Pmode
, reg
,
543 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
, offset
)));
547 #if defined (HAVE_lo_sum)
550 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
551 gen_rtx_HIGH (Pmode
, offset
)));
552 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
553 gen_rtx_LO_SUM (Pmode
, reg
, offset
)));
554 emit_insn (gen_rtx_USE (VOIDmode
, pic_offset_table_rtx
));
556 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
562 ptr_ref
= (gen_rtx_SYMBOL_REF
564 machopic_indirection_name (orig
, /*stub_p=*/false)));
566 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
568 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
569 machopic_define_symbol (ptr_ref
);
573 else if (GET_CODE (orig
) == CONST
)
577 /* legitimize both operands of the PLUS */
578 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
580 base
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 0),
582 orig
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 1),
583 (base
== reg
? 0 : reg
));
588 if (MACHOPIC_PURE
&& GET_CODE (orig
) == CONST_INT
)
589 result
= plus_constant (base
, INTVAL (orig
));
591 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
593 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
597 emit_move_insn (reg
, result
);
602 result
= force_reg (GET_MODE (result
), result
);
609 else if (GET_CODE (orig
) == MEM
)
610 XEXP (ptr_ref
, 0) = machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
611 /* When the target is i386, this code prevents crashes due to the
612 compiler's ignorance on how to move the PIC base register to
613 other registers. (The reload phase sometimes introduces such
615 else if (GET_CODE (orig
) == PLUS
616 && GET_CODE (XEXP (orig
, 0)) == REG
617 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
619 /* Prevent the same register from being erroneously used
620 as both the base and index registers. */
621 && GET_CODE (XEXP (orig
, 1)) == CONST
625 emit_move_insn (reg
, XEXP (orig
, 0));
626 XEXP (ptr_ref
, 0) = reg
;
631 /* Transform TARGET (a MEM), which is a function call target, to the
632 corresponding symbol_stub if necessary. Return a new MEM. */
635 machopic_indirect_call_target (rtx target
)
637 if (GET_CODE (target
) != MEM
)
640 if (MACHOPIC_INDIRECT
641 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
642 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
643 & MACHO_SYMBOL_FLAG_DEFINED
))
645 rtx sym_ref
= XEXP (target
, 0);
646 const char *stub_name
= machopic_indirection_name (sym_ref
,
648 enum machine_mode mode
= GET_MODE (sym_ref
);
650 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
651 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
652 MEM_READONLY_P (target
) = 1;
653 MEM_NOTRAP_P (target
) = 1;
660 machopic_legitimize_pic_address (rtx orig
, enum machine_mode mode
, rtx reg
)
664 if (! MACHOPIC_INDIRECT
)
667 /* First handle a simple SYMBOL_REF or LABEL_REF */
668 if (GET_CODE (orig
) == LABEL_REF
669 || (GET_CODE (orig
) == SYMBOL_REF
672 /* addr(foo) = &func+(foo-func) */
675 orig
= machopic_indirect_data_reference (orig
, reg
);
677 if (GET_CODE (orig
) == PLUS
678 && GET_CODE (XEXP (orig
, 0)) == REG
)
681 return force_reg (mode
, orig
);
683 emit_move_insn (reg
, orig
);
687 /* if dynamic-no-pic we don't have a pic base */
688 if (MACHO_DYNAMIC_NO_PIC_P
)
691 pic_base
= machopic_function_base_sym ();
693 if (GET_CODE (orig
) == MEM
)
697 gcc_assert (!reload_in_progress
);
698 reg
= gen_reg_rtx (Pmode
);
702 if (MACHO_DYNAMIC_NO_PIC_P
703 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
704 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
706 #if defined (TARGET_TOC) /* ppc */
707 rtx temp_reg
= (no_new_pseudos
) ? reg
: gen_reg_rtx (Pmode
);
708 rtx asym
= XEXP (orig
, 0);
711 emit_insn (gen_macho_high (temp_reg
, asym
));
712 mem
= gen_const_mem (GET_MODE (orig
),
713 gen_rtx_LO_SUM (Pmode
, temp_reg
, asym
));
714 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
716 /* Some other CPU -- WriteMe! but right now there are no other
717 platforms that can use dynamic-no-pic */
723 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
724 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
726 rtx offset
= gen_pic_offset (XEXP (orig
, 0), pic_base
);
727 #if defined (TARGET_TOC) /* i.e., PowerPC */
728 /* Generating a new reg may expose opportunities for
729 common subexpression elimination. */
730 rtx hi_sum_reg
= no_new_pseudos
? reg
: gen_reg_rtx (Pmode
);
735 sum
= gen_rtx_HIGH (Pmode
, offset
);
736 if (! MACHO_DYNAMIC_NO_PIC_P
)
737 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
739 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
741 mem
= gen_const_mem (GET_MODE (orig
),
742 gen_rtx_LO_SUM (Pmode
,
743 hi_sum_reg
, offset
));
744 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
745 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
749 emit_insn (gen_rtx_USE (VOIDmode
,
751 PIC_OFFSET_TABLE_REGNUM
)));
753 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
755 gen_rtx_CONST (Pmode
,
757 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
758 gen_rtx_LO_SUM (Pmode
, reg
,
759 gen_rtx_CONST (Pmode
, offset
))));
760 pic_ref
= gen_rtx_PLUS (Pmode
,
761 pic_offset_table_rtx
, reg
);
765 #endif /* HAVE_lo_sum */
767 rtx pic
= pic_offset_table_rtx
;
768 if (GET_CODE (pic
) != REG
)
770 emit_move_insn (reg
, pic
);
774 emit_insn (gen_rtx_USE (VOIDmode
,
776 PIC_OFFSET_TABLE_REGNUM
)));
779 if (reload_in_progress
)
780 regs_ever_live
[REGNO (pic
)] = 1;
781 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
782 gen_pic_offset (XEXP (orig
, 0),
786 #if !defined (TARGET_TOC)
787 emit_move_insn (reg
, pic_ref
);
788 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
795 if (GET_CODE (orig
) == SYMBOL_REF
796 || GET_CODE (orig
) == LABEL_REF
)
798 rtx offset
= gen_pic_offset (orig
, pic_base
);
799 #if defined (TARGET_TOC) /* i.e., PowerPC */
804 gcc_assert (!reload_in_progress
);
805 reg
= gen_reg_rtx (Pmode
);
810 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
811 (MACHO_DYNAMIC_NO_PIC_P
)
812 ? gen_rtx_HIGH (Pmode
, offset
)
813 : gen_rtx_PLUS (Pmode
,
814 pic_offset_table_rtx
,
817 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
818 gen_rtx_LO_SUM (Pmode
,
819 hi_sum_reg
, offset
)));
822 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
823 gen_rtx_HIGH (Pmode
, offset
)));
824 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
825 gen_rtx_LO_SUM (Pmode
, reg
, offset
)));
826 pic_ref
= gen_rtx_PLUS (Pmode
,
827 pic_offset_table_rtx
, reg
);
831 #endif /* HAVE_lo_sum */
834 || GET_CODE (orig
) == SUBREG
)
840 rtx pic
= pic_offset_table_rtx
;
841 if (GET_CODE (pic
) != REG
)
843 emit_move_insn (reg
, pic
);
847 emit_insn (gen_rtx_USE (VOIDmode
,
848 pic_offset_table_rtx
));
850 if (reload_in_progress
)
851 regs_ever_live
[REGNO (pic
)] = 1;
852 pic_ref
= gen_rtx_PLUS (Pmode
,
854 gen_pic_offset (orig
, pic_base
));
859 if (GET_CODE (pic_ref
) != REG
)
863 emit_move_insn (reg
, pic_ref
);
868 return force_reg (mode
, pic_ref
);
877 else if (GET_CODE (orig
) == SYMBOL_REF
)
880 else if (GET_CODE (orig
) == PLUS
881 && (GET_CODE (XEXP (orig
, 0)) == MEM
882 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
883 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
884 && XEXP (orig
, 0) != pic_offset_table_rtx
885 && GET_CODE (XEXP (orig
, 1)) != REG
)
889 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
891 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
892 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
893 Pmode
, (base
== reg
? 0 : reg
));
894 if (GET_CODE (orig
) == CONST_INT
)
896 pic_ref
= plus_constant (base
, INTVAL (orig
));
900 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
902 if (reg
&& is_complex
)
904 emit_move_insn (reg
, pic_ref
);
907 /* Likewise, should we set special REG_NOTEs here? */
910 else if (GET_CODE (orig
) == CONST
)
912 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
915 else if (GET_CODE (orig
) == MEM
916 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
918 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
919 addr
= replace_equiv_address (orig
, addr
);
920 emit_move_insn (reg
, addr
);
927 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
928 DATA is the FILE* for assembly output. Called from
932 machopic_output_indirection (void **slot
, void *data
)
934 machopic_indirection
*p
= *((machopic_indirection
**) slot
);
935 FILE *asm_out_file
= (FILE *) data
;
937 const char *sym_name
;
938 const char *ptr_name
;
944 sym_name
= XSTR (symbol
, 0);
945 ptr_name
= p
->ptr_name
;
953 id
= maybe_get_identifier (sym_name
);
958 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
959 id
= TREE_CHAIN (id
);
961 sym_name
= IDENTIFIER_POINTER (id
);
964 sym
= alloca (strlen (sym_name
) + 2);
965 if (sym_name
[0] == '*' || sym_name
[0] == '&')
966 strcpy (sym
, sym_name
+ 1);
967 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
968 strcpy (sym
, sym_name
);
970 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
972 stub
= alloca (strlen (ptr_name
) + 2);
973 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
974 strcpy (stub
, ptr_name
+ 1);
976 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
978 machopic_output_stub (asm_out_file
, sym
, stub
);
980 else if (! indirect_data (symbol
)
981 && (machopic_symbol_defined_p (symbol
)
982 || SYMBOL_REF_LOCAL_P (symbol
)))
984 switch_to_section (data_section
);
985 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
986 assemble_label (ptr_name
);
987 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
988 GET_MODE_SIZE (Pmode
),
989 GET_MODE_ALIGNMENT (Pmode
), 1);
993 rtx init
= const0_rtx
;
995 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
996 assemble_name (asm_out_file
, ptr_name
);
997 fprintf (asm_out_file
, ":\n");
999 fprintf (asm_out_file
, "\t.indirect_symbol ");
1000 assemble_name (asm_out_file
, sym_name
);
1001 fprintf (asm_out_file
, "\n");
1003 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1004 have their symbol name instead of 0 in the second entry of
1005 the non-lazy symbol pointer data structure when they are
1006 defined. This allows the runtime to rebind newer instances
1007 of the translation unit with the original instance of the
1010 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1011 && machopic_symbol_defined_p (symbol
))
1012 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1014 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1015 GET_MODE_ALIGNMENT (Pmode
), 1);
1022 machopic_finish (FILE *asm_out_file
)
1024 if (machopic_indirections
)
1025 htab_traverse_noresize (machopic_indirections
,
1026 machopic_output_indirection
,
1031 machopic_operand_p (rtx op
)
1033 if (MACHOPIC_JUST_INDIRECT
)
1035 while (GET_CODE (op
) == CONST
)
1038 if (GET_CODE (op
) == SYMBOL_REF
)
1039 return machopic_symbol_defined_p (op
);
1044 while (GET_CODE (op
) == CONST
)
1047 if (GET_CODE (op
) == MINUS
1048 && GET_CODE (XEXP (op
, 0)) == SYMBOL_REF
1049 && GET_CODE (XEXP (op
, 1)) == SYMBOL_REF
1050 && machopic_symbol_defined_p (XEXP (op
, 0))
1051 && machopic_symbol_defined_p (XEXP (op
, 1)))
1057 /* This function records whether a given name corresponds to a defined
1058 or undefined function or variable, for machopic_classify_ident to
1062 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1066 /* Do the standard encoding things first. */
1067 default_encode_section_info (decl
, rtl
, first
);
1069 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1072 sym_ref
= XEXP (rtl
, 0);
1073 if (TREE_CODE (decl
) == VAR_DECL
)
1074 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1076 if (!DECL_EXTERNAL (decl
)
1077 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1078 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1079 && ((TREE_STATIC (decl
)
1080 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1081 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1082 && DECL_INITIAL (decl
) != error_mark_node
)))
1083 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1085 if (! TREE_PUBLIC (decl
))
1086 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1090 darwin_mark_decl_preserved (const char *name
)
1092 fprintf (asm_out_file
, ".no_dead_strip ");
1093 assemble_name (asm_out_file
, name
);
1094 fputc ('\n', asm_out_file
);
1098 darwin_text_section (int reloc
, int weak
)
1102 ? darwin_sections
[text_unlikely_coal_section
]
1103 : unlikely_text_section ());
1106 ? darwin_sections
[text_coal_section
]
1111 darwin_rodata_section (int weak
)
1114 ? darwin_sections
[const_coal_section
]
1115 : darwin_sections
[const_section
]);
1119 darwin_mergeable_string_section (tree exp
,
1120 unsigned HOST_WIDE_INT align
)
1122 if (flag_merge_constants
1123 && TREE_CODE (exp
) == STRING_CST
1124 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1126 && ((size_t) TREE_STRING_LENGTH (exp
)
1127 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1128 return darwin_sections
[cstring_section
];
1130 return readonly_data_section
;
1133 #ifndef HAVE_GAS_LITERAL16
1134 #define HAVE_GAS_LITERAL16 0
1138 darwin_mergeable_constant_section (tree exp
,
1139 unsigned HOST_WIDE_INT align
)
1141 enum machine_mode mode
= DECL_MODE (exp
);
1142 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1144 if (flag_merge_constants
1147 && modesize
<= align
1150 && (align
& (align
-1)) == 0)
1152 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1154 if (TREE_CODE (size
) == INTEGER_CST
1155 && TREE_INT_CST_LOW (size
) == 4
1156 && TREE_INT_CST_HIGH (size
) == 0)
1157 return darwin_sections
[literal4_section
];
1158 else if (TREE_CODE (size
) == INTEGER_CST
1159 && TREE_INT_CST_LOW (size
) == 8
1160 && TREE_INT_CST_HIGH (size
) == 0)
1161 return darwin_sections
[literal8_section
];
1162 else if (HAVE_GAS_LITERAL16
1164 && TREE_CODE (size
) == INTEGER_CST
1165 && TREE_INT_CST_LOW (size
) == 16
1166 && TREE_INT_CST_HIGH (size
) == 0)
1167 return darwin_sections
[literal16_section
];
1169 return readonly_data_section
;
1172 return readonly_data_section
;
1176 machopic_select_section (tree decl
,
1178 unsigned HOST_WIDE_INT align
)
1180 bool weak
= (DECL_P (decl
)
1182 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
1183 || ! lookup_attribute ("weak_import",
1184 DECL_ATTRIBUTES (decl
))));
1185 int shlib
= flag_pic
;
1186 section
*base_section
;
1188 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
1191 base_section
= darwin_text_section (reloc
, weak
);
1195 case SECCAT_SRODATA
:
1196 base_section
= darwin_rodata_section (weak
);
1199 case SECCAT_RODATA_MERGE_STR
:
1200 base_section
= darwin_mergeable_string_section (decl
, align
);
1203 case SECCAT_RODATA_MERGE_STR_INIT
:
1204 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1207 case SECCAT_RODATA_MERGE_CONST
:
1208 base_section
= darwin_mergeable_constant_section (decl
, align
);
1212 case SECCAT_DATA_REL
:
1213 case SECCAT_DATA_REL_LOCAL
:
1214 case SECCAT_DATA_REL_RO
:
1215 case SECCAT_DATA_REL_RO_LOCAL
:
1221 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
1222 base_section
= weak
? darwin_sections
[const_data_coal_section
]
1223 : darwin_sections
[const_data_section
];
1225 base_section
= weak
? darwin_sections
[data_coal_section
] : data_section
;
1232 /* Darwin weird special cases. */
1233 if (TREE_CODE (decl
) == CONSTRUCTOR
1235 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1236 && TYPE_NAME (TREE_TYPE (decl
)))
1238 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1239 if (TREE_CODE (name
) == TYPE_DECL
)
1240 name
= DECL_NAME (name
);
1242 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1244 if (flag_next_runtime
)
1245 return darwin_sections
[objc_constant_string_object_section
];
1247 return darwin_sections
[objc_string_object_section
];
1250 return base_section
;
1252 else if (TREE_CODE (decl
) == VAR_DECL
1254 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1255 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1256 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1258 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1260 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1261 return darwin_sections
[objc_cls_meth_section
];
1262 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1263 return darwin_sections
[objc_inst_meth_section
];
1264 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1265 return darwin_sections
[objc_cat_cls_meth_section
];
1266 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1267 return darwin_sections
[objc_cat_inst_meth_section
];
1268 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1269 return darwin_sections
[objc_class_vars_section
];
1270 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1271 return darwin_sections
[objc_instance_vars_section
];
1272 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1273 return darwin_sections
[objc_cat_cls_meth_section
];
1274 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1275 return darwin_sections
[objc_class_names_section
];
1276 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1277 return darwin_sections
[objc_meth_var_names_section
];
1278 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1279 return darwin_sections
[objc_meth_var_types_section
];
1280 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1281 return darwin_sections
[objc_cls_refs_section
];
1282 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1283 return darwin_sections
[objc_class_section
];
1284 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1285 return darwin_sections
[objc_meta_class_section
];
1286 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1287 return darwin_sections
[objc_category_section
];
1288 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1289 return darwin_sections
[objc_selector_refs_section
];
1290 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1291 return darwin_sections
[objc_selector_fixup_section
];
1292 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1293 return darwin_sections
[objc_symbols_section
];
1294 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1295 return darwin_sections
[objc_module_info_section
];
1296 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1297 return darwin_sections
[objc_image_info_section
];
1298 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1299 return darwin_sections
[objc_cat_inst_meth_section
];
1300 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1301 return darwin_sections
[objc_cat_cls_meth_section
];
1302 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1303 return darwin_sections
[objc_cat_cls_meth_section
];
1304 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1305 return darwin_sections
[objc_protocol_section
];
1307 return base_section
;
1310 return base_section
;
1313 /* This can be called with address expressions as "rtx".
1314 They must go in "const". */
1317 machopic_select_rtx_section (enum machine_mode mode
, rtx x
,
1318 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1320 if (GET_MODE_SIZE (mode
) == 8
1321 && (GET_CODE (x
) == CONST_INT
1322 || GET_CODE (x
) == CONST_DOUBLE
))
1323 return darwin_sections
[literal8_section
];
1324 else if (GET_MODE_SIZE (mode
) == 4
1325 && (GET_CODE (x
) == CONST_INT
1326 || GET_CODE (x
) == CONST_DOUBLE
))
1327 return darwin_sections
[literal4_section
];
1328 else if (HAVE_GAS_LITERAL16
1330 && GET_MODE_SIZE (mode
) == 16
1331 && (GET_CODE (x
) == CONST_INT
1332 || GET_CODE (x
) == CONST_DOUBLE
1333 || GET_CODE (x
) == CONST_VECTOR
))
1334 return darwin_sections
[literal16_section
];
1335 else if (MACHOPIC_INDIRECT
1336 && (GET_CODE (x
) == SYMBOL_REF
1337 || GET_CODE (x
) == CONST
1338 || GET_CODE (x
) == LABEL_REF
))
1339 return darwin_sections
[const_data_section
];
1341 return darwin_sections
[const_section
];
1345 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1347 if (MACHOPIC_INDIRECT
)
1348 switch_to_section (darwin_sections
[mod_init_section
]);
1350 switch_to_section (darwin_sections
[constructor_section
]);
1351 assemble_align (POINTER_SIZE
);
1352 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1354 if (! MACHOPIC_INDIRECT
)
1355 fprintf (asm_out_file
, ".reference .constructors_used\n");
1359 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1361 if (MACHOPIC_INDIRECT
)
1362 switch_to_section (darwin_sections
[mod_term_section
]);
1364 switch_to_section (darwin_sections
[destructor_section
]);
1365 assemble_align (POINTER_SIZE
);
1366 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1368 if (! MACHOPIC_INDIRECT
)
1369 fprintf (asm_out_file
, ".reference .destructors_used\n");
1373 darwin_globalize_label (FILE *stream
, const char *name
)
1375 if (!!strncmp (name
, "_OBJC_", 6))
1376 default_globalize_label (stream
, name
);
1380 darwin_asm_named_section (const char *name
,
1381 unsigned int flags ATTRIBUTE_UNUSED
,
1382 tree decl ATTRIBUTE_UNUSED
)
1384 fprintf (asm_out_file
, "\t.section %s\n", name
);
1388 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
1390 /* Darwin does not use unique sections. */
1393 /* Handle __attribute__ ((apple_kext_compatibility)).
1394 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1395 vtable for classes with this attribute (and their descendants) by not
1396 outputting the new 3.0 nondeleting destructor. This means that such
1397 objects CANNOT be allocated on the stack or as globals UNLESS they have
1398 a completely empty `operator delete'.
1399 Luckily, this fits in with the Darwin kext model.
1401 This attribute also disables gcc3's potential overlaying of derived
1402 class data members on the padding at the end of the base class. */
1405 darwin_handle_kext_attribute (tree
*node
, tree name
,
1406 tree args ATTRIBUTE_UNUSED
,
1407 int flags ATTRIBUTE_UNUSED
,
1410 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1411 if (! TARGET_KEXTABI
)
1413 warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
1414 "only when compiling a kext", IDENTIFIER_POINTER (name
));
1416 *no_add_attrs
= true;
1418 else if (TREE_CODE (*node
) != RECORD_TYPE
)
1420 warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
1421 "only to C++ classes", IDENTIFIER_POINTER (name
));
1423 *no_add_attrs
= true;
1429 /* Handle a "weak_import" attribute; arguments as in
1430 struct attribute_spec.handler. */
1433 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
1434 tree
ARG_UNUSED (args
),
1435 int ARG_UNUSED (flags
),
1436 bool * no_add_attrs
)
1438 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
1440 warning (OPT_Wattributes
, "%qs attribute ignored",
1441 IDENTIFIER_POINTER (name
));
1442 *no_add_attrs
= true;
1445 declare_weak (*node
);
1451 no_dead_strip (FILE *file
, const char *lab
)
1453 fprintf (file
, ".no_dead_strip %s\n", lab
);
1456 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1457 The third parameter is nonzero if this is for exception handling.
1458 The fourth parameter is nonzero if this is just a placeholder for an
1459 FDE that we are omitting. */
1462 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
1468 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
1469 base
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1471 base
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1473 base
= targetm
.strip_name_encoding (base
);
1474 need_quotes
= name_needs_quotes (base
);
1479 lab
= concat (need_quotes
? "\"" : "", user_label_prefix
, base
, ".eh",
1480 need_quotes
? "\"" : "", NULL
);
1482 if (TREE_PUBLIC (decl
))
1483 fprintf (file
, "\t%s %s\n",
1484 (DECL_VISIBILITY (decl
) != VISIBILITY_HIDDEN
1486 : ".private_extern"),
1489 if (DECL_WEAK (decl
))
1490 fprintf (file
, "\t.weak_definition %s\n", lab
);
1494 fprintf (file
, "%s = 0\n", lab
);
1496 /* Mark the absolute .eh and .eh1 style labels as needed to
1497 ensure that we don't dead code strip them and keep such
1498 labels from another instantiation point until we can fix this
1499 properly with group comdat support. */
1500 no_dead_strip (file
, lab
);
1503 fprintf (file
, "%s:\n", lab
);
1508 static GTY(()) unsigned long except_table_label_num
;
1511 darwin_emit_except_table_label (FILE *file
)
1513 char section_start_label
[30];
1515 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
1516 except_table_label_num
++);
1517 ASM_OUTPUT_LABEL (file
, section_start_label
);
1519 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1522 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
1524 const char *nlp_name
;
1526 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
1528 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
1529 fputs ("\t.long\t", file
);
1530 ASM_OUTPUT_LABELREF (file
, nlp_name
);
1534 /* Emit an assembler directive to set visibility for a symbol. The
1535 only supported visibilities are VISIBILITY_DEFAULT and
1536 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1537 extern". There is no MACH-O equivalent of ELF's
1538 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1541 darwin_assemble_visibility (tree decl
, int vis
)
1543 if (vis
== VISIBILITY_DEFAULT
)
1545 else if (vis
== VISIBILITY_HIDDEN
)
1547 fputs ("\t.private_extern ", asm_out_file
);
1548 assemble_name (asm_out_file
,
1549 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
1550 fputs ("\n", asm_out_file
);
1553 warning (OPT_Wattributes
, "internal and protected visibility attributes "
1554 "not supported in this configuration; ignored");
1557 /* Output a difference of two labels that will be an assembly time
1558 constant if the two labels are local. (.long lab1-lab2 will be
1559 very different if lab1 is at the boundary between two sections; it
1560 will be relocated according to the second section, not the first,
1561 so one ends up with a difference between labels in different
1562 sections, which is bad in the dwarf2 eh context for instance.) */
1564 static int darwin_dwarf_label_counter
;
1567 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
1568 const char *lab1
, const char *lab2
)
1570 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
1571 && lab2
[0] == '*' && lab2
[1] == 'L');
1572 const char *directive
= (size
== 8 ? ".quad" : ".long");
1575 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
1577 fprintf (file
, "\t%s\t", directive
);
1578 assemble_name_raw (file
, lab1
);
1579 fprintf (file
, "-");
1580 assemble_name_raw (file
, lab2
);
1582 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
1585 /* Output labels for the start of the DWARF sections if necessary. */
1587 darwin_file_start (void)
1589 if (write_symbols
== DWARF2_DEBUG
)
1591 static const char * const debugnames
[] =
1593 DEBUG_FRAME_SECTION
,
1595 DEBUG_ABBREV_SECTION
,
1596 DEBUG_ARANGES_SECTION
,
1597 DEBUG_MACINFO_SECTION
,
1600 DEBUG_PUBNAMES_SECTION
,
1601 DEBUG_PUBTYPES_SECTION
,
1603 DEBUG_RANGES_SECTION
1607 for (i
= 0; i
< ARRAY_SIZE (debugnames
); i
++)
1611 switch_to_section (get_section (debugnames
[i
], SECTION_DEBUG
, NULL
));
1613 gcc_assert (strncmp (debugnames
[i
], "__DWARF,", 8) == 0);
1614 gcc_assert (strchr (debugnames
[i
] + 8, ','));
1616 namelen
= strchr (debugnames
[i
] + 8, ',') - (debugnames
[i
] + 8);
1617 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, debugnames
[i
] + 8);
1622 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
1623 offsets are not represented using relocs in .o files; either the
1624 section never leaves the .o file, or the linker or other tool is
1625 responsible for parsing the DWARF and updating the offsets. */
1628 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
1634 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
1635 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
1636 gcc_assert (strchr (base
->named
.name
+ 8, ','));
1638 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
1639 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
1640 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
1644 darwin_file_end (void)
1646 machopic_finish (asm_out_file
);
1647 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
1649 switch_to_section (darwin_sections
[constructor_section
]);
1650 switch_to_section (darwin_sections
[destructor_section
]);
1651 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
1653 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
1656 /* TODO: Add a language hook for identifying if a decl is a vtable. */
1657 #define DARWIN_VTABLE_P(DECL) 0
1659 /* Cross-module name binding. Darwin does not support overriding
1660 functions at dynamic-link time, except for vtables in kexts. */
1663 darwin_binds_local_p (tree decl
)
1665 return default_binds_local_p_1 (decl
,
1666 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
1670 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet. */
1671 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
1672 anchor relative to ".", the current section position. We cannot use
1673 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
1676 darwin_asm_output_anchor (rtx symbol
)
1678 fprintf (asm_out_file
, "\t.set\t");
1679 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1680 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
1681 SYMBOL_REF_BLOCK_OFFSET (symbol
));
1685 /* Set the darwin specific attributes on TYPE. */
1687 darwin_set_default_type_attributes (tree type
)
1689 if (darwin_ms_struct
1690 && TREE_CODE (type
) == RECORD_TYPE
)
1691 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
1693 TYPE_ATTRIBUTES (type
));
1696 /* True, iff we're generating code for loadable kernel extensions. */
1699 darwin_kextabi_p (void) {
1700 return flag_apple_kext
;
1704 darwin_override_options (void)
1706 if (flag_apple_kext
&& strcmp (lang_hooks
.name
, "GNU C++") != 0)
1708 warning (0, "command line option %<-fapple-kext%> is only valid for C++");
1709 flag_apple_kext
= 0;
1711 if (flag_mkernel
|| flag_apple_kext
)
1713 /* -mkernel implies -fapple-kext for C++ */
1714 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
1715 flag_apple_kext
= 1;
1719 /* No EH in kexts. */
1720 flag_exceptions
= 0;
1721 /* No -fnon-call-exceptions data in kexts. */
1722 flag_non_call_exceptions
= 0;
1726 #include "gt-darwin.h"