1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989-2023 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"
45 #include "targhooks.h"
47 #include "lto-section-names.h"
56 1) this facility requires suitable support from a modified version
57 of GDB, which is not provided on any system after MacOS 10.7/Darwin11.
58 2) There is no support for this in any X86 version of the FSF compiler.
60 Fix and continue was used on some earlier MacOS systems for rapid turn
61 around debugging. When code is compiled with the -mfix-and-continue
62 flag, two changes are made to the generated code that allow the system
63 to do things that it would normally not be able to do easily. These
64 changes allow gdb to load in recompilation of a translation unit that
65 has been changed into a running program and replace existing functions
66 and methods of that translation unit with versions of those functions
67 and methods from the newly compiled translation unit. The new functions
68 access the existing static symbols from the old translation unit, if the
69 symbol existed in the unit to be replaced, and from the new translation
72 The changes are to insert 5 nops at the beginning of all functions
73 and to use indirection to get at static symbols. The 5 nops
74 are required by consumers of the generated code. Currently, gdb
75 uses this to patch in a jump to the overriding function, this
76 allows all uses of the old name to forward to the replacement,
77 including existing function pointers and virtual methods. See
78 rs6000_emit_prologue for the code that handles the nop insertions.
80 The added indirection allows gdb to redirect accesses to static
81 symbols from the newly loaded translation unit to the existing
82 symbol, if any. @code{static} symbols are special and are handled by
83 setting the second word in the .non_lazy_symbol_pointer data
84 structure to symbol. See indirect_data for the code that handles
85 the extra indirection, and machopic_output_indirection and its use
86 of MACHO_SYMBOL_FLAG_STATIC for the code that handles @code{static}
87 symbol indirection. */
89 typedef struct GTY(()) cdtor_record
{
91 int priority
; /* [con/de]structor priority */
92 int position
; /* original position */
95 static GTY(()) vec
<cdtor_record
, va_gc
> *ctors
= NULL
;
96 static GTY(()) vec
<cdtor_record
, va_gc
> *dtors
= NULL
;
98 /* A flag to determine whether we are running c++ or obj-c++. This has to be
99 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
101 int darwin_running_cxx
;
103 /* Some code-gen now depends on OS major version numbers (at least). */
104 int generating_for_darwin_version
;
106 /* For older linkers we need to emit special sections (marked 'coalesced') for
107 for weak or single-definition items. */
108 static bool ld_uses_coal_sects
= false;
110 /* Very old (ld_classic) linkers need a symbol to mark the start of
112 static bool ld_needs_eh_markers
= false;
114 /* Emit a section-start symbol for mod init and term sections. */
115 static bool ld_init_term_start_labels
= false;
117 /* The source and version of dsymutil in use. */
118 #ifndef DSYMUTIL_VERSION
119 # warning Darwin toolchain without a defined dsymutil.
120 # define DSYMUTIL_VERSION DET_UNKNOWN,0,0,0
124 darwin_external_toolchain kind
; /* cctools, llvm, clang etc. */
125 int major
; /* version number. */
128 } dsymutil_version
= {DSYMUTIL_VERSION
};
131 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
133 /* While we transition to using in-tests instead of ifdef'd code. */
135 #define gen_macho_high(m,a,b) (a)
136 #define gen_macho_low(m,a,b,c) (a)
139 /* True if we're setting __attribute__ ((ms_struct)). */
140 int darwin_ms_struct
= false;
142 /* Earlier versions of Darwin as do not recognize an alignment field in
143 .comm directives, this should be set for versions that allow it. */
144 int emit_aligned_common
= false;
146 /* A get_unnamed_section callback used to switch to an ObjC section.
147 DIRECTIVE is as for output_section_asm_op. */
150 output_objc_section_asm_op (const char *directive
)
152 static bool been_here
= false;
154 /* The NeXT ObjC Runtime requires these sections to be present and in
155 order in the object. The code below implements this by emitting
156 a section header for each ObjC section the first time that an ObjC
157 section is requested. */
158 if (darwin_symbol_stubs
&& ! been_here
)
160 section
*saved_in_section
= in_section
;
161 static const enum darwin_section_enum tomark
[] =
163 /* written, cold -> hot */
164 objc_cat_cls_meth_section
,
165 objc_cat_inst_meth_section
,
166 objc_string_object_section
,
167 objc_constant_string_object_section
,
168 objc_selector_refs_section
,
169 objc_selector_fixup_section
,
170 objc_cls_refs_section
,
172 objc_meta_class_section
,
173 /* shared, hot -> cold */
174 objc_cls_meth_section
,
175 objc_inst_meth_section
,
176 objc_protocol_section
,
177 objc_class_names_section
,
178 objc_meth_var_types_section
,
179 objc_meth_var_names_section
,
180 objc_category_section
,
181 objc_class_vars_section
,
182 objc_instance_vars_section
,
183 objc_module_info_section
,
184 objc_symbols_section
,
187 static const enum darwin_section_enum tomarkv1
[] =
189 objc1_protocol_ext_section
,
190 objc1_class_ext_section
,
191 objc1_prop_list_section
194 static const enum darwin_section_enum tomarkv2
[] =
196 objc2_method_names_section
,
197 objc2_message_refs_section
,
198 objc2_selector_refs_section
,
200 objc2_classdefs_section
,
201 objc2_metadata_section
,
202 objc2_classrefs_section
,
203 objc2_class_names_section
,
204 objc2_classlist_section
,
205 objc2_categorylist_section
,
206 objc2_nonlazy_class_section
,
207 objc2_nonlazy_category_section
,
208 objc2_protocollist_section
,
209 objc2_protocolrefs_section
,
210 objc2_super_classrefs_section
,
211 objc2_constant_string_object_section
,
212 objc2_image_info_section
,
217 if (flag_objc_abi
< 2)
219 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
220 switch_to_section (darwin_sections
[tomark
[i
]]);
221 if (flag_objc_abi
== 1)
222 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
223 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
226 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
227 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
228 /* Make sure we don't get varasm.cc out of sync with us. */
229 switch_to_section (saved_in_section
);
231 output_section_asm_op (directive
);
235 /* Private flag applied to disable section-anchors in a particular section. */
236 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
239 /* Implement TARGET_ASM_INIT_SECTIONS. */
242 darwin_init_sections (void)
244 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
245 darwin_sections[NAME] = \
246 get_unnamed_section (FLAGS, (OBJC \
247 ? output_objc_section_asm_op \
248 : output_section_asm_op), \
250 #include "config/darwin-sections.def"
253 readonly_data_section
= darwin_sections
[const_section
];
254 exception_section
= darwin_sections
[darwin_exception_section
];
255 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
257 /* If our linker is new enough to coalesce weak symbols, then we
258 can just put picbase_thunks into the text section. */
259 if (! ld_uses_coal_sects
)
260 darwin_sections
[picbase_thunk_section
] = text_section
;
264 name_needs_quotes (const char *name
)
267 while ((c
= *name
++) != '\0')
269 && c
!= '.' && c
!= '$' && c
!= '_' )
275 dump_machopic_symref_flags (FILE *dump
, rtx sym_ref
)
277 unsigned long flags
= SYMBOL_REF_FLAGS (sym_ref
);
279 fprintf (dump
, "flags: %08lx %c%c%c%c%c%c%c",
281 (MACHO_SYMBOL_STATIC_P (sym_ref
) ? 's' : '-'),
282 (MACHO_SYMBOL_INDIRECTION_P (sym_ref
) ? 'I' : '-'),
283 (MACHO_SYMBOL_LINKER_VIS_P (sym_ref
) ? 'l' : '-'),
284 (MACHO_SYMBOL_HIDDEN_VIS_P (sym_ref
) ? 'h' : '-'),
285 (MACHO_SYMBOL_DEFINED_P (sym_ref
) ? 'd' : '-'),
286 (MACHO_SYMBOL_MUST_INDIRECT_P (sym_ref
) ? 'i' : '-'),
287 (MACHO_SYMBOL_VARIABLE_P (sym_ref
) ? 'v' : '-'));
290 fprintf (dump
, "%c%c%c%c",
291 (SYMBOL_REF_STUBVAR_P (sym_ref
) ? 'S' : '-'),
292 (SYMBOL_REF_DLLEXPORT_P (sym_ref
) ? 'X' : '-'),
293 (SYMBOL_REF_DLLIMPORT_P (sym_ref
) ? 'I' : '-'),
294 (SYMBOL_REF_FAR_ADDR_P (sym_ref
) ? 'F' : '-'));
297 fprintf (dump
, "%c%c%c%03u%c%c%c\n",
298 (SYMBOL_REF_ANCHOR_P (sym_ref
) ? 'a' : '-'),
299 (SYMBOL_REF_HAS_BLOCK_INFO_P (sym_ref
) ? 'b' : '-'),
300 (SYMBOL_REF_EXTERNAL_P (sym_ref
) ? 'e' : '-'),
301 (unsigned)SYMBOL_REF_TLS_MODEL (sym_ref
),
302 (SYMBOL_REF_SMALL_P (sym_ref
) ? 'm' : '-'),
303 (SYMBOL_REF_LOCAL_P (sym_ref
) ? 'l' : '-'),
304 (SYMBOL_REF_FUNCTION_P (sym_ref
) ? 'f' : '-'));
308 debug_machopic_symref_flags (rtx sym_ref
)
310 dump_machopic_symref_flags (stderr
, sym_ref
);
313 /* Return true if SYM_REF can be used without an indirection. */
315 machopic_symbol_defined_p (rtx sym_ref
)
317 if (MACHO_SYMBOL_DEFINED_P (sym_ref
))
320 /* If a symbol references local and is not an extern to this
321 file, then the symbol might be able to declared as defined. */
322 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
324 /* If the symbol references a variable and the variable is a
325 common symbol, then this symbol is not defined. */
326 if (MACHO_SYMBOL_VARIABLE_P (sym_ref
))
328 tree decl
= SYMBOL_REF_DECL (sym_ref
);
331 if (DECL_COMMON (decl
))
339 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
340 reference, which will not be changed. */
342 enum machopic_addr_class
343 machopic_classify_symbol (rtx sym_ref
)
347 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
348 if (machopic_symbol_defined_p (sym_ref
))
350 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
353 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
356 #ifndef TARGET_FIX_AND_CONTINUE
357 #define TARGET_FIX_AND_CONTINUE 0
360 /* Indicate when fix-and-continue style code generation is being used
361 and when a reference to data should be indirected so that it can be
362 rebound in a new translation unit to reference the original instance
363 of that data. Symbol names that are for code generation local to
364 the translation unit are bound to the new translation unit;
365 currently this means symbols that begin with L or _OBJC_;
366 otherwise, we indicate that an indirect reference should be made to
367 permit the runtime to rebind new instances of the translation unit
368 to the original instance of the data. */
371 indirect_data (rtx sym_ref
)
376 /* If we aren't generating fix-and-continue code, don't do anything
378 if (TARGET_FIX_AND_CONTINUE
== 0)
381 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
382 are indirected. Symbols that begin with L and _OBJC_ are always
383 bound to the current translation unit as they are used for
384 generated local data of the translation unit. */
386 name
= XSTR (sym_ref
, 0);
388 lprefix
= (((name
[0] == '*' || name
[0] == '&')
389 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
390 || (startswith (name
, "_OBJC_")));
396 machopic_data_defined_p (rtx sym_ref
)
398 if (indirect_data (sym_ref
))
401 switch (machopic_classify_symbol (sym_ref
))
403 case MACHOPIC_DEFINED_DATA
:
404 case MACHOPIC_DEFINED_FUNCTION
:
412 machopic_define_symbol (rtx mem
)
416 gcc_assert (GET_CODE (mem
) == MEM
);
417 sym_ref
= XEXP (mem
, 0);
418 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
421 /* Return either ORIG or:
423 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
425 depending on MACHO_DYNAMIC_NO_PIC_P. */
427 machopic_gen_offset (rtx orig
)
429 if (MACHO_DYNAMIC_NO_PIC_P
)
433 /* Play games to avoid marking the function as needing pic if we
434 are being called as part of the cost-estimation process. */
435 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
436 crtl
->uses_pic_offset_table
= 1;
437 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
438 UNSPEC_MACHOPIC_OFFSET
);
439 return gen_rtx_CONST (Pmode
, orig
);
443 static GTY(()) const char * function_base_func_name
= NULL
;
444 static GTY(()) unsigned current_pic_label_num
= 0;
445 static GTY(()) unsigned emitted_pic_label_num
= 0;
447 /* We need to keep one picbase label per function, but (when we emit code
448 to reload the picbase for setjump receiver) we might need to check for
449 a second use. So, only update the picbase label counter when we see a
450 new function. When there's no function decl, we assume that the call is
451 from the x86 stub generation code. */
453 update_pic_label_number_if_needed (void)
455 if (current_function_decl
)
458 const char *current_name
=
459 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
460 if (function_base_func_name
!= current_name
)
462 ++current_pic_label_num
;
463 function_base_func_name
= current_name
;
468 ++current_pic_label_num
;
469 function_base_func_name
= "L_machopic_stub_dummy";
474 machopic_output_function_base_name (FILE *file
)
476 /* We should only get here for -fPIC. */
477 gcc_checking_assert (MACHOPIC_PURE
);
479 update_pic_label_number_if_needed ();
480 fprintf (file
, "L%u$pb", current_pic_label_num
);
483 char curr_picbasename
[32];
486 machopic_get_function_picbase (void)
488 /* We should only get here for -fPIC. */
489 gcc_checking_assert (MACHOPIC_PURE
);
491 update_pic_label_number_if_needed ();
492 snprintf (curr_picbasename
, 32, "L%u$pb", current_pic_label_num
);
493 return (const char *) curr_picbasename
;
497 machopic_should_output_picbase_label (void)
499 update_pic_label_number_if_needed ();
501 if (current_pic_label_num
== emitted_pic_label_num
)
504 emitted_pic_label_num
= current_pic_label_num
;
508 /* The suffix attached to non-lazy pointer symbols. */
509 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
510 /* The suffix attached to stub symbols. */
511 #define STUB_SUFFIX "$stub"
513 typedef struct GTY ((for_user
)) machopic_indirection
515 /* The SYMBOL_REF for the entity referenced. */
517 /* The name of the stub or non-lazy pointer. */
518 const char * ptr_name
;
519 /* True iff this entry is for a stub (as opposed to a non-lazy
522 /* True iff this stub or pointer has been referenced. */
524 /* True iff a non-lazy symbol pointer should be emitted into the .data
525 section, rather than the non-lazy symbol pointers section. The cases
526 for which this occurred seem to have been unintentional, and later
527 toolchains emit all of the indirections to the 'usual' section. We
528 are keeping this in case it is necessary to preserve compatibility with
530 bool nlsp_in_data_section
;
531 } machopic_indirection
;
533 struct indirection_hasher
: ggc_ptr_hash
<machopic_indirection
>
535 typedef const char *compare_type
;
536 static hashval_t
hash (machopic_indirection
*);
537 static bool equal (machopic_indirection
*, const char *);
540 /* A table mapping stub names and non-lazy pointer names to
541 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
543 static GTY (()) hash_table
<indirection_hasher
> *machopic_indirections
;
545 /* Return a hash value for a SLOT in the indirections hash table. */
548 indirection_hasher::hash (machopic_indirection
*p
)
550 return htab_hash_string (p
->ptr_name
);
553 /* Returns true if the KEY is the same as that associated with
557 indirection_hasher::equal (machopic_indirection
*s
, const char *k
)
559 return strcmp (s
->ptr_name
, k
) == 0;
562 /* Return the name of the non-lazy pointer (if STUB_P is false) or
563 stub (if STUB_B is true) corresponding to the given name.
565 PR71767 - If we have a situation like:
572 ld64 will be unable to split this into two atoms (because the "L" makes
573 the second symbol 'invisible'). This means that legitimate direct accesses
574 to the second symbol will appear to be direct accesses to an atom of type
575 weak, global which are not allowed.
577 To avoid this, we make any data-section indirections have a leading 'l'
578 (lower-case L) which has a special meaning: linker can see this and use
579 it to determine atoms, but it is not placed into the final symbol table.
581 Symbols in the non-lazy symbol pointers section (or stubs) do not have this
582 problem because ld64 already knows the size of each entry.
586 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
588 const char *name
= XSTR (sym_ref
, 0);
589 tree id
= maybe_get_identifier (name
);
594 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
595 id
= TREE_CHAIN (id
);
597 name
= IDENTIFIER_POINTER (id
);
600 const char *prefix
= user_label_prefix
;
601 /* If we are emitting the label 'verbatim' then omit the U_L_P and count
602 the name without the leading '*'. */
609 /* Here we are undoing a number of causes that placed some indirections
610 (apparently erroneously) into the .data section. Specifically, some
611 symbols that are ABI mandated indirections and some hidden symbols
612 were being placed there - which cause difficulties with later
613 versions of ld64. Iff (after these checks) some symbol still gets an
614 indirection in the data section, we want to adjust the indirection
615 name to be linker visible to deal with PR71767 (notes above). */
616 bool nlsp_in_data_section
=
617 ! MACHO_SYMBOL_MUST_INDIRECT_P (sym_ref
)
618 && ! MACHO_SYMBOL_HIDDEN_VIS_P (sym_ref
)
619 && (machopic_symbol_defined_p (sym_ref
) || SYMBOL_REF_LOCAL_P (sym_ref
))
620 && ! indirect_data (sym_ref
);
622 const char *suffix
= stub_p
? STUB_SUFFIX
: NON_LAZY_POINTER_SUFFIX
;
623 /* If the indirection is in the data section, let the linker see it. */
624 char L_or_l
= (!stub_p
&& nlsp_in_data_section
) ? 'l' : 'L';
625 /* We have mangled symbols with spaces and punctuation which typically
626 need surrounding in quotes for the assembler to consume them. */
627 const char *quote
= name_needs_quotes (name
) ? "\"" : "";
628 char *buffer
= XALLOCAVEC (char, 2 /* strlen ("&L") or ("&l") */
635 /* Construct the name of the non-lazy pointer or stub. */
636 sprintf (buffer
, "&%s%c%s%s%s%s", quote
, L_or_l
, prefix
, name
,
639 if (!machopic_indirections
)
640 machopic_indirections
= hash_table
<indirection_hasher
>::create_ggc (37);
642 machopic_indirection
**slot
643 = machopic_indirections
->find_slot_with_hash (buffer
,
644 htab_hash_string (buffer
),
646 machopic_indirection
*p
;
651 p
= ggc_alloc
<machopic_indirection
> ();
653 p
->ptr_name
= xstrdup (buffer
);
656 p
->nlsp_in_data_section
= nlsp_in_data_section
;
663 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
664 or non-lazy pointer as used -- and mark the object to which the
665 pointer/stub refers as used as well, since the pointer/stub will
666 emit a reference to it. */
669 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
671 machopic_indirection
*p
672 = machopic_indirections
->find_with_hash (name
, htab_hash_string (name
));
675 const char *real_name
;
680 /* Do what output_addr_const will do when we actually call it. */
681 if (SYMBOL_REF_DECL (p
->symbol
))
682 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
684 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
686 id
= maybe_get_identifier (real_name
);
688 mark_referenced (id
);
692 /* Transform ORIG, which may be any data source, to the corresponding
693 source using indirections. */
696 machopic_indirect_data_reference (rtx orig
, rtx reg
)
700 if (! MACHOPIC_INDIRECT
)
703 if (GET_CODE (orig
) == SYMBOL_REF
)
705 int defined
= machopic_data_defined_p (orig
);
707 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
711 /* Create a new register for CSE opportunities. */
712 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
713 emit_insn (gen_macho_high (Pmode
, hi_reg
, orig
));
714 emit_insn (gen_macho_low (Pmode
, reg
, hi_reg
, orig
));
720 /* some other cpu -- writeme! */
723 else if (defined
&& ! MACHO_SYMBOL_MUST_INDIRECT_P (orig
))
726 if (DARWIN_PPC
|| HAVE_lo_sum
)
727 offset
= machopic_gen_offset (orig
);
731 rtx hi_sum_reg
= (!can_create_pseudo_p ()
733 : gen_reg_rtx (Pmode
));
737 emit_insn (gen_rtx_SET (hi_sum_reg
,
738 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
739 gen_rtx_HIGH (Pmode
, offset
))));
740 emit_insn (gen_rtx_SET (reg
,
741 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
742 copy_rtx (offset
))));
746 else if (HAVE_lo_sum
)
750 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
751 emit_insn (gen_rtx_SET (reg
, gen_rtx_LO_SUM (Pmode
, reg
,
752 copy_rtx (offset
))));
753 emit_use (pic_offset_table_rtx
);
755 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
760 ptr_ref
= (gen_rtx_SYMBOL_REF
762 machopic_indirection_name (orig
, /*stub_p=*/false)));
764 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
765 SYMBOL_REF_FLAGS (ptr_ref
) |= MACHO_SYMBOL_FLAG_INDIRECTION
;
767 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
768 machopic_define_symbol (ptr_ref
);
772 && MACHO_DYNAMIC_NO_PIC_P
)
774 emit_insn (gen_rtx_SET (reg
, ptr_ref
));
780 else if (GET_CODE (orig
) == CONST
)
782 /* If "(const (plus ...", walk the PLUS and return that result.
783 PLUS processing (below) will restore the "(const ..." if
785 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
786 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
790 else if (GET_CODE (orig
) == MEM
)
793 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
796 else if (GET_CODE (orig
) == PLUS
)
800 /* Legitimize both operands of the PLUS. */
801 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
802 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
803 (base
== reg
? 0 : reg
));
804 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
805 result
= plus_constant (Pmode
, base
, INTVAL (orig
));
807 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
809 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
813 emit_move_insn (reg
, result
);
818 result
= force_reg (GET_MODE (result
), result
);
827 /* Transform TARGET (a MEM), which is a function call target, to the
828 corresponding symbol_stub if necessary. Return a new MEM. */
831 machopic_indirect_call_target (rtx target
)
833 if (! darwin_symbol_stubs
)
836 if (GET_CODE (target
) != MEM
)
839 if (MACHOPIC_INDIRECT
840 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
841 && ! MACHO_SYMBOL_DEFINED_P (XEXP (target
, 0)))
843 rtx sym_ref
= XEXP (target
, 0);
844 const char *stub_name
= machopic_indirection_name (sym_ref
,
846 machine_mode mode
= GET_MODE (sym_ref
);
848 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
849 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
850 SYMBOL_REF_FLAGS (XEXP (target
, 0)) |= MACHO_SYMBOL_FLAG_INDIRECTION
;
851 MEM_READONLY_P (target
) = 1;
852 MEM_NOTRAP_P (target
) = 1;
859 machopic_legitimize_pic_address (rtx orig
, machine_mode mode
, rtx reg
)
863 if (! MACHOPIC_INDIRECT
)
866 /* First handle a simple SYMBOL_REF or LABEL_REF */
867 if (GET_CODE (orig
) == LABEL_REF
868 || GET_CODE (orig
) == SYMBOL_REF
)
870 /* addr(foo) = &func+(foo-func) */
871 orig
= machopic_indirect_data_reference (orig
, reg
);
873 if (GET_CODE (orig
) == PLUS
874 && GET_CODE (XEXP (orig
, 0)) == REG
)
877 return force_reg (mode
, orig
);
879 emit_move_insn (reg
, orig
);
883 if (GET_CODE (orig
) == MEM
)
887 gcc_assert (!lra_in_progress
);
888 reg
= gen_reg_rtx (Pmode
);
892 if (MACHO_DYNAMIC_NO_PIC_P
893 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
894 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
896 #if defined (TARGET_TOC) /* ppc */
897 rtx temp_reg
= (!can_create_pseudo_p ()
899 gen_reg_rtx (Pmode
));
900 rtx asym
= XEXP (orig
, 0);
903 emit_insn (gen_macho_high (Pmode
, temp_reg
, asym
));
904 mem
= gen_const_mem (GET_MODE (orig
),
905 gen_rtx_LO_SUM (Pmode
, temp_reg
,
907 emit_insn (gen_rtx_SET (reg
, mem
));
909 /* Some other CPU -- WriteMe! but right now there are no other
910 platforms that can use dynamic-no-pic */
916 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
917 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
919 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
920 #if defined (TARGET_TOC) /* i.e., PowerPC */
921 /* Generating a new reg may expose opportunities for
922 common subexpression elimination. */
923 rtx hi_sum_reg
= (!can_create_pseudo_p ()
925 : gen_reg_rtx (Pmode
));
929 sum
= gen_rtx_HIGH (Pmode
, offset
);
930 if (! MACHO_DYNAMIC_NO_PIC_P
)
931 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
933 emit_insn (gen_rtx_SET (hi_sum_reg
, sum
));
935 mem
= gen_const_mem (GET_MODE (orig
),
936 gen_rtx_LO_SUM (Pmode
,
939 rtx_insn
*insn
= emit_insn (gen_rtx_SET (reg
, mem
));
940 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
944 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
946 emit_insn (gen_rtx_SET (reg
,
948 gen_rtx_CONST (Pmode
,
950 emit_insn (gen_rtx_SET (reg
,
951 gen_rtx_LO_SUM (Pmode
, reg
,
952 gen_rtx_CONST (Pmode
,
953 copy_rtx (offset
)))));
954 pic_ref
= gen_rtx_PLUS (Pmode
,
955 pic_offset_table_rtx
, reg
);
959 #endif /* HAVE_lo_sum */
961 rtx pic
= pic_offset_table_rtx
;
962 if (GET_CODE (pic
) != REG
)
964 emit_move_insn (reg
, pic
);
968 if (lra_in_progress
&& HARD_REGISTER_P (pic
))
969 df_set_regs_ever_live (REGNO (pic
), true);
970 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
971 machopic_gen_offset (XEXP (orig
, 0)));
974 #if !defined (TARGET_TOC)
975 emit_move_insn (reg
, pic_ref
);
976 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
983 if (GET_CODE (orig
) == SYMBOL_REF
984 || GET_CODE (orig
) == LABEL_REF
)
986 rtx offset
= machopic_gen_offset (orig
);
987 #if defined (TARGET_TOC) /* i.e., PowerPC */
992 gcc_assert (!lra_in_progress
);
993 reg
= gen_reg_rtx (Pmode
);
998 emit_insn (gen_rtx_SET (hi_sum_reg
,
999 (MACHO_DYNAMIC_NO_PIC_P
)
1000 ? gen_rtx_HIGH (Pmode
, offset
)
1001 : gen_rtx_PLUS (Pmode
,
1002 pic_offset_table_rtx
,
1003 gen_rtx_HIGH (Pmode
,
1005 emit_insn (gen_rtx_SET (reg
,
1006 gen_rtx_LO_SUM (Pmode
,
1008 copy_rtx (offset
))));
1011 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
1012 emit_insn (gen_rtx_SET (reg
,
1013 gen_rtx_LO_SUM (Pmode
, reg
,
1014 copy_rtx (offset
))));
1015 pic_ref
= gen_rtx_PLUS (Pmode
,
1016 pic_offset_table_rtx
, reg
);
1020 #endif /* HAVE_lo_sum */
1023 || GET_CODE (orig
) == SUBREG
)
1029 rtx pic
= pic_offset_table_rtx
;
1030 if (GET_CODE (pic
) != REG
)
1032 emit_move_insn (reg
, pic
);
1036 if (lra_in_progress
&& HARD_REGISTER_P (pic
))
1037 df_set_regs_ever_live (REGNO (pic
), true);
1038 pic_ref
= gen_rtx_PLUS (Pmode
,
1040 machopic_gen_offset (orig
));
1045 if (GET_CODE (pic_ref
) != REG
)
1049 emit_move_insn (reg
, pic_ref
);
1054 return force_reg (mode
, pic_ref
);
1062 else if (GET_CODE (orig
) == PLUS
1063 && (GET_CODE (XEXP (orig
, 0)) == MEM
1064 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
1065 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
1066 && XEXP (orig
, 0) != pic_offset_table_rtx
1067 && GET_CODE (XEXP (orig
, 1)) != REG
)
1071 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
1073 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1074 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
1075 Pmode
, (base
== reg
? 0 : reg
));
1076 if (GET_CODE (orig
) == CONST_INT
)
1078 pic_ref
= plus_constant (Pmode
, base
, INTVAL (orig
));
1082 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
1084 if (reg
&& is_complex
)
1086 emit_move_insn (reg
, pic_ref
);
1089 /* Likewise, should we set special REG_NOTEs here? */
1091 else if (GET_CODE (orig
) == CONST
)
1093 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1095 else if (GET_CODE (orig
) == MEM
1096 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
1098 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1099 addr
= replace_equiv_address (orig
, addr
);
1100 emit_move_insn (reg
, addr
);
1107 /* Callbacks to output the stub or non-lazy pointers.
1108 Each works on the item in *SLOT,if it has been used.
1109 DATA is the FILE* for assembly output.
1110 Called from htab_traverses, invoked from machopic_finish(). */
1113 machopic_output_data_section_indirection (machopic_indirection
**slot
,
1116 machopic_indirection
*p
= *slot
;
1118 if (!p
->used
|| !p
->nlsp_in_data_section
)
1121 rtx symbol
= p
->symbol
;
1122 /* The original symbol name. */
1123 const char *sym_name
= XSTR (symbol
, 0);
1124 /* The name of the indirection symbol. */
1125 const char *ptr_name
= p
->ptr_name
;
1127 switch_to_section (data_section
);
1128 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1129 assemble_label (out_file
, ptr_name
);
1130 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1131 GET_MODE_SIZE (Pmode
),
1132 GET_MODE_ALIGNMENT (Pmode
), 1);
1138 machopic_output_stub_indirection (machopic_indirection
**slot
,
1141 machopic_indirection
*p
= *slot
;
1143 if (!p
->used
|| !p
->stub_p
)
1146 rtx symbol
= p
->symbol
;
1147 /* The original symbol name. */
1148 const char *sym_name
= XSTR (symbol
, 0);
1149 /* The name of the stub symbol. */
1150 const char *ptr_name
= p
->ptr_name
;
1152 tree id
= maybe_get_identifier (sym_name
);
1157 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1158 id
= TREE_CHAIN (id
);
1160 sym_name
= IDENTIFIER_POINTER (id
);
1163 char *sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1164 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1165 strcpy (sym
, sym_name
+ 1);
1166 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1167 strcpy (sym
, sym_name
);
1169 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1171 char *stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1172 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1173 strcpy (stub
, ptr_name
+ 1);
1175 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1177 machopic_output_stub (out_file
, sym
, stub
);
1183 machopic_output_indirection (machopic_indirection
**slot
, FILE *out_file
)
1185 machopic_indirection
*p
= *slot
;
1187 if (!p
->used
|| p
->stub_p
|| p
->nlsp_in_data_section
)
1190 rtx symbol
= p
->symbol
;
1191 /* The original symbol name. */
1192 const char *sym_name
= XSTR (symbol
, 0);
1193 /* The nonlazy-stub symbol name. */
1194 const char *ptr_name
= p
->ptr_name
;
1196 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1198 /* Mach-O symbols are passed around in code through indirect references and
1199 the original symbol_ref hasn't passed through the generic handling and
1200 reference-catching in output_operand, so we need to manually mark weak
1201 references as such. */
1203 if (SYMBOL_REF_WEAK (symbol
))
1205 tree decl
= SYMBOL_REF_DECL (symbol
);
1206 gcc_checking_assert (DECL_P (decl
));
1208 if (decl
!= NULL_TREE
1209 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1210 /* Handle only actual external-only definitions, not
1211 e.g. extern inline code or variables for which
1212 storage has been allocated. */
1213 && !TREE_STATIC (decl
))
1215 fputs ("\t.weak_reference ", out_file
);
1216 assemble_name (out_file
, sym_name
);
1217 fputc ('\n', out_file
);
1221 assemble_name (out_file
, ptr_name
);
1222 fprintf (out_file
, ":\n");
1224 fprintf (out_file
, "\t.indirect_symbol ");
1225 assemble_name (out_file
, sym_name
);
1226 fprintf (out_file
, "\n");
1228 /* Variables that are marked with MACHO_SYMBOL_FLAG_STATIC need to
1229 have their symbol name instead of 0 in the second entry of
1230 the non-lazy symbol pointer data structure when they are
1231 defined. This allows the runtime to rebind newer instances
1232 of the translation unit with the original instance of the
1235 rtx init
= const0_rtx
;
1236 if (MACHO_SYMBOL_STATIC_P (symbol
) && machopic_symbol_defined_p (symbol
))
1237 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1239 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1240 GET_MODE_ALIGNMENT (Pmode
), 1);
1246 machopic_finish (FILE *out_file
)
1248 if (!machopic_indirections
)
1251 /* First output an symbol indirections that have been placed into .data
1252 (we don't expect these now). */
1253 machopic_indirections
->traverse_noresize
1254 <FILE *, machopic_output_data_section_indirection
> (out_file
);
1256 machopic_indirections
->traverse_noresize
1257 <FILE *, machopic_output_stub_indirection
> (out_file
);
1259 machopic_indirections
->traverse_noresize
1260 <FILE *, machopic_output_indirection
> (out_file
);
1264 machopic_operand_p (rtx op
)
1266 if (MACHOPIC_JUST_INDIRECT
)
1267 return (GET_CODE (op
) == SYMBOL_REF
1268 && machopic_symbol_defined_p (op
));
1270 return (GET_CODE (op
) == CONST
1271 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1272 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1276 computes and caches a series of flags that characterise the symbol's
1277 properties that affect Mach-O code gen (including accidental cases
1278 from older toolchains).
1281 Here we also need to do enough analysis to determine if a symbol's
1282 name needs to be made linker-visible. This is more tricky - since
1283 it depends on whether we've previously seen a global weak definition
1284 in the same section.
1288 darwin_encode_section_info (tree decl
, rtx rtl
, int first
)
1290 /* Careful not to prod global register variables. */
1294 /* Do the standard encoding things first; this sets:
1295 SYMBOL_FLAG_FUNCTION,
1296 SYMBOL_FLAG_LOCAL, (binds_local_p)
1297 TLS_MODEL, SYMBOL_FLAG_SMALL
1298 SYMBOL_FLAG_EXTERNAL. */
1299 default_encode_section_info (decl
, rtl
, first
);
1301 if (! VAR_OR_FUNCTION_DECL_P (decl
))
1304 rtx sym_ref
= XEXP (rtl
, 0);
1306 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1308 /* Only really common if there's no initialiser. */
1309 bool really_common_p
= (DECL_COMMON (decl
)
1310 && (DECL_INITIAL (decl
) == NULL
1312 && DECL_INITIAL (decl
) == error_mark_node
)));
1314 /* For Darwin, if we have specified visibility and it's not the default
1315 that's counted 'hidden'. */
1316 if (DECL_VISIBILITY_SPECIFIED (decl
)
1317 && DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
)
1318 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_HIDDEN_VIS
;
1320 if (!DECL_EXTERNAL (decl
)
1321 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1322 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1323 && ((TREE_STATIC (decl
)
1324 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1325 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1326 && DECL_INITIAL (decl
) != error_mark_node
)))
1327 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1329 if (! TREE_PUBLIC (decl
))
1330 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_STATIC
;
1332 /* Short cut check for Darwin 'must indirect' rules. */
1334 || (DECL_WEAK (decl
) && ! MACHO_SYMBOL_HIDDEN_VIS_P (sym_ref
))
1335 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
1336 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_MUST_INDIRECT
;
1339 /* Objective C V2 (m64) IVAR offset refs from Apple GCC-4.x have an
1340 indirection for m64 code on PPC. Historically, these indirections
1341 also appear in the .data section. */
1342 tree o2meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1343 o2meta
= o2meta
? TREE_VALUE (o2meta
) : NULL_TREE
;
1345 if (o2meta
&& startswith (IDENTIFIER_POINTER (o2meta
), "V2_IVRF"))
1346 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_MUST_INDIRECT
;
1351 darwin_mark_decl_preserved (const char *name
)
1353 /* Actually we shouldn't mark any local symbol this way, but for now
1354 this only happens with ObjC meta-data. */
1355 if (darwin_label_is_anonymous_local_objc_name (name
))
1358 fprintf (asm_out_file
, "\t.no_dead_strip ");
1359 assemble_name (asm_out_file
, name
);
1360 fputc ('\n', asm_out_file
);
1364 darwin_rodata_section (int use_coal
, bool zsize
, int reloc
)
1367 ? darwin_sections
[const_coal_section
]
1368 : (zsize
? darwin_sections
[zobj_const_section
]
1369 : reloc
? darwin_sections
[const_data_section
]
1370 : darwin_sections
[const_section
]));
1374 darwin_mergeable_string_section (tree exp
,
1375 unsigned HOST_WIDE_INT align
)
1377 /* Darwin's ld expects to see non-writable string literals in the .cstring
1378 section. Later versions of ld check and complain when CFStrings are
1379 enabled. Therefore we shall force the strings into .cstring since we
1380 don't support writable ones anyway. */
1381 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1382 && TREE_CODE (exp
) == STRING_CST
1383 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1385 && (int_size_in_bytes (TREE_TYPE (exp
))
1386 == TREE_STRING_LENGTH (exp
))
1387 && ((size_t) TREE_STRING_LENGTH (exp
)
1388 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1389 return darwin_sections
[cstring_section
];
1391 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1392 && TREE_CODE (exp
) == STRING_CST
1393 && TREE_STRING_LENGTH (exp
) == 0)
1394 return darwin_sections
[zobj_const_section
];
1396 return readonly_data_section
;
1399 #ifndef HAVE_GAS_LITERAL16
1400 #define HAVE_GAS_LITERAL16 0
1404 darwin_mergeable_constant_section (tree exp
,
1405 unsigned HOST_WIDE_INT align
,
1409 return darwin_sections
[zobj_const_section
];
1411 machine_mode mode
= DECL_MODE (exp
);
1412 if (!flag_merge_constants
1417 || (align
& (align
-1)) != 0)
1418 return readonly_data_section
;
1420 /* This will ICE if the mode is not a constant size, but that is reasonable,
1421 since one cannot put a variable-sized thing into a constant section, we
1422 shouldn't be trying. */
1423 const unsigned int modesize
= GET_MODE_BITSIZE (mode
).to_constant ();
1425 if (modesize
> align
)
1426 return readonly_data_section
;
1428 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1430 if (TREE_CODE (size
) != INTEGER_CST
)
1431 return readonly_data_section
;
1433 unsigned isize
= TREE_INT_CST_LOW (size
);
1435 return darwin_sections
[literal4_section
];
1436 else if (isize
== 8)
1437 return darwin_sections
[literal8_section
];
1438 else if (HAVE_GAS_LITERAL16
1441 return darwin_sections
[literal16_section
];
1443 return readonly_data_section
;
1447 darwin_tm_clone_table_section (void)
1449 return get_named_section (NULL
,
1450 "__DATA,__tm_clone_table,regular,no_dead_strip",
1455 machopic_reloc_rw_mask (void)
1457 return MACHOPIC_INDIRECT
? 3 : 0;
1460 /* We have to deal with ObjC/C++ metadata section placement in the common
1461 code, since it will also be called from LTO.
1463 Return metadata attributes, if present (searching for ABI=2 first)
1464 Return NULL_TREE if no such attributes are found. */
1467 is_objc_metadata (tree decl
)
1470 && (VAR_P (decl
) || TREE_CODE (decl
) == CONST_DECL
)
1471 && DECL_ATTRIBUTES (decl
))
1473 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1476 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1483 static int classes_seen
;
1484 static int objc_metadata_seen
;
1486 /* Return the section required for Objective C ABI 2 metadata. */
1488 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1491 tree ident
= TREE_VALUE (meta
);
1492 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1493 p
= IDENTIFIER_POINTER (ident
);
1495 gcc_checking_assert (flag_next_runtime
>= 1 && flag_objc_abi
== 2);
1497 objc_metadata_seen
= 1;
1499 if (base
== data_section
)
1500 base
= darwin_sections
[objc2_metadata_section
];
1502 /* Most of the OBJC2 META-data end up in the base section, so check it
1504 if (startswith (p
, "V2_BASE"))
1506 else if (startswith (p
, "V2_CNAM"))
1507 return darwin_sections
[objc2_class_names_section
];
1508 else if (startswith (p
, "V2_MNAM"))
1509 return darwin_sections
[objc2_method_names_section
];
1510 else if (startswith (p
, "V2_MTYP"))
1511 return darwin_sections
[objc2_method_types_section
];
1512 else if (startswith (p
, "V2_STRG"))
1513 return darwin_sections
[cstring_section
];
1515 else if (startswith (p
, "G2_META") || startswith (p
, "G2_CLAS"))
1516 return darwin_sections
[objc2_classdefs_section
];
1517 else if (startswith (p
, "V2_PCOL"))
1518 return ld_uses_coal_sects
? darwin_sections
[data_coal_section
]
1519 : darwin_sections
[objc2_data_section
];
1520 else if (startswith (p
, "V2_MREF"))
1521 return darwin_sections
[objc2_message_refs_section
];
1522 else if (startswith (p
, "V2_CLRF"))
1523 return darwin_sections
[objc2_classrefs_section
];
1524 else if (startswith (p
, "V2_SURF"))
1525 return darwin_sections
[objc2_super_classrefs_section
];
1526 else if (startswith (p
, "V2_NLCL"))
1527 return darwin_sections
[objc2_nonlazy_class_section
];
1528 else if (startswith (p
, "V2_CLAB"))
1531 return darwin_sections
[objc2_classlist_section
];
1533 else if (startswith (p
, "V2_SRFS"))
1534 return darwin_sections
[objc2_selector_refs_section
];
1535 else if (startswith (p
, "V2_NLCA"))
1536 return darwin_sections
[objc2_nonlazy_category_section
];
1537 else if (startswith (p
, "V2_CALA"))
1538 return darwin_sections
[objc2_categorylist_section
];
1540 else if (startswith (p
, "V2_PLST"))
1541 return darwin_sections
[objc2_protocollist_section
];
1542 else if (startswith (p
, "V2_PRFS"))
1543 return darwin_sections
[objc2_protocolrefs_section
];
1545 else if (startswith (p
, "V2_INFO"))
1546 return darwin_sections
[objc2_image_info_section
];
1548 else if (startswith (p
, "V2_EHTY"))
1549 return ld_uses_coal_sects
? darwin_sections
[data_coal_section
]
1552 else if (startswith (p
, "V2_CSTR"))
1553 return darwin_sections
[objc2_constant_string_object_section
];
1555 else if (startswith (p
, "V2_IVRF"))
1556 return darwin_sections
[objc2_ivar_section
];
1558 /* Not recognized, default. */
1562 /* Return the section required for Objective C ABI 0/1 metadata. */
1564 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1567 tree ident
= TREE_VALUE (meta
);
1568 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1569 p
= IDENTIFIER_POINTER (ident
);
1571 gcc_checking_assert (flag_next_runtime
>= 1 && flag_objc_abi
< 2);
1573 objc_metadata_seen
= 1;
1575 /* String sections first, cos there are lots of strings. */
1576 if (startswith (p
, "V1_STRG"))
1577 return darwin_sections
[cstring_section
];
1578 else if (startswith (p
, "V1_CLSN"))
1579 return darwin_sections
[objc_class_names_section
];
1580 else if (startswith (p
, "V1_METN"))
1581 return darwin_sections
[objc_meth_var_names_section
];
1582 else if (startswith (p
, "V1_METT"))
1583 return darwin_sections
[objc_meth_var_types_section
];
1585 else if (startswith (p
, "V1_CLAS"))
1588 return darwin_sections
[objc_class_section
];
1590 else if (startswith (p
, "V1_META"))
1591 return darwin_sections
[objc_meta_class_section
];
1592 else if (startswith (p
, "V1_CATG"))
1593 return darwin_sections
[objc_category_section
];
1594 else if (startswith (p
, "V1_PROT"))
1595 return darwin_sections
[objc_protocol_section
];
1597 else if (startswith (p
, "V1_CLCV"))
1598 return darwin_sections
[objc_class_vars_section
];
1599 else if (startswith (p
, "V1_CLIV"))
1600 return darwin_sections
[objc_instance_vars_section
];
1602 else if (startswith (p
, "V1_CLCM"))
1603 return darwin_sections
[objc_cls_meth_section
];
1604 else if (startswith (p
, "V1_CLIM"))
1605 return darwin_sections
[objc_inst_meth_section
];
1606 else if (startswith (p
, "V1_CACM"))
1607 return darwin_sections
[objc_cat_cls_meth_section
];
1608 else if (startswith (p
, "V1_CAIM"))
1609 return darwin_sections
[objc_cat_inst_meth_section
];
1610 else if (startswith (p
, "V1_PNSM"))
1611 return darwin_sections
[objc_cat_inst_meth_section
];
1612 else if (startswith (p
, "V1_PCLM"))
1613 return darwin_sections
[objc_cat_cls_meth_section
];
1615 else if (startswith (p
, "V1_CLPR"))
1616 return darwin_sections
[objc_cat_cls_meth_section
];
1617 else if (startswith (p
, "V1_CAPR"))
1618 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1620 else if (startswith (p
, "V1_PRFS"))
1621 return darwin_sections
[objc_cat_cls_meth_section
];
1622 else if (startswith (p
, "V1_CLRF"))
1623 return darwin_sections
[objc_cls_refs_section
];
1624 else if (startswith (p
, "V1_SRFS"))
1625 return darwin_sections
[objc_selector_refs_section
];
1627 else if (startswith (p
, "V1_MODU"))
1628 return darwin_sections
[objc_module_info_section
];
1629 else if (startswith (p
, "V1_SYMT"))
1630 return darwin_sections
[objc_symbols_section
];
1631 else if (startswith (p
, "V1_INFO"))
1632 return darwin_sections
[objc_image_info_section
];
1634 else if (startswith (p
, "V1_PLST"))
1635 return darwin_sections
[objc1_prop_list_section
];
1636 else if (startswith (p
, "V1_PEXT"))
1637 return darwin_sections
[objc1_protocol_ext_section
];
1638 else if (startswith (p
, "V1_CEXT"))
1639 return darwin_sections
[objc1_class_ext_section
];
1641 else if (startswith (p
, "V2_CSTR"))
1642 return darwin_sections
[objc_constant_string_object_section
];
1648 machopic_select_section (tree decl
,
1650 unsigned HOST_WIDE_INT align
)
1652 bool zsize
, one
, weak
, use_coal
, ro
;
1653 section
*base_section
= NULL
;
1655 weak
= (DECL_P (decl
)
1657 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1659 /* Darwin pads zero-sized objects with at least one byte, so that the ld64
1660 atom model is preserved (objects must have distinct regions starting with
1661 a unique linker-visible symbol).
1662 In order to support section anchors, we need to move objects with zero
1663 size into sections which are marked as "no section anchors"; the padded
1664 objects, obviously, have real sizes that differ from their DECL sizes. */
1665 zsize
= DARWIN_SECTION_ANCHORS
&& flag_section_anchors
;
1667 /* In the streaming of LTO symbol data, we might have a situation where the
1668 var is incomplete or layout not finished (DECL_SIZE_UNIT is NULL_TREE).
1669 We cannot tell if it is zero-sized then, but we can get the section
1670 category correct so that nm reports the right kind of section
1671 (e.g. BSS c.f. data). */
1674 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1675 && DECL_SIZE_UNIT (decl
)
1676 && tree_to_uhwi (DECL_SIZE_UNIT (decl
)) == 0);
1679 && TREE_CODE (decl
) == VAR_DECL
1680 && DECL_COMDAT_GROUP (decl
);
1682 use_coal
= (weak
|| one
) && ld_uses_coal_sects
;
1684 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1686 switch (categorize_decl_for_section (decl
, reloc
))
1693 case SECCAT_SRODATA
:
1694 base_section
= darwin_rodata_section (use_coal
, zsize
, reloc
);
1697 case SECCAT_RODATA_MERGE_STR
:
1698 base_section
= darwin_mergeable_string_section (decl
, align
);
1701 case SECCAT_RODATA_MERGE_STR_INIT
:
1702 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1705 case SECCAT_RODATA_MERGE_CONST
:
1706 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1710 case SECCAT_DATA_REL
:
1711 case SECCAT_DATA_REL_LOCAL
:
1712 case SECCAT_DATA_REL_RO
:
1713 case SECCAT_DATA_REL_RO_LOCAL
:
1719 base_section
= darwin_sections
[const_data_coal_section
];
1721 base_section
= darwin_sections
[data_coal_section
];
1725 /* If we're doing section anchors, then punt zero-sized objects into
1726 their own sections so that they don't interfere with offset
1727 computation for the remaining vars. */
1729 base_section
= darwin_sections
[zobj_const_data_section
];
1731 base_section
= darwin_sections
[zobj_data_section
];
1734 base_section
= darwin_sections
[const_data_section
];
1736 base_section
= data_section
;
1742 base_section
= darwin_sections
[data_coal_section
];
1745 if (!TREE_PUBLIC (decl
))
1746 base_section
= lcomm_section
;
1747 else if (bss_noswitch_section
)
1748 base_section
= bss_noswitch_section
;
1750 base_section
= data_section
;
1758 /* Darwin weird special cases.
1759 a) OBJC Meta-data. */
1761 && (TREE_CODE (decl
) == VAR_DECL
1762 || TREE_CODE (decl
) == CONST_DECL
)
1763 && DECL_ATTRIBUTES (decl
))
1765 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1767 return darwin_objc2_section (decl
, meta
, base_section
);
1768 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1770 return darwin_objc1_section (decl
, meta
, base_section
);
1771 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1773 return base_section
; /* GNU runtime is happy with it all in one pot. */
1776 /* b) Constant string objects. */
1777 if (TREE_CODE (decl
) == CONSTRUCTOR
1779 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1780 && TYPE_NAME (TREE_TYPE (decl
)))
1782 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1783 if (TREE_CODE (name
) == TYPE_DECL
)
1784 name
= DECL_NAME (name
);
1786 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1788 if (flag_next_runtime
)
1790 if (flag_objc_abi
== 2)
1791 return darwin_sections
[objc2_constant_string_object_section
];
1793 return darwin_sections
[objc_constant_string_object_section
];
1796 return darwin_sections
[objc_string_object_section
];
1798 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1799 return darwin_sections
[cfstring_constant_object_section
];
1801 return base_section
;
1803 else if (flag_next_runtime
1806 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1807 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1808 && startswith (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_"))
1809 /* c) legacy meta-data selection was deprecated at 4.6, removed now. */
1812 return base_section
;
1815 /* This can be called with address expressions as "rtx".
1816 They must go in "const". */
1819 machopic_select_rtx_section (machine_mode mode
, rtx x
,
1820 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1822 if (known_eq (GET_MODE_SIZE (mode
), 8)
1823 && (GET_CODE (x
) == CONST_INT
1824 || GET_CODE (x
) == CONST_WIDE_INT
1825 || GET_CODE (x
) == CONST_DOUBLE
))
1826 return darwin_sections
[literal8_section
];
1827 else if (known_eq (GET_MODE_SIZE (mode
), 4)
1828 && (GET_CODE (x
) == CONST_INT
1829 || GET_CODE (x
) == CONST_WIDE_INT
1830 || GET_CODE (x
) == CONST_DOUBLE
))
1831 return darwin_sections
[literal4_section
];
1832 else if (HAVE_GAS_LITERAL16
1834 && known_eq (GET_MODE_SIZE (mode
), 16)
1835 && (GET_CODE (x
) == CONST_INT
1836 || GET_CODE (x
) == CONST_WIDE_INT
1837 || GET_CODE (x
) == CONST_DOUBLE
1838 || GET_CODE (x
) == CONST_VECTOR
))
1839 return darwin_sections
[literal16_section
];
1840 else if (MACHOPIC_INDIRECT
1841 && (GET_CODE (x
) == SYMBOL_REF
1842 || GET_CODE (x
) == CONST
1843 || GET_CODE (x
) == LABEL_REF
))
1844 return darwin_sections
[const_data_section
];
1846 return darwin_sections
[const_section
];
1850 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1852 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (ctors
)};
1854 vec_safe_push (ctors
, new_elt
);
1856 if (! MACHOPIC_INDIRECT
)
1857 fprintf (asm_out_file
, ".reference .constructors_used\n");
1861 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1863 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (dtors
)};
1865 vec_safe_push (dtors
, new_elt
);
1867 if (! MACHOPIC_INDIRECT
)
1868 fprintf (asm_out_file
, ".reference .destructors_used\n");
1872 sort_cdtor_records (const void * a
, const void * b
)
1874 const cdtor_record
*cda
= (const cdtor_record
*)a
;
1875 const cdtor_record
*cdb
= (const cdtor_record
*)b
;
1876 if (cda
->priority
> cdb
->priority
)
1878 if (cda
->priority
< cdb
->priority
)
1880 if (cda
->position
> cdb
->position
)
1882 if (cda
->position
< cdb
->position
)
1893 if (MACHOPIC_INDIRECT
)
1894 switch_to_section (darwin_sections
[mod_init_section
]);
1896 switch_to_section (darwin_sections
[constructor_section
]);
1898 /* Where needed, provide a linker-visible section-start symbol so that we
1899 have stable output between debug and non-debug. */
1900 if (ld_init_term_start_labels
)
1901 fputs (MACHOPIC_INDIRECT
? "_Mod.init:\n" : "_CTOR.sect:\n", asm_out_file
);
1903 if (vec_safe_length (ctors
) > 1)
1904 ctors
->qsort (sort_cdtor_records
);
1905 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
1907 assemble_align (POINTER_SIZE
);
1908 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1918 if (MACHOPIC_INDIRECT
)
1919 switch_to_section (darwin_sections
[mod_term_section
]);
1921 switch_to_section (darwin_sections
[destructor_section
]);
1923 /* Where needed, provide a linker-visible section-start symbol so that we
1924 have stable output between debug and non-debug. */
1925 if (ld_init_term_start_labels
)
1926 fputs (MACHOPIC_INDIRECT
? "_Mod.term:\n" : "_DTOR.sect:\n", asm_out_file
);
1928 if (vec_safe_length (dtors
) > 1)
1929 dtors
->qsort (sort_cdtor_records
);
1930 FOR_EACH_VEC_SAFE_ELT (dtors
, i
, elt
)
1932 assemble_align (POINTER_SIZE
);
1933 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1938 darwin_globalize_label (FILE *stream
, const char *name
)
1940 if (!startswith (name
, "_OBJC_"))
1941 default_globalize_label (stream
, name
);
1942 /* We have some Objective C cases that need to be global, but only on newer
1944 if (flag_objc_abi
< 2 || flag_next_runtime
< 100700)
1946 if (startswith (name
+6, "LabelPro"))
1947 default_globalize_label (stream
, name
);
1948 if (startswith (name
+6, "Protocol_"))
1949 default_globalize_label (stream
, name
);
1952 /* This routine returns non-zero if 'name' starts with the special objective-c
1953 anonymous file-scope static name. It accommodates c++'s mangling of such
1954 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1957 darwin_label_is_anonymous_local_objc_name (const char *name
)
1959 const unsigned char *p
= (const unsigned char *) name
;
1962 if (p
[1] == 'Z' && p
[2] == 'L')
1965 while (*p
>= '0' && *p
<= '9')
1968 if (!startswith ((const char *)p
, "_OBJC_"))
1971 /* We need some of the objective c meta-data symbols to be visible to the
1972 linker (when the target OS version is newer). FIXME: this is horrible,
1973 we need a better mechanism. */
1975 if (flag_objc_abi
< 2 || flag_next_runtime
< 100700)
1979 if (startswith ((const char *)p
, "ClassRef"))
1981 else if (startswith ((const char *)p
, "SelRef"))
1983 else if (startswith ((const char *)p
, "Category"))
1985 if (p
[8] == '_' || p
[8] == 'I' || p
[8] == 'P' || p
[8] == 'C' )
1989 else if (startswith ((const char *)p
, "ClassMethods"))
1991 else if (startswith ((const char *)p
, "ClassProtocols"))
1993 else if (startswith ((const char *)p
, "Instance"))
1995 if (p
[8] == 'I' || p
[8] == 'M')
1999 else if (startswith ((const char *)p
, "CLASS_RO"))
2001 else if (startswith ((const char *)p
, "METACLASS_RO"))
2003 else if (startswith ((const char *)p
, "Protocol"))
2005 if (p
[8] == '_' || p
[8] == 'I' || p
[8] == 'P'
2006 || p
[8] == 'M' || p
[8] == 'C' || p
[8] == 'O')
2010 else if (startswith ((const char *)p
, "LabelPro"))
2015 /* LTO support for Mach-O.
2017 This version uses three mach-o sections to encapsulate the (unlimited
2018 number of) lto sections.
2020 __GNU_LTO, __lto_sections contains the concatented GNU LTO section data.
2021 __GNU_LTO, __section_names contains the GNU LTO section names.
2022 __GNU_LTO, __section_index contains an array of values that index these.
2025 <section offset from the start of __GNU_LTO, __lto_sections>,
2027 <name offset from the start of __GNU_LTO, __section_names,
2030 At present, for both m32 and m64 mach-o files each of these fields is
2031 represented by a uint32_t. This is because, AFAICT, a mach-o object
2032 cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
2035 "offset An integer specifying the offset to this section in the file." */
2037 /* Count lto section numbers. */
2038 static unsigned int lto_section_num
= 0;
2040 /* A vector of information about LTO sections, at present, we only have
2041 the name. TODO: see if we can get the data length somehow. */
2042 typedef struct GTY (()) darwin_lto_section_e
{
2043 const char *sectname
;
2044 } darwin_lto_section_e
;
2046 static GTY (()) vec
<darwin_lto_section_e
, va_gc
> *lto_section_names
;
2048 /* Section wrapper scheme (used here to wrap the unlimited number of LTO
2049 sections into three Mach-O ones).
2050 NOTE: These names MUST be kept in sync with those in
2051 libiberty/simple-object-mach-o. */
2052 #define LTO_SECTS_SECTION "__wrapper_sects"
2053 #define LTO_NAMES_SECTION "__wrapper_names"
2054 #define LTO_INDEX_SECTION "__wrapper_index"
2056 /* File to temporarily store LTO data. This is appended to asm_out_file
2057 in darwin_end_file. */
2058 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
2059 static char *lto_asm_out_name
;
2060 static enum debug_info_levels saved_debug_info_level
;
2062 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
2063 asm_out_file and switching to an alternative output file. */
2065 darwin_asm_lto_start (void)
2067 gcc_assert (! saved_asm_out_file
);
2068 saved_asm_out_file
= asm_out_file
;
2069 saved_debug_info_level
= debug_info_level
;
2070 debug_info_level
= DINFO_LEVEL_NONE
;
2071 if (! lto_asm_out_name
)
2072 lto_asm_out_name
= make_temp_file (".lto.s");
2073 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
2074 if (lto_asm_out_file
== NULL
)
2075 fatal_error (input_location
,
2076 "failed to open temporary file %s for LTO output",
2078 asm_out_file
= lto_asm_out_file
;
2081 /* Restore asm_out_file. */
2083 darwin_asm_lto_end (void)
2085 gcc_assert (saved_asm_out_file
);
2086 fclose (lto_asm_out_file
);
2087 asm_out_file
= saved_asm_out_file
;
2088 saved_asm_out_file
= NULL
;
2089 debug_info_level
= saved_debug_info_level
;
2093 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2094 tree decl
, bool is_for_lto
);
2096 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
2099 darwin_asm_named_section (const char *name
,
2101 tree decl ATTRIBUTE_UNUSED
)
2103 /* LTO sections go in a special section that encapsulates the (unlimited)
2104 number of GNU LTO sections within a single mach-o one. */
2105 if (startswith (name
, LTO_SECTION_NAME_PREFIX
))
2107 darwin_lto_section_e e
;
2108 /* We expect certain flags to be set... */
2109 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2110 == (SECTION_DEBUG
| SECTION_NAMED
));
2112 /* Switch to our combined section. */
2113 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2114 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
2115 /* Output a label for the start of this sub-section. */
2116 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# %s\n",
2117 lto_section_num
, name
);
2118 /* We have to jump through hoops to get the values of the intra-section
2120 fprintf (asm_out_file
, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
2121 lto_section_num
, lto_section_num
);
2122 fprintf (asm_out_file
,
2123 "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
2124 lto_section_num
, lto_section_num
+1, lto_section_num
);
2126 e
.sectname
= xstrdup (name
);
2127 /* Keep the names, we'll need to make a table later.
2128 TODO: check that we do not revisit sections, that would break
2129 the assumption of how this is done. */
2130 if (lto_section_names
== NULL
)
2131 vec_alloc (lto_section_names
, 16);
2132 vec_safe_push (lto_section_names
, e
);
2134 else if (startswith (name
, "__DWARF,"))
2135 darwin_asm_dwarf_section (name
, flags
, decl
, false);
2136 else if (startswith (name
, "__GNU_DWARF_LTO,"))
2137 darwin_asm_dwarf_section (name
, flags
, decl
, true);
2139 fprintf (asm_out_file
, "\t.section %s\n", name
);
2143 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
2145 /* Darwin does not use unique sections. */
2148 /* Handle __attribute__ ((apple_kext_compatibility)).
2149 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
2150 vtable for classes with this attribute (and their descendants) by not
2151 outputting the new 3.0 nondeleting destructor. This means that such
2152 objects CANNOT be allocated on the stack or as globals UNLESS they have
2153 a completely empty `operator delete'.
2154 Luckily, this fits in with the Darwin kext model.
2156 This attribute also disables gcc3's potential overlaying of derived
2157 class data members on the padding at the end of the base class. */
2160 darwin_handle_kext_attribute (tree
*node
, tree name
,
2161 tree args ATTRIBUTE_UNUSED
,
2162 int flags ATTRIBUTE_UNUSED
,
2165 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
2166 if (! TARGET_KEXTABI
)
2168 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2169 "only when compiling a kext", name
);
2171 *no_add_attrs
= true;
2173 else if (TREE_CODE (*node
) != RECORD_TYPE
)
2175 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2176 "only to C++ classes", name
);
2178 *no_add_attrs
= true;
2184 /* Handle a "weak_import" attribute; arguments as in
2185 struct attribute_spec.handler. */
2188 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
2189 tree
ARG_UNUSED (args
),
2190 int ARG_UNUSED (flags
),
2191 bool * no_add_attrs
)
2193 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
2195 warning (OPT_Wattributes
, "%qE attribute ignored",
2197 *no_add_attrs
= true;
2200 declare_weak (*node
);
2205 /* Emit a label for an FDE, making it global and/or weak if appropriate.
2206 The third parameter is nonzero if this is for exception handling.
2207 The fourth parameter is nonzero if this is just a placeholder for an
2208 FDE that we are omitting. */
2211 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
2215 static int invok_count
= 0;
2216 static tree last_fun_decl
= NULL_TREE
;
2218 /* Modern linkers can produce distinct FDEs without compiler support. */
2219 if (! for_eh
|| ! ld_needs_eh_markers
)
2222 /* FIXME: This only works when the eh for all sections of a function are
2223 emitted at the same time. If that changes, we would need to use a lookup
2224 table of some form to determine what to do. Also, we should emit the
2225 unadorned label for the partition containing the public label for a
2226 function. This is of limited use, probably, since we do not currently
2227 enable partitioning. */
2228 strcpy (buf
, ".eh");
2229 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
2231 if (decl
== last_fun_decl
)
2234 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
2238 last_fun_decl
= decl
;
2243 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
2245 if (TREE_PUBLIC (decl
))
2247 targetm
.asm_out
.globalize_label (file
, lab
);
2248 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
2250 fputs ("\t.private_extern ", file
);
2251 assemble_name (file
, lab
);
2256 if (DECL_WEAK (decl
))
2258 fputs ("\t.weak_definition ", file
);
2259 assemble_name (file
, lab
);
2263 assemble_name (file
, lab
);
2266 fputs (" = 0\n", file
);
2268 /* Mark the absolute .eh and .eh1 style labels as needed to
2269 ensure that we don't dead code strip them and keep such
2270 labels from another instantiation point until we can fix this
2271 properly with group comdat support. */
2272 darwin_mark_decl_preserved (lab
);
2275 fputs (":\n", file
);
2280 static GTY(()) unsigned long except_table_label_num
;
2283 darwin_emit_except_table_label (FILE *file
)
2285 char section_start_label
[30];
2287 fputs ("\t.p2align\t2\n", file
);
2288 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
2289 except_table_label_num
++);
2290 ASM_OUTPUT_LABEL (file
, section_start_label
);
2294 darwin_make_eh_symbol_indirect (rtx orig
, bool ARG_UNUSED (pubvis
))
2296 if (DARWIN_PPC
== 0 && TARGET_64BIT
)
2299 return gen_rtx_SYMBOL_REF (Pmode
,
2300 machopic_indirection_name (orig
,
2304 /* The unwinders in earlier Darwin versions are based on an old version
2305 of libgcc_s and need current frame address stateto be reset after a
2306 DW_CFA_restore_state recovers the register values. */
2309 darwin_should_restore_cfa_state (void)
2311 return generating_for_darwin_version
<= 10;
2314 /* Return, and mark as used, the name of the stub for the mcount function.
2315 Currently, this is only called by X86 code in the expansion of the
2316 FUNCTION_PROFILER macro, when stubs are enabled. */
2319 machopic_mcount_stub_name (void)
2321 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
2322 const char *name
= machopic_indirection_name (symbol
, /*stub_p=*/true);
2323 machopic_validate_stub_or_non_lazy_ptr (name
);
2327 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2330 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2332 const char *nlp_name
;
2334 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2336 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2337 fputs ("\t.long\t", file
);
2338 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2342 /* If this is uncommented, details of each allocation will be printed
2343 in the asm right before the actual code. WARNING - this will cause some
2344 test-suite fails (since the printout will contain items that some tests
2345 are not expecting) -- so don't leave it on by default (it bloats the
2347 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2349 /* The first two of these routines are ostensibly just intended to put
2350 names into the asm. However, they are both hijacked in order to ensure
2351 that zero-sized items do not make their way into the output. Consequently,
2352 we also need to make these participate in provisions for dealing with
2353 such items in section anchors. */
2355 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2356 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2357 but it does need to be referenced via indirect PIC data pointers.
2358 The machopic_define_symbol calls are telling the machopic subsystem
2359 that the name *is* defined in this module, so it doesn't need to
2360 make them indirect. */
2362 darwin_asm_declare_object_name (FILE *file
,
2363 const char *nam
, tree decl
)
2365 const char *xname
= nam
;
2366 unsigned HOST_WIDE_INT size
;
2367 bool local_def
, weak
;
2369 weak
= (DECL_P (decl
)
2371 && !lookup_attribute ("weak_import",
2372 DECL_ATTRIBUTES (decl
)));
2374 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2375 && (!DECL_COMMON (decl
)
2376 || !TREE_PUBLIC (decl
)));
2378 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2379 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2383 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2385 machopic_define_symbol (DECL_RTL (decl
));
2388 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2390 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2391 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2392 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2393 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2394 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2395 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2396 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2397 (unsigned long)DECL_INITIAL (decl
));
2400 /* Darwin needs help to support local zero-sized objects.
2401 They must be made at least one byte, and the section containing must be
2402 marked as unsuitable for section-anchors (see storage allocators below).
2404 For non-zero objects this output is handled by varasm.cc.
2408 unsigned int l2align
= 0;
2410 /* The align must be honored, even for zero-sized. */
2411 if (DECL_ALIGN (decl
))
2413 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2414 fprintf (file
, "\t.align\t%u\n", l2align
);
2417 ASM_OUTPUT_LABEL (file
, xname
);
2419 fprintf (file
, "\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2421 /* Check that we've correctly picked up the zero-sized item and placed it
2423 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2425 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2428 ASM_OUTPUT_LABEL (file
, xname
);
2431 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2433 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2434 const_tree exp ATTRIBUTE_UNUSED
,
2437 assemble_label (file
, name
);
2438 /* As for other items, we need at least one byte. */
2441 fputs ("\t.space\t1\n", file
);
2442 /* Check that we've correctly picked up the zero-sized item and placed it
2444 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2446 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2450 /* Darwin storage allocators.
2452 Zerofill sections are desirable for large blank data since, otherwise, these
2453 data bloat objects (PR33210).
2455 However, section anchors don't work in .zerofill sections (one cannot switch
2456 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2457 to put (at least some) data into 'normal' switchable sections.
2459 Here we set a relatively arbitrary value for the size of an object to trigger
2460 zerofill when section anchors are enabled (anything bigger than a page for
2461 current Darwin implementations). FIXME: there ought to be some objective way
2462 to make this choice.
2464 When section anchor are off this is ignored anyway. */
2466 #define BYTES_ZFILL 4096
2468 /* Emit a chunk of data for items coalesced by the linker. */
2470 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2471 unsigned HOST_WIDE_INT size
,
2475 /* Since the sections used here are coalesced, they will not be eligible
2476 for section anchors, and therefore we don't need to break that out.
2477 CHECKME: for modern linker on PowerPC. */
2478 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2479 switch_to_section (use_coal
? darwin_sections
[const_data_coal_section
]
2480 : darwin_sections
[const_data_section
]);
2482 switch_to_section (use_coal
? darwin_sections
[data_coal_section
]
2485 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2486 the align info for zero-sized items... but do it here otherwise. */
2488 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2490 if (TREE_PUBLIC (decl
))
2491 darwin_globalize_label (fp
, name
);
2493 /* ... and we let it deal with outputting one byte of zero for them too. */
2494 darwin_asm_declare_object_name (fp
, name
, decl
);
2496 assemble_zeros (size
);
2499 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2501 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2502 unsigned HOST_WIDE_INT size
,
2503 unsigned int align
, tree meta
)
2505 section
*ocs
= data_section
;
2507 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2508 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2510 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2512 switch_to_section (ocs
);
2514 /* We shall declare that zero-sized meta-data are not valid (yet). */
2516 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2518 /* ... and we let it deal with outputting one byte of zero for them too. */
2519 darwin_asm_declare_object_name (fp
, name
, decl
);
2520 assemble_zeros (size
);
2523 /* This routine emits 'local' storage:
2525 When Section Anchors are off this routine emits .zerofill commands in
2526 sections named for their alignment.
2528 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2529 the .static_data section so that the section anchoring system can see them.
2530 Larger items are still placed in .zerofill sections, addressing PR33210.
2531 The routine has no checking - it is all assumed to be done by the caller.
2534 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2535 unsigned HOST_WIDE_INT size
,
2536 unsigned int l2align
)
2538 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2540 /* Put smaller objects in _static_data, where the section anchors system
2542 However, if they are zero-sized punt them to yet a different section
2543 (that is not allowed to participate in anchoring). */
2546 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2547 in_section
= darwin_sections
[zobj_bss_section
];
2552 fputs ("\t.static_data\n", fp
);
2553 in_section
= darwin_sections
[static_data_section
];
2557 fprintf (fp
, "\t.align\t%u\n", l2align
);
2559 assemble_name (fp
, name
);
2560 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2564 /* When we are on a non-section anchor target (or not using section
2565 anchors, we can get zero-sized items here. However, all we need to
2566 do is to bump them to one byte and the section alignment will take
2567 care of the rest. */
2569 snprintf (secnam
, 64, "__DATA,__bss");
2570 unsigned int flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2571 in_section
= get_section (secnam
, flags
, NULL
);
2572 fprintf (fp
, "\t.zerofill %s,", secnam
);
2573 assemble_name (fp
, name
);
2578 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2579 size
, (unsigned) l2align
);
2581 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",0\n", size
);
2584 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2585 /* This is defined as a file-scope var, so we know to notify machopic. */
2586 machopic_define_symbol (DECL_RTL (decl
));
2589 /* Emit a chunk of common. */
2591 darwin_emit_common (FILE *fp
, const char *name
,
2592 unsigned HOST_WIDE_INT size
, unsigned int align
)
2594 unsigned HOST_WIDE_INT rounded
;
2595 unsigned int l2align
;
2597 /* Earlier systems complain if the alignment exceeds the page size.
2598 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2599 if (!emit_aligned_common
&& (align
> 32768UL))
2600 align
= 4096UL; /* In units. */
2602 align
/= BITS_PER_UNIT
;
2604 /* Make sure we have a meaningful align. */
2608 /* For earlier toolchains, we need to emit the var as a rounded size to
2609 tell ld the alignment. */
2613 rounded
= (size
+ (align
-1)) & ~(align
-1);
2615 l2align
= floor_log2 (align
);
2617 in_section
= comm_section
;
2618 /* We mustn't allow multiple public symbols to share an address when using
2619 the normal OSX toolchain. */
2622 /* Put at least one byte. */
2624 /* This section can no longer participate in section anchoring. */
2625 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2628 fputs ("\t.comm\t", fp
);
2629 assemble_name (fp
, name
);
2630 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2631 emit_aligned_common
?size
:rounded
);
2632 if (l2align
&& emit_aligned_common
)
2633 fprintf (fp
, ",%u", l2align
);
2637 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2638 or coalescable data sections (for weak or comdat) as appropriate. */
2641 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2642 unsigned HOST_WIDE_INT size
, unsigned int align
)
2644 unsigned int l2align
;
2645 bool one
, pub
, weak
;
2648 pub
= TREE_PUBLIC (decl
);
2649 one
= DECL_ONE_ONLY (decl
);
2650 weak
= (DECL_P (decl
)
2652 && !lookup_attribute ("weak_import",
2653 DECL_ATTRIBUTES (decl
)));
2655 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2656 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2657 " pub %d weak %d one %d init %lx\n",
2658 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2659 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2660 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2663 /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS
2664 before the target has a chance to comment. */
2665 if ((meta
= is_objc_metadata (decl
)))
2667 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2671 /* Check that any initializer is valid. */
2672 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2673 || (DECL_INITIAL (decl
) == error_mark_node
)
2674 || initializer_zerop (DECL_INITIAL (decl
)));
2676 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2677 gcc_assert (!DECL_COMMON (decl
));
2679 /* Pick up the correct alignment. */
2680 if (!size
|| !align
)
2681 align
= DECL_ALIGN (decl
);
2683 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2684 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2686 last_assemble_variable_decl
= decl
;
2688 /* We would rather not have to check this here - but it seems that we might
2689 be passed a decl that should be in coalesced space. */
2692 /* Weak or COMDAT objects are put in mergeable sections. */
2693 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2694 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2698 /* If this is not public, then emit according to local rules. */
2701 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2705 /* So we have a public symbol. */
2706 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2708 /* Put smaller objects in data, where the section anchors system can get
2709 them. However, if they are zero-sized punt them to yet a different
2710 section (that is not allowed to participate in anchoring). */
2713 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2714 in_section
= darwin_sections
[zobj_data_section
];
2719 fputs ("\t.data\n", fp
);
2720 in_section
= data_section
;
2724 fprintf (fp
, "\t.align\t%u\n", l2align
);
2726 assemble_name (fp
, name
);
2727 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2731 /* Section anchors not in use. */
2732 unsigned int flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2734 snprintf (secnam
, 64, "__DATA,__common");
2735 in_section
= get_section (secnam
, flags
, NULL
);
2736 fprintf (fp
, "\t.zerofill %s,", secnam
);
2737 assemble_name (fp
, name
);
2742 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2744 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",0\n", size
);
2746 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2749 /* Output a chunk of common, with alignment specified (where the target
2752 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2753 unsigned HOST_WIDE_INT size
,
2756 unsigned int l2align
;
2760 /* No corresponding var. */
2763 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2764 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2766 /* Common variables are limited to a maximum alignment of 2^15. */
2768 error_at (UNKNOWN_LOCATION
, "common variables must have an alignment"
2769 " of 32678 or less");
2770 darwin_emit_common (fp
, name
, size
, align
);
2774 one
= DECL_ONE_ONLY (decl
);
2775 weak
= (DECL_P (decl
)
2777 && !lookup_attribute ("weak_import",
2778 DECL_ATTRIBUTES (decl
)));
2780 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2781 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2782 " weak %d one %d init %lx\n",
2783 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2784 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2785 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2788 /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS
2789 before the target has a chance to comment. */
2790 if ((meta
= is_objc_metadata (decl
)))
2792 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2796 /* We shouldn't be messing with this if the decl has a section name. */
2797 gcc_checking_assert (DECL_SECTION_NAME (decl
) == NULL
);
2799 /* We would rather not have to check this here - but it seems that we might
2800 be passed a decl that should be in coalesced space. */
2803 /* Weak or COMDAT objects are put in mergable sections. */
2804 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2805 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2809 /* We should only get here for DECL_COMMON, with a zero init (and, in
2810 principle, only for public symbols too - although we deal with local
2813 /* Check the initializer is OK. */
2814 gcc_assert (DECL_COMMON (decl
)
2815 && ((DECL_INITIAL (decl
) == NULL
)
2816 || (DECL_INITIAL (decl
) == error_mark_node
)
2817 || initializer_zerop (DECL_INITIAL (decl
))));
2819 last_assemble_variable_decl
= decl
;
2821 if (!size
|| !align
)
2822 align
= DECL_ALIGN (decl
);
2824 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2825 /* Check we aren't asking for more aligment than the platform allows. */
2826 gcc_checking_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2828 if (TREE_PUBLIC (decl
) != 0)
2830 /* Common variables are limited to a maximum alignment of 2^15. */
2832 error_at (DECL_SOURCE_LOCATION (decl
), "common variables must have"
2833 " an alignment of 32678 or less");
2834 darwin_emit_common (fp
, name
, size
, align
);
2837 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2840 /* Output a chunk of BSS with alignment specfied. */
2842 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2843 unsigned HOST_WIDE_INT size
,
2846 unsigned long l2align
;
2850 one
= DECL_ONE_ONLY (decl
);
2851 weak
= (DECL_P (decl
)
2853 && !lookup_attribute ("weak_import",
2854 DECL_ATTRIBUTES (decl
)));
2856 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2857 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2858 " weak %d init %lx\n",
2859 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2860 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2861 weak
, (unsigned long)DECL_INITIAL (decl
));
2864 /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS
2865 before the target has a chance to comment. */
2866 if ((meta
= is_objc_metadata (decl
)))
2868 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2872 /* We shouldn't be messing with this if the decl has a section name. */
2873 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2875 /* We would rather not have to check this here - but it seems that we might
2876 be passed a decl that should be in coalesced space. */
2879 /* Weak or COMDAT objects are put in mergable sections. */
2880 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2881 ld_uses_coal_sects
, DECL_ALIGN (decl
));
2885 /* .. and it should be suitable for placement in local mem. */
2886 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2887 /* .. and any initializer must be all-zero. */
2888 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2889 || (DECL_INITIAL (decl
) == error_mark_node
)
2890 || initializer_zerop (DECL_INITIAL (decl
)));
2892 last_assemble_variable_decl
= decl
;
2894 if (!size
|| !align
)
2895 align
= DECL_ALIGN (decl
);
2897 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2898 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2900 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2903 /* Emit an assembler directive to set visibility for a symbol. The
2904 only supported visibilities are VISIBILITY_DEFAULT and
2905 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2906 extern". There is no MACH-O equivalent of ELF's
2907 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2910 darwin_assemble_visibility (tree decl
, int vis
)
2912 if (vis
== VISIBILITY_DEFAULT
)
2914 else if (vis
== VISIBILITY_HIDDEN
|| vis
== VISIBILITY_INTERNAL
)
2916 fputs ("\t.private_extern ", asm_out_file
);
2917 assemble_name (asm_out_file
,
2918 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2919 fputs ("\n", asm_out_file
);
2922 warning (OPT_Wattributes
, "protected visibility attribute "
2923 "not supported in this configuration; ignored");
2926 /* vec used by darwin_asm_dwarf_section.
2927 Maybe a hash tab would be better here - but the intention is that this is
2928 a very short list (fewer than 16 items) and each entry should (ideally,
2929 eventually) only be presented once.
2931 A structure to hold a dwarf debug section used entry. */
2933 typedef struct GTY(()) dwarf_sect_used_entry
{
2937 dwarf_sect_used_entry
;
2940 /* A list of used __DWARF sections. */
2941 static GTY (()) vec
<dwarf_sect_used_entry
, va_gc
> *dwarf_sect_names_table
;
2943 /* This is called when we are asked to assemble a named section and the
2944 name begins with __DWARF,. We keep a list of the section names (without
2945 the __DWARF, prefix) and use this to emit our required start label on the
2946 first switch to each section. */
2949 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2950 tree
ARG_UNUSED (decl
), bool is_for_lto
)
2953 int namelen
, extra
= 0;
2954 const char *sect
, *lto_add
= "";
2956 dwarf_sect_used_entry
*ref
;
2959 gcc_checking_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2960 == (SECTION_DEBUG
| SECTION_NAMED
));
2962 /* We know that the name starts with __DWARF, or __GNU_DAWRF_LTO */
2963 sect
= strchr (name
, ',') + 1;
2964 namelen
= strchr (sect
, ',') - sect
;
2965 gcc_checking_assert (namelen
);
2967 /* The section switch is output as written... */
2968 fprintf (asm_out_file
, "\t.section %s\n", name
);
2970 /* ... but the string we keep to make section start labels needs
2971 adjustment for lto cases. */
2978 snprintf (sname
, 64, "%.*s%.*s", namelen
, sect
, extra
, lto_add
);
2981 if (dwarf_sect_names_table
== NULL
)
2982 vec_alloc (dwarf_sect_names_table
, 16);
2985 dwarf_sect_names_table
->iterate (i
, &ref
);
2990 if (!strcmp (ref
->name
, sname
))
3000 dwarf_sect_used_entry e
;
3001 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
3003 e
.name
= xstrdup (sname
);
3004 vec_safe_push (dwarf_sect_names_table
, e
);
3008 /* Output a difference of two labels that will be an assembly time
3009 constant if the two labels are local. (.long lab1-lab2 will be
3010 very different if lab1 is at the boundary between two sections; it
3011 will be relocated according to the second section, not the first,
3012 so one ends up with a difference between labels in different
3013 sections, which is bad in the dwarf2 eh context for instance.) */
3015 static int darwin_dwarf_label_counter
;
3018 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
3019 const char *lab1
, const char *lab2
,
3020 HOST_WIDE_INT offset
)
3022 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
3023 && lab2
[0] == '*' && lab2
[1] == 'L');
3024 const char *directive
= (size
== 8 ? ".quad" : ".long");
3027 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
3029 fprintf (file
, "\t%s\t", directive
);
3031 assemble_name_raw (file
, lab1
);
3032 fprintf (file
, "-");
3033 assemble_name_raw (file
, lab2
);
3035 fprintf (file
, "+" HOST_WIDE_INT_PRINT_DEC
, offset
);
3037 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
3040 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
3041 offsets are not represented using relocs in .o files; either the
3042 section never leaves the .o file, or the linker or other tool is
3043 responsible for parsing the DWARF and updating the offsets. */
3046 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
3047 HOST_WIDE_INT offset
, section
*base
)
3050 int namelen
, extra
= 0;
3052 const char *lto_add
= "";
3054 gcc_checking_assert (base
->common
.flags
& SECTION_NAMED
);
3055 is_for_lto
= startswith (base
->named
.name
, "__GNU_DWARF_LTO,");
3056 gcc_checking_assert (is_for_lto
3057 || startswith (base
->named
.name
, "__DWARF,"));
3058 const char *name
= strchr (base
->named
.name
, ',') + 1;
3059 gcc_checking_assert (name
);
3061 namelen
= strchr (name
, ',') - (name
);
3067 snprintf (sname
, 64, "*Lsection%.*s%.*s", namelen
, name
, extra
, lto_add
);
3068 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
, offset
);
3071 /* Called from the within the TARGET_ASM_FILE_START for each target. */
3074 darwin_file_start (void)
3076 #ifdef HAVE_AS_MMACOSX_VERSION_MIN_OPTION
3077 /* This should not happen with a well-formed command line, but the user could
3078 invoke cc1* directly without it. */
3079 if (!darwin_macosx_version_min
)
3081 /* This assumes that the version passed has been validated in the driver. */
3082 unsigned maj
, min
, tiny
;
3083 int count
= sscanf (darwin_macosx_version_min
, "%u.%u.%u", &maj
, &min
, &tiny
);
3090 const char *directive
;
3091 #ifdef HAVE_AS_MACOS_BUILD_VERSION
3092 /* We only handle macos, so far. */
3093 if (generating_for_darwin_version
>= 18)
3094 directive
= "build_version macos, ";
3097 directive
= "macosx_version_min ";
3098 if (count
> 2 && tiny
!= 0)
3099 fprintf (asm_out_file
, "\t.%s %u, %u, %u\n", directive
, maj
, min
, tiny
);
3101 fprintf (asm_out_file
, "\t.%s %u, %u\n", directive
, maj
, min
);
3103 fprintf (asm_out_file
, "\t.%s %u, 0\n", directive
, maj
);
3107 /* Called for the TARGET_ASM_FILE_END hook.
3108 Emit the mach-o pic indirection data, the lto data and, finally a flag
3109 to tell the linker that it can break the file object into sections and
3110 move those around for efficiency. */
3113 darwin_file_end (void)
3115 if (!vec_safe_is_empty (ctors
))
3117 if (!vec_safe_is_empty (dtors
))
3120 /* If we are expecting to output NeXT ObjC meta-data, (and we actually see
3121 some) then we output the fix-and-continue marker (Image Info).
3122 This applies to Objective C, Objective C++ and LTO with either language
3123 as part of the input. */
3124 if (flag_next_runtime
&& objc_metadata_seen
)
3126 unsigned int flags
= 0;
3127 if (flag_objc_abi
>= 2)
3130 switch_to_section (darwin_sections
[objc2_image_info_section
]);
3133 switch_to_section (darwin_sections
[objc_image_info_section
]);
3135 ASM_OUTPUT_ALIGN (asm_out_file
, 2);
3136 fputs ("L_OBJC_ImageInfo:\n", asm_out_file
);
3138 flags
|= (flag_replace_objc_classes
&& classes_seen
) ? 1 : 0;
3139 flags
|= flag_objc_gc
? 2 : 0;
3141 fprintf (asm_out_file
, "\t.long\t0\n\t.long\t%u\n", flags
);
3144 machopic_finish (asm_out_file
);
3145 if (flag_apple_kext
)
3147 /* These sections are only used for kernel code. */
3148 switch_to_section (darwin_sections
[constructor_section
]);
3149 switch_to_section (darwin_sections
[destructor_section
]);
3150 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
3153 /* If there was LTO assembler output, append it to asm_out_file. */
3154 if (lto_asm_out_name
)
3157 char *buf
, *lto_asm_txt
;
3159 /* Shouldn't be here if we failed to switch back. */
3160 gcc_assert (! saved_asm_out_file
);
3162 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
3163 if (lto_asm_out_file
== NULL
)
3164 fatal_error (input_location
,
3165 "failed to open temporary file %s with LTO output",
3167 fseek (lto_asm_out_file
, 0, SEEK_END
);
3168 n
= ftell (lto_asm_out_file
);
3171 fseek (lto_asm_out_file
, 0, SEEK_SET
);
3172 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
3173 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
3174 fputs (lto_asm_txt
, asm_out_file
);
3175 /* Put a termination label. */
3176 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3177 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
3178 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# end of lto\n",
3180 /* Make sure our termination label stays in this section. */
3181 fputs ("\t.space\t1\n", asm_out_file
);
3184 /* Remove the temporary file. */
3185 fclose (lto_asm_out_file
);
3186 unlink_if_ordinary (lto_asm_out_name
);
3187 free (lto_asm_out_name
);
3190 /* Output the names and indices. */
3191 if (lto_section_names
&& lto_section_names
->length ())
3194 darwin_lto_section_e
*ref
;
3195 /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
3196 the latter up ourselves. */
3197 const char *op
= integer_asm_op (4,0);
3199 /* Emit the names. */
3200 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3201 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
3202 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
3204 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\n", count
);
3205 /* We have to jump through hoops to get the values of the intra-section
3207 fprintf (asm_out_file
,
3208 "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
3210 fprintf (asm_out_file
,
3211 "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
3212 count
, count
+1, count
);
3213 fprintf (asm_out_file
, "\t.asciz\t\"%s\"\n", ref
->sectname
);
3215 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num
);
3216 /* make sure our termination label stays in this section. */
3217 fputs ("\t.space\t1\n", asm_out_file
);
3219 /* Emit the Index. */
3220 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3221 LTO_SEGMENT_NAME
, LTO_INDEX_SECTION
);
3222 fputs ("\t.align\t2\n", asm_out_file
);
3223 fputs ("# Section offset, Section length, Name offset, Name length\n",
3225 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
3227 fprintf (asm_out_file
, "%s L$gnu$lto$offs%d\t;# %s\n",
3228 op
, count
, ref
->sectname
);
3229 fprintf (asm_out_file
, "%s L$gnu$lto$size%d\n", op
, count
);
3230 fprintf (asm_out_file
, "%s L$gnu$lto$noff%d\n", op
, count
);
3231 fprintf (asm_out_file
, "%s L$gnu$lto$nsiz%d\n", op
, count
);
3235 /* If we have section anchors, then we must prevent the linker from
3236 re-arranging data. */
3237 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
3238 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
3240 /* We rely on this being NULL at the start of compilation; reset it here
3241 so that JIT can reuse a context. */
3242 if (dwarf_sect_names_table
!= NULL
)
3244 dwarf_sect_names_table
->truncate (0);
3245 dwarf_sect_names_table
= NULL
;
3249 /* TODO: Add a language hook for identifying if a decl is a vtable. */
3250 #define DARWIN_VTABLE_P(DECL) 0
3252 /* Cross-module name binding. Darwin does not support overriding
3253 functions at dynamic-link time, except for vtables in kexts. */
3256 darwin_binds_local_p (const_tree decl
)
3258 /* We use the "shlib" input to indicate that a symbol should be
3259 considered overridable; only relevant for vtables in kernel modules
3260 on earlier system versions, and with a TODO to complete. */
3261 bool force_overridable
= TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
);
3262 return default_binds_local_p_3 (decl
, force_overridable
/* shlib */,
3263 false /* weak dominate */,
3264 false /* extern_protected_data */,
3265 false /* common_local_p */);
3268 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
3269 anchor relative to ".", the current section position. We cannot use
3270 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
3272 darwin_asm_output_anchor (rtx symbol
)
3274 fprintf (asm_out_file
, "\t.set\t");
3275 assemble_name (asm_out_file
, XSTR (symbol
, 0));
3276 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
3277 SYMBOL_REF_BLOCK_OFFSET (symbol
));
3280 /* Disable section anchoring on any section containing a zero-sized
3283 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
3285 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
3288 /* If the section contains a zero-sized object it's ineligible. */
3289 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
3290 /* This should have the effect of disabling anchors for vars that follow
3291 any zero-sized one, in a given section. */
3292 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
3295 /* Also check the normal reasons for suppressing. */
3296 return default_use_anchors_for_symbol_p (symbol
);
3302 /* Set the darwin specific attributes on TYPE. */
3304 darwin_set_default_type_attributes (tree type
)
3306 if (darwin_ms_struct
3307 && TREE_CODE (type
) == RECORD_TYPE
)
3308 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
3310 TYPE_ATTRIBUTES (type
));
3313 /* True, iff we're generating code for loadable kernel extensions. */
3316 darwin_kextabi_p (void) {
3317 return flag_apple_kext
;
3321 darwin_override_options (void)
3323 /* Keep track of which (major) version we're generating code for. */
3324 if (darwin_macosx_version_min
)
3326 if (strverscmp (darwin_macosx_version_min
, "10.14") >= 0)
3327 generating_for_darwin_version
= 18;
3328 else if (strverscmp (darwin_macosx_version_min
, "10.8") >= 0)
3329 generating_for_darwin_version
= 12;
3330 else if (strverscmp (darwin_macosx_version_min
, "10.7") >= 0)
3331 generating_for_darwin_version
= 11;
3332 else if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
3333 generating_for_darwin_version
= 10;
3334 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
3335 generating_for_darwin_version
= 9;
3336 else if (strverscmp (darwin_macosx_version_min
, "10.4") >= 0)
3337 generating_for_darwin_version
= 8;
3339 /* Earlier versions are not specifically accounted, until required. */
3342 /* Some codegen needs to account for the capabilities of the target
3344 if (darwin_target_linker
)
3346 /* Older Darwin ld could not coalesce weak entities without them being
3347 placed in special sections. */
3348 if (strverscmp (darwin_target_linker
, MIN_LD64_NO_COAL_SECTS
) < 0)
3349 ld_uses_coal_sects
= true;
3351 /* Some newer assemblers emit section start temp symbols for mod init
3352 and term sections if there is no suitable symbol present already.
3353 The temp symbols are linker visible and therefore appear in the
3354 symbol tables. Since the temp symbol number can vary when debug is
3355 enabled, that causes compare-debug fails. The solution is to provide
3356 a stable linker-visible symbol. */
3357 if (strverscmp (darwin_target_linker
,
3358 MIN_LD64_INIT_TERM_START_LABELS
) >= 0)
3359 ld_init_term_start_labels
= true;
3362 /* In principle, this should be c-family only. However, we really need to
3363 set sensible defaults for LTO as well, since the section selection stuff
3364 should check for correctness re. the ABI. TODO: check and provide the
3365 flags (runtime & ABI) from the lto wrapper). */
3367 /* At present, make a hard update to the runtime version based on the target
3369 if (flag_next_runtime
)
3371 if (generating_for_darwin_version
> 10)
3372 flag_next_runtime
= 100705;
3373 else if (generating_for_darwin_version
> 9)
3374 flag_next_runtime
= 100608;
3375 else if (generating_for_darwin_version
> 8)
3376 flag_next_runtime
= 100508;
3378 flag_next_runtime
= 100000;
3381 /* Unless set, force ABI=2 for NeXT and m64, 0 otherwise. */
3382 if (!OPTION_SET_P (flag_objc_abi
))
3383 global_options
.x_flag_objc_abi
3384 = (!flag_next_runtime
)
3387 : (generating_for_darwin_version
>= 9) ? 1
3390 if (OPTION_SET_P (flag_objc_abi
) && flag_next_runtime
)
3392 if (TARGET_64BIT
&& global_options
.x_flag_objc_abi
!= 2)
3393 /* The Objective-C family ABI 2 is the only valid version NeXT/m64. */
3394 error_at (UNKNOWN_LOCATION
,
3395 "%<-fobjc-abi-version%> 2 must be used for 64 bit targets"
3396 " with %<-fnext-runtime%>");
3397 else if (!TARGET_64BIT
&& global_options
.x_flag_objc_abi
>= 2)
3398 /* ABI versions 0 and 1 are the only valid versions NeXT/m32. */
3399 error_at (UNKNOWN_LOCATION
,
3400 "%<-fobjc-abi-version%> %d is not supported for 32 bit"
3401 " targets with %<-fnext-runtime%>",
3402 global_options
.x_flag_objc_abi
);
3405 /* Limit DWARF to the chosen version, the linker and debug linker might not
3406 be able to consume newer structures. */
3407 if (!OPTION_SET_P (dwarf_strict
))
3410 if (!OPTION_SET_P (dwarf_version
))
3412 /* External toolchains based on LLVM or clang 7+ have support for
3414 if ((dsymutil_version
.kind
== LLVM
&& dsymutil_version
.major
>= 7)
3415 || (dsymutil_version
.kind
== CLANG
&& dsymutil_version
.major
>= 7))
3417 else if (dsymutil_version
.kind
== DWARFUTILS
3418 && dsymutil_version
.major
>= 121)
3419 dwarf_version
= 3; /* From XC 6.4. */
3421 dwarf_version
= 2; /* Older cannot safely exceed dwarf-2. */
3424 if (OPTION_SET_P (dwarf_split_debug_info
) && dwarf_split_debug_info
)
3426 inform (input_location
,
3427 "%<-gsplit-dwarf%> is not supported on this platform, ignored");
3428 dwarf_split_debug_info
= 0;
3429 OPTION_SET_P (dwarf_split_debug_info
) = 0;
3432 /* Do not allow unwind tables to be generated by default for m32.
3433 fnon-call-exceptions will override this, regardless of what we do. */
3434 if (generating_for_darwin_version
< 10
3435 && !OPTION_SET_P (flag_asynchronous_unwind_tables
)
3437 global_options
.x_flag_asynchronous_unwind_tables
= 0;
3439 /* Disable -freorder-blocks-and-partition when unwind tables are being
3440 emitted for Darwin < 9 (OSX 10.5).
3441 The strategy is, "Unless the user has specifically set/unset an unwind
3442 flag we will switch off -freorder-blocks-and-partition when unwind tables
3443 will be generated". If the user specifically sets flags, we have to
3444 assume they know why. */
3445 if (generating_for_darwin_version
< 9
3446 && OPTION_SET_P (flag_reorder_blocks_and_partition
)
3447 && flag_reorder_blocks_and_partition
3448 && ((global_options
.x_flag_exceptions
/* User, c++, java */
3449 && !OPTION_SET_P (flag_exceptions
)) /* User specified... */
3450 || (global_options
.x_flag_unwind_tables
3451 && !OPTION_SET_P (flag_unwind_tables
))
3452 || (global_options
.x_flag_non_call_exceptions
3453 && !OPTION_SET_P (flag_non_call_exceptions
))
3454 || (global_options
.x_flag_asynchronous_unwind_tables
3455 && !OPTION_SET_P (flag_asynchronous_unwind_tables
))))
3457 inform (input_location
,
3458 "%<-freorder-blocks-and-partition%> does not work with "
3459 "exceptions on this architecture");
3460 flag_reorder_blocks_and_partition
= 0;
3461 flag_reorder_blocks
= 1;
3464 /* FIXME: flag_objc_sjlj_exceptions is no longer needed since there is only
3465 one valid choice of exception scheme for each runtime. */
3466 if (!OPTION_SET_P (flag_objc_sjlj_exceptions
))
3467 global_options
.x_flag_objc_sjlj_exceptions
=
3468 flag_next_runtime
&& !TARGET_64BIT
;
3470 /* FIXME: and this could be eliminated then too. */
3471 if (!OPTION_SET_P (flag_exceptions
)
3472 && flag_objc_exceptions
3474 flag_exceptions
= 1;
3476 if (flag_mkernel
|| flag_apple_kext
)
3478 /* -mkernel implies -fapple-kext for C++ */
3479 if (lang_GNU_CXX ())
3480 flag_apple_kext
= 1;
3484 /* No EH in kexts. */
3485 flag_exceptions
= 0;
3486 /* No -fnon-call-exceptions data in kexts. */
3487 flag_non_call_exceptions
= 0;
3488 /* so no tables either.. */
3489 flag_unwind_tables
= 0;
3490 flag_asynchronous_unwind_tables
= 0;
3493 if (flag_var_tracking_uninit
== 0
3494 && generating_for_darwin_version
>= 9
3495 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
3496 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
3497 && dwarf_debuginfo_p ())
3498 flag_var_tracking_uninit
= flag_var_tracking
;
3500 if (OPTION_SET_P (flag_pie
) && flag_pie
)
3502 /* This is a little complicated, to match Xcode tools.
3503 For Darwin, PIE requires PIC codegen, but otherwise is only a link-
3504 time change. For almost all Darwin, we do not report __PIE__; the
3505 exception is Darwin12-17 and for 32b only. */
3506 flag_pie
= generating_for_darwin_version
>= 12 && !TARGET_64BIT
? 2 : 0;
3507 flag_pic
= 2; /* We always set this. */
3510 /* Final check on PIC options. */
3511 if (MACHO_DYNAMIC_NO_PIC_P
)
3514 warning_at (UNKNOWN_LOCATION
, 0,
3515 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
3516 " %<-fpie%> or %<-fPIE%>");
3519 else if (flag_pic
== 1
3520 || (flag_pic
== 0 && !(flag_mkernel
|| flag_apple_kext
)))
3522 /* Darwin's -fpic is -fPIC.
3523 We only support "static" code in the kernel and kernel exts. */
3527 /* Linkers >= ld64-62.1 (at least) are capable of making the necessary PIC
3528 indirections and we no longer need to emit pic symbol stubs.
3529 However, if we are generating code for earlier ones (or for use in the
3530 kernel) the stubs might still be required, and this will be set true.
3531 If the user sets it on or off - then that takes precedence.
3533 Linkers that don't need stubs, don't need the EH symbol markers either.
3536 if (!OPTION_SET_P (darwin_symbol_stubs
))
3538 if (darwin_target_linker
)
3540 if (strverscmp (darwin_target_linker
, MIN_LD64_OMIT_STUBS
) < 0)
3542 darwin_symbol_stubs
= true;
3543 ld_needs_eh_markers
= true;
3546 else if (generating_for_darwin_version
< 9)
3548 /* If we don't know the linker version and we're targeting an old
3549 system, we know no better than to assume the use of an earlier
3551 darwin_symbol_stubs
= true;
3552 ld_needs_eh_markers
= true;
3555 else if (DARWIN_X86
&& darwin_symbol_stubs
&& TARGET_64BIT
)
3557 inform (input_location
,
3558 "%<-mpic-symbol-stubs%> is not required for 64-bit code "
3560 darwin_symbol_stubs
= false;
3563 if (generating_for_darwin_version
>= 9)
3564 /* Later systems can support aligned common. */
3565 emit_aligned_common
= true;
3567 /* The c_dialect...() macros are not available to us here. */
3568 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
3572 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
3575 darwin_patch_builtin (enum built_in_function fncode
)
3577 tree fn
= builtin_decl_explicit (fncode
);
3584 sym
= DECL_ASSEMBLER_NAME (fn
);
3585 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
3587 set_user_assembler_name (fn
, newname
);
3589 fn
= builtin_decl_implicit (fncode
);
3591 set_user_assembler_name (fn
, newname
);
3595 darwin_patch_builtins (void)
3597 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
3600 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
3601 #define PATCH_BUILTIN_NO64(fncode) \
3602 if (!TARGET_64BIT) \
3603 darwin_patch_builtin (fncode);
3604 #define PATCH_BUILTIN_VARIADIC(fncode) \
3606 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
3607 darwin_patch_builtin (fncode);
3608 #include "darwin-ppc-ldouble-patch.def"
3609 #undef PATCH_BUILTIN
3610 #undef PATCH_BUILTIN_NO64
3611 #undef PATCH_BUILTIN_VARIADIC
3615 /* CFStrings implementation. */
3616 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3617 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3618 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3619 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3620 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3621 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3623 static enum built_in_function darwin_builtin_cfstring
;
3625 /* Store all constructed constant CFStrings in a hash table so that
3626 they get uniqued properly. */
3628 typedef struct GTY ((for_user
)) cfstring_descriptor
{
3629 /* The string literal. */
3631 /* The resulting constant CFString. */
3633 } cfstring_descriptor
;
3635 struct cfstring_hasher
: ggc_ptr_hash
<cfstring_descriptor
>
3637 static hashval_t
hash (cfstring_descriptor
*);
3638 static bool equal (cfstring_descriptor
*, cfstring_descriptor
*);
3641 static GTY (()) hash_table
<cfstring_hasher
> *cfstring_htab
;
3644 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3646 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3647 get_identifier (name
), type
);
3651 *chain
= &DECL_CHAIN (field
);
3657 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3659 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3662 darwin_builtin_cfstring
=
3663 (enum built_in_function
) builtin_cfstring
;
3665 /* struct __builtin_CFString {
3666 const int *isa; (will point at
3667 int flags; __CFConstantStringClassReference)
3672 pcint_type_node
= build_pointer_type
3673 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3675 pcchar_type_node
= build_pointer_type
3676 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3678 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3680 /* Have to build backwards for finish struct. */
3681 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3682 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3683 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3684 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3685 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3688 /* const struct __builtin_CFstring *
3689 __builtin___CFStringMakeConstantString (const char *); */
3691 ccfstring_type_node
= build_qualified_type
3692 (cfstring_type_node
, TYPE_QUAL_CONST
);
3693 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3694 pccfstring_ftype_pcchar
= build_function_type_list
3695 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3697 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3698 get_identifier ("__builtin___CFStringMakeConstantString"),
3699 pccfstring_ftype_pcchar
);
3701 TREE_PUBLIC (cfsfun
) = 1;
3702 DECL_EXTERNAL (cfsfun
) = 1;
3703 DECL_ARTIFICIAL (cfsfun
) = 1;
3704 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3705 in place of the existing, which may be NULL. */
3706 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3707 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3708 set_decl_built_in_function (cfsfun
, BUILT_IN_MD
, darwin_builtin_cfstring
);
3709 lang_hooks
.builtin_function (cfsfun
);
3711 /* extern int __CFConstantStringClassReference[]; */
3712 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3713 get_identifier ("__CFConstantStringClassReference"),
3714 build_array_type (integer_type_node
, NULL_TREE
));
3716 TREE_PUBLIC (cfstring_class_reference
) = 1;
3717 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3718 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3719 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3720 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3722 /* Initialize the hash table used to hold the constant CFString objects. */
3723 cfstring_htab
= hash_table
<cfstring_hasher
>::create_ggc (31);
3725 return cfstring_type_node
;
3729 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3730 bool ARG_UNUSED (ignore
))
3732 int fcode
= DECL_MD_FUNCTION_CODE (fndecl
);
3734 if (fcode
== darwin_builtin_cfstring
)
3736 if (!darwin_constant_cfstrings
)
3738 error ("built-in function %qD requires the"
3739 " %<-mconstant-cfstrings%> flag", fndecl
);
3740 return error_mark_node
;
3745 error ("built-in function %qD takes one argument only", fndecl
);
3746 return error_mark_node
;
3749 return darwin_build_constant_cfstring (*argp
);
3756 darwin_rename_builtins (void)
3760 /* Implementation for the TARGET_LIBC_HAS_FUNCTION hook. */
3763 darwin_libc_has_function (enum function_class fn_class
,
3764 tree type ATTRIBUTE_UNUSED
)
3766 if (fn_class
== function_sincos
&& darwin_macosx_version_min
)
3767 return (strverscmp (darwin_macosx_version_min
, "10.9") >= 0);
3768 #if DARWIN_PPC && SUPPORT_DARWIN_LEGACY
3769 if (fn_class
== function_c99_math_complex
3770 || fn_class
== function_c99_misc
)
3771 return (TARGET_64BIT
3772 || (darwin_macosx_version_min
&&
3773 strverscmp (darwin_macosx_version_min
, "10.3") >= 0));
3775 return default_libc_has_function (fn_class
, type
);
3779 cfstring_hasher::hash (cfstring_descriptor
*ptr
)
3781 tree str
= ptr
->literal
;
3782 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3783 int i
, len
= TREE_STRING_LENGTH (str
);
3786 for (i
= 0; i
< len
; i
++)
3787 h
= ((h
* 613) + p
[i
]);
3793 cfstring_hasher::equal (cfstring_descriptor
*ptr1
, cfstring_descriptor
*ptr2
)
3795 tree str1
= ptr1
->literal
;
3796 tree str2
= ptr2
->literal
;
3797 int len1
= TREE_STRING_LENGTH (str1
);
3799 return (len1
== TREE_STRING_LENGTH (str2
)
3800 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3805 darwin_build_constant_cfstring (tree str
)
3807 struct cfstring_descriptor
*desc
, key
;
3812 error ("CFString literal is missing");
3813 return error_mark_node
;
3818 if (TREE_CODE (str
) == ADDR_EXPR
)
3819 str
= TREE_OPERAND (str
, 0);
3821 if (TREE_CODE (str
) != STRING_CST
)
3823 error ("CFString literal expression is not a string constant");
3824 return error_mark_node
;
3827 /* Perhaps we already constructed a constant CFString just like this one? */
3829 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3834 tree var
, constructor
, field
;
3835 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3836 int length
= TREE_STRING_LENGTH (str
) - 1;
3838 if (darwin_warn_nonportable_cfstrings
)
3840 const char *s
= TREE_STRING_POINTER (str
);
3843 for (l
= 0; l
< length
; l
++)
3844 if (!s
[l
] || !isascii (s
[l
]))
3846 warning (darwin_warn_nonportable_cfstrings
,
3847 s
[l
] ? G_("non-ASCII character in CFString literal")
3848 : G_("embedded NUL in CFString literal"));
3853 *loc
= desc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3854 desc
->literal
= str
;
3857 field
= TYPE_FIELDS (ccfstring_type_node
);
3858 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3859 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3860 cfstring_class_reference
));
3862 field
= DECL_CHAIN (field
);
3863 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3864 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3866 field
= DECL_CHAIN (field
);
3867 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3868 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3870 field
= DECL_CHAIN (field
);
3871 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3872 build_int_cst (TREE_TYPE (field
), length
));
3874 constructor
= build_constructor (ccfstring_type_node
, v
);
3875 TREE_READONLY (constructor
) = 1;
3876 TREE_CONSTANT (constructor
) = 1;
3877 TREE_STATIC (constructor
) = 1;
3879 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3880 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3881 being built without any knowledge of C++ tree accessors; hence, we shall
3882 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3883 if (darwin_running_cxx
)
3884 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3886 /* Create an anonymous global variable for this CFString. */
3887 var
= build_decl (input_location
, CONST_DECL
,
3888 NULL
, TREE_TYPE (constructor
));
3889 DECL_ARTIFICIAL (var
) = 1;
3890 TREE_STATIC (var
) = 1;
3891 DECL_INITIAL (var
) = constructor
;
3892 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3893 DECL_CONTEXT (var
) = NULL_TREE
;
3894 desc
->constructor
= var
;
3897 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3898 TREE_CONSTANT (addr
) = 1;
3904 darwin_cfstring_p (tree str
)
3906 struct cfstring_descriptor key
;
3913 if (TREE_CODE (str
) == ADDR_EXPR
)
3914 str
= TREE_OPERAND (str
, 0);
3916 if (TREE_CODE (str
) != STRING_CST
)
3920 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, NO_INSERT
);
3929 darwin_enter_string_into_cfstring_table (tree str
)
3931 struct cfstring_descriptor key
;
3934 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3938 *loc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3939 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3943 /* Choose named function section based on its frequency. */
3946 darwin_function_section (tree decl
, enum node_frequency freq
,
3947 bool startup
, bool exit
)
3949 /* Decide if we need to put this in a coalescable section. */
3952 && (!DECL_ATTRIBUTES (decl
)
3953 || !lookup_attribute ("weak_import",
3954 DECL_ATTRIBUTES (decl
))));
3956 bool use_coal
= weak
&& ld_uses_coal_sects
;
3957 /* If there is a specified section name, we should not be trying to
3959 if (decl
&& DECL_SECTION_NAME (decl
) != NULL
)
3960 return get_named_section (decl
, NULL
, 0);
3962 /* We always put unlikely executed stuff in the cold section; we have to put
3963 this ahead of the global init section, since partitioning within a section
3964 breaks some assumptions made in the DWARF handling. */
3965 if (freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3966 return (use_coal
) ? darwin_sections
[text_cold_coal_section
]
3967 : darwin_sections
[text_cold_section
];
3969 /* Intercept functions in global init; these are placed in separate sections.
3970 FIXME: there should be some neater way to do this, FIXME we should be able
3971 to partition within a section. */
3972 if (DECL_NAME (decl
)
3973 && (startswith (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_GLOBAL__sub_I")
3974 || startswith (IDENTIFIER_POINTER (DECL_NAME (decl
)),
3975 "__static_initialization_and_destruction")))
3976 return darwin_sections
[static_init_section
];
3978 /* If we have LTO *and* feedback information, then let LTO handle
3979 the function ordering, it makes a better job (for normal, hot,
3980 startup and exit - hence the bailout for cold above). */
3981 if (in_lto_p
&& flag_profile_values
)
3982 goto default_function_sections
;
3984 /* Non-cold startup code should go to startup subsection. */
3986 return (use_coal
) ? darwin_sections
[text_startup_coal_section
]
3987 : darwin_sections
[text_startup_section
];
3989 /* Similarly for exit. */
3991 return (use_coal
) ? darwin_sections
[text_exit_coal_section
]
3992 : darwin_sections
[text_exit_section
];
3994 /* Place hot code. */
3995 if (freq
== NODE_FREQUENCY_HOT
)
3996 return (use_coal
) ? darwin_sections
[text_hot_coal_section
]
3997 : darwin_sections
[text_hot_section
];
3999 /* Otherwise, default to the 'normal' non-reordered sections. */
4000 default_function_sections
:
4001 return (use_coal
) ? darwin_sections
[text_coal_section
]
4005 #include "gt-darwin.h"