1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989-2021 Free Software Foundation, Inc.
3 Contributed by Apple Computer Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
33 #include "stringpool.h"
35 #include "insn-config.h"
38 #include "lto-streamer.h"
41 #include "stor-layout.h"
44 #include "langhooks.h"
46 #include "lto-section-names.h"
53 1) this facility requires suitable support from a modified version
54 of GDB, which is not provided on any system after MacOS 10.7/Darwin11.
55 2) There is no support for this in any X86 version of the FSF compiler.
57 Fix and continue was used on some earlier MacOS systems for rapid turn
58 around debugging. When code is compiled with the -mfix-and-continue
59 flag, two changes are made to the generated code that allow the system
60 to do things that it would normally not be able to do easily. These
61 changes allow gdb to load in recompilation of a translation unit that
62 has been changed into a running program and replace existing functions
63 and methods of that translation unit with versions of those functions
64 and methods from the newly compiled translation unit. The new functions
65 access the existing static symbols from the old translation unit, if the
66 symbol existed in the unit to be replaced, and from the new translation
69 The changes are to insert 5 nops at the beginning of all functions
70 and to use indirection to get at static symbols. The 5 nops
71 are required by consumers of the generated code. Currently, gdb
72 uses this to patch in a jump to the overriding function, this
73 allows all uses of the old name to forward to the replacement,
74 including existing function pointers and virtual methods. See
75 rs6000_emit_prologue for the code that handles the nop insertions.
77 The added indirection allows gdb to redirect accesses to static
78 symbols from the newly loaded translation unit to the existing
79 symbol, if any. @code{static} symbols are special and are handled by
80 setting the second word in the .non_lazy_symbol_pointer data
81 structure to symbol. See indirect_data for the code that handles
82 the extra indirection, and machopic_output_indirection and its use
83 of MACHO_SYMBOL_FLAG_STATIC for the code that handles @code{static}
84 symbol indirection. */
86 typedef struct GTY(()) cdtor_record
{
88 int priority
; /* [con/de]structor priority */
89 int position
; /* original position */
92 static GTY(()) vec
<cdtor_record
, va_gc
> *ctors
= NULL
;
93 static GTY(()) vec
<cdtor_record
, va_gc
> *dtors
= NULL
;
95 /* A flag to determine whether we are running c++ or obj-c++. This has to be
96 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
98 int darwin_running_cxx
;
100 /* Some code-gen now depends on OS major version numbers (at least). */
101 int generating_for_darwin_version
;
103 /* For older linkers we need to emit special sections (marked 'coalesced') for
104 for weak or single-definition items. */
105 static bool ld_uses_coal_sects
= false;
107 /* Very old (ld_classic) linkers need a symbol to mark the start of
109 static bool ld_needs_eh_markers
= false;
111 /* Emit a section-start symbol for mod init and term sections. */
112 static bool ld_init_term_start_labels
= false;
115 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
117 /* While we transition to using in-tests instead of ifdef'd code. */
119 #define gen_macho_high(m,a,b) (a)
120 #define gen_macho_low(m,a,b,c) (a)
123 /* True if we're setting __attribute__ ((ms_struct)). */
124 int darwin_ms_struct
= false;
126 /* Earlier versions of Darwin as do not recognize an alignment field in
127 .comm directives, this should be set for versions that allow it. */
128 int emit_aligned_common
= false;
130 /* A get_unnamed_section callback used to switch to an ObjC section.
131 DIRECTIVE is as for output_section_asm_op. */
134 output_objc_section_asm_op (const void *directive
)
136 static bool been_here
= false;
138 /* The NeXT ObjC Runtime requires these sections to be present and in
139 order in the object. The code below implements this by emitting
140 a section header for each ObjC section the first time that an ObjC
141 section is requested. */
142 if (darwin_symbol_stubs
&& ! been_here
)
144 section
*saved_in_section
= in_section
;
145 static const enum darwin_section_enum tomark
[] =
147 /* written, cold -> hot */
148 objc_cat_cls_meth_section
,
149 objc_cat_inst_meth_section
,
150 objc_string_object_section
,
151 objc_constant_string_object_section
,
152 objc_selector_refs_section
,
153 objc_selector_fixup_section
,
154 objc_cls_refs_section
,
156 objc_meta_class_section
,
157 /* shared, hot -> cold */
158 objc_cls_meth_section
,
159 objc_inst_meth_section
,
160 objc_protocol_section
,
161 objc_class_names_section
,
162 objc_meth_var_types_section
,
163 objc_meth_var_names_section
,
164 objc_category_section
,
165 objc_class_vars_section
,
166 objc_instance_vars_section
,
167 objc_module_info_section
,
168 objc_symbols_section
,
171 static const enum darwin_section_enum tomarkv1
[] =
173 objc1_protocol_ext_section
,
174 objc1_class_ext_section
,
175 objc1_prop_list_section
178 static const enum darwin_section_enum tomarkv2
[] =
180 objc2_method_names_section
,
181 objc2_message_refs_section
,
182 objc2_selector_refs_section
,
184 objc2_classdefs_section
,
185 objc2_metadata_section
,
186 objc2_classrefs_section
,
187 objc2_class_names_section
,
188 objc2_classlist_section
,
189 objc2_categorylist_section
,
190 objc2_nonlazy_class_section
,
191 objc2_nonlazy_category_section
,
192 objc2_protocollist_section
,
193 objc2_protocolrefs_section
,
194 objc2_super_classrefs_section
,
195 objc2_constant_string_object_section
,
196 objc2_image_info_section
,
201 if (flag_objc_abi
< 2)
203 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
204 switch_to_section (darwin_sections
[tomark
[i
]]);
205 if (flag_objc_abi
== 1)
206 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
207 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
210 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
211 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
212 /* Make sure we don't get varasm.c out of sync with us. */
213 switch_to_section (saved_in_section
);
215 output_section_asm_op (directive
);
219 /* Private flag applied to disable section-anchors in a particular section. */
220 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
223 /* Implement TARGET_ASM_INIT_SECTIONS. */
226 darwin_init_sections (void)
228 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
229 darwin_sections[NAME] = \
230 get_unnamed_section (FLAGS, (OBJC \
231 ? output_objc_section_asm_op \
232 : output_section_asm_op), \
234 #include "config/darwin-sections.def"
237 readonly_data_section
= darwin_sections
[const_section
];
238 exception_section
= darwin_sections
[darwin_exception_section
];
239 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
241 /* If our linker is new enough to coalesce weak symbols, then we
242 can just put picbase_thunks into the text section. */
243 if (! ld_uses_coal_sects
)
244 darwin_sections
[picbase_thunk_section
] = text_section
;
248 name_needs_quotes (const char *name
)
251 while ((c
= *name
++) != '\0')
253 && c
!= '.' && c
!= '$' && c
!= '_' )
258 /* Return true if SYM_REF can be used without an indirection. */
260 machopic_symbol_defined_p (rtx sym_ref
)
262 if (MACHO_SYMBOL_DEFINED_P (sym_ref
))
265 /* If a symbol references local and is not an extern to this
266 file, then the symbol might be able to declared as defined. */
267 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
269 /* If the symbol references a variable and the variable is a
270 common symbol, then this symbol is not defined. */
271 if (MACHO_SYMBOL_VARIABLE_P (sym_ref
))
273 tree decl
= SYMBOL_REF_DECL (sym_ref
);
276 if (DECL_COMMON (decl
))
284 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
285 reference, which will not be changed. */
287 enum machopic_addr_class
288 machopic_classify_symbol (rtx sym_ref
)
292 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
293 if (machopic_symbol_defined_p (sym_ref
))
295 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
298 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
301 #ifndef TARGET_FIX_AND_CONTINUE
302 #define TARGET_FIX_AND_CONTINUE 0
305 /* Indicate when fix-and-continue style code generation is being used
306 and when a reference to data should be indirected so that it can be
307 rebound in a new translation unit to reference the original instance
308 of that data. Symbol names that are for code generation local to
309 the translation unit are bound to the new translation unit;
310 currently this means symbols that begin with L or _OBJC_;
311 otherwise, we indicate that an indirect reference should be made to
312 permit the runtime to rebind new instances of the translation unit
313 to the original instance of the data. */
316 indirect_data (rtx sym_ref
)
321 /* If we aren't generating fix-and-continue code, don't do anything
323 if (TARGET_FIX_AND_CONTINUE
== 0)
326 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
327 are indirected. Symbols that begin with L and _OBJC_ are always
328 bound to the current translation unit as they are used for
329 generated local data of the translation unit. */
331 name
= XSTR (sym_ref
, 0);
333 lprefix
= (((name
[0] == '*' || name
[0] == '&')
334 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
335 || (strncmp (name
, "_OBJC_", 6) == 0));
341 machopic_data_defined_p (rtx sym_ref
)
343 if (indirect_data (sym_ref
))
346 switch (machopic_classify_symbol (sym_ref
))
348 case MACHOPIC_DEFINED_DATA
:
349 case MACHOPIC_DEFINED_FUNCTION
:
357 machopic_define_symbol (rtx mem
)
361 gcc_assert (GET_CODE (mem
) == MEM
);
362 sym_ref
= XEXP (mem
, 0);
363 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
366 /* Return either ORIG or:
368 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
370 depending on MACHO_DYNAMIC_NO_PIC_P. */
372 machopic_gen_offset (rtx orig
)
374 if (MACHO_DYNAMIC_NO_PIC_P
)
378 /* Play games to avoid marking the function as needing pic if we
379 are being called as part of the cost-estimation process. */
380 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
381 crtl
->uses_pic_offset_table
= 1;
382 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
383 UNSPEC_MACHOPIC_OFFSET
);
384 return gen_rtx_CONST (Pmode
, orig
);
388 static GTY(()) const char * function_base_func_name
= NULL
;
389 static GTY(()) unsigned current_pic_label_num
= 0;
390 static GTY(()) unsigned emitted_pic_label_num
= 0;
392 /* We need to keep one picbase label per function, but (when we emit code
393 to reload the picbase for setjump receiver) we might need to check for
394 a second use. So, only update the picbase label counter when we see a
395 new function. When there's no function decl, we assume that the call is
396 from the x86 stub generation code. */
398 update_pic_label_number_if_needed (void)
400 if (current_function_decl
)
403 const char *current_name
=
404 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
405 if (function_base_func_name
!= current_name
)
407 ++current_pic_label_num
;
408 function_base_func_name
= current_name
;
413 ++current_pic_label_num
;
414 function_base_func_name
= "L_machopic_stub_dummy";
419 machopic_output_function_base_name (FILE *file
)
421 /* We should only get here for -fPIC. */
422 gcc_checking_assert (MACHOPIC_PURE
);
424 update_pic_label_number_if_needed ();
425 fprintf (file
, "L%u$pb", current_pic_label_num
);
428 char curr_picbasename
[32];
431 machopic_get_function_picbase (void)
433 /* We should only get here for -fPIC. */
434 gcc_checking_assert (MACHOPIC_PURE
);
436 update_pic_label_number_if_needed ();
437 snprintf (curr_picbasename
, 32, "L%u$pb", current_pic_label_num
);
438 return (const char *) curr_picbasename
;
442 machopic_should_output_picbase_label (void)
444 update_pic_label_number_if_needed ();
446 if (current_pic_label_num
== emitted_pic_label_num
)
449 emitted_pic_label_num
= current_pic_label_num
;
453 /* The suffix attached to non-lazy pointer symbols. */
454 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
455 /* The suffix attached to stub symbols. */
456 #define STUB_SUFFIX "$stub"
458 typedef struct GTY ((for_user
)) machopic_indirection
460 /* The SYMBOL_REF for the entity referenced. */
462 /* The name of the stub or non-lazy pointer. */
463 const char * ptr_name
;
464 /* True iff this entry is for a stub (as opposed to a non-lazy
467 /* True iff this stub or pointer has been referenced. */
469 /* True iff a non-lazy symbol pointer should be emitted into the .data
470 section, rather than the non-lazy symbol pointers section. The cases
471 for which this occurred seem to have been unintentional, and later
472 toolchains emit all of the indirections to the 'usual' section. We
473 are keeping this in case it is necessary to preserve compatibility with
475 bool nlsp_in_data_section
;
476 } machopic_indirection
;
478 struct indirection_hasher
: ggc_ptr_hash
<machopic_indirection
>
480 typedef const char *compare_type
;
481 static hashval_t
hash (machopic_indirection
*);
482 static bool equal (machopic_indirection
*, const char *);
485 /* A table mapping stub names and non-lazy pointer names to
486 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
488 static GTY (()) hash_table
<indirection_hasher
> *machopic_indirections
;
490 /* Return a hash value for a SLOT in the indirections hash table. */
493 indirection_hasher::hash (machopic_indirection
*p
)
495 return htab_hash_string (p
->ptr_name
);
498 /* Returns true if the KEY is the same as that associated with
502 indirection_hasher::equal (machopic_indirection
*s
, const char *k
)
504 return strcmp (s
->ptr_name
, k
) == 0;
507 /* Return the name of the non-lazy pointer (if STUB_P is false) or
508 stub (if STUB_B is true) corresponding to the given name.
510 PR71767 - If we have a situation like:
517 ld64 will be unable to split this into two atoms (because the "L" makes
518 the second symbol 'invisible'). This means that legitimate direct accesses
519 to the second symbol will appear to be direct accesses to an atom of type
520 weak, global which are not allowed.
522 To avoid this, we make any data-section indirections have a leading 'l'
523 (lower-case L) which has a special meaning: linker can see this and use
524 it to determine atoms, but it is not placed into the final symbol table.
526 Symbols in the non-lazy symbol pointers section (or stubs) do not have this
527 problem because ld64 already knows the size of each entry.
531 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
533 const char *name
= XSTR (sym_ref
, 0);
534 tree id
= maybe_get_identifier (name
);
539 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
540 id
= TREE_CHAIN (id
);
542 name
= IDENTIFIER_POINTER (id
);
545 const char *prefix
= user_label_prefix
;
546 /* If we are emitting the label 'verbatim' then omit the U_L_P and count
547 the name without the leading '*'. */
554 /* Here we are undoing a number of causes that placed some indirections
555 (apparently erroneously) into the .data section. Specifically, some
556 symbols that are ABI mandated indirections and some hidden symbols
557 were being placed there - which cause difficulties with later
558 versions of ld64. Iff (after these checks) some symbol still gets an
559 indirection in the data section, we want to adjust the indirection
560 name to be linker visible to deal with PR71767 (notes above). */
561 bool nlsp_in_data_section
=
562 ! MACHO_SYMBOL_MUST_INDIRECT_P (sym_ref
)
563 && ! MACHO_SYMBOL_HIDDEN_VIS_P (sym_ref
)
564 && (machopic_symbol_defined_p (sym_ref
) || SYMBOL_REF_LOCAL_P (sym_ref
))
565 && ! indirect_data (sym_ref
);
567 const char *suffix
= stub_p
? STUB_SUFFIX
: NON_LAZY_POINTER_SUFFIX
;
568 /* If the indirection is in the data section, let the linker see it. */
569 char L_or_l
= (!stub_p
&& nlsp_in_data_section
) ? 'l' : 'L';
570 /* We have mangled symbols with spaces and punctuation which typically
571 need surrounding in quotes for the assembler to consume them. */
572 const char *quote
= name_needs_quotes (name
) ? "\"" : "";
573 char *buffer
= XALLOCAVEC (char, 2 /* strlen ("&L") or ("&l") */
580 /* Construct the name of the non-lazy pointer or stub. */
581 sprintf (buffer
, "&%s%c%s%s%s%s", quote
, L_or_l
, prefix
, name
,
584 if (!machopic_indirections
)
585 machopic_indirections
= hash_table
<indirection_hasher
>::create_ggc (37);
587 machopic_indirection
**slot
588 = machopic_indirections
->find_slot_with_hash (buffer
,
589 htab_hash_string (buffer
),
591 machopic_indirection
*p
;
596 p
= ggc_alloc
<machopic_indirection
> ();
598 p
->ptr_name
= xstrdup (buffer
);
601 p
->nlsp_in_data_section
= nlsp_in_data_section
;
608 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
609 or non-lazy pointer as used -- and mark the object to which the
610 pointer/stub refers as used as well, since the pointer/stub will
611 emit a reference to it. */
614 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
616 machopic_indirection
*p
617 = machopic_indirections
->find_with_hash (name
, htab_hash_string (name
));
620 const char *real_name
;
625 /* Do what output_addr_const will do when we actually call it. */
626 if (SYMBOL_REF_DECL (p
->symbol
))
627 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
629 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
631 id
= maybe_get_identifier (real_name
);
633 mark_referenced (id
);
637 /* Transform ORIG, which may be any data source, to the corresponding
638 source using indirections. */
641 machopic_indirect_data_reference (rtx orig
, rtx reg
)
645 if (! MACHOPIC_INDIRECT
)
648 if (GET_CODE (orig
) == SYMBOL_REF
)
650 int defined
= machopic_data_defined_p (orig
);
652 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
656 /* Create a new register for CSE opportunities. */
657 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
658 emit_insn (gen_macho_high (Pmode
, hi_reg
, orig
));
659 emit_insn (gen_macho_low (Pmode
, reg
, hi_reg
, orig
));
665 /* some other cpu -- writeme! */
668 else if (defined
&& ! MACHO_SYMBOL_MUST_INDIRECT_P (orig
))
671 if (DARWIN_PPC
|| HAVE_lo_sum
)
672 offset
= machopic_gen_offset (orig
);
676 rtx hi_sum_reg
= (!can_create_pseudo_p ()
678 : gen_reg_rtx (Pmode
));
682 emit_insn (gen_rtx_SET (hi_sum_reg
,
683 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
684 gen_rtx_HIGH (Pmode
, offset
))));
685 emit_insn (gen_rtx_SET (reg
,
686 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
687 copy_rtx (offset
))));
691 else if (HAVE_lo_sum
)
695 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
696 emit_insn (gen_rtx_SET (reg
, gen_rtx_LO_SUM (Pmode
, reg
,
697 copy_rtx (offset
))));
698 emit_use (pic_offset_table_rtx
);
700 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
705 ptr_ref
= (gen_rtx_SYMBOL_REF
707 machopic_indirection_name (orig
, /*stub_p=*/false)));
709 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
710 SYMBOL_REF_FLAGS (ptr_ref
) |= MACHO_SYMBOL_FLAG_INDIRECTION
;
712 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
713 machopic_define_symbol (ptr_ref
);
717 && MACHO_DYNAMIC_NO_PIC_P
)
719 emit_insn (gen_rtx_SET (reg
, ptr_ref
));
725 else if (GET_CODE (orig
) == CONST
)
727 /* If "(const (plus ...", walk the PLUS and return that result.
728 PLUS processing (below) will restore the "(const ..." if
730 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
731 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
735 else if (GET_CODE (orig
) == MEM
)
738 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
741 else if (GET_CODE (orig
) == PLUS
)
745 /* Legitimize both operands of the PLUS. */
746 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
747 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
748 (base
== reg
? 0 : reg
));
749 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
750 result
= plus_constant (Pmode
, base
, INTVAL (orig
));
752 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
754 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
758 emit_move_insn (reg
, result
);
763 result
= force_reg (GET_MODE (result
), result
);
772 /* Transform TARGET (a MEM), which is a function call target, to the
773 corresponding symbol_stub if necessary. Return a new MEM. */
776 machopic_indirect_call_target (rtx target
)
778 if (! darwin_symbol_stubs
)
781 if (GET_CODE (target
) != MEM
)
784 if (MACHOPIC_INDIRECT
785 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
786 && ! MACHO_SYMBOL_DEFINED_P (XEXP (target
, 0)))
788 rtx sym_ref
= XEXP (target
, 0);
789 const char *stub_name
= machopic_indirection_name (sym_ref
,
791 machine_mode mode
= GET_MODE (sym_ref
);
793 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
794 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
795 SYMBOL_REF_FLAGS (XEXP (target
, 0)) |= MACHO_SYMBOL_FLAG_INDIRECTION
;
796 MEM_READONLY_P (target
) = 1;
797 MEM_NOTRAP_P (target
) = 1;
804 machopic_legitimize_pic_address (rtx orig
, machine_mode mode
, rtx reg
)
808 if (! MACHOPIC_INDIRECT
)
811 /* First handle a simple SYMBOL_REF or LABEL_REF */
812 if (GET_CODE (orig
) == LABEL_REF
813 || GET_CODE (orig
) == SYMBOL_REF
)
815 /* addr(foo) = &func+(foo-func) */
816 orig
= machopic_indirect_data_reference (orig
, reg
);
818 if (GET_CODE (orig
) == PLUS
819 && GET_CODE (XEXP (orig
, 0)) == REG
)
822 return force_reg (mode
, orig
);
824 emit_move_insn (reg
, orig
);
828 if (GET_CODE (orig
) == MEM
)
832 gcc_assert (!lra_in_progress
);
833 reg
= gen_reg_rtx (Pmode
);
837 if (MACHO_DYNAMIC_NO_PIC_P
838 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
839 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
841 #if defined (TARGET_TOC) /* ppc */
842 rtx temp_reg
= (!can_create_pseudo_p ()
844 gen_reg_rtx (Pmode
));
845 rtx asym
= XEXP (orig
, 0);
848 emit_insn (gen_macho_high (Pmode
, temp_reg
, asym
));
849 mem
= gen_const_mem (GET_MODE (orig
),
850 gen_rtx_LO_SUM (Pmode
, temp_reg
,
852 emit_insn (gen_rtx_SET (reg
, mem
));
854 /* Some other CPU -- WriteMe! but right now there are no other
855 platforms that can use dynamic-no-pic */
861 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
862 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
864 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
865 #if defined (TARGET_TOC) /* i.e., PowerPC */
866 /* Generating a new reg may expose opportunities for
867 common subexpression elimination. */
868 rtx hi_sum_reg
= (!can_create_pseudo_p ()
870 : gen_reg_rtx (Pmode
));
874 sum
= gen_rtx_HIGH (Pmode
, offset
);
875 if (! MACHO_DYNAMIC_NO_PIC_P
)
876 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
878 emit_insn (gen_rtx_SET (hi_sum_reg
, sum
));
880 mem
= gen_const_mem (GET_MODE (orig
),
881 gen_rtx_LO_SUM (Pmode
,
884 rtx_insn
*insn
= emit_insn (gen_rtx_SET (reg
, mem
));
885 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
889 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
891 emit_insn (gen_rtx_SET (reg
,
893 gen_rtx_CONST (Pmode
,
895 emit_insn (gen_rtx_SET (reg
,
896 gen_rtx_LO_SUM (Pmode
, reg
,
897 gen_rtx_CONST (Pmode
,
898 copy_rtx (offset
)))));
899 pic_ref
= gen_rtx_PLUS (Pmode
,
900 pic_offset_table_rtx
, reg
);
904 #endif /* HAVE_lo_sum */
906 rtx pic
= pic_offset_table_rtx
;
907 if (GET_CODE (pic
) != REG
)
909 emit_move_insn (reg
, pic
);
913 if (lra_in_progress
&& HARD_REGISTER_P (pic
))
914 df_set_regs_ever_live (REGNO (pic
), true);
915 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
916 machopic_gen_offset (XEXP (orig
, 0)));
919 #if !defined (TARGET_TOC)
920 emit_move_insn (reg
, pic_ref
);
921 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
928 if (GET_CODE (orig
) == SYMBOL_REF
929 || GET_CODE (orig
) == LABEL_REF
)
931 rtx offset
= machopic_gen_offset (orig
);
932 #if defined (TARGET_TOC) /* i.e., PowerPC */
937 gcc_assert (!lra_in_progress
);
938 reg
= gen_reg_rtx (Pmode
);
943 emit_insn (gen_rtx_SET (hi_sum_reg
,
944 (MACHO_DYNAMIC_NO_PIC_P
)
945 ? gen_rtx_HIGH (Pmode
, offset
)
946 : gen_rtx_PLUS (Pmode
,
947 pic_offset_table_rtx
,
950 emit_insn (gen_rtx_SET (reg
,
951 gen_rtx_LO_SUM (Pmode
,
953 copy_rtx (offset
))));
956 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
957 emit_insn (gen_rtx_SET (reg
,
958 gen_rtx_LO_SUM (Pmode
, reg
,
959 copy_rtx (offset
))));
960 pic_ref
= gen_rtx_PLUS (Pmode
,
961 pic_offset_table_rtx
, reg
);
965 #endif /* HAVE_lo_sum */
968 || GET_CODE (orig
) == SUBREG
)
974 rtx pic
= pic_offset_table_rtx
;
975 if (GET_CODE (pic
) != REG
)
977 emit_move_insn (reg
, pic
);
981 if (lra_in_progress
&& HARD_REGISTER_P (pic
))
982 df_set_regs_ever_live (REGNO (pic
), true);
983 pic_ref
= gen_rtx_PLUS (Pmode
,
985 machopic_gen_offset (orig
));
990 if (GET_CODE (pic_ref
) != REG
)
994 emit_move_insn (reg
, pic_ref
);
999 return force_reg (mode
, pic_ref
);
1007 else if (GET_CODE (orig
) == PLUS
1008 && (GET_CODE (XEXP (orig
, 0)) == MEM
1009 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
1010 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
1011 && XEXP (orig
, 0) != pic_offset_table_rtx
1012 && GET_CODE (XEXP (orig
, 1)) != REG
)
1016 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
1018 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1019 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
1020 Pmode
, (base
== reg
? 0 : reg
));
1021 if (GET_CODE (orig
) == CONST_INT
)
1023 pic_ref
= plus_constant (Pmode
, base
, INTVAL (orig
));
1027 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
1029 if (reg
&& is_complex
)
1031 emit_move_insn (reg
, pic_ref
);
1034 /* Likewise, should we set special REG_NOTEs here? */
1036 else if (GET_CODE (orig
) == CONST
)
1038 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1040 else if (GET_CODE (orig
) == MEM
1041 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
1043 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1044 addr
= replace_equiv_address (orig
, addr
);
1045 emit_move_insn (reg
, addr
);
1052 /* Callbacks to output the stub or non-lazy pointers.
1053 Each works on the item in *SLOT,if it has been used.
1054 DATA is the FILE* for assembly output.
1055 Called from htab_traverses, invoked from machopic_finish(). */
1058 machopic_output_data_section_indirection (machopic_indirection
**slot
,
1061 machopic_indirection
*p
= *slot
;
1063 if (!p
->used
|| !p
->nlsp_in_data_section
)
1066 rtx symbol
= p
->symbol
;
1067 /* The original symbol name. */
1068 const char *sym_name
= XSTR (symbol
, 0);
1069 /* The name of the indirection symbol. */
1070 const char *ptr_name
= p
->ptr_name
;
1072 switch_to_section (data_section
);
1073 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1074 assemble_label (asm_out_file
, ptr_name
);
1075 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1076 GET_MODE_SIZE (Pmode
),
1077 GET_MODE_ALIGNMENT (Pmode
), 1);
1083 machopic_output_stub_indirection (machopic_indirection
**slot
,
1086 machopic_indirection
*p
= *slot
;
1088 if (!p
->used
|| !p
->stub_p
)
1091 rtx symbol
= p
->symbol
;
1092 /* The original symbol name. */
1093 const char *sym_name
= XSTR (symbol
, 0);
1094 /* The name of the stub symbol. */
1095 const char *ptr_name
= p
->ptr_name
;
1097 tree id
= maybe_get_identifier (sym_name
);
1102 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1103 id
= TREE_CHAIN (id
);
1105 sym_name
= IDENTIFIER_POINTER (id
);
1108 char *sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1109 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1110 strcpy (sym
, sym_name
+ 1);
1111 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1112 strcpy (sym
, sym_name
);
1114 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1116 char *stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1117 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1118 strcpy (stub
, ptr_name
+ 1);
1120 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1122 machopic_output_stub (asm_out_file
, sym
, stub
);
1128 machopic_output_indirection (machopic_indirection
**slot
, FILE *asm_out_file
)
1130 machopic_indirection
*p
= *slot
;
1132 if (!p
->used
|| p
->stub_p
|| p
->nlsp_in_data_section
)
1135 rtx symbol
= p
->symbol
;
1136 /* The original symbol name. */
1137 const char *sym_name
= XSTR (symbol
, 0);
1138 /* The nonlazy-stub symbol name. */
1139 const char *ptr_name
= p
->ptr_name
;
1141 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1143 /* Mach-O symbols are passed around in code through indirect references and
1144 the original symbol_ref hasn't passed through the generic handling and
1145 reference-catching in output_operand, so we need to manually mark weak
1146 references as such. */
1148 if (SYMBOL_REF_WEAK (symbol
))
1150 tree decl
= SYMBOL_REF_DECL (symbol
);
1151 gcc_checking_assert (DECL_P (decl
));
1153 if (decl
!= NULL_TREE
1154 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1155 /* Handle only actual external-only definitions, not
1156 e.g. extern inline code or variables for which
1157 storage has been allocated. */
1158 && !TREE_STATIC (decl
))
1160 fputs ("\t.weak_reference ", asm_out_file
);
1161 assemble_name (asm_out_file
, sym_name
);
1162 fputc ('\n', asm_out_file
);
1166 assemble_name (asm_out_file
, ptr_name
);
1167 fprintf (asm_out_file
, ":\n");
1169 fprintf (asm_out_file
, "\t.indirect_symbol ");
1170 assemble_name (asm_out_file
, sym_name
);
1171 fprintf (asm_out_file
, "\n");
1173 /* Variables that are marked with MACHO_SYMBOL_FLAG_STATIC need to
1174 have their symbol name instead of 0 in the second entry of
1175 the non-lazy symbol pointer data structure when they are
1176 defined. This allows the runtime to rebind newer instances
1177 of the translation unit with the original instance of the
1180 rtx init
= const0_rtx
;
1181 if (MACHO_SYMBOL_STATIC_P (symbol
) && machopic_symbol_defined_p (symbol
))
1182 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1184 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1185 GET_MODE_ALIGNMENT (Pmode
), 1);
1191 machopic_finish (FILE *asm_out_file
)
1193 if (!machopic_indirections
)
1196 /* First output an symbol indirections that have been placed into .data
1197 (we don't expect these now). */
1198 machopic_indirections
->traverse_noresize
1199 <FILE *, machopic_output_data_section_indirection
> (asm_out_file
);
1201 machopic_indirections
->traverse_noresize
1202 <FILE *, machopic_output_stub_indirection
> (asm_out_file
);
1204 machopic_indirections
->traverse_noresize
1205 <FILE *, machopic_output_indirection
> (asm_out_file
);
1209 machopic_operand_p (rtx op
)
1211 if (MACHOPIC_JUST_INDIRECT
)
1212 return (GET_CODE (op
) == SYMBOL_REF
1213 && machopic_symbol_defined_p (op
));
1215 return (GET_CODE (op
) == CONST
1216 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1217 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1221 computes and caches a series of flags that characterise the symbol's
1222 properties that affect Mach-O code gen (including accidental cases
1223 from older toolchains).
1226 Here we also need to do enough analysis to determine if a symbol's
1227 name needs to be made linker-visible. This is more tricky - since
1228 it depends on whether we've previously seen a global weak definition
1229 in the same section.
1233 darwin_encode_section_info (tree decl
, rtx rtl
, int first
)
1235 /* Careful not to prod global register variables. */
1239 /* Do the standard encoding things first; this sets:
1240 SYMBOL_FLAG_FUNCTION,
1241 SYMBOL_FLAG_LOCAL, (binds_local_p)
1242 TLS_MODEL, SYMBOL_FLAG_SMALL
1243 SYMBOL_FLAG_EXTERNAL. */
1244 default_encode_section_info (decl
, rtl
, first
);
1246 if (! VAR_OR_FUNCTION_DECL_P (decl
))
1249 rtx sym_ref
= XEXP (rtl
, 0);
1251 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1253 /* Only really common if there's no initialiser. */
1254 bool really_common_p
= (DECL_COMMON (decl
)
1255 && (DECL_INITIAL (decl
) == NULL
1257 && DECL_INITIAL (decl
) == error_mark_node
)));
1259 /* For Darwin, if we have specified visibility and it's not the default
1260 that's counted 'hidden'. */
1261 if (DECL_VISIBILITY_SPECIFIED (decl
)
1262 && DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
)
1263 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_HIDDEN_VIS
;
1265 if (!DECL_EXTERNAL (decl
)
1266 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1267 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1268 && ((TREE_STATIC (decl
)
1269 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1270 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1271 && DECL_INITIAL (decl
) != error_mark_node
)))
1272 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1274 if (! TREE_PUBLIC (decl
))
1275 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_STATIC
;
1277 /* Short cut check for Darwin 'must indirect' rules. */
1279 || (DECL_WEAK (decl
) && ! MACHO_SYMBOL_HIDDEN_VIS_P (sym_ref
))
1280 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
1281 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_MUST_INDIRECT
;
1284 /* Objective C V2 (m64) IVAR offset refs from Apple GCC-4.x have an
1285 indirection for m64 code on PPC. Historically, these indirections
1286 also appear in the .data section. */
1287 tree o2meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1288 o2meta
= o2meta
? TREE_VALUE (o2meta
) : NULL_TREE
;
1290 if (o2meta
&& strncmp (IDENTIFIER_POINTER (o2meta
), "V2_IVRF",7) == 0)
1291 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_MUST_INDIRECT
;
1296 darwin_mark_decl_preserved (const char *name
)
1298 /* Actually we shouldn't mark any local symbol this way, but for now
1299 this only happens with ObjC meta-data. */
1300 if (darwin_label_is_anonymous_local_objc_name (name
))
1303 fprintf (asm_out_file
, "\t.no_dead_strip ");
1304 assemble_name (asm_out_file
, name
);
1305 fputc ('\n', asm_out_file
);
1309 darwin_rodata_section (int use_coal
, bool zsize
, int reloc
)
1312 ? darwin_sections
[const_coal_section
]
1313 : (zsize
? darwin_sections
[zobj_const_section
]
1314 : reloc
? darwin_sections
[const_data_section
]
1315 : darwin_sections
[const_section
]));
1319 darwin_mergeable_string_section (tree exp
,
1320 unsigned HOST_WIDE_INT align
)
1322 /* Darwin's ld expects to see non-writable string literals in the .cstring
1323 section. Later versions of ld check and complain when CFStrings are
1324 enabled. Therefore we shall force the strings into .cstring since we
1325 don't support writable ones anyway. */
1326 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1327 && TREE_CODE (exp
) == STRING_CST
1328 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1330 && (int_size_in_bytes (TREE_TYPE (exp
))
1331 == TREE_STRING_LENGTH (exp
))
1332 && ((size_t) TREE_STRING_LENGTH (exp
)
1333 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1334 return darwin_sections
[cstring_section
];
1336 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1337 && TREE_CODE (exp
) == STRING_CST
1338 && TREE_STRING_LENGTH (exp
) == 0)
1339 return darwin_sections
[zobj_const_section
];
1341 return readonly_data_section
;
1344 #ifndef HAVE_GAS_LITERAL16
1345 #define HAVE_GAS_LITERAL16 0
1349 darwin_mergeable_constant_section (tree exp
,
1350 unsigned HOST_WIDE_INT align
,
1354 return darwin_sections
[zobj_const_section
];
1356 machine_mode mode
= DECL_MODE (exp
);
1357 if (!flag_merge_constants
1362 || (align
& (align
-1)) != 0)
1363 return readonly_data_section
;
1365 /* This will ICE if the mode is not a constant size, but that is reasonable,
1366 since one cannot put a variable-sized thing into a constant section, we
1367 shouldn't be trying. */
1368 const unsigned int modesize
= GET_MODE_BITSIZE (mode
).to_constant ();
1370 if (modesize
> align
)
1371 return readonly_data_section
;
1373 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1375 if (TREE_CODE (size
) != INTEGER_CST
)
1376 return readonly_data_section
;
1378 unsigned isize
= TREE_INT_CST_LOW (size
);
1380 return darwin_sections
[literal4_section
];
1381 else if (isize
== 8)
1382 return darwin_sections
[literal8_section
];
1383 else if (HAVE_GAS_LITERAL16
1386 return darwin_sections
[literal16_section
];
1388 return readonly_data_section
;
1392 darwin_tm_clone_table_section (void)
1394 return get_named_section (NULL
,
1395 "__DATA,__tm_clone_table,regular,no_dead_strip",
1400 machopic_reloc_rw_mask (void)
1402 return MACHOPIC_INDIRECT
? 3 : 0;
1405 /* We have to deal with ObjC/C++ metadata section placement in the common
1406 code, since it will also be called from LTO.
1408 Return metadata attributes, if present (searching for ABI=2 first)
1409 Return NULL_TREE if no such attributes are found. */
1412 is_objc_metadata (tree decl
)
1415 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1416 && DECL_ATTRIBUTES (decl
))
1418 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1421 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1428 static int classes_seen
;
1429 static int objc_metadata_seen
;
1431 /* Return the section required for Objective C ABI 2 metadata. */
1433 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1436 tree ident
= TREE_VALUE (meta
);
1437 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1438 p
= IDENTIFIER_POINTER (ident
);
1440 gcc_checking_assert (flag_next_runtime
>= 1 && flag_objc_abi
== 2);
1442 objc_metadata_seen
= 1;
1444 if (base
== data_section
)
1445 base
= darwin_sections
[objc2_metadata_section
];
1447 /* Most of the OBJC2 META-data end up in the base section, so check it
1449 if (!strncmp (p
, "V2_BASE", 7))
1451 else if (!strncmp (p
, "V2_CNAM", 7))
1452 return darwin_sections
[objc2_class_names_section
];
1453 else if (!strncmp (p
, "V2_MNAM", 7))
1454 return darwin_sections
[objc2_method_names_section
];
1455 else if (!strncmp (p
, "V2_MTYP", 7))
1456 return darwin_sections
[objc2_method_types_section
];
1457 else if (!strncmp (p
, "V2_STRG", 7))
1458 return darwin_sections
[cstring_section
];
1460 else if (!strncmp (p
, "G2_META", 7) || !strncmp (p
, "G2_CLAS", 7))
1461 return darwin_sections
[objc2_classdefs_section
];
1462 else if (!strncmp (p
, "V2_PCOL", 7))
1463 return ld_uses_coal_sects
? darwin_sections
[data_coal_section
]
1464 : darwin_sections
[objc2_data_section
];
1465 else if (!strncmp (p
, "V2_MREF", 7))
1466 return darwin_sections
[objc2_message_refs_section
];
1467 else if (!strncmp (p
, "V2_CLRF", 7))
1468 return darwin_sections
[objc2_classrefs_section
];
1469 else if (!strncmp (p
, "V2_SURF", 7))
1470 return darwin_sections
[objc2_super_classrefs_section
];
1471 else if (!strncmp (p
, "V2_NLCL", 7))
1472 return darwin_sections
[objc2_nonlazy_class_section
];
1473 else if (!strncmp (p
, "V2_CLAB", 7))
1476 return darwin_sections
[objc2_classlist_section
];
1478 else if (!strncmp (p
, "V2_SRFS", 7))
1479 return darwin_sections
[objc2_selector_refs_section
];
1480 else if (!strncmp (p
, "V2_NLCA", 7))
1481 return darwin_sections
[objc2_nonlazy_category_section
];
1482 else if (!strncmp (p
, "V2_CALA", 7))
1483 return darwin_sections
[objc2_categorylist_section
];
1485 else if (!strncmp (p
, "V2_PLST", 7))
1486 return darwin_sections
[objc2_protocollist_section
];
1487 else if (!strncmp (p
, "V2_PRFS", 7))
1488 return darwin_sections
[objc2_protocolrefs_section
];
1490 else if (!strncmp (p
, "V2_INFO", 7))
1491 return darwin_sections
[objc2_image_info_section
];
1493 else if (!strncmp (p
, "V2_EHTY", 7))
1494 return ld_uses_coal_sects
? darwin_sections
[data_coal_section
]
1497 else if (!strncmp (p
, "V2_CSTR", 7))
1498 return darwin_sections
[objc2_constant_string_object_section
];
1500 else if (!strncmp (p
, "V2_IVRF", 7))
1501 return darwin_sections
[objc2_ivar_section
];
1503 /* Not recognized, default. */
1507 /* Return the section required for Objective C ABI 0/1 metadata. */
1509 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1512 tree ident
= TREE_VALUE (meta
);
1513 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1514 p
= IDENTIFIER_POINTER (ident
);
1516 gcc_checking_assert (flag_next_runtime
>= 1 && flag_objc_abi
< 2);
1518 objc_metadata_seen
= 1;
1520 /* String sections first, cos there are lots of strings. */
1521 if (!strncmp (p
, "V1_STRG", 7))
1522 return darwin_sections
[cstring_section
];
1523 else if (!strncmp (p
, "V1_CLSN", 7))
1524 return darwin_sections
[objc_class_names_section
];
1525 else if (!strncmp (p
, "V1_METN", 7))
1526 return darwin_sections
[objc_meth_var_names_section
];
1527 else if (!strncmp (p
, "V1_METT", 7))
1528 return darwin_sections
[objc_meth_var_types_section
];
1530 else if (!strncmp (p
, "V1_CLAS", 7))
1533 return darwin_sections
[objc_class_section
];
1535 else if (!strncmp (p
, "V1_META", 7))
1536 return darwin_sections
[objc_meta_class_section
];
1537 else if (!strncmp (p
, "V1_CATG", 7))
1538 return darwin_sections
[objc_category_section
];
1539 else if (!strncmp (p
, "V1_PROT", 7))
1540 return darwin_sections
[objc_protocol_section
];
1542 else if (!strncmp (p
, "V1_CLCV", 7))
1543 return darwin_sections
[objc_class_vars_section
];
1544 else if (!strncmp (p
, "V1_CLIV", 7))
1545 return darwin_sections
[objc_instance_vars_section
];
1547 else if (!strncmp (p
, "V1_CLCM", 7))
1548 return darwin_sections
[objc_cls_meth_section
];
1549 else if (!strncmp (p
, "V1_CLIM", 7))
1550 return darwin_sections
[objc_inst_meth_section
];
1551 else if (!strncmp (p
, "V1_CACM", 7))
1552 return darwin_sections
[objc_cat_cls_meth_section
];
1553 else if (!strncmp (p
, "V1_CAIM", 7))
1554 return darwin_sections
[objc_cat_inst_meth_section
];
1555 else if (!strncmp (p
, "V1_PNSM", 7))
1556 return darwin_sections
[objc_cat_inst_meth_section
];
1557 else if (!strncmp (p
, "V1_PCLM", 7))
1558 return darwin_sections
[objc_cat_cls_meth_section
];
1560 else if (!strncmp (p
, "V1_CLPR", 7))
1561 return darwin_sections
[objc_cat_cls_meth_section
];
1562 else if (!strncmp (p
, "V1_CAPR", 7))
1563 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1565 else if (!strncmp (p
, "V1_PRFS", 7))
1566 return darwin_sections
[objc_cat_cls_meth_section
];
1567 else if (!strncmp (p
, "V1_CLRF", 7))
1568 return darwin_sections
[objc_cls_refs_section
];
1569 else if (!strncmp (p
, "V1_SRFS", 7))
1570 return darwin_sections
[objc_selector_refs_section
];
1572 else if (!strncmp (p
, "V1_MODU", 7))
1573 return darwin_sections
[objc_module_info_section
];
1574 else if (!strncmp (p
, "V1_SYMT", 7))
1575 return darwin_sections
[objc_symbols_section
];
1576 else if (!strncmp (p
, "V1_INFO", 7))
1577 return darwin_sections
[objc_image_info_section
];
1579 else if (!strncmp (p
, "V1_PLST", 7))
1580 return darwin_sections
[objc1_prop_list_section
];
1581 else if (!strncmp (p
, "V1_PEXT", 7))
1582 return darwin_sections
[objc1_protocol_ext_section
];
1583 else if (!strncmp (p
, "V1_CEXT", 7))
1584 return darwin_sections
[objc1_class_ext_section
];
1586 else if (!strncmp (p
, "V2_CSTR", 7))
1587 return darwin_sections
[objc_constant_string_object_section
];
1593 machopic_select_section (tree decl
,
1595 unsigned HOST_WIDE_INT align
)
1597 bool zsize
, one
, weak
, use_coal
, ro
;
1598 section
*base_section
= NULL
;
1600 weak
= (DECL_P (decl
)
1602 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1604 /* Darwin pads zero-sized objects with at least one byte, so that the ld64
1605 atom model is preserved (objects must have distinct regions starting with
1606 a unique linker-visible symbol).
1607 In order to support section anchors, we need to move objects with zero
1608 size into sections which are marked as "no section anchors"; the padded
1609 objects, obviously, have real sizes that differ from their DECL sizes. */
1610 zsize
= DARWIN_SECTION_ANCHORS
&& flag_section_anchors
;
1612 /* In the streaming of LTO symbol data, we might have a situation where the
1613 var is incomplete or layout not finished (DECL_SIZE_UNIT is NULL_TREE).
1614 We cannot tell if it is zero-sized then, but we can get the section
1615 category correct so that nm reports the right kind of section
1616 (e.g. BSS c.f. data). */
1619 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1620 && DECL_SIZE_UNIT (decl
)
1621 && tree_to_uhwi (DECL_SIZE_UNIT (decl
)) == 0);
1624 && TREE_CODE (decl
) == VAR_DECL
1625 && DECL_COMDAT_GROUP (decl
);
1627 use_coal
= (weak
|| one
) && ld_uses_coal_sects
;
1629 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1631 switch (categorize_decl_for_section (decl
, reloc
))
1638 case SECCAT_SRODATA
:
1639 base_section
= darwin_rodata_section (use_coal
, zsize
, reloc
);
1642 case SECCAT_RODATA_MERGE_STR
:
1643 base_section
= darwin_mergeable_string_section (decl
, align
);
1646 case SECCAT_RODATA_MERGE_STR_INIT
:
1647 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1650 case SECCAT_RODATA_MERGE_CONST
:
1651 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1655 case SECCAT_DATA_REL
:
1656 case SECCAT_DATA_REL_LOCAL
:
1657 case SECCAT_DATA_REL_RO
:
1658 case SECCAT_DATA_REL_RO_LOCAL
:
1664 base_section
= darwin_sections
[const_data_coal_section
];
1666 base_section
= darwin_sections
[data_coal_section
];
1670 /* If we're doing section anchors, then punt zero-sized objects into
1671 their own sections so that they don't interfere with offset
1672 computation for the remaining vars. */
1674 base_section
= darwin_sections
[zobj_const_data_section
];
1676 base_section
= darwin_sections
[zobj_data_section
];
1679 base_section
= darwin_sections
[const_data_section
];
1681 base_section
= data_section
;
1687 base_section
= darwin_sections
[data_coal_section
];
1690 if (!TREE_PUBLIC (decl
))
1691 base_section
= lcomm_section
;
1692 else if (bss_noswitch_section
)
1693 base_section
= bss_noswitch_section
;
1695 base_section
= data_section
;
1703 /* Darwin weird special cases.
1704 a) OBJC Meta-data. */
1706 && (TREE_CODE (decl
) == VAR_DECL
1707 || TREE_CODE (decl
) == CONST_DECL
)
1708 && DECL_ATTRIBUTES (decl
))
1710 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1712 return darwin_objc2_section (decl
, meta
, base_section
);
1713 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1715 return darwin_objc1_section (decl
, meta
, base_section
);
1716 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1718 return base_section
; /* GNU runtime is happy with it all in one pot. */
1721 /* b) Constant string objects. */
1722 if (TREE_CODE (decl
) == CONSTRUCTOR
1724 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1725 && TYPE_NAME (TREE_TYPE (decl
)))
1727 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1728 if (TREE_CODE (name
) == TYPE_DECL
)
1729 name
= DECL_NAME (name
);
1731 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1733 if (flag_next_runtime
)
1735 if (flag_objc_abi
== 2)
1736 return darwin_sections
[objc2_constant_string_object_section
];
1738 return darwin_sections
[objc_constant_string_object_section
];
1741 return darwin_sections
[objc_string_object_section
];
1743 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1744 return darwin_sections
[cfstring_constant_object_section
];
1746 return base_section
;
1748 else if (flag_next_runtime
1751 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1752 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1753 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1754 /* c) legacy meta-data selection was deprecated at 4.6, removed now. */
1757 return base_section
;
1760 /* This can be called with address expressions as "rtx".
1761 They must go in "const". */
1764 machopic_select_rtx_section (machine_mode mode
, rtx x
,
1765 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1767 if (known_eq (GET_MODE_SIZE (mode
), 8)
1768 && (GET_CODE (x
) == CONST_INT
1769 || GET_CODE (x
) == CONST_WIDE_INT
1770 || GET_CODE (x
) == CONST_DOUBLE
))
1771 return darwin_sections
[literal8_section
];
1772 else if (known_eq (GET_MODE_SIZE (mode
), 4)
1773 && (GET_CODE (x
) == CONST_INT
1774 || GET_CODE (x
) == CONST_WIDE_INT
1775 || GET_CODE (x
) == CONST_DOUBLE
))
1776 return darwin_sections
[literal4_section
];
1777 else if (HAVE_GAS_LITERAL16
1779 && known_eq (GET_MODE_SIZE (mode
), 16)
1780 && (GET_CODE (x
) == CONST_INT
1781 || GET_CODE (x
) == CONST_WIDE_INT
1782 || GET_CODE (x
) == CONST_DOUBLE
1783 || GET_CODE (x
) == CONST_VECTOR
))
1784 return darwin_sections
[literal16_section
];
1785 else if (MACHOPIC_INDIRECT
1786 && (GET_CODE (x
) == SYMBOL_REF
1787 || GET_CODE (x
) == CONST
1788 || GET_CODE (x
) == LABEL_REF
))
1789 return darwin_sections
[const_data_section
];
1791 return darwin_sections
[const_section
];
1795 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1797 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (ctors
)};
1799 vec_safe_push (ctors
, new_elt
);
1801 if (! MACHOPIC_INDIRECT
)
1802 fprintf (asm_out_file
, ".reference .constructors_used\n");
1806 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1808 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (dtors
)};
1810 vec_safe_push (dtors
, new_elt
);
1812 if (! MACHOPIC_INDIRECT
)
1813 fprintf (asm_out_file
, ".reference .destructors_used\n");
1817 sort_cdtor_records (const void * a
, const void * b
)
1819 const cdtor_record
*cda
= (const cdtor_record
*)a
;
1820 const cdtor_record
*cdb
= (const cdtor_record
*)b
;
1821 if (cda
->priority
> cdb
->priority
)
1823 if (cda
->priority
< cdb
->priority
)
1825 if (cda
->position
> cdb
->position
)
1827 if (cda
->position
< cdb
->position
)
1838 if (MACHOPIC_INDIRECT
)
1839 switch_to_section (darwin_sections
[mod_init_section
]);
1841 switch_to_section (darwin_sections
[constructor_section
]);
1843 /* Where needed, provide a linker-visible section-start symbol so that we
1844 have stable output between debug and non-debug. */
1845 if (ld_init_term_start_labels
)
1846 fputs (MACHOPIC_INDIRECT
? "_Mod.init:\n" : "_CTOR.sect:\n", asm_out_file
);
1848 if (vec_safe_length (ctors
) > 1)
1849 ctors
->qsort (sort_cdtor_records
);
1850 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
1852 assemble_align (POINTER_SIZE
);
1853 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1863 if (MACHOPIC_INDIRECT
)
1864 switch_to_section (darwin_sections
[mod_term_section
]);
1866 switch_to_section (darwin_sections
[destructor_section
]);
1868 /* Where needed, provide a linker-visible section-start symbol so that we
1869 have stable output between debug and non-debug. */
1870 if (ld_init_term_start_labels
)
1871 fputs (MACHOPIC_INDIRECT
? "_Mod.term:\n" : "_DTOR.sect:\n", asm_out_file
);
1873 if (vec_safe_length (dtors
) > 1)
1874 dtors
->qsort (sort_cdtor_records
);
1875 FOR_EACH_VEC_SAFE_ELT (dtors
, i
, elt
)
1877 assemble_align (POINTER_SIZE
);
1878 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1883 darwin_globalize_label (FILE *stream
, const char *name
)
1885 if (!!strncmp (name
, "_OBJC_", 6))
1886 default_globalize_label (stream
, name
);
1887 /* We have some Objective C cases that need to be global, but only on newer
1889 if (flag_objc_abi
< 2 || flag_next_runtime
< 100700)
1891 if (!strncmp (name
+6, "LabelPro", 8))
1892 default_globalize_label (stream
, name
);
1893 if (!strncmp (name
+6, "Protocol_", 9))
1894 default_globalize_label (stream
, name
);
1897 /* This routine returns non-zero if 'name' starts with the special objective-c
1898 anonymous file-scope static name. It accommodates c++'s mangling of such
1899 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1902 darwin_label_is_anonymous_local_objc_name (const char *name
)
1904 const unsigned char *p
= (const unsigned char *) name
;
1907 if (p
[1] == 'Z' && p
[2] == 'L')
1910 while (*p
>= '0' && *p
<= '9')
1913 if (strncmp ((const char *)p
, "_OBJC_", 6) != 0)
1916 /* We need some of the objective c meta-data symbols to be visible to the
1917 linker (when the target OS version is newer). FIXME: this is horrible,
1918 we need a better mechanism. */
1920 if (flag_objc_abi
< 2 || flag_next_runtime
< 100700)
1924 if (!strncmp ((const char *)p
, "ClassRef", 8))
1926 else if (!strncmp ((const char *)p
, "SelRef", 6))
1928 else if (!strncmp ((const char *)p
, "Category", 8))
1930 if (p
[8] == '_' || p
[8] == 'I' || p
[8] == 'P' || p
[8] == 'C' )
1934 else if (!strncmp ((const char *)p
, "ClassMethods", 12))
1936 else if (!strncmp ((const char *)p
, "Instance", 8))
1938 if (p
[8] == 'I' || p
[8] == 'M')
1942 else if (!strncmp ((const char *)p
, "CLASS_RO", 8))
1944 else if (!strncmp ((const char *)p
, "METACLASS_RO", 12))
1946 else if (!strncmp ((const char *)p
, "Protocol", 8))
1948 if (p
[8] == '_' || p
[8] == 'I' || p
[8] == 'P'
1949 || p
[8] == 'M' || p
[8] == 'C' || p
[8] == 'O')
1953 else if (!strncmp ((const char *)p
, "LabelPro", 8))
1958 /* LTO support for Mach-O.
1960 This version uses three mach-o sections to encapsulate the (unlimited
1961 number of) lto sections.
1963 __GNU_LTO, __lto_sections contains the concatented GNU LTO section data.
1964 __GNU_LTO, __section_names contains the GNU LTO section names.
1965 __GNU_LTO, __section_index contains an array of values that index these.
1968 <section offset from the start of __GNU_LTO, __lto_sections>,
1970 <name offset from the start of __GNU_LTO, __section_names,
1973 At present, for both m32 and m64 mach-o files each of these fields is
1974 represented by a uint32_t. This is because, AFAICT, a mach-o object
1975 cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
1978 "offset An integer specifying the offset to this section in the file." */
1980 /* Count lto section numbers. */
1981 static unsigned int lto_section_num
= 0;
1983 /* A vector of information about LTO sections, at present, we only have
1984 the name. TODO: see if we can get the data length somehow. */
1985 typedef struct GTY (()) darwin_lto_section_e
{
1986 const char *sectname
;
1987 } darwin_lto_section_e
;
1989 static GTY (()) vec
<darwin_lto_section_e
, va_gc
> *lto_section_names
;
1991 /* Section wrapper scheme (used here to wrap the unlimited number of LTO
1992 sections into three Mach-O ones).
1993 NOTE: These names MUST be kept in sync with those in
1994 libiberty/simple-object-mach-o. */
1995 #define LTO_SECTS_SECTION "__wrapper_sects"
1996 #define LTO_NAMES_SECTION "__wrapper_names"
1997 #define LTO_INDEX_SECTION "__wrapper_index"
1999 /* File to temporarily store LTO data. This is appended to asm_out_file
2000 in darwin_end_file. */
2001 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
2002 static char *lto_asm_out_name
;
2003 static enum debug_info_levels saved_debug_info_level
;
2005 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
2006 asm_out_file and switching to an alternative output file. */
2008 darwin_asm_lto_start (void)
2010 gcc_assert (! saved_asm_out_file
);
2011 saved_asm_out_file
= asm_out_file
;
2012 saved_debug_info_level
= debug_info_level
;
2013 debug_info_level
= DINFO_LEVEL_NONE
;
2014 if (! lto_asm_out_name
)
2015 lto_asm_out_name
= make_temp_file (".lto.s");
2016 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
2017 if (lto_asm_out_file
== NULL
)
2018 fatal_error (input_location
,
2019 "failed to open temporary file %s for LTO output",
2021 asm_out_file
= lto_asm_out_file
;
2024 /* Restore asm_out_file. */
2026 darwin_asm_lto_end (void)
2028 gcc_assert (saved_asm_out_file
);
2029 fclose (lto_asm_out_file
);
2030 asm_out_file
= saved_asm_out_file
;
2031 saved_asm_out_file
= NULL
;
2032 debug_info_level
= saved_debug_info_level
;
2036 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2037 tree decl
, bool is_for_lto
);
2039 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
2042 darwin_asm_named_section (const char *name
,
2044 tree decl ATTRIBUTE_UNUSED
)
2046 /* LTO sections go in a special section that encapsulates the (unlimited)
2047 number of GNU LTO sections within a single mach-o one. */
2048 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
2049 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
2051 darwin_lto_section_e e
;
2052 /* We expect certain flags to be set... */
2053 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2054 == (SECTION_DEBUG
| SECTION_NAMED
));
2056 /* Switch to our combined section. */
2057 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2058 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
2059 /* Output a label for the start of this sub-section. */
2060 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# %s\n",
2061 lto_section_num
, name
);
2062 /* We have to jump through hoops to get the values of the intra-section
2064 fprintf (asm_out_file
, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
2065 lto_section_num
, lto_section_num
);
2066 fprintf (asm_out_file
,
2067 "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
2068 lto_section_num
, lto_section_num
+1, lto_section_num
);
2070 e
.sectname
= xstrdup (name
);
2071 /* Keep the names, we'll need to make a table later.
2072 TODO: check that we do not revisit sections, that would break
2073 the assumption of how this is done. */
2074 if (lto_section_names
== NULL
)
2075 vec_alloc (lto_section_names
, 16);
2076 vec_safe_push (lto_section_names
, e
);
2078 else if (strncmp (name
, "__DWARF,", 8) == 0)
2079 darwin_asm_dwarf_section (name
, flags
, decl
, false);
2080 else if (strncmp (name
, "__GNU_DWARF_LTO,", 16) == 0)
2081 darwin_asm_dwarf_section (name
, flags
, decl
, true);
2083 fprintf (asm_out_file
, "\t.section %s\n", name
);
2087 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
2089 /* Darwin does not use unique sections. */
2092 /* Handle __attribute__ ((apple_kext_compatibility)).
2093 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
2094 vtable for classes with this attribute (and their descendants) by not
2095 outputting the new 3.0 nondeleting destructor. This means that such
2096 objects CANNOT be allocated on the stack or as globals UNLESS they have
2097 a completely empty `operator delete'.
2098 Luckily, this fits in with the Darwin kext model.
2100 This attribute also disables gcc3's potential overlaying of derived
2101 class data members on the padding at the end of the base class. */
2104 darwin_handle_kext_attribute (tree
*node
, tree name
,
2105 tree args ATTRIBUTE_UNUSED
,
2106 int flags ATTRIBUTE_UNUSED
,
2109 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
2110 if (! TARGET_KEXTABI
)
2112 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2113 "only when compiling a kext", name
);
2115 *no_add_attrs
= true;
2117 else if (TREE_CODE (*node
) != RECORD_TYPE
)
2119 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2120 "only to C++ classes", name
);
2122 *no_add_attrs
= true;
2128 /* Handle a "weak_import" attribute; arguments as in
2129 struct attribute_spec.handler. */
2132 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
2133 tree
ARG_UNUSED (args
),
2134 int ARG_UNUSED (flags
),
2135 bool * no_add_attrs
)
2137 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
2139 warning (OPT_Wattributes
, "%qE attribute ignored",
2141 *no_add_attrs
= true;
2144 declare_weak (*node
);
2149 /* Emit a label for an FDE, making it global and/or weak if appropriate.
2150 The third parameter is nonzero if this is for exception handling.
2151 The fourth parameter is nonzero if this is just a placeholder for an
2152 FDE that we are omitting. */
2155 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
2159 static int invok_count
= 0;
2160 static tree last_fun_decl
= NULL_TREE
;
2162 /* Modern linkers can produce distinct FDEs without compiler support. */
2163 if (! for_eh
|| ! ld_needs_eh_markers
)
2166 /* FIXME: This only works when the eh for all sections of a function are
2167 emitted at the same time. If that changes, we would need to use a lookup
2168 table of some form to determine what to do. Also, we should emit the
2169 unadorned label for the partition containing the public label for a
2170 function. This is of limited use, probably, since we do not currently
2171 enable partitioning. */
2172 strcpy (buf
, ".eh");
2173 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
2175 if (decl
== last_fun_decl
)
2178 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
2182 last_fun_decl
= decl
;
2187 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
2189 if (TREE_PUBLIC (decl
))
2191 targetm
.asm_out
.globalize_label (file
, lab
);
2192 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
2194 fputs ("\t.private_extern ", file
);
2195 assemble_name (file
, lab
);
2200 if (DECL_WEAK (decl
))
2202 fputs ("\t.weak_definition ", file
);
2203 assemble_name (file
, lab
);
2207 assemble_name (file
, lab
);
2210 fputs (" = 0\n", file
);
2212 /* Mark the absolute .eh and .eh1 style labels as needed to
2213 ensure that we don't dead code strip them and keep such
2214 labels from another instantiation point until we can fix this
2215 properly with group comdat support. */
2216 darwin_mark_decl_preserved (lab
);
2219 fputs (":\n", file
);
2224 static GTY(()) unsigned long except_table_label_num
;
2227 darwin_emit_except_table_label (FILE *file
)
2229 char section_start_label
[30];
2231 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
2232 except_table_label_num
++);
2233 ASM_OUTPUT_LABEL (file
, section_start_label
);
2237 darwin_make_eh_symbol_indirect (rtx orig
, bool ARG_UNUSED (pubvis
))
2239 if (DARWIN_PPC
== 0 && TARGET_64BIT
)
2242 return gen_rtx_SYMBOL_REF (Pmode
,
2243 machopic_indirection_name (orig
,
2247 /* The unwinders in earlier Darwin versions are based on an old version
2248 of libgcc_s and need current frame address stateto be reset after a
2249 DW_CFA_restore_state recovers the register values. */
2252 darwin_should_restore_cfa_state (void)
2254 return generating_for_darwin_version
<= 10;
2257 /* Return, and mark as used, the name of the stub for the mcount function.
2258 Currently, this is only called by X86 code in the expansion of the
2259 FUNCTION_PROFILER macro, when stubs are enabled. */
2262 machopic_mcount_stub_name (void)
2264 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
2265 const char *name
= machopic_indirection_name (symbol
, /*stub_p=*/true);
2266 machopic_validate_stub_or_non_lazy_ptr (name
);
2270 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2273 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2275 const char *nlp_name
;
2277 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2279 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2280 fputs ("\t.long\t", file
);
2281 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2285 /* If this is uncommented, details of each allocation will be printed
2286 in the asm right before the actual code. WARNING - this will cause some
2287 test-suite fails (since the printout will contain items that some tests
2288 are not expecting) -- so don't leave it on by default (it bloats the
2290 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2292 /* The first two of these routines are ostensibly just intended to put
2293 names into the asm. However, they are both hijacked in order to ensure
2294 that zero-sized items do not make their way into the output. Consequently,
2295 we also need to make these participate in provisions for dealing with
2296 such items in section anchors. */
2298 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2299 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2300 but it does need to be referenced via indirect PIC data pointers.
2301 The machopic_define_symbol calls are telling the machopic subsystem
2302 that the name *is* defined in this module, so it doesn't need to
2303 make them indirect. */
2305 darwin_asm_declare_object_name (FILE *file
,
2306 const char *nam
, tree decl
)
2308 const char *xname
= nam
;
2309 unsigned HOST_WIDE_INT size
;
2310 bool local_def
, weak
;
2312 weak
= (DECL_P (decl
)
2314 && !lookup_attribute ("weak_import",
2315 DECL_ATTRIBUTES (decl
)));
2317 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2318 && (!DECL_COMMON (decl
)
2319 || !TREE_PUBLIC (decl
)));
2321 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2322 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2326 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2328 machopic_define_symbol (DECL_RTL (decl
));
2331 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2333 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2334 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2335 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2336 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2337 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2338 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2339 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2340 (unsigned long)DECL_INITIAL (decl
));
2343 /* Darwin needs help to support local zero-sized objects.
2344 They must be made at least one byte, and the section containing must be
2345 marked as unsuitable for section-anchors (see storage allocators below).
2347 For non-zero objects this output is handled by varasm.c.
2351 unsigned int l2align
= 0;
2353 /* The align must be honored, even for zero-sized. */
2354 if (DECL_ALIGN (decl
))
2356 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2357 fprintf (file
, "\t.align\t%u\n", l2align
);
2360 ASM_OUTPUT_LABEL (file
, xname
);
2362 fprintf (file
, "\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2364 /* Check that we've correctly picked up the zero-sized item and placed it
2366 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2368 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2371 ASM_OUTPUT_LABEL (file
, xname
);
2374 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2376 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2377 const_tree exp ATTRIBUTE_UNUSED
,
2380 assemble_label (file
, name
);
2381 /* As for other items, we need at least one byte. */
2384 fputs ("\t.space\t1\n", file
);
2385 /* Check that we've correctly picked up the zero-sized item and placed it
2387 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2389 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2393 /* Darwin storage allocators.
2395 Zerofill sections are desirable for large blank data since, otherwise, these
2396 data bloat objects (PR33210).
2398 However, section anchors don't work in .zerofill sections (one cannot switch
2399 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2400 to put (at least some) data into 'normal' switchable sections.
2402 Here we set a relatively arbitrary value for the size of an object to trigger
2403 zerofill when section anchors are enabled (anything bigger than a page for
2404 current Darwin implementations). FIXME: there ought to be some objective way
2405 to make this choice.
2407 When section anchor are off this is ignored anyway. */
2409 #define BYTES_ZFILL 4096
2411 /* Emit a chunk of data for items coalesced by the linker. */
2413 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2414 unsigned HOST_WIDE_INT size
,
2418 /* Since the sections used here are coalesced, they will not be eligible
2419 for section anchors, and therefore we don't need to break that out.
2420 CHECKME: for modern linker on PowerPC. */
2421 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2422 switch_to_section (use_coal
? darwin_sections
[const_data_coal_section
]
2423 : darwin_sections
[const_data_section
]);
2425 switch_to_section (use_coal
? darwin_sections
[data_coal_section
]
2428 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2429 the align info for zero-sized items... but do it here otherwise. */
2431 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2433 if (TREE_PUBLIC (decl
))
2434 darwin_globalize_label (fp
, name
);
2436 /* ... and we let it deal with outputting one byte of zero for them too. */
2437 darwin_asm_declare_object_name (fp
, name
, decl
);
2439 assemble_zeros (size
);
2442 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2444 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2445 unsigned HOST_WIDE_INT size
,
2446 unsigned int align
, tree meta
)
2448 section
*ocs
= data_section
;
2450 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2451 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2453 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2455 switch_to_section (ocs
);
2457 /* We shall declare that zero-sized meta-data are not valid (yet). */
2459 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2461 /* ... and we let it deal with outputting one byte of zero for them too. */
2462 darwin_asm_declare_object_name (fp
, name
, decl
);
2463 assemble_zeros (size
);
2466 /* This routine emits 'local' storage:
2468 When Section Anchors are off this routine emits .zerofill commands in
2469 sections named for their alignment.
2471 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2472 the .static_data section so that the section anchoring system can see them.
2473 Larger items are still placed in .zerofill sections, addressing PR33210.
2474 The routine has no checking - it is all assumed to be done by the caller.
2477 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2478 unsigned HOST_WIDE_INT size
,
2479 unsigned int l2align
)
2481 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2483 /* Put smaller objects in _static_data, where the section anchors system
2485 However, if they are zero-sized punt them to yet a different section
2486 (that is not allowed to participate in anchoring). */
2489 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2490 in_section
= darwin_sections
[zobj_bss_section
];
2495 fputs ("\t.static_data\n", fp
);
2496 in_section
= darwin_sections
[static_data_section
];
2500 fprintf (fp
, "\t.align\t%u\n", l2align
);
2502 assemble_name (fp
, name
);
2503 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2507 /* When we are on a non-section anchor target (or not using section
2508 anchors, we can get zero-sized items here. However, all we need to
2509 do is to bump them to one byte and the section alignment will take
2510 care of the rest. */
2512 snprintf (secnam
, 64, "__DATA,__bss");
2513 unsigned int flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2514 in_section
= get_section (secnam
, flags
, NULL
);
2515 fprintf (fp
, "\t.zerofill %s,", secnam
);
2516 assemble_name (fp
, name
);
2521 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2522 size
, (unsigned) l2align
);
2524 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",0\n", size
);
2527 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2528 /* This is defined as a file-scope var, so we know to notify machopic. */
2529 machopic_define_symbol (DECL_RTL (decl
));
2532 /* Emit a chunk of common. */
2534 darwin_emit_common (FILE *fp
, const char *name
,
2535 unsigned HOST_WIDE_INT size
, unsigned int align
)
2537 unsigned HOST_WIDE_INT rounded
;
2538 unsigned int l2align
;
2540 /* Earlier systems complain if the alignment exceeds the page size.
2541 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2542 if (!emit_aligned_common
&& (align
> 32768UL))
2543 align
= 4096UL; /* In units. */
2545 align
/= BITS_PER_UNIT
;
2547 /* Make sure we have a meaningful align. */
2551 /* For earlier toolchains, we need to emit the var as a rounded size to
2552 tell ld the alignment. */
2556 rounded
= (size
+ (align
-1)) & ~(align
-1);
2558 l2align
= floor_log2 (align
);
2560 in_section
= comm_section
;
2561 /* We mustn't allow multiple public symbols to share an address when using
2562 the normal OSX toolchain. */
2565 /* Put at least one byte. */
2567 /* This section can no longer participate in section anchoring. */
2568 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2571 fputs ("\t.comm\t", fp
);
2572 assemble_name (fp
, name
);
2573 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2574 emit_aligned_common
?size
:rounded
);
2575 if (l2align
&& emit_aligned_common
)
2576 fprintf (fp
, ",%u", l2align
);
2580 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2581 or coalescable data sections (for weak or comdat) as appropriate. */
2584 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2585 unsigned HOST_WIDE_INT size
, unsigned int align
)
2587 unsigned int l2align
;
2588 bool one
, pub
, weak
;
2591 pub
= TREE_PUBLIC (decl
);
2592 one
= DECL_ONE_ONLY (decl
);
2593 weak
= (DECL_P (decl
)
2595 && !lookup_attribute ("weak_import",
2596 DECL_ATTRIBUTES (decl
)));
2598 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2599 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2600 " pub %d weak %d one %d init %lx\n",
2601 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2602 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2603 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2606 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2607 before the target has a chance to comment. */
2608 if ((meta
= is_objc_metadata (decl
)))
2610 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2614 /* Check that any initializer is valid. */
2615 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2616 || (DECL_INITIAL (decl
) == error_mark_node
)
2617 || initializer_zerop (DECL_INITIAL (decl
)));
2619 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2620 gcc_assert (!DECL_COMMON (decl
));
2622 /* Pick up the correct alignment. */
2623 if (!size
|| !align
)
2624 align
= DECL_ALIGN (decl
);
2626 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2627 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2629 last_assemble_variable_decl
= decl
;
2631 /* We would rather not have to check this here - but it seems that we might
2632 be passed a decl that should be in coalesced space. */
2635 /* Weak or COMDAT objects are put in mergeable sections. */
2636 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2637 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2641 /* If this is not public, then emit according to local rules. */
2644 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2648 /* So we have a public symbol. */
2649 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2651 /* Put smaller objects in data, where the section anchors system can get
2652 them. However, if they are zero-sized punt them to yet a different
2653 section (that is not allowed to participate in anchoring). */
2656 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2657 in_section
= darwin_sections
[zobj_data_section
];
2662 fputs ("\t.data\n", fp
);
2663 in_section
= data_section
;
2667 fprintf (fp
, "\t.align\t%u\n", l2align
);
2669 assemble_name (fp
, name
);
2670 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2674 /* Section anchors not in use. */
2675 unsigned int flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2677 snprintf (secnam
, 64, "__DATA,__common");
2678 in_section
= get_section (secnam
, flags
, NULL
);
2679 fprintf (fp
, "\t.zerofill %s,", secnam
);
2680 assemble_name (fp
, name
);
2685 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2687 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",0\n", size
);
2689 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2692 /* Output a chunk of common, with alignment specified (where the target
2695 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2696 unsigned HOST_WIDE_INT size
,
2699 unsigned int l2align
;
2703 /* No corresponding var. */
2706 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2707 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2709 /* Common variables are limited to a maximum alignment of 2^15. */
2711 error_at (UNKNOWN_LOCATION
, "common variables must have an alignment"
2712 " of 32678 or less");
2713 darwin_emit_common (fp
, name
, size
, align
);
2717 one
= DECL_ONE_ONLY (decl
);
2718 weak
= (DECL_P (decl
)
2720 && !lookup_attribute ("weak_import",
2721 DECL_ATTRIBUTES (decl
)));
2723 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2724 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2725 " weak %d one %d init %lx\n",
2726 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2727 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2728 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2731 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2732 before the target has a chance to comment. */
2733 if ((meta
= is_objc_metadata (decl
)))
2735 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2739 /* We shouldn't be messing with this if the decl has a section name. */
2740 gcc_checking_assert (DECL_SECTION_NAME (decl
) == NULL
);
2742 /* We would rather not have to check this here - but it seems that we might
2743 be passed a decl that should be in coalesced space. */
2746 /* Weak or COMDAT objects are put in mergable sections. */
2747 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2748 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2752 /* We should only get here for DECL_COMMON, with a zero init (and, in
2753 principle, only for public symbols too - although we deal with local
2756 /* Check the initializer is OK. */
2757 gcc_assert (DECL_COMMON (decl
)
2758 && ((DECL_INITIAL (decl
) == NULL
)
2759 || (DECL_INITIAL (decl
) == error_mark_node
)
2760 || initializer_zerop (DECL_INITIAL (decl
))));
2762 last_assemble_variable_decl
= decl
;
2764 if (!size
|| !align
)
2765 align
= DECL_ALIGN (decl
);
2767 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2768 /* Check we aren't asking for more aligment than the platform allows. */
2769 gcc_checking_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2771 if (TREE_PUBLIC (decl
) != 0)
2773 /* Common variables are limited to a maximum alignment of 2^15. */
2775 error_at (DECL_SOURCE_LOCATION (decl
), "common variables must have"
2776 " an alignment of 32678 or less");
2777 darwin_emit_common (fp
, name
, size
, align
);
2780 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2783 /* Output a chunk of BSS with alignment specfied. */
2785 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2786 unsigned HOST_WIDE_INT size
,
2789 unsigned long l2align
;
2793 one
= DECL_ONE_ONLY (decl
);
2794 weak
= (DECL_P (decl
)
2796 && !lookup_attribute ("weak_import",
2797 DECL_ATTRIBUTES (decl
)));
2799 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2800 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2801 " weak %d init %lx\n",
2802 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2803 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2804 weak
, (unsigned long)DECL_INITIAL (decl
));
2807 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2808 before the target has a chance to comment. */
2809 if ((meta
= is_objc_metadata (decl
)))
2811 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2815 /* We shouldn't be messing with this if the decl has a section name. */
2816 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2818 /* We would rather not have to check this here - but it seems that we might
2819 be passed a decl that should be in coalesced space. */
2822 /* Weak or COMDAT objects are put in mergable sections. */
2823 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2824 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2828 /* .. and it should be suitable for placement in local mem. */
2829 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2830 /* .. and any initializer must be all-zero. */
2831 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2832 || (DECL_INITIAL (decl
) == error_mark_node
)
2833 || initializer_zerop (DECL_INITIAL (decl
)));
2835 last_assemble_variable_decl
= decl
;
2837 if (!size
|| !align
)
2838 align
= DECL_ALIGN (decl
);
2840 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2841 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2843 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2846 /* Emit an assembler directive to set visibility for a symbol. The
2847 only supported visibilities are VISIBILITY_DEFAULT and
2848 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2849 extern". There is no MACH-O equivalent of ELF's
2850 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2853 darwin_assemble_visibility (tree decl
, int vis
)
2855 if (vis
== VISIBILITY_DEFAULT
)
2857 else if (vis
== VISIBILITY_HIDDEN
|| vis
== VISIBILITY_INTERNAL
)
2859 fputs ("\t.private_extern ", asm_out_file
);
2860 assemble_name (asm_out_file
,
2861 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2862 fputs ("\n", asm_out_file
);
2865 warning (OPT_Wattributes
, "protected visibility attribute "
2866 "not supported in this configuration; ignored");
2869 /* vec used by darwin_asm_dwarf_section.
2870 Maybe a hash tab would be better here - but the intention is that this is
2871 a very short list (fewer than 16 items) and each entry should (ideally,
2872 eventually) only be presented once.
2874 A structure to hold a dwarf debug section used entry. */
2876 typedef struct GTY(()) dwarf_sect_used_entry
{
2880 dwarf_sect_used_entry
;
2883 /* A list of used __DWARF sections. */
2884 static GTY (()) vec
<dwarf_sect_used_entry
, va_gc
> *dwarf_sect_names_table
;
2886 /* This is called when we are asked to assemble a named section and the
2887 name begins with __DWARF,. We keep a list of the section names (without
2888 the __DWARF, prefix) and use this to emit our required start label on the
2889 first switch to each section. */
2892 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2893 tree
ARG_UNUSED (decl
), bool is_for_lto
)
2896 int namelen
, extra
= 0;
2897 const char *sect
, *lto_add
= "";
2899 dwarf_sect_used_entry
*ref
;
2902 gcc_checking_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2903 == (SECTION_DEBUG
| SECTION_NAMED
));
2905 /* We know that the name starts with __DWARF, or __GNU_DAWRF_LTO */
2906 sect
= strchr (name
, ',') + 1;
2907 namelen
= strchr (sect
, ',') - sect
;
2908 gcc_checking_assert (namelen
);
2910 /* The section switch is output as written... */
2911 fprintf (asm_out_file
, "\t.section %s\n", name
);
2913 /* ... but the string we keep to make section start labels needs
2914 adjustment for lto cases. */
2921 snprintf (sname
, 64, "%.*s%.*s", namelen
, sect
, extra
, lto_add
);
2924 if (dwarf_sect_names_table
== NULL
)
2925 vec_alloc (dwarf_sect_names_table
, 16);
2928 dwarf_sect_names_table
->iterate (i
, &ref
);
2933 if (!strcmp (ref
->name
, sname
))
2943 dwarf_sect_used_entry e
;
2944 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
2946 e
.name
= xstrdup (sname
);
2947 vec_safe_push (dwarf_sect_names_table
, e
);
2951 /* Output a difference of two labels that will be an assembly time
2952 constant if the two labels are local. (.long lab1-lab2 will be
2953 very different if lab1 is at the boundary between two sections; it
2954 will be relocated according to the second section, not the first,
2955 so one ends up with a difference between labels in different
2956 sections, which is bad in the dwarf2 eh context for instance.) */
2958 static int darwin_dwarf_label_counter
;
2961 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
2962 const char *lab1
, const char *lab2
,
2963 HOST_WIDE_INT offset
)
2965 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
2966 && lab2
[0] == '*' && lab2
[1] == 'L');
2967 const char *directive
= (size
== 8 ? ".quad" : ".long");
2970 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
2972 fprintf (file
, "\t%s\t", directive
);
2974 assemble_name_raw (file
, lab1
);
2975 fprintf (file
, "-");
2976 assemble_name_raw (file
, lab2
);
2978 fprintf (file
, "+" HOST_WIDE_INT_PRINT_DEC
, offset
);
2980 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
2983 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
2984 offsets are not represented using relocs in .o files; either the
2985 section never leaves the .o file, or the linker or other tool is
2986 responsible for parsing the DWARF and updating the offsets. */
2989 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
2990 HOST_WIDE_INT offset
, section
*base
)
2993 int namelen
, extra
= 0;
2995 const char *lto_add
= "";
2997 gcc_checking_assert (base
->common
.flags
& SECTION_NAMED
);
2998 is_for_lto
= strncmp (base
->named
.name
, "__GNU_DWARF_LTO,", 16) == 0;
2999 gcc_checking_assert (is_for_lto
3000 || strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
3001 const char *name
= strchr (base
->named
.name
, ',') + 1;
3002 gcc_checking_assert (name
);
3004 namelen
= strchr (name
, ',') - (name
);
3010 snprintf (sname
, 64, "*Lsection%.*s%.*s", namelen
, name
, extra
, lto_add
);
3011 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
, offset
);
3014 /* Called from the within the TARGET_ASM_FILE_START for each target. */
3017 darwin_file_start (void)
3019 /* Nothing to do. */
3022 /* Called for the TARGET_ASM_FILE_END hook.
3023 Emit the mach-o pic indirection data, the lto data and, finally a flag
3024 to tell the linker that it can break the file object into sections and
3025 move those around for efficiency. */
3028 darwin_file_end (void)
3030 if (!vec_safe_is_empty (ctors
))
3032 if (!vec_safe_is_empty (dtors
))
3035 /* If we are expecting to output NeXT ObjC meta-data, (and we actually see
3036 some) then we output the fix-and-continue marker (Image Info).
3037 This applies to Objective C, Objective C++ and LTO with either language
3038 as part of the input. */
3039 if (flag_next_runtime
&& objc_metadata_seen
)
3041 unsigned int flags
= 0;
3042 if (flag_objc_abi
>= 2)
3045 switch_to_section (darwin_sections
[objc2_image_info_section
]);
3048 switch_to_section (darwin_sections
[objc_image_info_section
]);
3050 ASM_OUTPUT_ALIGN (asm_out_file
, 2);
3051 fputs ("L_OBJC_ImageInfo:\n", asm_out_file
);
3053 flags
|= (flag_replace_objc_classes
&& classes_seen
) ? 1 : 0;
3054 flags
|= flag_objc_gc
? 2 : 0;
3056 fprintf (asm_out_file
, "\t.long\t0\n\t.long\t%u\n", flags
);
3059 machopic_finish (asm_out_file
);
3060 if (flag_apple_kext
)
3062 /* These sections are only used for kernel code. */
3063 switch_to_section (darwin_sections
[constructor_section
]);
3064 switch_to_section (darwin_sections
[destructor_section
]);
3065 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
3068 /* If there was LTO assembler output, append it to asm_out_file. */
3069 if (lto_asm_out_name
)
3072 char *buf
, *lto_asm_txt
;
3074 /* Shouldn't be here if we failed to switch back. */
3075 gcc_assert (! saved_asm_out_file
);
3077 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
3078 if (lto_asm_out_file
== NULL
)
3079 fatal_error (input_location
,
3080 "failed to open temporary file %s with LTO output",
3082 fseek (lto_asm_out_file
, 0, SEEK_END
);
3083 n
= ftell (lto_asm_out_file
);
3086 fseek (lto_asm_out_file
, 0, SEEK_SET
);
3087 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
3088 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
3089 fputs (lto_asm_txt
, asm_out_file
);
3090 /* Put a termination label. */
3091 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3092 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
3093 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# end of lto\n",
3095 /* Make sure our termination label stays in this section. */
3096 fputs ("\t.space\t1\n", asm_out_file
);
3099 /* Remove the temporary file. */
3100 fclose (lto_asm_out_file
);
3101 unlink_if_ordinary (lto_asm_out_name
);
3102 free (lto_asm_out_name
);
3105 /* Output the names and indices. */
3106 if (lto_section_names
&& lto_section_names
->length ())
3109 darwin_lto_section_e
*ref
;
3110 /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
3111 the latter up ourselves. */
3112 const char *op
= integer_asm_op (4,0);
3114 /* Emit the names. */
3115 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3116 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
3117 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
3119 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\n", count
);
3120 /* We have to jump through hoops to get the values of the intra-section
3122 fprintf (asm_out_file
,
3123 "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
3125 fprintf (asm_out_file
,
3126 "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
3127 count
, count
+1, count
);
3128 fprintf (asm_out_file
, "\t.asciz\t\"%s\"\n", ref
->sectname
);
3130 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num
);
3131 /* make sure our termination label stays in this section. */
3132 fputs ("\t.space\t1\n", asm_out_file
);
3134 /* Emit the Index. */
3135 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3136 LTO_SEGMENT_NAME
, LTO_INDEX_SECTION
);
3137 fputs ("\t.align\t2\n", asm_out_file
);
3138 fputs ("# Section offset, Section length, Name offset, Name length\n",
3140 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
3142 fprintf (asm_out_file
, "%s L$gnu$lto$offs%d\t;# %s\n",
3143 op
, count
, ref
->sectname
);
3144 fprintf (asm_out_file
, "%s L$gnu$lto$size%d\n", op
, count
);
3145 fprintf (asm_out_file
, "%s L$gnu$lto$noff%d\n", op
, count
);
3146 fprintf (asm_out_file
, "%s L$gnu$lto$nsiz%d\n", op
, count
);
3150 /* If we have section anchors, then we must prevent the linker from
3151 re-arranging data. */
3152 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
3153 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
3155 /* We rely on this being NULL at the start of compilation; reset it here
3156 so that JIT can reuse a context. */
3157 if (dwarf_sect_names_table
!= NULL
)
3159 dwarf_sect_names_table
->truncate (0);
3160 dwarf_sect_names_table
= NULL
;
3164 /* TODO: Add a language hook for identifying if a decl is a vtable. */
3165 #define DARWIN_VTABLE_P(DECL) 0
3167 /* Cross-module name binding. Darwin does not support overriding
3168 functions at dynamic-link time, except for vtables in kexts. */
3171 darwin_binds_local_p (const_tree decl
)
3173 /* We use the "shlib" input to indicate that a symbol should be
3174 considered overridable; only relevant for vtables in kernel modules
3175 on earlier system versions, and with a TODO to complete. */
3176 bool force_overridable
= TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
);
3177 return default_binds_local_p_3 (decl
, force_overridable
/* shlib */,
3178 false /* weak dominate */,
3179 false /* extern_protected_data */,
3180 false /* common_local_p */);
3183 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
3184 anchor relative to ".", the current section position. We cannot use
3185 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
3187 darwin_asm_output_anchor (rtx symbol
)
3189 fprintf (asm_out_file
, "\t.set\t");
3190 assemble_name (asm_out_file
, XSTR (symbol
, 0));
3191 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
3192 SYMBOL_REF_BLOCK_OFFSET (symbol
));
3195 /* Disable section anchoring on any section containing a zero-sized
3198 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
3200 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
3203 /* If the section contains a zero-sized object it's ineligible. */
3204 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
3205 /* This should have the effect of disabling anchors for vars that follow
3206 any zero-sized one, in a given section. */
3207 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
3210 /* Also check the normal reasons for suppressing. */
3211 return default_use_anchors_for_symbol_p (symbol
);
3217 /* Set the darwin specific attributes on TYPE. */
3219 darwin_set_default_type_attributes (tree type
)
3221 if (darwin_ms_struct
3222 && TREE_CODE (type
) == RECORD_TYPE
)
3223 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
3225 TYPE_ATTRIBUTES (type
));
3228 /* True, iff we're generating code for loadable kernel extensions. */
3231 darwin_kextabi_p (void) {
3232 return flag_apple_kext
;
3236 darwin_override_options (void)
3238 /* Keep track of which (major) version we're generating code for. */
3239 if (darwin_macosx_version_min
)
3241 if (strverscmp (darwin_macosx_version_min
, "10.7") >= 0)
3242 generating_for_darwin_version
= 11;
3243 else if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
3244 generating_for_darwin_version
= 10;
3245 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
3246 generating_for_darwin_version
= 9;
3247 else if (strverscmp (darwin_macosx_version_min
, "10.4") >= 0)
3248 generating_for_darwin_version
= 8;
3250 /* Earlier versions are not specifically accounted, until required. */
3253 /* Some codegen needs to account for the capabilities of the target
3255 if (darwin_target_linker
)
3257 /* Older Darwin ld could not coalesce weak entities without them being
3258 placed in special sections. */
3259 if (strverscmp (darwin_target_linker
, MIN_LD64_NO_COAL_SECTS
) < 0)
3260 ld_uses_coal_sects
= true;
3262 /* Some newer assemblers emit section start temp symbols for mod init
3263 and term sections if there is no suitable symbol present already.
3264 The temp symbols are linker visible and therefore appear in the
3265 symbol tables. Since the temp symbol number can vary when debug is
3266 enabled, that causes compare-debug fails. The solution is to provide
3267 a stable linker-visible symbol. */
3268 if (strverscmp (darwin_target_linker
,
3269 MIN_LD64_INIT_TERM_START_LABELS
) >= 0)
3270 ld_init_term_start_labels
= true;
3273 /* In principle, this should be c-family only. However, we really need to
3274 set sensible defaults for LTO as well, since the section selection stuff
3275 should check for correctness re. the ABI. TODO: check and provide the
3276 flags (runtime & ABI) from the lto wrapper). */
3278 /* At present, make a hard update to the runtime version based on the target
3280 if (flag_next_runtime
)
3282 if (generating_for_darwin_version
> 10)
3283 flag_next_runtime
= 100705;
3284 else if (generating_for_darwin_version
> 9)
3285 flag_next_runtime
= 100608;
3286 else if (generating_for_darwin_version
> 8)
3287 flag_next_runtime
= 100508;
3289 flag_next_runtime
= 100000;
3292 /* Unless set, force ABI=2 for NeXT and m64, 0 otherwise. */
3293 if (!global_options_set
.x_flag_objc_abi
)
3294 global_options
.x_flag_objc_abi
3295 = (!flag_next_runtime
)
3298 : (generating_for_darwin_version
>= 9) ? 1
3301 if (global_options_set
.x_flag_objc_abi
&& flag_next_runtime
)
3303 if (TARGET_64BIT
&& global_options
.x_flag_objc_abi
!= 2)
3304 /* The Objective-C family ABI 2 is the only valid version NeXT/m64. */
3305 error_at (UNKNOWN_LOCATION
,
3306 "%<-fobjc-abi-version%> 2 must be used for 64 bit targets"
3307 " with %<-fnext-runtime%>");
3308 else if (!TARGET_64BIT
&& global_options
.x_flag_objc_abi
>= 2)
3309 /* ABI versions 0 and 1 are the only valid versions NeXT/m32. */
3310 error_at (UNKNOWN_LOCATION
,
3311 "%<-fobjc-abi-version%> %d is not supported for 32 bit"
3312 " targets with %<-fnext-runtime%>",
3313 global_options
.x_flag_objc_abi
);
3316 /* Don't emit DWARF3/4 unless specifically selected. This is a
3317 workaround for tool bugs. */
3318 if (!global_options_set
.x_dwarf_strict
)
3320 if (!global_options_set
.x_dwarf_version
)
3323 if (global_options_set
.x_dwarf_split_debug_info
)
3325 inform (input_location
,
3326 "%<-gsplit-dwarf%> is not supported on this platform, ignored");
3327 dwarf_split_debug_info
= 0;
3328 global_options_set
.x_dwarf_split_debug_info
= 0;
3331 /* Do not allow unwind tables to be generated by default for m32.
3332 fnon-call-exceptions will override this, regardless of what we do. */
3333 if (generating_for_darwin_version
< 10
3334 && !global_options_set
.x_flag_asynchronous_unwind_tables
3336 global_options
.x_flag_asynchronous_unwind_tables
= 0;
3338 /* Disable -freorder-blocks-and-partition when unwind tables are being
3339 emitted for Darwin < 9 (OSX 10.5).
3340 The strategy is, "Unless the User has specifically set/unset an unwind
3341 flag we will switch off -freorder-blocks-and-partition when unwind tables
3342 will be generated". If the User specifically sets flags... we assume
3343 (s)he knows why... */
3344 if (generating_for_darwin_version
< 9
3345 && global_options_set
.x_flag_reorder_blocks_and_partition
3346 && ((global_options
.x_flag_exceptions
/* User, c++, java */
3347 && !global_options_set
.x_flag_exceptions
) /* User specified... */
3348 || (global_options
.x_flag_unwind_tables
3349 && !global_options_set
.x_flag_unwind_tables
)
3350 || (global_options
.x_flag_non_call_exceptions
3351 && !global_options_set
.x_flag_non_call_exceptions
)
3352 || (global_options
.x_flag_asynchronous_unwind_tables
3353 && !global_options_set
.x_flag_asynchronous_unwind_tables
)))
3355 inform (input_location
,
3356 "%<-freorder-blocks-and-partition%> does not work with "
3357 "exceptions on this architecture");
3358 flag_reorder_blocks_and_partition
= 0;
3359 flag_reorder_blocks
= 1;
3362 /* FIXME: flag_objc_sjlj_exceptions is no longer needed since there is only
3363 one valid choice of exception scheme for each runtime. */
3364 if (!global_options_set
.x_flag_objc_sjlj_exceptions
)
3365 global_options
.x_flag_objc_sjlj_exceptions
=
3366 flag_next_runtime
&& !TARGET_64BIT
;
3368 /* FIXME: and this could be eliminated then too. */
3369 if (!global_options_set
.x_flag_exceptions
3370 && flag_objc_exceptions
3372 flag_exceptions
= 1;
3374 if (flag_mkernel
|| flag_apple_kext
)
3376 /* -mkernel implies -fapple-kext for C++ */
3377 if (lang_GNU_CXX ())
3378 flag_apple_kext
= 1;
3382 /* No EH in kexts. */
3383 flag_exceptions
= 0;
3384 /* No -fnon-call-exceptions data in kexts. */
3385 flag_non_call_exceptions
= 0;
3386 /* so no tables either.. */
3387 flag_unwind_tables
= 0;
3388 flag_asynchronous_unwind_tables
= 0;
3391 if (flag_var_tracking_uninit
== 0
3392 && generating_for_darwin_version
>= 9
3393 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
3394 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
3395 && write_symbols
== DWARF2_DEBUG
)
3396 flag_var_tracking_uninit
= flag_var_tracking
;
3398 /* Final check on PCI options; for Darwin these are not dependent on the PIE
3399 ones, although PIE does require PIC to support it. */
3400 if (MACHO_DYNAMIC_NO_PIC_P
)
3403 warning_at (UNKNOWN_LOCATION
, 0,
3404 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
3405 " %<-fpie%> or %<-fPIE%>");
3408 else if (flag_pic
== 1
3409 || (flag_pic
== 0 && !(flag_mkernel
|| flag_apple_kext
)))
3411 /* Darwin's -fpic is -fPIC.
3412 We only support "static" code in the kernel and kernel exts. */
3416 /* Linkers >= ld64-62.1 (at least) are capable of making the necessary PIC
3417 indirections and we no longer need to emit pic symbol stubs.
3418 However, if we are generating code for earlier ones (or for use in the
3419 kernel) the stubs might still be required, and this will be set true.
3420 If the user sets it on or off - then that takes precedence.
3422 Linkers that don't need stubs, don't need the EH symbol markers either.
3425 if (!global_options_set
.x_darwin_symbol_stubs
)
3427 if (darwin_target_linker
)
3429 if (strverscmp (darwin_target_linker
, MIN_LD64_OMIT_STUBS
) < 0)
3431 darwin_symbol_stubs
= true;
3432 ld_needs_eh_markers
= true;
3435 else if (generating_for_darwin_version
< 9)
3437 /* If we don't know the linker version and we're targeting an old
3438 system, we know no better than to assume the use of an earlier
3440 darwin_symbol_stubs
= true;
3441 ld_needs_eh_markers
= true;
3444 else if (DARWIN_X86
&& darwin_symbol_stubs
&& TARGET_64BIT
)
3446 inform (input_location
,
3447 "%<-mpic-symbol-stubs%> is not required for 64-bit code "
3449 darwin_symbol_stubs
= false;
3452 if (generating_for_darwin_version
>= 9)
3453 /* Later systems can support aligned common. */
3454 emit_aligned_common
= true;
3456 /* The c_dialect...() macros are not available to us here. */
3457 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
3461 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
3464 darwin_patch_builtin (enum built_in_function fncode
)
3466 tree fn
= builtin_decl_explicit (fncode
);
3473 sym
= DECL_ASSEMBLER_NAME (fn
);
3474 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
3476 set_user_assembler_name (fn
, newname
);
3478 fn
= builtin_decl_implicit (fncode
);
3480 set_user_assembler_name (fn
, newname
);
3484 darwin_patch_builtins (void)
3486 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
3489 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
3490 #define PATCH_BUILTIN_NO64(fncode) \
3491 if (!TARGET_64BIT) \
3492 darwin_patch_builtin (fncode);
3493 #define PATCH_BUILTIN_VARIADIC(fncode) \
3495 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
3496 darwin_patch_builtin (fncode);
3497 #include "darwin-ppc-ldouble-patch.def"
3498 #undef PATCH_BUILTIN
3499 #undef PATCH_BUILTIN_NO64
3500 #undef PATCH_BUILTIN_VARIADIC
3504 /* CFStrings implementation. */
3505 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3506 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3507 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3508 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3509 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3510 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3512 static enum built_in_function darwin_builtin_cfstring
;
3514 /* Store all constructed constant CFStrings in a hash table so that
3515 they get uniqued properly. */
3517 typedef struct GTY ((for_user
)) cfstring_descriptor
{
3518 /* The string literal. */
3520 /* The resulting constant CFString. */
3522 } cfstring_descriptor
;
3524 struct cfstring_hasher
: ggc_ptr_hash
<cfstring_descriptor
>
3526 static hashval_t
hash (cfstring_descriptor
*);
3527 static bool equal (cfstring_descriptor
*, cfstring_descriptor
*);
3530 static GTY (()) hash_table
<cfstring_hasher
> *cfstring_htab
;
3533 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3535 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3536 get_identifier (name
), type
);
3540 *chain
= &DECL_CHAIN (field
);
3546 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3548 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3551 darwin_builtin_cfstring
=
3552 (enum built_in_function
) builtin_cfstring
;
3554 /* struct __builtin_CFString {
3555 const int *isa; (will point at
3556 int flags; __CFConstantStringClassReference)
3561 pcint_type_node
= build_pointer_type
3562 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3564 pcchar_type_node
= build_pointer_type
3565 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3567 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3569 /* Have to build backwards for finish struct. */
3570 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3571 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3572 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3573 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3574 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3577 /* const struct __builtin_CFstring *
3578 __builtin___CFStringMakeConstantString (const char *); */
3580 ccfstring_type_node
= build_qualified_type
3581 (cfstring_type_node
, TYPE_QUAL_CONST
);
3582 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3583 pccfstring_ftype_pcchar
= build_function_type_list
3584 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3586 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3587 get_identifier ("__builtin___CFStringMakeConstantString"),
3588 pccfstring_ftype_pcchar
);
3590 TREE_PUBLIC (cfsfun
) = 1;
3591 DECL_EXTERNAL (cfsfun
) = 1;
3592 DECL_ARTIFICIAL (cfsfun
) = 1;
3593 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3594 in place of the existing, which may be NULL. */
3595 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3596 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3597 set_decl_built_in_function (cfsfun
, BUILT_IN_MD
, darwin_builtin_cfstring
);
3598 lang_hooks
.builtin_function (cfsfun
);
3600 /* extern int __CFConstantStringClassReference[]; */
3601 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3602 get_identifier ("__CFConstantStringClassReference"),
3603 build_array_type (integer_type_node
, NULL_TREE
));
3605 TREE_PUBLIC (cfstring_class_reference
) = 1;
3606 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3607 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3608 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3609 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3611 /* Initialize the hash table used to hold the constant CFString objects. */
3612 cfstring_htab
= hash_table
<cfstring_hasher
>::create_ggc (31);
3614 return cfstring_type_node
;
3618 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3619 bool ARG_UNUSED (ignore
))
3621 unsigned int fcode
= DECL_MD_FUNCTION_CODE (fndecl
);
3623 if (fcode
== darwin_builtin_cfstring
)
3625 if (!darwin_constant_cfstrings
)
3627 error ("built-in function %qD requires the"
3628 " %<-mconstant-cfstrings%> flag", fndecl
);
3629 return error_mark_node
;
3634 error ("built-in function %qD takes one argument only", fndecl
);
3635 return error_mark_node
;
3638 return darwin_build_constant_cfstring (*argp
);
3645 darwin_rename_builtins (void)
3650 darwin_libc_has_function (enum function_class fn_class
,
3651 tree type ATTRIBUTE_UNUSED
)
3653 if (fn_class
== function_sincos
)
3654 return (strverscmp (darwin_macosx_version_min
, "10.9") >= 0);
3656 if (fn_class
== function_c99_math_complex
3657 || fn_class
== function_c99_misc
)
3658 return (TARGET_64BIT
3659 || strverscmp (darwin_macosx_version_min
, "10.3") >= 0);
3665 cfstring_hasher::hash (cfstring_descriptor
*ptr
)
3667 tree str
= ptr
->literal
;
3668 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3669 int i
, len
= TREE_STRING_LENGTH (str
);
3672 for (i
= 0; i
< len
; i
++)
3673 h
= ((h
* 613) + p
[i
]);
3679 cfstring_hasher::equal (cfstring_descriptor
*ptr1
, cfstring_descriptor
*ptr2
)
3681 tree str1
= ptr1
->literal
;
3682 tree str2
= ptr2
->literal
;
3683 int len1
= TREE_STRING_LENGTH (str1
);
3685 return (len1
== TREE_STRING_LENGTH (str2
)
3686 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3691 darwin_build_constant_cfstring (tree str
)
3693 struct cfstring_descriptor
*desc
, key
;
3698 error ("CFString literal is missing");
3699 return error_mark_node
;
3704 if (TREE_CODE (str
) == ADDR_EXPR
)
3705 str
= TREE_OPERAND (str
, 0);
3707 if (TREE_CODE (str
) != STRING_CST
)
3709 error ("CFString literal expression is not a string constant");
3710 return error_mark_node
;
3713 /* Perhaps we already constructed a constant CFString just like this one? */
3715 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3720 tree var
, constructor
, field
;
3721 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3722 int length
= TREE_STRING_LENGTH (str
) - 1;
3724 if (darwin_warn_nonportable_cfstrings
)
3726 const char *s
= TREE_STRING_POINTER (str
);
3729 for (l
= 0; l
< length
; l
++)
3730 if (!s
[l
] || !isascii (s
[l
]))
3732 warning (darwin_warn_nonportable_cfstrings
,
3733 s
[l
] ? G_("non-ASCII character in CFString literal")
3734 : G_("embedded NUL in CFString literal"));
3739 *loc
= desc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3740 desc
->literal
= str
;
3743 field
= TYPE_FIELDS (ccfstring_type_node
);
3744 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3745 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3746 cfstring_class_reference
));
3748 field
= DECL_CHAIN (field
);
3749 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3750 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3752 field
= DECL_CHAIN (field
);
3753 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3754 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3756 field
= DECL_CHAIN (field
);
3757 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3758 build_int_cst (TREE_TYPE (field
), length
));
3760 constructor
= build_constructor (ccfstring_type_node
, v
);
3761 TREE_READONLY (constructor
) = 1;
3762 TREE_CONSTANT (constructor
) = 1;
3763 TREE_STATIC (constructor
) = 1;
3765 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3766 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3767 being built without any knowledge of C++ tree accessors; hence, we shall
3768 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3769 if (darwin_running_cxx
)
3770 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3772 /* Create an anonymous global variable for this CFString. */
3773 var
= build_decl (input_location
, CONST_DECL
,
3774 NULL
, TREE_TYPE (constructor
));
3775 DECL_ARTIFICIAL (var
) = 1;
3776 TREE_STATIC (var
) = 1;
3777 DECL_INITIAL (var
) = constructor
;
3778 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3779 DECL_CONTEXT (var
) = NULL_TREE
;
3780 desc
->constructor
= var
;
3783 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3784 TREE_CONSTANT (addr
) = 1;
3790 darwin_cfstring_p (tree str
)
3792 struct cfstring_descriptor key
;
3799 if (TREE_CODE (str
) == ADDR_EXPR
)
3800 str
= TREE_OPERAND (str
, 0);
3802 if (TREE_CODE (str
) != STRING_CST
)
3806 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, NO_INSERT
);
3815 darwin_enter_string_into_cfstring_table (tree str
)
3817 struct cfstring_descriptor key
;
3820 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3824 *loc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3825 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3829 /* Choose named function section based on its frequency. */
3832 darwin_function_section (tree decl
, enum node_frequency freq
,
3833 bool startup
, bool exit
)
3835 /* Decide if we need to put this in a coalescable section. */
3838 && (!DECL_ATTRIBUTES (decl
)
3839 || !lookup_attribute ("weak_import",
3840 DECL_ATTRIBUTES (decl
))));
3842 bool use_coal
= weak
&& ld_uses_coal_sects
;
3843 /* If there is a specified section name, we should not be trying to
3845 if (decl
&& DECL_SECTION_NAME (decl
) != NULL
)
3846 return get_named_section (decl
, NULL
, 0);
3848 /* We always put unlikely executed stuff in the cold section. */
3849 if (freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3850 return (use_coal
) ? darwin_sections
[text_cold_coal_section
]
3851 : darwin_sections
[text_cold_section
];
3853 /* If we have LTO *and* feedback information, then let LTO handle
3854 the function ordering, it makes a better job (for normal, hot,
3855 startup and exit - hence the bailout for cold above). */
3856 if (in_lto_p
&& flag_profile_values
)
3857 goto default_function_sections
;
3859 /* Non-cold startup code should go to startup subsection. */
3861 return (use_coal
) ? darwin_sections
[text_startup_coal_section
]
3862 : darwin_sections
[text_startup_section
];
3864 /* Similarly for exit. */
3866 return (use_coal
) ? darwin_sections
[text_exit_coal_section
]
3867 : darwin_sections
[text_exit_section
];
3869 /* Place hot code. */
3870 if (freq
== NODE_FREQUENCY_HOT
)
3871 return (use_coal
) ? darwin_sections
[text_hot_coal_section
]
3872 : darwin_sections
[text_hot_section
];
3874 /* Otherwise, default to the 'normal' non-reordered sections. */
3875 default_function_sections
:
3876 return (use_coal
) ? darwin_sections
[text_coal_section
]
3880 #include "gt-darwin.h"