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, 2011
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"
44 #include "diagnostic-core.h"
50 #include "lto-streamer.h"
52 /* Darwin supports a feature called fix-and-continue, which is used
53 for rapid turn around debugging. When code is compiled with the
54 -mfix-and-continue flag, two changes are made to the generated code
55 that allow the system to do things that it would normally not be
56 able to do easily. These changes allow gdb to load in
57 recompilation of a translation unit that has been changed into a
58 running program and replace existing functions and methods of that
59 translation unit with versions of those functions and methods
60 from the newly compiled translation unit. The new functions access
61 the existing static symbols from the old translation unit, if the
62 symbol existed in the unit to be replaced, and from the new
63 translation unit, otherwise.
65 The changes are to insert 5 nops at the beginning of all functions
66 and to use indirection to get at static symbols. The 5 nops
67 are required by consumers of the generated code. Currently, gdb
68 uses this to patch in a jump to the overriding function, this
69 allows all uses of the old name to forward to the replacement,
70 including existing function pointers and virtual methods. See
71 rs6000_emit_prologue for the code that handles the nop insertions.
73 The added indirection allows gdb to redirect accesses to static
74 symbols from the newly loaded translation unit to the existing
75 symbol, if any. @code{static} symbols are special and are handled by
76 setting the second word in the .non_lazy_symbol_pointer data
77 structure to symbol. See indirect_data for the code that handles
78 the extra indirection, and machopic_output_indirection and its use
79 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
80 symbol indirection. */
82 /* For darwin >= 9 (OSX 10.5) the linker is capable of making the necessary
83 branch islands and we no longer need to emit darwin stubs.
84 However, if we are generating code for earlier systems (or for use in the
85 kernel) the stubs might still be required, and this will be set true. */
86 int darwin_emit_branch_islands
= false;
88 /* A flag to determine whether we are running c++ or obj-c++. This has to be
89 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
91 int darwin_running_cxx
;
93 /* Some code-gen now depends on OS major version numbers (at least). */
94 int generating_for_darwin_version
;
97 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
99 /* While we transition to using in-tests instead of ifdef'd code. */
101 #define HAVE_lo_sum 0
102 #define gen_macho_high(a,b) (a)
103 #define gen_macho_low(a,b,c) (a)
106 /* True if we're setting __attribute__ ((ms_struct)). */
107 int darwin_ms_struct
= false;
109 /* Earlier versions of Darwin as do not recognize an alignment field in
110 .comm directives, this should be set for versions that allow it. */
111 int emit_aligned_common
= false;
113 /* A get_unnamed_section callback used to switch to an ObjC section.
114 DIRECTIVE is as for output_section_asm_op. */
117 output_objc_section_asm_op (const void *directive
)
119 static bool been_here
= false;
121 /* The NeXT ObjC Runtime requires these sections to be present and in
122 order in the object. The code below implements this by emitting
123 a section header for each ObjC section the first time that an ObjC
124 section is requested. */
127 section
*saved_in_section
= in_section
;
128 static const enum darwin_section_enum tomark
[] =
130 /* written, cold -> hot */
131 objc_cat_cls_meth_section
,
132 objc_cat_inst_meth_section
,
133 objc_string_object_section
,
134 objc_constant_string_object_section
,
135 objc_selector_refs_section
,
136 objc_selector_fixup_section
,
137 objc_cls_refs_section
,
139 objc_meta_class_section
,
140 /* shared, hot -> cold */
141 objc_cls_meth_section
,
142 objc_inst_meth_section
,
143 objc_protocol_section
,
144 objc_class_names_section
,
145 objc_meth_var_types_section
,
146 objc_meth_var_names_section
,
147 objc_category_section
,
148 objc_class_vars_section
,
149 objc_instance_vars_section
,
150 objc_module_info_section
,
151 objc_symbols_section
,
154 static const enum darwin_section_enum tomarkv1
[] =
156 objc1_protocol_ext_section
,
157 objc1_class_ext_section
,
158 objc1_prop_list_section
161 static const enum darwin_section_enum tomarkv2
[] =
163 objc2_message_refs_section
,
164 objc2_classdefs_section
,
165 objc2_metadata_section
,
166 objc2_classrefs_section
,
167 objc2_classlist_section
,
168 objc2_categorylist_section
,
169 objc2_selector_refs_section
,
170 objc2_nonlazy_class_section
,
171 objc2_nonlazy_category_section
,
172 objc2_protocollist_section
,
173 objc2_protocolrefs_section
,
174 objc2_super_classrefs_section
,
175 objc2_image_info_section
,
176 objc2_constant_string_object_section
181 if (flag_objc_abi
< 2)
183 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
184 switch_to_section (darwin_sections
[tomark
[i
]]);
185 if (flag_objc_abi
== 1)
186 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
187 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
190 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
191 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
192 /* Make sure we don't get varasm.c out of sync with us. */
193 switch_to_section (saved_in_section
);
195 output_section_asm_op (directive
);
199 /* Private flag applied to disable section-anchors in a particular section. */
200 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
203 /* Implement TARGET_ASM_INIT_SECTIONS. */
206 darwin_init_sections (void)
208 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
209 darwin_sections[NAME] = \
210 get_unnamed_section (FLAGS, (OBJC \
211 ? output_objc_section_asm_op \
212 : output_section_asm_op), \
214 #include "config/darwin-sections.def"
217 readonly_data_section
= darwin_sections
[const_section
];
218 exception_section
= darwin_sections
[darwin_exception_section
];
219 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
223 name_needs_quotes (const char *name
)
226 while ((c
= *name
++) != '\0')
228 && c
!= '.' && c
!= '$' && c
!= '_' )
233 /* Return true if SYM_REF can be used without an indirection. */
235 machopic_symbol_defined_p (rtx sym_ref
)
237 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
240 /* If a symbol references local and is not an extern to this
241 file, then the symbol might be able to declared as defined. */
242 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
244 /* If the symbol references a variable and the variable is a
245 common symbol, then this symbol is not defined. */
246 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
248 tree decl
= SYMBOL_REF_DECL (sym_ref
);
251 if (DECL_COMMON (decl
))
259 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
260 reference, which will not be changed. */
262 enum machopic_addr_class
263 machopic_classify_symbol (rtx sym_ref
)
267 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
268 if (machopic_symbol_defined_p (sym_ref
))
270 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
273 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
276 #ifndef TARGET_FIX_AND_CONTINUE
277 #define TARGET_FIX_AND_CONTINUE 0
280 /* Indicate when fix-and-continue style code generation is being used
281 and when a reference to data should be indirected so that it can be
282 rebound in a new translation unit to reference the original instance
283 of that data. Symbol names that are for code generation local to
284 the translation unit are bound to the new translation unit;
285 currently this means symbols that begin with L or _OBJC_;
286 otherwise, we indicate that an indirect reference should be made to
287 permit the runtime to rebind new instances of the translation unit
288 to the original instance of the data. */
291 indirect_data (rtx sym_ref
)
296 /* If we aren't generating fix-and-continue code, don't do anything
298 if (TARGET_FIX_AND_CONTINUE
== 0)
301 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
302 are indirected. Symbols that begin with L and _OBJC_ are always
303 bound to the current translation unit as they are used for
304 generated local data of the translation unit. */
306 name
= XSTR (sym_ref
, 0);
308 lprefix
= (((name
[0] == '*' || name
[0] == '&')
309 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
310 || (strncmp (name
, "_OBJC_", 6) == 0));
316 machopic_data_defined_p (rtx sym_ref
)
318 if (indirect_data (sym_ref
))
321 switch (machopic_classify_symbol (sym_ref
))
323 case MACHOPIC_DEFINED_DATA
:
324 case MACHOPIC_DEFINED_FUNCTION
:
332 machopic_define_symbol (rtx mem
)
336 gcc_assert (GET_CODE (mem
) == MEM
);
337 sym_ref
= XEXP (mem
, 0);
338 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
341 /* Return either ORIG or:
343 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
345 depending on MACHO_DYNAMIC_NO_PIC_P. */
347 machopic_gen_offset (rtx orig
)
349 if (MACHO_DYNAMIC_NO_PIC_P
)
353 /* Play games to avoid marking the function as needing pic if we
354 are being called as part of the cost-estimation process. */
355 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
356 crtl
->uses_pic_offset_table
= 1;
357 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
358 UNSPEC_MACHOPIC_OFFSET
);
359 return gen_rtx_CONST (Pmode
, orig
);
363 static GTY(()) const char * function_base_func_name
;
364 static GTY(()) int current_pic_label_num
;
367 machopic_output_function_base_name (FILE *file
)
369 const char *current_name
;
371 /* If dynamic-no-pic is on, we should not get here. */
372 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
373 /* When we are generating _get_pc thunks within stubs, there is no current
375 if (current_function_decl
)
378 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
379 if (function_base_func_name
!= current_name
)
381 ++current_pic_label_num
;
382 function_base_func_name
= current_name
;
387 ++current_pic_label_num
;
388 function_base_func_name
= "L_machopic_stub_dummy";
390 fprintf (file
, "L%011d$pb", current_pic_label_num
);
393 /* The suffix attached to non-lazy pointer symbols. */
394 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
395 /* The suffix attached to stub symbols. */
396 #define STUB_SUFFIX "$stub"
398 typedef struct GTY (()) machopic_indirection
400 /* The SYMBOL_REF for the entity referenced. */
402 /* The name of the stub or non-lazy pointer. */
403 const char * ptr_name
;
404 /* True iff this entry is for a stub (as opposed to a non-lazy
407 /* True iff this stub or pointer pointer has been referenced. */
409 } machopic_indirection
;
411 /* A table mapping stub names and non-lazy pointer names to
412 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
414 static GTY ((param_is (struct machopic_indirection
))) htab_t
415 machopic_indirections
;
417 /* Return a hash value for a SLOT in the indirections hash table. */
420 machopic_indirection_hash (const void *slot
)
422 const machopic_indirection
*p
= (const machopic_indirection
*) slot
;
423 return htab_hash_string (p
->ptr_name
);
426 /* Returns true if the KEY is the same as that associated with
430 machopic_indirection_eq (const void *slot
, const void *key
)
432 return strcmp (((const machopic_indirection
*) slot
)->ptr_name
,
433 (const char *) key
) == 0;
436 /* Return the name of the non-lazy pointer (if STUB_P is false) or
437 stub (if STUB_B is true) corresponding to the given name. */
440 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
443 const char *name
= XSTR (sym_ref
, 0);
444 size_t namelen
= strlen (name
);
445 machopic_indirection
*p
;
449 const char *prefix
= user_label_prefix
;
450 const char *quote
= "";
453 id
= maybe_get_identifier (name
);
458 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
459 id
= TREE_CHAIN (id
);
462 name
= IDENTIFIER_POINTER (id
);
463 namelen
= strlen (name
);
474 needs_quotes
= name_needs_quotes (name
);
481 suffix
= STUB_SUFFIX
;
483 suffix
= NON_LAZY_POINTER_SUFFIX
;
485 buffer
= XALLOCAVEC (char, strlen ("&L")
492 /* Construct the name of the non-lazy pointer or stub. */
493 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
495 if (!machopic_indirections
)
496 machopic_indirections
= htab_create_ggc (37,
497 machopic_indirection_hash
,
498 machopic_indirection_eq
,
501 slot
= htab_find_slot_with_hash (machopic_indirections
, buffer
,
502 htab_hash_string (buffer
), INSERT
);
505 p
= (machopic_indirection
*) *slot
;
509 p
= ggc_alloc_machopic_indirection ();
511 p
->ptr_name
= xstrdup (buffer
);
520 /* Return the name of the stub for the mcount function. */
523 machopic_mcount_stub_name (void)
525 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
526 return machopic_indirection_name (symbol
, /*stub_p=*/true);
529 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
530 or non-lazy pointer as used -- and mark the object to which the
531 pointer/stub refers as used as well, since the pointer/stub will
532 emit a reference to it. */
535 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
537 machopic_indirection
*p
;
539 p
= ((machopic_indirection
*)
540 (htab_find_with_hash (machopic_indirections
, name
,
541 htab_hash_string (name
))));
544 const char *real_name
;
549 /* Do what output_addr_const will do when we actually call it. */
550 if (SYMBOL_REF_DECL (p
->symbol
))
551 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
553 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
555 id
= maybe_get_identifier (real_name
);
557 mark_referenced (id
);
561 /* Transform ORIG, which may be any data source, to the corresponding
562 source using indirections. */
565 machopic_indirect_data_reference (rtx orig
, rtx reg
)
569 if (! MACHOPIC_INDIRECT
)
572 if (GET_CODE (orig
) == SYMBOL_REF
)
574 int defined
= machopic_data_defined_p (orig
);
576 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
580 /* Create a new register for CSE opportunities. */
581 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
582 emit_insn (gen_macho_high (hi_reg
, orig
));
583 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
589 /* some other cpu -- writeme! */
595 if (DARWIN_PPC
|| HAVE_lo_sum
)
596 offset
= machopic_gen_offset (orig
);
600 rtx hi_sum_reg
= (!can_create_pseudo_p ()
602 : gen_reg_rtx (Pmode
));
606 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
607 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
608 gen_rtx_HIGH (Pmode
, offset
))));
609 emit_insn (gen_rtx_SET (Pmode
, reg
,
610 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
611 copy_rtx (offset
))));
615 else if (HAVE_lo_sum
)
619 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
620 gen_rtx_HIGH (Pmode
, offset
)));
621 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
622 gen_rtx_LO_SUM (Pmode
, reg
,
623 copy_rtx (offset
))));
624 emit_use (pic_offset_table_rtx
);
626 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
631 ptr_ref
= (gen_rtx_SYMBOL_REF
633 machopic_indirection_name (orig
, /*stub_p=*/false)));
635 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
637 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
638 machopic_define_symbol (ptr_ref
);
642 && MACHO_DYNAMIC_NO_PIC_P
)
644 emit_insn (gen_rtx_SET (Pmode
, reg
, ptr_ref
));
650 else if (GET_CODE (orig
) == CONST
)
652 /* If "(const (plus ...", walk the PLUS and return that result.
653 PLUS processing (below) will restore the "(const ..." if
655 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
656 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
660 else if (GET_CODE (orig
) == MEM
)
663 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
666 else if (GET_CODE (orig
) == PLUS
)
669 /* When the target is i386, this code prevents crashes due to the
670 compiler's ignorance on how to move the PIC base register to
671 other registers. (The reload phase sometimes introduces such
673 if (GET_CODE (XEXP (orig
, 0)) == REG
674 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
675 /* Prevent the same register from being erroneously used
676 as both the base and index registers. */
677 && (DARWIN_X86
&& (GET_CODE (XEXP (orig
, 1)) == CONST
))
680 emit_move_insn (reg
, XEXP (orig
, 0));
681 XEXP (ptr_ref
, 0) = reg
;
685 /* Legitimize both operands of the PLUS. */
686 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
687 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
688 (base
== reg
? 0 : reg
));
689 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
690 result
= plus_constant (base
, INTVAL (orig
));
692 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
694 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
698 emit_move_insn (reg
, result
);
703 result
= force_reg (GET_MODE (result
), result
);
712 /* Transform TARGET (a MEM), which is a function call target, to the
713 corresponding symbol_stub if necessary. Return a new MEM. */
716 machopic_indirect_call_target (rtx target
)
718 if (! darwin_emit_branch_islands
)
721 if (GET_CODE (target
) != MEM
)
724 if (MACHOPIC_INDIRECT
725 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
726 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
727 & MACHO_SYMBOL_FLAG_DEFINED
))
729 rtx sym_ref
= XEXP (target
, 0);
730 const char *stub_name
= machopic_indirection_name (sym_ref
,
732 enum machine_mode mode
= GET_MODE (sym_ref
);
734 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
735 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
736 MEM_READONLY_P (target
) = 1;
737 MEM_NOTRAP_P (target
) = 1;
744 machopic_legitimize_pic_address (rtx orig
, enum machine_mode mode
, rtx reg
)
748 if (! MACHOPIC_INDIRECT
)
751 /* First handle a simple SYMBOL_REF or LABEL_REF */
752 if (GET_CODE (orig
) == LABEL_REF
753 || (GET_CODE (orig
) == SYMBOL_REF
756 /* addr(foo) = &func+(foo-func) */
757 orig
= machopic_indirect_data_reference (orig
, reg
);
759 if (GET_CODE (orig
) == PLUS
760 && GET_CODE (XEXP (orig
, 0)) == REG
)
763 return force_reg (mode
, orig
);
765 emit_move_insn (reg
, orig
);
769 if (GET_CODE (orig
) == MEM
)
773 gcc_assert (!reload_in_progress
);
774 reg
= gen_reg_rtx (Pmode
);
778 if (MACHO_DYNAMIC_NO_PIC_P
779 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
780 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
782 #if defined (TARGET_TOC) /* ppc */
783 rtx temp_reg
= (!can_create_pseudo_p ()
785 gen_reg_rtx (Pmode
));
786 rtx asym
= XEXP (orig
, 0);
789 emit_insn (gen_macho_high (temp_reg
, asym
));
790 mem
= gen_const_mem (GET_MODE (orig
),
791 gen_rtx_LO_SUM (Pmode
, temp_reg
,
793 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
795 /* Some other CPU -- WriteMe! but right now there are no other
796 platforms that can use dynamic-no-pic */
802 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
803 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
805 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
806 #if defined (TARGET_TOC) /* i.e., PowerPC */
807 /* Generating a new reg may expose opportunities for
808 common subexpression elimination. */
809 rtx hi_sum_reg
= (!can_create_pseudo_p ()
811 : gen_reg_rtx (Pmode
));
816 sum
= gen_rtx_HIGH (Pmode
, offset
);
817 if (! MACHO_DYNAMIC_NO_PIC_P
)
818 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
820 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
822 mem
= gen_const_mem (GET_MODE (orig
),
823 gen_rtx_LO_SUM (Pmode
,
826 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
827 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
831 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
833 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
835 gen_rtx_CONST (Pmode
,
837 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
838 gen_rtx_LO_SUM (Pmode
, reg
,
839 gen_rtx_CONST (Pmode
,
840 copy_rtx (offset
)))));
841 pic_ref
= gen_rtx_PLUS (Pmode
,
842 pic_offset_table_rtx
, reg
);
846 #endif /* HAVE_lo_sum */
848 rtx pic
= pic_offset_table_rtx
;
849 if (GET_CODE (pic
) != REG
)
851 emit_move_insn (reg
, pic
);
855 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
858 if (reload_in_progress
)
859 df_set_regs_ever_live (REGNO (pic
), true);
860 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
861 machopic_gen_offset (XEXP (orig
, 0)));
864 #if !defined (TARGET_TOC)
865 emit_move_insn (reg
, pic_ref
);
866 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
873 if (GET_CODE (orig
) == SYMBOL_REF
874 || GET_CODE (orig
) == LABEL_REF
)
876 rtx offset
= machopic_gen_offset (orig
);
877 #if defined (TARGET_TOC) /* i.e., PowerPC */
882 gcc_assert (!reload_in_progress
);
883 reg
= gen_reg_rtx (Pmode
);
888 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
889 (MACHO_DYNAMIC_NO_PIC_P
)
890 ? gen_rtx_HIGH (Pmode
, offset
)
891 : gen_rtx_PLUS (Pmode
,
892 pic_offset_table_rtx
,
895 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
896 gen_rtx_LO_SUM (Pmode
,
898 copy_rtx (offset
))));
901 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
902 gen_rtx_HIGH (Pmode
, offset
)));
903 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
904 gen_rtx_LO_SUM (Pmode
, reg
,
905 copy_rtx (offset
))));
906 pic_ref
= gen_rtx_PLUS (Pmode
,
907 pic_offset_table_rtx
, reg
);
911 #endif /* HAVE_lo_sum */
914 || GET_CODE (orig
) == SUBREG
)
920 rtx pic
= pic_offset_table_rtx
;
921 if (GET_CODE (pic
) != REG
)
923 emit_move_insn (reg
, pic
);
927 emit_use (pic_offset_table_rtx
);
929 if (reload_in_progress
)
930 df_set_regs_ever_live (REGNO (pic
), true);
931 pic_ref
= gen_rtx_PLUS (Pmode
,
933 machopic_gen_offset (orig
));
938 if (GET_CODE (pic_ref
) != REG
)
942 emit_move_insn (reg
, pic_ref
);
947 return force_reg (mode
, pic_ref
);
956 else if (GET_CODE (orig
) == SYMBOL_REF
)
959 else if (GET_CODE (orig
) == PLUS
960 && (GET_CODE (XEXP (orig
, 0)) == MEM
961 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
962 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
963 && XEXP (orig
, 0) != pic_offset_table_rtx
964 && GET_CODE (XEXP (orig
, 1)) != REG
)
968 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
970 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
971 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
972 Pmode
, (base
== reg
? 0 : reg
));
973 if (GET_CODE (orig
) == CONST_INT
)
975 pic_ref
= plus_constant (base
, INTVAL (orig
));
979 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
981 if (reg
&& is_complex
)
983 emit_move_insn (reg
, pic_ref
);
986 /* Likewise, should we set special REG_NOTEs here? */
989 else if (GET_CODE (orig
) == CONST
)
991 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
994 else if (GET_CODE (orig
) == MEM
995 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
997 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
998 addr
= replace_equiv_address (orig
, addr
);
999 emit_move_insn (reg
, addr
);
1006 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
1007 DATA is the FILE* for assembly output. Called from
1011 machopic_output_indirection (void **slot
, void *data
)
1013 machopic_indirection
*p
= *((machopic_indirection
**) slot
);
1014 FILE *asm_out_file
= (FILE *) data
;
1016 const char *sym_name
;
1017 const char *ptr_name
;
1023 sym_name
= XSTR (symbol
, 0);
1024 ptr_name
= p
->ptr_name
;
1032 id
= maybe_get_identifier (sym_name
);
1037 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1038 id
= TREE_CHAIN (id
);
1040 sym_name
= IDENTIFIER_POINTER (id
);
1043 sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1044 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1045 strcpy (sym
, sym_name
+ 1);
1046 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1047 strcpy (sym
, sym_name
);
1049 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1051 stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1052 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1053 strcpy (stub
, ptr_name
+ 1);
1055 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1057 machopic_output_stub (asm_out_file
, sym
, stub
);
1059 else if (! indirect_data (symbol
)
1060 && (machopic_symbol_defined_p (symbol
)
1061 || SYMBOL_REF_LOCAL_P (symbol
)))
1063 switch_to_section (data_section
);
1064 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1065 assemble_label (asm_out_file
, ptr_name
);
1066 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1067 GET_MODE_SIZE (Pmode
),
1068 GET_MODE_ALIGNMENT (Pmode
), 1);
1072 rtx init
= const0_rtx
;
1074 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1076 /* Mach-O symbols are passed around in code through indirect
1077 references and the original symbol_ref hasn't passed through
1078 the generic handling and reference-catching in
1079 output_operand, so we need to manually mark weak references
1081 if (SYMBOL_REF_WEAK (symbol
))
1083 tree decl
= SYMBOL_REF_DECL (symbol
);
1084 gcc_assert (DECL_P (decl
));
1086 if (decl
!= NULL_TREE
1087 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1088 /* Handle only actual external-only definitions, not
1089 e.g. extern inline code or variables for which
1090 storage has been allocated. */
1091 && !TREE_STATIC (decl
))
1093 fputs ("\t.weak_reference ", asm_out_file
);
1094 assemble_name (asm_out_file
, sym_name
);
1095 fputc ('\n', asm_out_file
);
1099 assemble_name (asm_out_file
, ptr_name
);
1100 fprintf (asm_out_file
, ":\n");
1102 fprintf (asm_out_file
, "\t.indirect_symbol ");
1103 assemble_name (asm_out_file
, sym_name
);
1104 fprintf (asm_out_file
, "\n");
1106 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1107 have their symbol name instead of 0 in the second entry of
1108 the non-lazy symbol pointer data structure when they are
1109 defined. This allows the runtime to rebind newer instances
1110 of the translation unit with the original instance of the
1113 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1114 && machopic_symbol_defined_p (symbol
))
1115 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1117 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1118 GET_MODE_ALIGNMENT (Pmode
), 1);
1125 machopic_finish (FILE *asm_out_file
)
1127 if (machopic_indirections
)
1128 htab_traverse_noresize (machopic_indirections
,
1129 machopic_output_indirection
,
1134 machopic_operand_p (rtx op
)
1136 if (MACHOPIC_JUST_INDIRECT
)
1137 return (GET_CODE (op
) == SYMBOL_REF
1138 && machopic_symbol_defined_p (op
));
1140 return (GET_CODE (op
) == CONST
1141 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1142 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1145 /* This function records whether a given name corresponds to a defined
1146 or undefined function or variable, for machopic_classify_ident to
1150 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1154 /* Do the standard encoding things first. */
1155 default_encode_section_info (decl
, rtl
, first
);
1157 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1160 sym_ref
= XEXP (rtl
, 0);
1161 if (TREE_CODE (decl
) == VAR_DECL
)
1162 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1164 if (!DECL_EXTERNAL (decl
)
1165 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1166 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1167 && ((TREE_STATIC (decl
)
1168 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1169 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1170 && DECL_INITIAL (decl
) != error_mark_node
)))
1171 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1173 if (! TREE_PUBLIC (decl
))
1174 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1178 darwin_mark_decl_preserved (const char *name
)
1180 fprintf (asm_out_file
, "\t.no_dead_strip ");
1181 assemble_name (asm_out_file
, name
);
1182 fputc ('\n', asm_out_file
);
1186 darwin_rodata_section (int weak
, bool zsize
)
1189 ? darwin_sections
[const_coal_section
]
1190 : (zsize
? darwin_sections
[zobj_const_section
]
1191 : darwin_sections
[const_section
]));
1195 darwin_mergeable_string_section (tree exp
,
1196 unsigned HOST_WIDE_INT align
)
1198 /* Darwin's ld expects to see non-writable string literals in the .cstring
1199 section. Later versions of ld check and complain when CFStrings are
1200 enabled. Therefore we shall force the strings into .cstring since we
1201 don't support writable ones anyway. */
1202 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1203 && TREE_CODE (exp
) == STRING_CST
1204 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1206 && (int_size_in_bytes (TREE_TYPE (exp
))
1207 == TREE_STRING_LENGTH (exp
))
1208 && ((size_t) TREE_STRING_LENGTH (exp
)
1209 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1210 return darwin_sections
[cstring_section
];
1212 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1213 && TREE_CODE (exp
) == STRING_CST
1214 && TREE_STRING_LENGTH (exp
) == 0)
1215 return darwin_sections
[zobj_const_section
];
1217 return readonly_data_section
;
1220 #ifndef HAVE_GAS_LITERAL16
1221 #define HAVE_GAS_LITERAL16 0
1225 darwin_mergeable_constant_section (tree exp
,
1226 unsigned HOST_WIDE_INT align
,
1229 enum machine_mode mode
= DECL_MODE (exp
);
1230 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1232 if (DARWIN_SECTION_ANCHORS
1233 && flag_section_anchors
1235 return darwin_sections
[zobj_const_section
];
1237 if (flag_merge_constants
1240 && modesize
<= align
1243 && (align
& (align
-1)) == 0)
1245 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1247 if (TREE_CODE (size
) == INTEGER_CST
1248 && TREE_INT_CST_LOW (size
) == 4
1249 && TREE_INT_CST_HIGH (size
) == 0)
1250 return darwin_sections
[literal4_section
];
1251 else if (TREE_CODE (size
) == INTEGER_CST
1252 && TREE_INT_CST_LOW (size
) == 8
1253 && TREE_INT_CST_HIGH (size
) == 0)
1254 return darwin_sections
[literal8_section
];
1255 else if (HAVE_GAS_LITERAL16
1257 && TREE_CODE (size
) == INTEGER_CST
1258 && TREE_INT_CST_LOW (size
) == 16
1259 && TREE_INT_CST_HIGH (size
) == 0)
1260 return darwin_sections
[literal16_section
];
1262 return readonly_data_section
;
1265 return readonly_data_section
;
1269 machopic_reloc_rw_mask (void)
1271 return MACHOPIC_INDIRECT
? 3 : 0;
1274 /* We have to deal with ObjC/C++ metadata section placement in the common
1275 code, since it will also be called from LTO.
1277 Return metadata attributes, if present (searching for ABI=2 first)
1278 Return NULL_TREE if no such attributes are found. */
1281 is_objc_metadata (tree decl
)
1284 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1285 && DECL_ATTRIBUTES (decl
))
1287 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1290 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1297 /* Return the section required for Objective C ABI 2 metadata. */
1299 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1302 tree ident
= TREE_VALUE (meta
);
1303 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1304 p
= IDENTIFIER_POINTER (ident
);
1306 /* If we are in LTO, then we don't know the state of flag_next_runtime
1307 or flag_objc_abi when the code was generated. We set these from the
1308 meta-data - which is needed to deal with const string constructors. */
1310 flag_next_runtime
= 1;
1313 if (base
== data_section
)
1314 base
= darwin_sections
[objc2_metadata_section
];
1316 /* Most of the OBJC2 META-data end up in the base section, so check it
1318 if (!strncmp (p
, "V2_BASE", 7))
1320 else if (!strncmp (p
, "V2_STRG", 7))
1321 return darwin_sections
[cstring_section
];
1323 else if (!strncmp (p
, "G2_META", 7) || !strncmp (p
, "G2_CLAS", 7))
1324 return darwin_sections
[objc2_classdefs_section
];
1325 else if (!strncmp (p
, "V2_MREF", 7))
1326 return darwin_sections
[objc2_message_refs_section
];
1327 else if (!strncmp (p
, "V2_CLRF", 7))
1328 return darwin_sections
[objc2_classrefs_section
];
1329 else if (!strncmp (p
, "V2_SURF", 7))
1330 return darwin_sections
[objc2_super_classrefs_section
];
1331 else if (!strncmp (p
, "V2_NLCL", 7))
1332 return darwin_sections
[objc2_nonlazy_class_section
];
1333 else if (!strncmp (p
, "V2_CLAB", 7))
1334 return darwin_sections
[objc2_classlist_section
];
1335 else if (!strncmp (p
, "V2_SRFS", 7))
1336 return darwin_sections
[objc2_selector_refs_section
];
1337 else if (!strncmp (p
, "V2_NLCA", 7))
1338 return darwin_sections
[objc2_nonlazy_category_section
];
1339 else if (!strncmp (p
, "V2_CALA", 7))
1340 return darwin_sections
[objc2_categorylist_section
];
1342 else if (!strncmp (p
, "V2_PLST", 7))
1343 return darwin_sections
[objc2_protocollist_section
];
1344 else if (!strncmp (p
, "V2_PRFS", 7))
1345 return darwin_sections
[objc2_protocolrefs_section
];
1347 else if (!strncmp (p
, "V2_INFO", 7))
1348 return darwin_sections
[objc2_image_info_section
];
1350 else if (!strncmp (p
, "V2_EHTY", 7))
1351 return darwin_sections
[data_coal_section
];
1353 else if (!strncmp (p
, "V2_CSTR", 7))
1354 return darwin_sections
[objc2_constant_string_object_section
];
1356 /* Not recognized, default. */
1360 /* Return the section required for Objective C ABI 0/1 metadata. */
1362 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1365 tree ident
= TREE_VALUE (meta
);
1366 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1367 p
= IDENTIFIER_POINTER (ident
);
1369 /* If we are in LTO, then we don't know the state of flag_next_runtime
1370 or flag_objc_abi when the code was generated. We set these from the
1371 meta-data - which is needed to deal with const string constructors. */
1372 flag_next_runtime
= 1;
1373 if (!global_options_set
.x_flag_objc_abi
)
1376 /* String sections first, cos there are lots of strings. */
1377 if (!strncmp (p
, "V1_STRG", 7))
1378 return darwin_sections
[cstring_section
];
1379 else if (!strncmp (p
, "V1_CLSN", 7))
1380 return darwin_sections
[objc_class_names_section
];
1381 else if (!strncmp (p
, "V1_METN", 7))
1382 return darwin_sections
[objc_meth_var_names_section
];
1383 else if (!strncmp (p
, "V1_METT", 7))
1384 return darwin_sections
[objc_meth_var_types_section
];
1386 else if (!strncmp (p
, "V1_CLAS", 7))
1387 return darwin_sections
[objc_class_section
];
1388 else if (!strncmp (p
, "V1_META", 7))
1389 return darwin_sections
[objc_meta_class_section
];
1390 else if (!strncmp (p
, "V1_CATG", 7))
1391 return darwin_sections
[objc_category_section
];
1392 else if (!strncmp (p
, "V1_PROT", 7))
1393 return darwin_sections
[objc_protocol_section
];
1395 else if (!strncmp (p
, "V1_CLCV", 7))
1396 return darwin_sections
[objc_class_vars_section
];
1397 else if (!strncmp (p
, "V1_CLIV", 7))
1398 return darwin_sections
[objc_instance_vars_section
];
1400 else if (!strncmp (p
, "V1_CLCM", 7))
1401 return darwin_sections
[objc_cls_meth_section
];
1402 else if (!strncmp (p
, "V1_CLIM", 7))
1403 return darwin_sections
[objc_inst_meth_section
];
1404 else if (!strncmp (p
, "V1_CACM", 7))
1405 return darwin_sections
[objc_cat_cls_meth_section
];
1406 else if (!strncmp (p
, "V1_CAIM", 7))
1407 return darwin_sections
[objc_cat_inst_meth_section
];
1408 else if (!strncmp (p
, "V1_PNSM", 7))
1409 return darwin_sections
[objc_cat_inst_meth_section
];
1410 else if (!strncmp (p
, "V1_PCLM", 7))
1411 return darwin_sections
[objc_cat_cls_meth_section
];
1413 else if (!strncmp (p
, "V1_CLPR", 7))
1414 return darwin_sections
[objc_cat_cls_meth_section
];
1415 else if (!strncmp (p
, "V1_CAPR", 7))
1416 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1418 else if (!strncmp (p
, "V1_PRFS", 7))
1419 return darwin_sections
[objc_cat_cls_meth_section
];
1420 else if (!strncmp (p
, "V1_CLRF", 7))
1421 return darwin_sections
[objc_cls_refs_section
];
1422 else if (!strncmp (p
, "V1_SRFS", 7))
1423 return darwin_sections
[objc_selector_refs_section
];
1425 else if (!strncmp (p
, "V1_MODU", 7))
1426 return darwin_sections
[objc_module_info_section
];
1427 else if (!strncmp (p
, "V1_SYMT", 7))
1428 return darwin_sections
[objc_symbols_section
];
1429 else if (!strncmp (p
, "V1_INFO", 7))
1430 return darwin_sections
[objc_image_info_section
];
1432 else if (!strncmp (p
, "V1_PLST", 7))
1433 return darwin_sections
[objc1_prop_list_section
];
1434 else if (!strncmp (p
, "V1_PEXT", 7))
1435 return darwin_sections
[objc1_protocol_ext_section
];
1436 else if (!strncmp (p
, "V1_CEXT", 7))
1437 return darwin_sections
[objc1_class_ext_section
];
1439 else if (!strncmp (p
, "V2_CSTR", 7))
1440 return darwin_sections
[objc_constant_string_object_section
];
1446 machopic_select_section (tree decl
,
1448 unsigned HOST_WIDE_INT align
)
1450 bool zsize
, one
, weak
, ro
;
1451 section
*base_section
= NULL
;
1453 weak
= (DECL_P (decl
)
1455 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1457 zsize
= (DECL_P (decl
)
1458 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1459 && tree_low_cst (DECL_SIZE_UNIT (decl
), 1) == 0);
1462 && TREE_CODE (decl
) == VAR_DECL
1463 && DECL_ONE_ONLY (decl
);
1465 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1467 switch (categorize_decl_for_section (decl
, reloc
))
1474 case SECCAT_SRODATA
:
1475 base_section
= darwin_rodata_section (weak
, zsize
);
1478 case SECCAT_RODATA_MERGE_STR
:
1479 base_section
= darwin_mergeable_string_section (decl
, align
);
1482 case SECCAT_RODATA_MERGE_STR_INIT
:
1483 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1486 case SECCAT_RODATA_MERGE_CONST
:
1487 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1491 case SECCAT_DATA_REL
:
1492 case SECCAT_DATA_REL_LOCAL
:
1493 case SECCAT_DATA_REL_RO
:
1494 case SECCAT_DATA_REL_RO_LOCAL
:
1500 base_section
= darwin_sections
[const_data_coal_section
];
1502 base_section
= darwin_sections
[data_coal_section
];
1504 else if (DARWIN_SECTION_ANCHORS
1505 && flag_section_anchors
1508 /* If we're doing section anchors, then punt zero-sized objects into
1509 their own sections so that they don't interfere with offset
1510 computation for the remaining vars. This does not need to be done
1511 for stuff in mergeable sections, since these are ineligible for
1514 base_section
= darwin_sections
[zobj_const_data_section
];
1516 base_section
= darwin_sections
[zobj_data_section
];
1519 base_section
= darwin_sections
[const_data_section
];
1521 base_section
= data_section
;
1527 base_section
= darwin_sections
[data_coal_section
];
1530 if (!TREE_PUBLIC (decl
))
1531 base_section
= lcomm_section
;
1532 else if (bss_noswitch_section
)
1533 base_section
= bss_noswitch_section
;
1535 base_section
= data_section
;
1543 /* Darwin weird special cases.
1544 a) OBJC Meta-data. */
1546 && (TREE_CODE (decl
) == VAR_DECL
1547 || TREE_CODE (decl
) == CONST_DECL
)
1548 && DECL_ATTRIBUTES (decl
))
1550 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1552 return darwin_objc2_section (decl
, meta
, base_section
);
1553 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1555 return darwin_objc1_section (decl
, meta
, base_section
);
1556 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1558 return base_section
; /* GNU runtime is happy with it all in one pot. */
1561 /* b) Constant string objects. */
1562 if (TREE_CODE (decl
) == CONSTRUCTOR
1564 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1565 && TYPE_NAME (TREE_TYPE (decl
)))
1567 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1568 if (TREE_CODE (name
) == TYPE_DECL
)
1569 name
= DECL_NAME (name
);
1571 /* FIXME: This is unsatisfactory for LTO, since it relies on other
1572 metadata determining the source FE. */
1573 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1575 if (flag_next_runtime
)
1577 if (flag_objc_abi
== 2)
1578 return darwin_sections
[objc2_constant_string_object_section
];
1580 return darwin_sections
[objc_constant_string_object_section
];
1583 return darwin_sections
[objc_string_object_section
];
1585 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1586 return darwin_sections
[cfstring_constant_object_section
];
1588 return base_section
;
1590 /* c) legacy meta-data selection. */
1591 else if (TREE_CODE (decl
) == VAR_DECL
1593 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1594 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1595 && flag_next_runtime
1596 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1598 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1599 static bool warned_objc_46
= false;
1600 /* We shall assert that zero-sized objects are an error in ObjC
1602 gcc_assert (tree_low_cst (DECL_SIZE_UNIT (decl
), 1) != 0);
1604 /* ??? This mechanism for determining the metadata section is
1605 broken when LTO is in use, since the frontend that generated
1606 the data is not identified. We will keep the capability for
1607 the short term - in case any non-Objective-C programs are using
1608 it to place data in specified sections. */
1609 if (!warned_objc_46
)
1611 location_t loc
= DECL_SOURCE_LOCATION (decl
);
1612 warning_at (loc
, 0, "the use of _OBJC_-prefixed variable names"
1613 " to select meta-data sections is deprecated at 4.6"
1614 " and will be removed in 4.7");
1615 warned_objc_46
= true;
1618 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1619 return darwin_sections
[objc_cls_meth_section
];
1620 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1621 return darwin_sections
[objc_inst_meth_section
];
1622 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 29))
1623 return darwin_sections
[objc_cat_cls_meth_section
];
1624 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 32))
1625 return darwin_sections
[objc_cat_inst_meth_section
];
1626 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1627 return darwin_sections
[objc_class_vars_section
];
1628 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1629 return darwin_sections
[objc_instance_vars_section
];
1630 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1631 return darwin_sections
[objc_cat_cls_meth_section
];
1632 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1633 return darwin_sections
[objc_class_names_section
];
1634 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1635 return darwin_sections
[objc_meth_var_names_section
];
1636 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1637 return darwin_sections
[objc_meth_var_types_section
];
1638 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1639 return darwin_sections
[objc_cls_refs_section
];
1640 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1641 return darwin_sections
[objc_class_section
];
1642 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1643 return darwin_sections
[objc_meta_class_section
];
1644 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1645 return darwin_sections
[objc_category_section
];
1646 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1647 return darwin_sections
[objc_selector_refs_section
];
1648 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1649 return darwin_sections
[objc_selector_fixup_section
];
1650 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1651 return darwin_sections
[objc_symbols_section
];
1652 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1653 return darwin_sections
[objc_module_info_section
];
1654 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1655 return darwin_sections
[objc_image_info_section
];
1656 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1657 return darwin_sections
[objc_cat_inst_meth_section
];
1658 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1659 return darwin_sections
[objc_cat_cls_meth_section
];
1660 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1661 return darwin_sections
[objc_cat_cls_meth_section
];
1662 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1663 return darwin_sections
[objc_protocol_section
];
1665 return base_section
;
1668 return base_section
;
1671 /* This can be called with address expressions as "rtx".
1672 They must go in "const". */
1675 machopic_select_rtx_section (enum machine_mode mode
, rtx x
,
1676 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1678 if (GET_MODE_SIZE (mode
) == 8
1679 && (GET_CODE (x
) == CONST_INT
1680 || GET_CODE (x
) == CONST_DOUBLE
))
1681 return darwin_sections
[literal8_section
];
1682 else if (GET_MODE_SIZE (mode
) == 4
1683 && (GET_CODE (x
) == CONST_INT
1684 || GET_CODE (x
) == CONST_DOUBLE
))
1685 return darwin_sections
[literal4_section
];
1686 else if (HAVE_GAS_LITERAL16
1688 && GET_MODE_SIZE (mode
) == 16
1689 && (GET_CODE (x
) == CONST_INT
1690 || GET_CODE (x
) == CONST_DOUBLE
1691 || GET_CODE (x
) == CONST_VECTOR
))
1692 return darwin_sections
[literal16_section
];
1693 else if (MACHOPIC_INDIRECT
1694 && (GET_CODE (x
) == SYMBOL_REF
1695 || GET_CODE (x
) == CONST
1696 || GET_CODE (x
) == LABEL_REF
))
1697 return darwin_sections
[const_data_section
];
1699 return darwin_sections
[const_section
];
1703 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1705 if (MACHOPIC_INDIRECT
)
1706 switch_to_section (darwin_sections
[mod_init_section
]);
1708 switch_to_section (darwin_sections
[constructor_section
]);
1709 assemble_align (POINTER_SIZE
);
1710 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1712 if (! MACHOPIC_INDIRECT
)
1713 fprintf (asm_out_file
, ".reference .constructors_used\n");
1717 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1719 if (MACHOPIC_INDIRECT
)
1720 switch_to_section (darwin_sections
[mod_term_section
]);
1722 switch_to_section (darwin_sections
[destructor_section
]);
1723 assemble_align (POINTER_SIZE
);
1724 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1726 if (! MACHOPIC_INDIRECT
)
1727 fprintf (asm_out_file
, ".reference .destructors_used\n");
1731 darwin_globalize_label (FILE *stream
, const char *name
)
1733 if (!!strncmp (name
, "_OBJC_", 6))
1734 default_globalize_label (stream
, name
);
1737 /* This routine returns non-zero if 'name' starts with the special objective-c
1738 anonymous file-scope static name. It accommodates c++'s mangling of such
1739 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1742 darwin_label_is_anonymous_local_objc_name (const char *name
)
1744 const unsigned char *p
= (const unsigned char *) name
;
1747 if (p
[1] == 'Z' && p
[2] == 'L')
1750 while (*p
>= '0' && *p
<= '9')
1753 return (!strncmp ((const char *)p
, "_OBJC_", 6));
1756 /* LTO support for Mach-O. */
1758 /* Section names for LTO sections. */
1759 static unsigned int lto_section_names_offset
= 0;
1761 /* This is the obstack which we use to allocate the many strings. */
1762 static struct obstack lto_section_names_obstack
;
1764 /* Segment name for LTO sections. */
1765 #define LTO_SEGMENT_NAME "__GNU_LTO"
1767 /* Section name for LTO section names section. */
1768 #define LTO_NAMES_SECTION "__section_names"
1770 /* File to temporarily store LTO data. This is appended to asm_out_file
1771 in darwin_end_file. */
1772 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
1773 static char *lto_asm_out_name
;
1775 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
1776 asm_out_file and switching to an alternative output file. */
1778 darwin_asm_lto_start (void)
1780 gcc_assert (! saved_asm_out_file
);
1781 saved_asm_out_file
= asm_out_file
;
1782 if (! lto_asm_out_name
)
1783 lto_asm_out_name
= make_temp_file (".lto.s");
1784 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
1785 if (lto_asm_out_file
== NULL
)
1786 fatal_error ("failed to open temporary file %s for LTO output",
1788 asm_out_file
= lto_asm_out_file
;
1791 /* Restore asm_out_file. */
1793 darwin_asm_lto_end (void)
1795 gcc_assert (saved_asm_out_file
);
1796 fclose (lto_asm_out_file
);
1797 asm_out_file
= saved_asm_out_file
;
1798 saved_asm_out_file
= NULL
;
1802 darwin_asm_dwarf_section (const char *name
, unsigned int flags
, tree decl
);
1804 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
1807 darwin_asm_named_section (const char *name
,
1809 tree decl ATTRIBUTE_UNUSED
)
1811 /* LTO sections go in a special segment __GNU_LTO. We want to replace the
1812 section name with something we can use to represent arbitrary-length
1813 names (section names in Mach-O are at most 16 characters long). */
1814 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
1815 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
1817 /* We expect certain flags to be set... */
1818 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
1819 == (SECTION_DEBUG
| SECTION_NAMED
));
1821 /* Add the section name to the things to output when we end the
1822 current assembler output file.
1823 This is all not very efficient, but that doesn't matter -- this
1824 shouldn't be a hot path in the compiler... */
1825 obstack_1grow (<o_section_names_obstack
, '\t');
1826 obstack_grow (<o_section_names_obstack
, ".ascii ", 7);
1827 obstack_1grow (<o_section_names_obstack
, '"');
1828 obstack_grow (<o_section_names_obstack
, name
, strlen (name
));
1829 obstack_grow (<o_section_names_obstack
, "\\0\"\n", 4);
1831 /* Output the dummy section name. */
1832 fprintf (asm_out_file
, "\t# %s\n", name
);
1833 fprintf (asm_out_file
, "\t.section %s,__%08X,regular,debug\n",
1834 LTO_SEGMENT_NAME
, lto_section_names_offset
);
1836 /* Update the offset for the next section name. Make sure we stay
1837 within reasonable length. */
1838 lto_section_names_offset
+= strlen (name
) + 1;
1839 gcc_assert (lto_section_names_offset
> 0
1840 && lto_section_names_offset
< ((unsigned) 1 << 31));
1842 else if (strncmp (name
, "__DWARF,", 8) == 0)
1843 darwin_asm_dwarf_section (name
, flags
, decl
);
1845 fprintf (asm_out_file
, "\t.section %s\n", name
);
1849 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
1851 /* Darwin does not use unique sections. */
1854 /* Handle __attribute__ ((apple_kext_compatibility)).
1855 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1856 vtable for classes with this attribute (and their descendants) by not
1857 outputting the new 3.0 nondeleting destructor. This means that such
1858 objects CANNOT be allocated on the stack or as globals UNLESS they have
1859 a completely empty `operator delete'.
1860 Luckily, this fits in with the Darwin kext model.
1862 This attribute also disables gcc3's potential overlaying of derived
1863 class data members on the padding at the end of the base class. */
1866 darwin_handle_kext_attribute (tree
*node
, tree name
,
1867 tree args ATTRIBUTE_UNUSED
,
1868 int flags ATTRIBUTE_UNUSED
,
1871 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
1872 if (! TARGET_KEXTABI
)
1874 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1875 "only when compiling a kext", name
);
1877 *no_add_attrs
= true;
1879 else if (TREE_CODE (*node
) != RECORD_TYPE
)
1881 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1882 "only to C++ classes", name
);
1884 *no_add_attrs
= true;
1890 /* Handle a "weak_import" attribute; arguments as in
1891 struct attribute_spec.handler. */
1894 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
1895 tree
ARG_UNUSED (args
),
1896 int ARG_UNUSED (flags
),
1897 bool * no_add_attrs
)
1899 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
1901 warning (OPT_Wattributes
, "%qE attribute ignored",
1903 *no_add_attrs
= true;
1906 declare_weak (*node
);
1911 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1912 The third parameter is nonzero if this is for exception handling.
1913 The fourth parameter is nonzero if this is just a placeholder for an
1914 FDE that we are omitting. */
1917 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
1921 static int invok_count
= 0;
1922 static tree last_fun_decl
= NULL_TREE
;
1924 /* We use the linker to emit the .eh labels for Darwin 9 and above. */
1925 if (! for_eh
|| generating_for_darwin_version
>= 9)
1928 /* FIXME: This only works when the eh for all sections of a function is
1929 emitted at the same time. If that changes, we would need to use a lookup
1930 table of some form to determine what to do. Also, we should emit the
1931 unadorned label for the partition containing the public label for a
1932 function. This is of limited use, probably, since we do not currently
1933 enable partitioning. */
1934 strcpy (buf
, ".eh");
1935 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
1937 if (decl
== last_fun_decl
)
1940 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
1944 last_fun_decl
= decl
;
1949 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
1951 if (TREE_PUBLIC (decl
))
1953 targetm
.asm_out
.globalize_label (file
, lab
);
1954 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
1956 fputs ("\t.private_extern ", file
);
1957 assemble_name (file
, lab
);
1962 if (DECL_WEAK (decl
))
1964 fputs ("\t.weak_definition ", file
);
1965 assemble_name (file
, lab
);
1969 assemble_name (file
, lab
);
1972 fputs (" = 0\n", file
);
1974 /* Mark the absolute .eh and .eh1 style labels as needed to
1975 ensure that we don't dead code strip them and keep such
1976 labels from another instantiation point until we can fix this
1977 properly with group comdat support. */
1978 darwin_mark_decl_preserved (lab
);
1981 fputs (":\n", file
);
1986 static GTY(()) unsigned long except_table_label_num
;
1989 darwin_emit_except_table_label (FILE *file
)
1991 char section_start_label
[30];
1993 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
1994 except_table_label_num
++);
1995 ASM_OUTPUT_LABEL (file
, section_start_label
);
1997 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2000 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2002 const char *nlp_name
;
2004 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2006 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2007 fputs ("\t.long\t", file
);
2008 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2012 /* If this is uncommented, details of each allocation will be printed
2013 in the asm right before the actual code. WARNING - this will cause some
2014 test-suite fails (since the printout will contain items that some tests
2015 are not expecting) -- so don't leave it on by default (it bloats the
2017 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2019 /* The first two of these routines are ostensibly just intended to put
2020 names into the asm. However, they are both hijacked in order to ensure
2021 that zero-sized items do not make their way into the output. Consequently,
2022 we also need to make these participate in provisions for dealing with
2023 such items in section anchors. */
2025 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2026 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2027 but it does need to be referenced via indirect PIC data pointers.
2028 The machopic_define_symbol calls are telling the machopic subsystem
2029 that the name *is* defined in this module, so it doesn't need to
2030 make them indirect. */
2032 darwin_asm_declare_object_name (FILE *file
,
2033 const char *nam
, tree decl
)
2035 const char *xname
= nam
;
2036 unsigned HOST_WIDE_INT size
;
2037 bool local_def
, weak
;
2039 weak
= (DECL_P (decl
)
2041 && !lookup_attribute ("weak_import",
2042 DECL_ATTRIBUTES (decl
)));
2044 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2045 && (!DECL_COMMON (decl
)
2046 || !TREE_PUBLIC (decl
)));
2048 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2049 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2053 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2055 machopic_define_symbol (DECL_RTL (decl
));
2058 size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
2060 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2061 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2062 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2063 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2064 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2065 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2066 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2067 (unsigned long)DECL_INITIAL (decl
));
2070 /* Darwin needs help to support local zero-sized objects.
2071 They must be made at least one byte, and the section containing must be
2072 marked as unsuitable for section-anchors (see storage allocators below).
2074 For non-zero objects this output is handled by varasm.c.
2078 unsigned int l2align
= 0;
2080 /* The align must be honored, even for zero-sized. */
2081 if (DECL_ALIGN (decl
))
2083 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2084 fprintf (file
, "\t.align\t%u\n", l2align
);
2087 ASM_OUTPUT_LABEL (file
, xname
);
2089 fprintf (file
, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2091 /* Check that we've correctly picked up the zero-sized item and placed it
2093 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2095 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2098 ASM_OUTPUT_LABEL (file
, xname
);
2101 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2103 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2104 const_tree exp ATTRIBUTE_UNUSED
,
2107 assemble_label (file
, name
);
2108 /* As for other items, we need at least one byte. */
2111 fputs ("\t.space\t1\n", file
);
2112 /* Check that we've correctly picked up the zero-sized item and placed it
2114 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2116 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2120 /* Darwin storage allocators.
2122 Zerofill sections are desirable for large blank data since, otherwise, these
2123 data bloat objects (PR33210).
2125 However, section anchors don't work in .zerofill sections (one cannot switch
2126 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2127 to put (at least some) data into 'normal' switchable sections.
2129 Here we set a relatively arbitrary value for the size of an object to trigger
2130 zerofill when section anchors are enabled (anything bigger than a page for
2131 current Darwin implementations). FIXME: there ought to be some objective way
2132 to make this choice.
2134 When section anchor are off this is ignored anyway. */
2136 #define BYTES_ZFILL 4096
2138 /* Emit a chunk of data for items coalesced by the linker. */
2140 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2141 unsigned HOST_WIDE_INT size
,
2144 /* Since the sections used here are coalesed, they will not be eligible
2145 for section anchors, and therefore we don't need to break that out. */
2146 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2147 switch_to_section (darwin_sections
[const_data_coal_section
]);
2149 switch_to_section (darwin_sections
[data_coal_section
]);
2151 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2152 the align info for zero-sized items... but do it here otherwise. */
2154 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2156 if (TREE_PUBLIC (decl
))
2157 darwin_globalize_label (fp
, name
);
2159 /* ... and we let it deal with outputting one byte of zero for them too. */
2160 darwin_asm_declare_object_name (fp
, name
, decl
);
2162 assemble_zeros (size
);
2165 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2167 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2168 unsigned HOST_WIDE_INT size
,
2169 unsigned int align
, tree meta
)
2171 section
*ocs
= data_section
;
2173 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2174 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2176 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2178 switch_to_section (ocs
);
2180 /* We shall declare that zero-sized meta-data are not valid (yet). */
2182 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2184 /* ... and we let it deal with outputting one byte of zero for them too. */
2185 darwin_asm_declare_object_name (fp
, name
, decl
);
2186 assemble_zeros (size
);
2189 /* This routine emits 'local' storage:
2191 When Section Anchors are off this routine emits .zerofill commands in
2192 sections named for their alignment.
2194 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2195 the .static_data section so that the section anchoring system can see them.
2196 Larger items are still placed in .zerofill sections, addressing PR33210.
2197 The routine has no checking - it is all assumed to be done by the caller.
2200 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2201 unsigned HOST_WIDE_INT size
,
2202 unsigned int l2align
)
2204 /* FIXME: We have a fudge to make this work with Java even when the target does
2205 not use sections anchors -- Java seems to need at least one small item in a
2206 non-zerofill segment. */
2207 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2208 || (size
&& size
<= 2))
2210 /* Put smaller objects in _static_data, where the section anchors system
2212 However, if they are zero-sized punt them to yet a different section
2213 (that is not allowed to participate in anchoring). */
2216 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2217 in_section
= darwin_sections
[zobj_bss_section
];
2222 fputs ("\t.static_data\n", fp
);
2223 in_section
= darwin_sections
[static_data_section
];
2227 fprintf (fp
, "\t.align\t%u\n", l2align
);
2229 assemble_name (fp
, name
);
2230 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2234 /* When we are on a non-section anchor target, we can get zero-sized
2235 items here. However, all we need to do is to bump them to one byte
2236 and the section alignment will take care of the rest. */
2238 unsigned int flags
;
2239 snprintf (secnam
, 64, "__DATA,__%sbss%u", ((size
)?"":"zo_"),
2240 (unsigned) l2align
);
2241 /* We can't anchor (yet, if ever) in zerofill sections, because we can't
2242 switch to them and emit a label. */
2243 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2244 in_section
= get_section (secnam
, flags
, NULL
);
2245 fprintf (fp
, "\t.zerofill %s,", secnam
);
2246 assemble_name (fp
, name
);
2251 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2252 size
, (unsigned) l2align
);
2254 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2257 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2258 /* This is defined as a file-scope var, so we know to notify machopic. */
2259 machopic_define_symbol (DECL_RTL (decl
));
2262 /* Emit a chunk of common. */
2264 darwin_emit_common (FILE *fp
, const char *name
,
2265 unsigned HOST_WIDE_INT size
, unsigned int align
)
2267 unsigned HOST_WIDE_INT rounded
;
2268 unsigned int l2align
;
2270 /* Earlier systems complain if the alignment exceeds the page size.
2271 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2272 if (!emit_aligned_common
&& (align
> 32768UL))
2273 align
= 4096UL; /* In units. */
2275 align
/= BITS_PER_UNIT
;
2277 /* Make sure we have a meaningful align. */
2281 /* For earlier toolchains, we need to emit the var as a rounded size to
2282 tell ld the alignment. */
2286 rounded
= (size
+ (align
-1)) & ~(align
-1);
2288 l2align
= floor_log2 (align
);
2289 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2291 in_section
= comm_section
;
2292 /* We mustn't allow multiple public symbols to share an address when using
2293 the normal OSX toolchain. */
2296 /* Put at least one byte. */
2298 /* This section can no longer participate in section anchoring. */
2299 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2302 fputs ("\t.comm\t", fp
);
2303 assemble_name (fp
, name
);
2304 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2305 emit_aligned_common
?size
:rounded
);
2306 if (l2align
&& emit_aligned_common
)
2307 fprintf (fp
, ",%u", l2align
);
2311 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2312 or coalescable data sections (for weak or comdat) as appropriate. */
2315 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2316 unsigned HOST_WIDE_INT size
, unsigned int align
)
2318 unsigned int l2align
;
2319 bool one
, pub
, weak
;
2322 pub
= TREE_PUBLIC (decl
);
2323 one
= DECL_ONE_ONLY (decl
);
2324 weak
= (DECL_P (decl
)
2326 && !lookup_attribute ("weak_import",
2327 DECL_ATTRIBUTES (decl
)));
2329 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2330 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2331 " pub %d weak %d one %d init %lx\n",
2332 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2333 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2334 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2337 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2338 before the target has a chance to comment. */
2339 if ((meta
= is_objc_metadata (decl
)))
2341 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2345 /* Check that any initializer is valid. */
2346 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2347 || (DECL_INITIAL (decl
) == error_mark_node
)
2348 || initializer_zerop (DECL_INITIAL (decl
)));
2350 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2351 gcc_assert (!DECL_COMMON (decl
));
2353 /* Pick up the correct alignment. */
2354 if (!size
|| !align
)
2355 align
= DECL_ALIGN (decl
);
2357 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2358 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2360 last_assemble_variable_decl
= decl
;
2362 /* We would rather not have to check this here - but it seems that we might
2363 be passed a decl that should be in coalesced space. */
2366 /* Weak or COMDAT objects are put in mergeable sections. */
2367 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2372 /* If this is not public, then emit according to local rules. */
2375 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2379 /* So we have a public symbol (small item fudge for Java, see above). */
2380 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2381 || (size
&& size
<= 2))
2383 /* Put smaller objects in data, where the section anchors system can get
2384 them. However, if they are zero-sized punt them to yet a different
2385 section (that is not allowed to participate in anchoring). */
2388 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2389 in_section
= darwin_sections
[zobj_data_section
];
2394 fputs ("\t.data\n", fp
);
2395 in_section
= data_section
;
2399 fprintf (fp
, "\t.align\t%u\n", l2align
);
2401 assemble_name (fp
, name
);
2402 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2407 unsigned int flags
;
2408 /* When we are on a non-section anchor target, we can get zero-sized
2409 items here. However, all we need to do is to bump them to one byte
2410 and the section alignment will take care of the rest. */
2411 snprintf (secnam
, 64, "__DATA,__%spu_bss%u", ((size
)?"":"zo_"), l2align
);
2413 /* We can't anchor in zerofill sections, because we can't switch
2414 to them and emit a label. */
2415 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2416 in_section
= get_section (secnam
, flags
, NULL
);
2417 fprintf (fp
, "\t.zerofill %s,", secnam
);
2418 assemble_name (fp
, name
);
2423 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2425 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2427 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2430 /* Output a chunk of common, with alignment specified (where the target
2433 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2434 unsigned HOST_WIDE_INT size
,
2437 unsigned int l2align
;
2441 /* No corresponding var. */
2444 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2445 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2447 darwin_emit_common (fp
, name
, size
, align
);
2451 one
= DECL_ONE_ONLY (decl
);
2452 weak
= (DECL_P (decl
)
2454 && !lookup_attribute ("weak_import",
2455 DECL_ATTRIBUTES (decl
)));
2457 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2458 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2459 " weak %d one %d init %lx\n",
2460 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2461 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2462 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2465 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2466 before the target has a chance to comment. */
2467 if ((meta
= is_objc_metadata (decl
)))
2469 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2473 /* We shouldn't be messing with this if the decl has a section name. */
2474 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2476 /* We would rather not have to check this here - but it seems that we might
2477 be passed a decl that should be in coalesced space. */
2480 /* Weak or COMDAT objects are put in mergable sections. */
2481 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2486 /* We should only get here for DECL_COMMON, with a zero init (and, in
2487 principle, only for public symbols too - although we deal with local
2490 /* Check the initializer is OK. */
2491 gcc_assert (DECL_COMMON (decl
)
2492 && ((DECL_INITIAL (decl
) == NULL
)
2493 || (DECL_INITIAL (decl
) == error_mark_node
)
2494 || initializer_zerop (DECL_INITIAL (decl
))));
2496 last_assemble_variable_decl
= decl
;
2498 if (!size
|| !align
)
2499 align
= DECL_ALIGN (decl
);
2501 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2502 /* Check we aren't asking for more aligment than the platform allows. */
2503 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2505 if (TREE_PUBLIC (decl
) != 0)
2506 darwin_emit_common (fp
, name
, size
, align
);
2508 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2511 /* Output a chunk of BSS with alignment specfied. */
2513 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2514 unsigned HOST_WIDE_INT size
,
2517 unsigned long l2align
;
2521 one
= DECL_ONE_ONLY (decl
);
2522 weak
= (DECL_P (decl
)
2524 && !lookup_attribute ("weak_import",
2525 DECL_ATTRIBUTES (decl
)));
2527 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2528 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2529 " weak %d init %lx\n",
2530 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2531 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2532 weak
, (unsigned long)DECL_INITIAL (decl
));
2535 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2536 before the target has a chance to comment. */
2537 if ((meta
= is_objc_metadata (decl
)))
2539 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2543 /* We shouldn't be messing with this if the decl has a section name. */
2544 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2546 /* We would rather not have to check this here - but it seems that we might
2547 be passed a decl that should be in coalesced space. */
2550 /* Weak or COMDAT objects are put in mergable sections. */
2551 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2556 /* .. and it should be suitable for placement in local mem. */
2557 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2558 /* .. and any initializer must be all-zero. */
2559 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2560 || (DECL_INITIAL (decl
) == error_mark_node
)
2561 || initializer_zerop (DECL_INITIAL (decl
)));
2563 last_assemble_variable_decl
= decl
;
2565 if (!size
|| !align
)
2566 align
= DECL_ALIGN (decl
);
2568 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2569 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2571 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2574 /* Emit an assembler directive to set visibility for a symbol. The
2575 only supported visibilities are VISIBILITY_DEFAULT and
2576 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2577 extern". There is no MACH-O equivalent of ELF's
2578 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2581 darwin_assemble_visibility (tree decl
, int vis
)
2583 if (vis
== VISIBILITY_DEFAULT
)
2585 else if (vis
== VISIBILITY_HIDDEN
)
2587 fputs ("\t.private_extern ", asm_out_file
);
2588 assemble_name (asm_out_file
,
2589 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2590 fputs ("\n", asm_out_file
);
2593 warning (OPT_Wattributes
, "internal and protected visibility attributes "
2594 "not supported in this configuration; ignored");
2597 /* VEC Used by darwin_asm_dwarf_section.
2598 Maybe a hash tab would be better here - but the intention is that this is
2599 a very short list (fewer than 16 items) and each entry should (ideally,
2600 eventually) only be presented once.
2602 A structure to hold a dwarf debug section used entry. */
2604 typedef struct GTY(()) dwarf_sect_used_entry
{
2608 dwarf_sect_used_entry
;
2610 DEF_VEC_O(dwarf_sect_used_entry
);
2611 DEF_VEC_ALLOC_O(dwarf_sect_used_entry
, gc
);
2613 /* A list of used __DWARF sections. */
2614 static GTY (()) VEC (dwarf_sect_used_entry
, gc
) * dwarf_sect_names_table
;
2616 /* This is called when we are asked to assemble a named section and the
2617 name begins with __DWARF,. We keep a list of the section names (without
2618 the __DWARF, prefix) and use this to emit our required start label on the
2619 first switch to each section. */
2622 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2623 tree
ARG_UNUSED (decl
))
2628 dwarf_sect_used_entry
*ref
;
2630 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2631 == (SECTION_DEBUG
| SECTION_NAMED
));
2632 /* We know that the name starts with __DWARF, */
2634 namelen
= strchr (sname
, ',') - sname
;
2635 gcc_assert (namelen
);
2636 if (dwarf_sect_names_table
== NULL
)
2637 dwarf_sect_names_table
= VEC_alloc (dwarf_sect_used_entry
, gc
, 16);
2640 VEC_iterate (dwarf_sect_used_entry
, dwarf_sect_names_table
, i
, ref
);
2645 if (!strcmp (ref
->name
, sname
))
2653 fprintf (asm_out_file
, "\t.section %s\n", name
);
2656 dwarf_sect_used_entry e
;
2657 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
2659 e
.name
= xstrdup (sname
);
2660 VEC_safe_push (dwarf_sect_used_entry
, gc
, dwarf_sect_names_table
, &e
);
2664 /* Output a difference of two labels that will be an assembly time
2665 constant if the two labels are local. (.long lab1-lab2 will be
2666 very different if lab1 is at the boundary between two sections; it
2667 will be relocated according to the second section, not the first,
2668 so one ends up with a difference between labels in different
2669 sections, which is bad in the dwarf2 eh context for instance.) */
2671 static int darwin_dwarf_label_counter
;
2674 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
2675 const char *lab1
, const char *lab2
)
2677 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
2678 && lab2
[0] == '*' && lab2
[1] == 'L');
2679 const char *directive
= (size
== 8 ? ".quad" : ".long");
2682 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
2684 fprintf (file
, "\t%s\t", directive
);
2686 assemble_name_raw (file
, lab1
);
2687 fprintf (file
, "-");
2688 assemble_name_raw (file
, lab2
);
2690 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
2693 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
2694 offsets are not represented using relocs in .o files; either the
2695 section never leaves the .o file, or the linker or other tool is
2696 responsible for parsing the DWARF and updating the offsets. */
2699 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
2705 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
2706 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
2707 gcc_assert (strchr (base
->named
.name
+ 8, ','));
2709 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
2710 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
2711 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
2714 /* Called from the within the TARGET_ASM_FILE_START for each target.
2715 Initialize the stuff we need for LTO long section names support. */
2718 darwin_file_start (void)
2720 /* We fill this obstack with the complete section text for the lto section
2721 names to write in darwin_file_end. */
2722 obstack_init (<o_section_names_obstack
);
2723 lto_section_names_offset
= 0;
2726 /* Called for the TARGET_ASM_FILE_END hook.
2727 Emit the mach-o pic indirection data, the lto data and, finally a flag
2728 to tell the linker that it can break the file object into sections and
2729 move those around for efficiency. */
2732 darwin_file_end (void)
2734 const char *lto_section_names
;
2736 machopic_finish (asm_out_file
);
2737 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
2739 switch_to_section (darwin_sections
[constructor_section
]);
2740 switch_to_section (darwin_sections
[destructor_section
]);
2741 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
2744 /* If there was LTO assembler output, append it to asm_out_file. */
2745 if (lto_asm_out_name
)
2748 char *buf
, *lto_asm_txt
;
2750 /* Shouldn't be here if we failed to switch back. */
2751 gcc_assert (! saved_asm_out_file
);
2753 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
2754 if (lto_asm_out_file
== NULL
)
2755 fatal_error ("failed to open temporary file %s with LTO output",
2757 fseek (lto_asm_out_file
, 0, SEEK_END
);
2758 n
= ftell (lto_asm_out_file
);
2761 fseek (lto_asm_out_file
, 0, SEEK_SET
);
2762 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
2763 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
2764 fputs (lto_asm_txt
, asm_out_file
);
2767 /* Remove the temporary file. */
2768 fclose (lto_asm_out_file
);
2769 unlink_if_ordinary (lto_asm_out_name
);
2770 free (lto_asm_out_name
);
2773 /* Finish the LTO section names obstack. Don't output anything if
2774 there are no recorded section names. */
2775 obstack_1grow (<o_section_names_obstack
, '\0');
2776 lto_section_names
= XOBFINISH (<o_section_names_obstack
, const char *);
2777 if (strlen (lto_section_names
) > 0)
2779 fprintf (asm_out_file
,
2780 "\t.section %s,%s,regular,debug\n",
2781 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
2782 fprintf (asm_out_file
,
2783 "\t# Section names in %s are offsets into this table\n",
2785 fprintf (asm_out_file
, "%s\n", lto_section_names
);
2787 obstack_free (<o_section_names_obstack
, NULL
);
2789 /* If we have section anchors, then we must prevent the linker from
2790 re-arranging data. */
2791 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2792 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
2795 /* TODO: Add a language hook for identifying if a decl is a vtable. */
2796 #define DARWIN_VTABLE_P(DECL) 0
2798 /* Cross-module name binding. Darwin does not support overriding
2799 functions at dynamic-link time, except for vtables in kexts. */
2802 darwin_binds_local_p (const_tree decl
)
2804 return default_binds_local_p_1 (decl
,
2805 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
2808 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
2809 anchor relative to ".", the current section position. We cannot use
2810 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
2812 darwin_asm_output_anchor (rtx symbol
)
2814 fprintf (asm_out_file
, "\t.set\t");
2815 assemble_name (asm_out_file
, XSTR (symbol
, 0));
2816 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
2817 SYMBOL_REF_BLOCK_OFFSET (symbol
));
2820 /* Disable section anchoring on any section containing a zero-sized
2823 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
2825 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
2828 /* If the section contains a zero-sized object it's ineligible. */
2829 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
2830 /* This should have the effect of disabling anchors for vars that follow
2831 any zero-sized one, in a given section. */
2832 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
2835 /* Also check the normal reasons for suppressing. */
2836 return default_use_anchors_for_symbol_p (symbol
);
2842 /* Set the darwin specific attributes on TYPE. */
2844 darwin_set_default_type_attributes (tree type
)
2846 if (darwin_ms_struct
2847 && TREE_CODE (type
) == RECORD_TYPE
)
2848 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
2850 TYPE_ATTRIBUTES (type
));
2853 /* True, iff we're generating code for loadable kernel extensions. */
2856 darwin_kextabi_p (void) {
2857 return flag_apple_kext
;
2861 darwin_override_options (void)
2863 /* Keep track of which (major) version we're generating code for. */
2864 if (darwin_macosx_version_min
)
2866 if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
2867 generating_for_darwin_version
= 10;
2868 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
2869 generating_for_darwin_version
= 9;
2871 /* Earlier versions are not specifically accounted, until required. */
2874 /* Don't emit DWARF3/4 unless specifically selected. This is a
2875 workaround for tool bugs. */
2876 if (!global_options_set
.x_dwarf_strict
)
2879 /* Do not allow unwind tables to be generated by default for m32.
2880 fnon-call-exceptions will override this, regardless of what we do. */
2881 if (generating_for_darwin_version
< 10
2882 && !global_options_set
.x_flag_asynchronous_unwind_tables
2884 global_options
.x_flag_asynchronous_unwind_tables
= 0;
2886 /* Disable -freorder-blocks-and-partition when unwind tables are being
2887 emitted for Darwin < 9 (OSX 10.5).
2888 The strategy is, "Unless the User has specifically set/unset an unwind
2889 flag we will switch off -freorder-blocks-and-partition when unwind tables
2890 will be generated". If the User specifically sets flags... we assume
2891 (s)he knows why... */
2892 if (generating_for_darwin_version
< 9
2893 && global_options_set
.x_flag_reorder_blocks_and_partition
2894 && ((global_options
.x_flag_exceptions
/* User, c++, java */
2895 && !global_options_set
.x_flag_exceptions
) /* User specified... */
2896 || (global_options
.x_flag_unwind_tables
2897 && !global_options_set
.x_flag_unwind_tables
)
2898 || (global_options
.x_flag_non_call_exceptions
2899 && !global_options_set
.x_flag_non_call_exceptions
)
2900 || (global_options
.x_flag_asynchronous_unwind_tables
2901 && !global_options_set
.x_flag_asynchronous_unwind_tables
)))
2903 inform (input_location
,
2904 "-freorder-blocks-and-partition does not work with exceptions "
2905 "on this architecture");
2906 flag_reorder_blocks_and_partition
= 0;
2907 flag_reorder_blocks
= 1;
2910 if (flag_mkernel
|| flag_apple_kext
)
2912 /* -mkernel implies -fapple-kext for C++ */
2913 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
2914 flag_apple_kext
= 1;
2918 /* No EH in kexts. */
2919 flag_exceptions
= 0;
2920 /* No -fnon-call-exceptions data in kexts. */
2921 flag_non_call_exceptions
= 0;
2922 /* so no tables either.. */
2923 flag_unwind_tables
= 0;
2924 flag_asynchronous_unwind_tables
= 0;
2925 /* We still need to emit branch islands for kernel context. */
2926 darwin_emit_branch_islands
= true;
2929 if (flag_var_tracking
2930 && generating_for_darwin_version
>= 9
2931 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
2932 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
2933 && write_symbols
== DWARF2_DEBUG
)
2934 flag_var_tracking_uninit
= 1;
2936 if (MACHO_DYNAMIC_NO_PIC_P
)
2939 warning_at (UNKNOWN_LOCATION
, 0,
2940 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
2941 " %<-fpie%> or %<-fPIE%>");
2944 else if (flag_pic
== 1)
2946 /* Darwin's -fpic is -fPIC. */
2950 /* It is assumed that branch island stubs are needed for earlier systems. */
2951 if (generating_for_darwin_version
< 9)
2952 darwin_emit_branch_islands
= true;
2954 emit_aligned_common
= true; /* Later systems can support aligned common. */
2956 /* The c_dialect...() macros are not available to us here. */
2957 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
2961 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
2964 darwin_patch_builtin (enum built_in_function fncode
)
2966 tree fn
= builtin_decl_explicit (fncode
);
2973 sym
= DECL_ASSEMBLER_NAME (fn
);
2974 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
2976 set_user_assembler_name (fn
, newname
);
2978 fn
= builtin_decl_implicit (fncode
);
2980 set_user_assembler_name (fn
, newname
);
2984 darwin_patch_builtins (void)
2986 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
2989 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
2990 #define PATCH_BUILTIN_NO64(fncode) \
2991 if (!TARGET_64BIT) \
2992 darwin_patch_builtin (fncode);
2993 #define PATCH_BUILTIN_VARIADIC(fncode) \
2995 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
2996 darwin_patch_builtin (fncode);
2997 #include "darwin-ppc-ldouble-patch.def"
2998 #undef PATCH_BUILTIN
2999 #undef PATCH_BUILTIN_NO64
3000 #undef PATCH_BUILTIN_VARIADIC
3004 /* CFStrings implementation. */
3005 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3006 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3007 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3008 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3009 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3010 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3012 static enum built_in_function darwin_builtin_cfstring
;
3014 /* Store all constructed constant CFStrings in a hash table so that
3015 they get uniqued properly. */
3017 typedef struct GTY (()) cfstring_descriptor
{
3018 /* The string literal. */
3020 /* The resulting constant CFString. */
3022 } cfstring_descriptor
;
3024 static GTY ((param_is (struct cfstring_descriptor
))) htab_t cfstring_htab
;
3026 static hashval_t
cfstring_hash (const void *);
3027 static int cfstring_eq (const void *, const void *);
3030 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3032 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3033 get_identifier (name
), type
);
3037 *chain
= &DECL_CHAIN (field
);
3043 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3045 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3048 darwin_builtin_cfstring
=
3049 (enum built_in_function
) builtin_cfstring
;
3051 /* struct __builtin_CFString {
3052 const int *isa; (will point at
3053 int flags; __CFConstantStringClassReference)
3058 pcint_type_node
= build_pointer_type
3059 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3061 pcchar_type_node
= build_pointer_type
3062 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3064 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3066 /* Have to build backwards for finish struct. */
3067 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3068 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3069 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3070 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3071 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3074 /* const struct __builtin_CFstring *
3075 __builtin___CFStringMakeConstantString (const char *); */
3077 ccfstring_type_node
= build_qualified_type
3078 (cfstring_type_node
, TYPE_QUAL_CONST
);
3079 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3080 pccfstring_ftype_pcchar
= build_function_type_list
3081 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3083 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3084 get_identifier ("__builtin___CFStringMakeConstantString"),
3085 pccfstring_ftype_pcchar
);
3087 TREE_PUBLIC (cfsfun
) = 1;
3088 DECL_EXTERNAL (cfsfun
) = 1;
3089 DECL_ARTIFICIAL (cfsfun
) = 1;
3090 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3091 in place of the existing, which may be NULL. */
3092 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3093 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3094 DECL_BUILT_IN_CLASS (cfsfun
) = BUILT_IN_MD
;
3095 DECL_FUNCTION_CODE (cfsfun
) = darwin_builtin_cfstring
;
3096 lang_hooks
.builtin_function (cfsfun
);
3098 /* extern int __CFConstantStringClassReference[]; */
3099 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3100 get_identifier ("__CFConstantStringClassReference"),
3101 build_array_type (integer_type_node
, NULL_TREE
));
3103 TREE_PUBLIC (cfstring_class_reference
) = 1;
3104 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3105 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3106 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3107 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3109 /* Initialize the hash table used to hold the constant CFString objects. */
3110 cfstring_htab
= htab_create_ggc (31, cfstring_hash
, cfstring_eq
, NULL
);
3112 return cfstring_type_node
;
3116 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3117 bool ARG_UNUSED (ignore
))
3119 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3121 if (fcode
== darwin_builtin_cfstring
)
3123 if (!darwin_constant_cfstrings
)
3125 error ("built-in function %qD requires the"
3126 " %<-mconstant-cfstrings%> flag", fndecl
);
3127 return error_mark_node
;
3132 error ("built-in function %qD takes one argument only", fndecl
);
3133 return error_mark_node
;
3136 return darwin_build_constant_cfstring (*argp
);
3143 darwin_rename_builtins (void)
3145 /* The system ___divdc3 routine in libSystem on darwin10 is not
3146 accurate to 1ulp, ours is, so we avoid ever using the system name
3147 for this routine and instead install a non-conflicting name that
3150 When -ffast-math or -funsafe-math-optimizations is given, we can
3151 use the faster version. */
3152 if (!flag_unsafe_math_optimizations
)
3154 enum built_in_function dcode
3155 = (enum built_in_function
)(BUILT_IN_COMPLEX_DIV_MIN
3156 + DCmode
- MIN_MODE_COMPLEX_FLOAT
);
3157 tree fn
= builtin_decl_explicit (dcode
);
3158 /* Fortran and c call TARGET_INIT_BUILTINS and
3159 TARGET_INIT_LIBFUNCS at different times, so we have to put a
3160 call into each to ensure that at least one of them is called
3161 after build_common_builtin_nodes. A better fix is to add a
3162 new hook to run after build_common_builtin_nodes runs. */
3164 set_user_assembler_name (fn
, "___ieee_divdc3");
3165 fn
= builtin_decl_implicit (dcode
);
3167 set_user_assembler_name (fn
, "___ieee_divdc3");
3172 cfstring_hash (const void *ptr
)
3174 tree str
= ((const struct cfstring_descriptor
*)ptr
)->literal
;
3175 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3176 int i
, len
= TREE_STRING_LENGTH (str
);
3179 for (i
= 0; i
< len
; i
++)
3180 h
= ((h
* 613) + p
[i
]);
3186 cfstring_eq (const void *ptr1
, const void *ptr2
)
3188 tree str1
= ((const struct cfstring_descriptor
*)ptr1
)->literal
;
3189 tree str2
= ((const struct cfstring_descriptor
*)ptr2
)->literal
;
3190 int len1
= TREE_STRING_LENGTH (str1
);
3192 return (len1
== TREE_STRING_LENGTH (str2
)
3193 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3198 darwin_build_constant_cfstring (tree str
)
3200 struct cfstring_descriptor
*desc
, key
;
3206 error ("CFString literal is missing");
3207 return error_mark_node
;
3212 if (TREE_CODE (str
) == ADDR_EXPR
)
3213 str
= TREE_OPERAND (str
, 0);
3215 if (TREE_CODE (str
) != STRING_CST
)
3217 error ("CFString literal expression is not a string constant");
3218 return error_mark_node
;
3221 /* Perhaps we already constructed a constant CFString just like this one? */
3223 loc
= htab_find_slot (cfstring_htab
, &key
, INSERT
);
3224 desc
= (struct cfstring_descriptor
*) *loc
;
3228 tree var
, constructor
, field
;
3229 VEC(constructor_elt
,gc
) *v
= NULL
;
3230 int length
= TREE_STRING_LENGTH (str
) - 1;
3232 if (darwin_warn_nonportable_cfstrings
)
3234 const char *s
= TREE_STRING_POINTER (str
);
3237 for (l
= 0; l
< length
; l
++)
3238 if (!s
[l
] || !isascii (s
[l
]))
3240 warning (darwin_warn_nonportable_cfstrings
, "%s in CFString literal",
3241 s
[l
] ? "non-ASCII character" : "embedded NUL");
3246 *loc
= desc
= ggc_alloc_cleared_cfstring_descriptor ();
3247 desc
->literal
= str
;
3250 field
= TYPE_FIELDS (ccfstring_type_node
);
3251 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3252 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3253 cfstring_class_reference
));
3255 field
= DECL_CHAIN (field
);
3256 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3257 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3259 field
= DECL_CHAIN (field
);
3260 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3261 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3263 field
= DECL_CHAIN (field
);
3264 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3265 build_int_cst (TREE_TYPE (field
), length
));
3267 constructor
= build_constructor (ccfstring_type_node
, v
);
3268 TREE_READONLY (constructor
) = 1;
3269 TREE_CONSTANT (constructor
) = 1;
3270 TREE_STATIC (constructor
) = 1;
3272 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3273 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3274 being built without any knowledge of C++ tree accessors; hence, we shall
3275 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3276 if (darwin_running_cxx
)
3277 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3279 /* Create an anonymous global variable for this CFString. */
3280 var
= build_decl (input_location
, CONST_DECL
,
3281 NULL
, TREE_TYPE (constructor
));
3282 DECL_ARTIFICIAL (var
) = 1;
3283 TREE_STATIC (var
) = 1;
3284 DECL_INITIAL (var
) = constructor
;
3285 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3286 DECL_CONTEXT (var
) = NULL_TREE
;
3287 desc
->constructor
= var
;
3290 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3291 TREE_CONSTANT (addr
) = 1;
3297 darwin_cfstring_p (tree str
)
3299 struct cfstring_descriptor key
;
3307 if (TREE_CODE (str
) == ADDR_EXPR
)
3308 str
= TREE_OPERAND (str
, 0);
3310 if (TREE_CODE (str
) != STRING_CST
)
3314 loc
= htab_find_slot (cfstring_htab
, &key
, NO_INSERT
);
3323 darwin_enter_string_into_cfstring_table (tree str
)
3325 struct cfstring_descriptor key
;
3329 loc
= htab_find_slot (cfstring_htab
, &key
, INSERT
);
3333 *loc
= ggc_alloc_cleared_cfstring_descriptor ();
3334 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3338 /* Choose named function section based on its frequency. */
3341 darwin_function_section (tree decl
, enum node_frequency freq
,
3342 bool startup
, bool exit
)
3344 /* Decide if we need to put this in a coalescable section. */
3347 && (!DECL_ATTRIBUTES (decl
)
3348 || !lookup_attribute ("weak_import",
3349 DECL_ATTRIBUTES (decl
))));
3351 /* If there is a specified section name, we should not be trying to
3353 if (decl
&& DECL_SECTION_NAME (decl
) != NULL_TREE
)
3354 return get_named_section (decl
, NULL
, 0);
3356 /* Default when there is no function re-ordering. */
3357 if (!flag_reorder_functions
)
3359 ? darwin_sections
[text_coal_section
]
3362 /* Startup code should go to startup subsection unless it is
3363 unlikely executed (this happens especially with function splitting
3364 where we can split away unnecesary parts of static constructors). */
3365 if (startup
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3367 ? darwin_sections
[text_startup_coal_section
]
3368 : darwin_sections
[text_startup_section
];
3370 /* Similarly for exit. */
3371 if (exit
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3373 ? darwin_sections
[text_exit_coal_section
]
3374 : darwin_sections
[text_exit_section
];
3376 /* Group cold functions together, similarly for hot code. */
3379 case NODE_FREQUENCY_UNLIKELY_EXECUTED
:
3381 ? darwin_sections
[text_cold_coal_section
]
3382 : darwin_sections
[text_cold_section
];
3384 case NODE_FREQUENCY_HOT
:
3386 ? darwin_sections
[text_hot_coal_section
]
3387 : darwin_sections
[text_hot_section
];
3391 ? darwin_sections
[text_coal_section
]
3397 /* When a function is partitioned between sections, we need to insert a label
3398 at the start of each new chunk - so that it may become a valid 'atom' for
3399 eh and debug purposes. Without this the linker will emit warnings if one
3400 tries to add line location information (since the switched fragment will
3404 darwin_function_switched_text_sections (FILE *fp
, tree decl
, bool new_is_cold
)
3407 snprintf (buf
, 128, "%s%s",new_is_cold
?"__cold_sect_of_":"__hot_sect_of_",
3408 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3409 /* Make sure we pick up all the relevant quotes etc. */
3410 assemble_name_raw (fp
, (const char *) buf
);
3414 #include "gt-darwin.h"