1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989-2015 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"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
35 #include "insn-attr.h"
38 #include "fold-const.h"
39 #include "stringpool.h"
41 #include "stor-layout.h"
50 #include "langhooks.h"
53 #include "diagnostic-core.h"
59 #include "cfgcleanup.h"
61 #include "internal-fn.h"
62 #include "gimple-fold.h"
66 #include "alloc-pool.h"
67 #include "lto-streamer.h"
68 #include "lto-section-names.h"
70 /* Darwin supports a feature called fix-and-continue, which is used
71 for rapid turn around debugging. When code is compiled with the
72 -mfix-and-continue flag, two changes are made to the generated code
73 that allow the system to do things that it would normally not be
74 able to do easily. These changes allow gdb to load in
75 recompilation of a translation unit that has been changed into a
76 running program and replace existing functions and methods of that
77 translation unit with versions of those functions and methods
78 from the newly compiled translation unit. The new functions access
79 the existing static symbols from the old translation unit, if the
80 symbol existed in the unit to be replaced, and from the new
81 translation unit, otherwise.
83 The changes are to insert 5 nops at the beginning of all functions
84 and to use indirection to get at static symbols. The 5 nops
85 are required by consumers of the generated code. Currently, gdb
86 uses this to patch in a jump to the overriding function, this
87 allows all uses of the old name to forward to the replacement,
88 including existing function pointers and virtual methods. See
89 rs6000_emit_prologue for the code that handles the nop insertions.
91 The added indirection allows gdb to redirect accesses to static
92 symbols from the newly loaded translation unit to the existing
93 symbol, if any. @code{static} symbols are special and are handled by
94 setting the second word in the .non_lazy_symbol_pointer data
95 structure to symbol. See indirect_data for the code that handles
96 the extra indirection, and machopic_output_indirection and its use
97 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
98 symbol indirection. */
100 /* For darwin >= 9 (OSX 10.5) the linker is capable of making the necessary
101 branch islands and we no longer need to emit darwin stubs.
102 However, if we are generating code for earlier systems (or for use in the
103 kernel) the stubs might still be required, and this will be set true. */
104 int darwin_emit_branch_islands
= false;
106 typedef struct GTY(()) cdtor_record
{
108 int priority
; /* [con/de]structor priority */
109 int position
; /* original position */
112 static GTY(()) vec
<cdtor_record
, va_gc
> *ctors
= NULL
;
113 static GTY(()) vec
<cdtor_record
, va_gc
> *dtors
= NULL
;
115 /* A flag to determine whether we are running c++ or obj-c++. This has to be
116 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
118 int darwin_running_cxx
;
120 /* Some code-gen now depends on OS major version numbers (at least). */
121 int generating_for_darwin_version
;
124 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
126 /* While we transition to using in-tests instead of ifdef'd code. */
128 #define gen_macho_high(a,b) (a)
129 #define gen_macho_low(a,b,c) (a)
132 /* True if we're setting __attribute__ ((ms_struct)). */
133 int darwin_ms_struct
= false;
135 /* Earlier versions of Darwin as do not recognize an alignment field in
136 .comm directives, this should be set for versions that allow it. */
137 int emit_aligned_common
= false;
139 /* A get_unnamed_section callback used to switch to an ObjC section.
140 DIRECTIVE is as for output_section_asm_op. */
143 output_objc_section_asm_op (const void *directive
)
145 static bool been_here
= false;
147 /* The NeXT ObjC Runtime requires these sections to be present and in
148 order in the object. The code below implements this by emitting
149 a section header for each ObjC section the first time that an ObjC
150 section is requested. */
153 section
*saved_in_section
= in_section
;
154 static const enum darwin_section_enum tomark
[] =
156 /* written, cold -> hot */
157 objc_cat_cls_meth_section
,
158 objc_cat_inst_meth_section
,
159 objc_string_object_section
,
160 objc_constant_string_object_section
,
161 objc_selector_refs_section
,
162 objc_selector_fixup_section
,
163 objc_cls_refs_section
,
165 objc_meta_class_section
,
166 /* shared, hot -> cold */
167 objc_cls_meth_section
,
168 objc_inst_meth_section
,
169 objc_protocol_section
,
170 objc_class_names_section
,
171 objc_meth_var_types_section
,
172 objc_meth_var_names_section
,
173 objc_category_section
,
174 objc_class_vars_section
,
175 objc_instance_vars_section
,
176 objc_module_info_section
,
177 objc_symbols_section
,
180 static const enum darwin_section_enum tomarkv1
[] =
182 objc1_protocol_ext_section
,
183 objc1_class_ext_section
,
184 objc1_prop_list_section
187 static const enum darwin_section_enum tomarkv2
[] =
189 objc2_message_refs_section
,
190 objc2_classdefs_section
,
191 objc2_metadata_section
,
192 objc2_classrefs_section
,
193 objc2_classlist_section
,
194 objc2_categorylist_section
,
195 objc2_selector_refs_section
,
196 objc2_nonlazy_class_section
,
197 objc2_nonlazy_category_section
,
198 objc2_protocollist_section
,
199 objc2_protocolrefs_section
,
200 objc2_super_classrefs_section
,
201 objc2_image_info_section
,
202 objc2_constant_string_object_section
207 if (flag_objc_abi
< 2)
209 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
210 switch_to_section (darwin_sections
[tomark
[i
]]);
211 if (flag_objc_abi
== 1)
212 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
213 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
216 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
217 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
218 /* Make sure we don't get varasm.c out of sync with us. */
219 switch_to_section (saved_in_section
);
221 output_section_asm_op (directive
);
225 /* Private flag applied to disable section-anchors in a particular section. */
226 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
229 /* Implement TARGET_ASM_INIT_SECTIONS. */
232 darwin_init_sections (void)
234 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
235 darwin_sections[NAME] = \
236 get_unnamed_section (FLAGS, (OBJC \
237 ? output_objc_section_asm_op \
238 : output_section_asm_op), \
240 #include "config/darwin-sections.def"
243 readonly_data_section
= darwin_sections
[const_section
];
244 exception_section
= darwin_sections
[darwin_exception_section
];
245 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
249 name_needs_quotes (const char *name
)
252 while ((c
= *name
++) != '\0')
254 && c
!= '.' && c
!= '$' && c
!= '_' )
259 /* Return true if SYM_REF can be used without an indirection. */
261 machopic_symbol_defined_p (rtx sym_ref
)
263 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
266 /* If a symbol references local and is not an extern to this
267 file, then the symbol might be able to declared as defined. */
268 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
270 /* If the symbol references a variable and the variable is a
271 common symbol, then this symbol is not defined. */
272 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
274 tree decl
= SYMBOL_REF_DECL (sym_ref
);
277 if (DECL_COMMON (decl
))
285 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
286 reference, which will not be changed. */
288 enum machopic_addr_class
289 machopic_classify_symbol (rtx sym_ref
)
293 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
294 if (machopic_symbol_defined_p (sym_ref
))
296 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
299 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
302 #ifndef TARGET_FIX_AND_CONTINUE
303 #define TARGET_FIX_AND_CONTINUE 0
306 /* Indicate when fix-and-continue style code generation is being used
307 and when a reference to data should be indirected so that it can be
308 rebound in a new translation unit to reference the original instance
309 of that data. Symbol names that are for code generation local to
310 the translation unit are bound to the new translation unit;
311 currently this means symbols that begin with L or _OBJC_;
312 otherwise, we indicate that an indirect reference should be made to
313 permit the runtime to rebind new instances of the translation unit
314 to the original instance of the data. */
317 indirect_data (rtx sym_ref
)
322 /* If we aren't generating fix-and-continue code, don't do anything
324 if (TARGET_FIX_AND_CONTINUE
== 0)
327 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
328 are indirected. Symbols that begin with L and _OBJC_ are always
329 bound to the current translation unit as they are used for
330 generated local data of the translation unit. */
332 name
= XSTR (sym_ref
, 0);
334 lprefix
= (((name
[0] == '*' || name
[0] == '&')
335 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
336 || (strncmp (name
, "_OBJC_", 6) == 0));
342 machopic_data_defined_p (rtx sym_ref
)
344 if (indirect_data (sym_ref
))
347 switch (machopic_classify_symbol (sym_ref
))
349 case MACHOPIC_DEFINED_DATA
:
350 case MACHOPIC_DEFINED_FUNCTION
:
358 machopic_define_symbol (rtx mem
)
362 gcc_assert (GET_CODE (mem
) == MEM
);
363 sym_ref
= XEXP (mem
, 0);
364 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
367 /* Return either ORIG or:
369 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
371 depending on MACHO_DYNAMIC_NO_PIC_P. */
373 machopic_gen_offset (rtx orig
)
375 if (MACHO_DYNAMIC_NO_PIC_P
)
379 /* Play games to avoid marking the function as needing pic if we
380 are being called as part of the cost-estimation process. */
381 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
382 crtl
->uses_pic_offset_table
= 1;
383 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
384 UNSPEC_MACHOPIC_OFFSET
);
385 return gen_rtx_CONST (Pmode
, orig
);
389 static GTY(()) const char * function_base_func_name
;
390 static GTY(()) int current_pic_label_num
;
391 static GTY(()) int emitted_pic_label_num
;
394 update_pic_label_number_if_needed (void)
396 const char *current_name
;
398 /* When we are generating _get_pc thunks within stubs, there is no current
400 if (current_function_decl
)
403 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
404 if (function_base_func_name
!= current_name
)
406 ++current_pic_label_num
;
407 function_base_func_name
= current_name
;
412 ++current_pic_label_num
;
413 function_base_func_name
= "L_machopic_stub_dummy";
418 machopic_output_function_base_name (FILE *file
)
420 /* If dynamic-no-pic is on, we should not get here. */
421 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
423 update_pic_label_number_if_needed ();
424 fprintf (file
, "L%d$pb", current_pic_label_num
);
427 char curr_picbasename
[32];
430 machopic_get_function_picbase (void)
432 /* If dynamic-no-pic is on, we should not get here. */
433 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
435 update_pic_label_number_if_needed ();
436 snprintf (curr_picbasename
, 32, "L%d$pb", current_pic_label_num
);
437 return (const char *) curr_picbasename
;
441 machopic_should_output_picbase_label (void)
443 update_pic_label_number_if_needed ();
445 if (current_pic_label_num
== emitted_pic_label_num
)
448 emitted_pic_label_num
= current_pic_label_num
;
452 /* The suffix attached to non-lazy pointer symbols. */
453 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
454 /* The suffix attached to stub symbols. */
455 #define STUB_SUFFIX "$stub"
457 typedef struct GTY ((for_user
)) machopic_indirection
459 /* The SYMBOL_REF for the entity referenced. */
461 /* The name of the stub or non-lazy pointer. */
462 const char * ptr_name
;
463 /* True iff this entry is for a stub (as opposed to a non-lazy
466 /* True iff this stub or pointer has been referenced. */
468 } machopic_indirection
;
470 struct indirection_hasher
: ggc_ptr_hash
<machopic_indirection
>
472 typedef const char *compare_type
;
473 static hashval_t
hash (machopic_indirection
*);
474 static bool equal (machopic_indirection
*, const char *);
477 /* A table mapping stub names and non-lazy pointer names to
478 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
480 static GTY (()) hash_table
<indirection_hasher
> *machopic_indirections
;
482 /* Return a hash value for a SLOT in the indirections hash table. */
485 indirection_hasher::hash (machopic_indirection
*p
)
487 return htab_hash_string (p
->ptr_name
);
490 /* Returns true if the KEY is the same as that associated with
494 indirection_hasher::equal (machopic_indirection
*s
, const char *k
)
496 return strcmp (s
->ptr_name
, k
) == 0;
499 /* Return the name of the non-lazy pointer (if STUB_P is false) or
500 stub (if STUB_B is true) corresponding to the given name. */
503 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
506 const char *name
= XSTR (sym_ref
, 0);
507 size_t namelen
= strlen (name
);
508 machopic_indirection
*p
;
511 const char *prefix
= user_label_prefix
;
512 const char *quote
= "";
515 id
= maybe_get_identifier (name
);
520 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
521 id
= TREE_CHAIN (id
);
524 name
= IDENTIFIER_POINTER (id
);
525 namelen
= strlen (name
);
536 needs_quotes
= name_needs_quotes (name
);
543 suffix
= STUB_SUFFIX
;
545 suffix
= NON_LAZY_POINTER_SUFFIX
;
547 buffer
= XALLOCAVEC (char, strlen ("&L")
554 /* Construct the name of the non-lazy pointer or stub. */
555 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
557 if (!machopic_indirections
)
558 machopic_indirections
= hash_table
<indirection_hasher
>::create_ggc (37);
560 machopic_indirection
**slot
561 = machopic_indirections
->find_slot_with_hash (buffer
,
562 htab_hash_string (buffer
),
570 p
= ggc_alloc
<machopic_indirection
> ();
572 p
->ptr_name
= xstrdup (buffer
);
581 /* Return the name of the stub for the mcount function. */
584 machopic_mcount_stub_name (void)
586 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
587 return machopic_indirection_name (symbol
, /*stub_p=*/true);
590 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
591 or non-lazy pointer as used -- and mark the object to which the
592 pointer/stub refers as used as well, since the pointer/stub will
593 emit a reference to it. */
596 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
598 machopic_indirection
*p
599 = machopic_indirections
->find_with_hash (name
, htab_hash_string (name
));
602 const char *real_name
;
607 /* Do what output_addr_const will do when we actually call it. */
608 if (SYMBOL_REF_DECL (p
->symbol
))
609 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
611 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
613 id
= maybe_get_identifier (real_name
);
615 mark_referenced (id
);
619 /* Transform ORIG, which may be any data source, to the corresponding
620 source using indirections. */
623 machopic_indirect_data_reference (rtx orig
, rtx reg
)
627 if (! MACHOPIC_INDIRECT
)
630 if (GET_CODE (orig
) == SYMBOL_REF
)
632 int defined
= machopic_data_defined_p (orig
);
634 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
638 /* Create a new register for CSE opportunities. */
639 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
640 emit_insn (gen_macho_high (hi_reg
, orig
));
641 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
647 /* some other cpu -- writeme! */
653 if (DARWIN_PPC
|| HAVE_lo_sum
)
654 offset
= machopic_gen_offset (orig
);
658 rtx hi_sum_reg
= (!can_create_pseudo_p ()
660 : gen_reg_rtx (Pmode
));
664 emit_insn (gen_rtx_SET (hi_sum_reg
,
665 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
666 gen_rtx_HIGH (Pmode
, offset
))));
667 emit_insn (gen_rtx_SET (reg
,
668 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
669 copy_rtx (offset
))));
673 else if (HAVE_lo_sum
)
677 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
678 emit_insn (gen_rtx_SET (reg
, gen_rtx_LO_SUM (Pmode
, reg
,
679 copy_rtx (offset
))));
680 emit_use (pic_offset_table_rtx
);
682 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
687 ptr_ref
= (gen_rtx_SYMBOL_REF
689 machopic_indirection_name (orig
, /*stub_p=*/false)));
691 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
693 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
694 machopic_define_symbol (ptr_ref
);
698 && MACHO_DYNAMIC_NO_PIC_P
)
700 emit_insn (gen_rtx_SET (reg
, ptr_ref
));
706 else if (GET_CODE (orig
) == CONST
)
708 /* If "(const (plus ...", walk the PLUS and return that result.
709 PLUS processing (below) will restore the "(const ..." if
711 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
712 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
716 else if (GET_CODE (orig
) == MEM
)
719 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
722 else if (GET_CODE (orig
) == PLUS
)
725 /* When the target is i386, this code prevents crashes due to the
726 compiler's ignorance on how to move the PIC base register to
727 other registers. (The reload phase sometimes introduces such
729 if (GET_CODE (XEXP (orig
, 0)) == REG
730 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
731 /* Prevent the same register from being erroneously used
732 as both the base and index registers. */
733 && (DARWIN_X86
&& (GET_CODE (XEXP (orig
, 1)) == CONST
))
736 emit_move_insn (reg
, XEXP (orig
, 0));
737 XEXP (ptr_ref
, 0) = reg
;
741 /* Legitimize both operands of the PLUS. */
742 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
743 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
744 (base
== reg
? 0 : reg
));
745 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
746 result
= plus_constant (Pmode
, base
, INTVAL (orig
));
748 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
750 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
754 emit_move_insn (reg
, result
);
759 result
= force_reg (GET_MODE (result
), result
);
768 /* Transform TARGET (a MEM), which is a function call target, to the
769 corresponding symbol_stub if necessary. Return a new MEM. */
772 machopic_indirect_call_target (rtx target
)
774 if (! darwin_emit_branch_islands
)
777 if (GET_CODE (target
) != MEM
)
780 if (MACHOPIC_INDIRECT
781 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
782 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
783 & MACHO_SYMBOL_FLAG_DEFINED
))
785 rtx sym_ref
= XEXP (target
, 0);
786 const char *stub_name
= machopic_indirection_name (sym_ref
,
788 machine_mode mode
= GET_MODE (sym_ref
);
790 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
791 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
792 MEM_READONLY_P (target
) = 1;
793 MEM_NOTRAP_P (target
) = 1;
800 machopic_legitimize_pic_address (rtx orig
, machine_mode mode
, rtx reg
)
804 if (! MACHOPIC_INDIRECT
)
807 /* First handle a simple SYMBOL_REF or LABEL_REF */
808 if (GET_CODE (orig
) == LABEL_REF
809 || (GET_CODE (orig
) == SYMBOL_REF
812 /* addr(foo) = &func+(foo-func) */
813 orig
= machopic_indirect_data_reference (orig
, reg
);
815 if (GET_CODE (orig
) == PLUS
816 && GET_CODE (XEXP (orig
, 0)) == REG
)
819 return force_reg (mode
, orig
);
821 emit_move_insn (reg
, orig
);
825 if (GET_CODE (orig
) == MEM
)
829 gcc_assert (!reload_in_progress
);
830 reg
= gen_reg_rtx (Pmode
);
834 if (MACHO_DYNAMIC_NO_PIC_P
835 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
836 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
838 #if defined (TARGET_TOC) /* ppc */
839 rtx temp_reg
= (!can_create_pseudo_p ()
841 gen_reg_rtx (Pmode
));
842 rtx asym
= XEXP (orig
, 0);
845 emit_insn (gen_macho_high (temp_reg
, asym
));
846 mem
= gen_const_mem (GET_MODE (orig
),
847 gen_rtx_LO_SUM (Pmode
, temp_reg
,
849 emit_insn (gen_rtx_SET (reg
, mem
));
851 /* Some other CPU -- WriteMe! but right now there are no other
852 platforms that can use dynamic-no-pic */
858 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
859 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
861 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
862 #if defined (TARGET_TOC) /* i.e., PowerPC */
863 /* Generating a new reg may expose opportunities for
864 common subexpression elimination. */
865 rtx hi_sum_reg
= (!can_create_pseudo_p ()
867 : gen_reg_rtx (Pmode
));
872 sum
= gen_rtx_HIGH (Pmode
, offset
);
873 if (! MACHO_DYNAMIC_NO_PIC_P
)
874 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
876 emit_insn (gen_rtx_SET (hi_sum_reg
, sum
));
878 mem
= gen_const_mem (GET_MODE (orig
),
879 gen_rtx_LO_SUM (Pmode
,
882 insn
= emit_insn (gen_rtx_SET (reg
, mem
));
883 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
887 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
889 emit_insn (gen_rtx_SET (reg
,
891 gen_rtx_CONST (Pmode
,
893 emit_insn (gen_rtx_SET (reg
,
894 gen_rtx_LO_SUM (Pmode
, reg
,
895 gen_rtx_CONST (Pmode
,
896 copy_rtx (offset
)))));
897 pic_ref
= gen_rtx_PLUS (Pmode
,
898 pic_offset_table_rtx
, reg
);
902 #endif /* HAVE_lo_sum */
904 rtx pic
= pic_offset_table_rtx
;
905 if (GET_CODE (pic
) != REG
)
907 emit_move_insn (reg
, pic
);
911 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
914 if (reload_in_progress
)
915 df_set_regs_ever_live (REGNO (pic
), true);
916 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
917 machopic_gen_offset (XEXP (orig
, 0)));
920 #if !defined (TARGET_TOC)
921 emit_move_insn (reg
, pic_ref
);
922 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
929 if (GET_CODE (orig
) == SYMBOL_REF
930 || GET_CODE (orig
) == LABEL_REF
)
932 rtx offset
= machopic_gen_offset (orig
);
933 #if defined (TARGET_TOC) /* i.e., PowerPC */
938 gcc_assert (!reload_in_progress
);
939 reg
= gen_reg_rtx (Pmode
);
944 emit_insn (gen_rtx_SET (hi_sum_reg
,
945 (MACHO_DYNAMIC_NO_PIC_P
)
946 ? gen_rtx_HIGH (Pmode
, offset
)
947 : gen_rtx_PLUS (Pmode
,
948 pic_offset_table_rtx
,
951 emit_insn (gen_rtx_SET (reg
,
952 gen_rtx_LO_SUM (Pmode
,
954 copy_rtx (offset
))));
957 emit_insn (gen_rtx_SET (reg
, gen_rtx_HIGH (Pmode
, offset
)));
958 emit_insn (gen_rtx_SET (reg
,
959 gen_rtx_LO_SUM (Pmode
, reg
,
960 copy_rtx (offset
))));
961 pic_ref
= gen_rtx_PLUS (Pmode
,
962 pic_offset_table_rtx
, reg
);
966 #endif /* HAVE_lo_sum */
969 || GET_CODE (orig
) == SUBREG
)
975 rtx pic
= pic_offset_table_rtx
;
976 if (GET_CODE (pic
) != REG
)
978 emit_move_insn (reg
, pic
);
982 emit_use (pic_offset_table_rtx
);
984 if (reload_in_progress
)
985 df_set_regs_ever_live (REGNO (pic
), true);
986 pic_ref
= gen_rtx_PLUS (Pmode
,
988 machopic_gen_offset (orig
));
993 if (GET_CODE (pic_ref
) != REG
)
997 emit_move_insn (reg
, pic_ref
);
1002 return force_reg (mode
, pic_ref
);
1011 else if (GET_CODE (orig
) == SYMBOL_REF
)
1014 else if (GET_CODE (orig
) == PLUS
1015 && (GET_CODE (XEXP (orig
, 0)) == MEM
1016 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
1017 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
1018 && XEXP (orig
, 0) != pic_offset_table_rtx
1019 && GET_CODE (XEXP (orig
, 1)) != REG
)
1023 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
1025 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1026 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
1027 Pmode
, (base
== reg
? 0 : reg
));
1028 if (GET_CODE (orig
) == CONST_INT
)
1030 pic_ref
= plus_constant (Pmode
, base
, INTVAL (orig
));
1034 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
1036 if (reg
&& is_complex
)
1038 emit_move_insn (reg
, pic_ref
);
1041 /* Likewise, should we set special REG_NOTEs here? */
1044 else if (GET_CODE (orig
) == CONST
)
1046 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1049 else if (GET_CODE (orig
) == MEM
1050 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
1052 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1053 addr
= replace_equiv_address (orig
, addr
);
1054 emit_move_insn (reg
, addr
);
1061 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
1062 DATA is the FILE* for assembly output. Called from
1066 machopic_output_indirection (machopic_indirection
**slot
, FILE *asm_out_file
)
1068 machopic_indirection
*p
= *slot
;
1070 const char *sym_name
;
1071 const char *ptr_name
;
1077 sym_name
= XSTR (symbol
, 0);
1078 ptr_name
= p
->ptr_name
;
1086 id
= maybe_get_identifier (sym_name
);
1091 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1092 id
= TREE_CHAIN (id
);
1094 sym_name
= IDENTIFIER_POINTER (id
);
1097 sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1098 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1099 strcpy (sym
, sym_name
+ 1);
1100 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1101 strcpy (sym
, sym_name
);
1103 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1105 stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1106 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1107 strcpy (stub
, ptr_name
+ 1);
1109 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1111 machopic_output_stub (asm_out_file
, sym
, stub
);
1113 else if (! indirect_data (symbol
)
1114 && (machopic_symbol_defined_p (symbol
)
1115 || SYMBOL_REF_LOCAL_P (symbol
)))
1117 switch_to_section (data_section
);
1118 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1119 assemble_label (asm_out_file
, ptr_name
);
1120 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1121 GET_MODE_SIZE (Pmode
),
1122 GET_MODE_ALIGNMENT (Pmode
), 1);
1126 rtx init
= const0_rtx
;
1128 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1130 /* Mach-O symbols are passed around in code through indirect
1131 references and the original symbol_ref hasn't passed through
1132 the generic handling and reference-catching in
1133 output_operand, so we need to manually mark weak references
1135 if (SYMBOL_REF_WEAK (symbol
))
1137 tree decl
= SYMBOL_REF_DECL (symbol
);
1138 gcc_assert (DECL_P (decl
));
1140 if (decl
!= NULL_TREE
1141 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1142 /* Handle only actual external-only definitions, not
1143 e.g. extern inline code or variables for which
1144 storage has been allocated. */
1145 && !TREE_STATIC (decl
))
1147 fputs ("\t.weak_reference ", asm_out_file
);
1148 assemble_name (asm_out_file
, sym_name
);
1149 fputc ('\n', asm_out_file
);
1153 assemble_name (asm_out_file
, ptr_name
);
1154 fprintf (asm_out_file
, ":\n");
1156 fprintf (asm_out_file
, "\t.indirect_symbol ");
1157 assemble_name (asm_out_file
, sym_name
);
1158 fprintf (asm_out_file
, "\n");
1160 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1161 have their symbol name instead of 0 in the second entry of
1162 the non-lazy symbol pointer data structure when they are
1163 defined. This allows the runtime to rebind newer instances
1164 of the translation unit with the original instance of the
1167 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1168 && machopic_symbol_defined_p (symbol
))
1169 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1171 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1172 GET_MODE_ALIGNMENT (Pmode
), 1);
1179 machopic_finish (FILE *asm_out_file
)
1181 if (machopic_indirections
)
1182 machopic_indirections
1183 ->traverse_noresize
<FILE *, machopic_output_indirection
> (asm_out_file
);
1187 machopic_operand_p (rtx op
)
1189 if (MACHOPIC_JUST_INDIRECT
)
1190 return (GET_CODE (op
) == SYMBOL_REF
1191 && machopic_symbol_defined_p (op
));
1193 return (GET_CODE (op
) == CONST
1194 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1195 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1198 /* This function records whether a given name corresponds to a defined
1199 or undefined function or variable, for machopic_classify_ident to
1203 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1207 /* Do the standard encoding things first. */
1208 default_encode_section_info (decl
, rtl
, first
);
1210 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1213 sym_ref
= XEXP (rtl
, 0);
1214 if (TREE_CODE (decl
) == VAR_DECL
)
1215 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1217 if (!DECL_EXTERNAL (decl
)
1218 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1219 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1220 && ((TREE_STATIC (decl
)
1221 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1222 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1223 && DECL_INITIAL (decl
) != error_mark_node
)))
1224 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1226 if (! TREE_PUBLIC (decl
))
1227 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1231 darwin_mark_decl_preserved (const char *name
)
1233 /* Actually we shouldn't mark any local symbol this way, but for now
1234 this only happens with ObjC meta-data. */
1235 if (darwin_label_is_anonymous_local_objc_name (name
))
1238 fprintf (asm_out_file
, "\t.no_dead_strip ");
1239 assemble_name (asm_out_file
, name
);
1240 fputc ('\n', asm_out_file
);
1244 darwin_rodata_section (int weak
, bool zsize
)
1247 ? darwin_sections
[const_coal_section
]
1248 : (zsize
? darwin_sections
[zobj_const_section
]
1249 : darwin_sections
[const_section
]));
1253 darwin_mergeable_string_section (tree exp
,
1254 unsigned HOST_WIDE_INT align
)
1256 /* Darwin's ld expects to see non-writable string literals in the .cstring
1257 section. Later versions of ld check and complain when CFStrings are
1258 enabled. Therefore we shall force the strings into .cstring since we
1259 don't support writable ones anyway. */
1260 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1261 && TREE_CODE (exp
) == STRING_CST
1262 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1264 && (int_size_in_bytes (TREE_TYPE (exp
))
1265 == TREE_STRING_LENGTH (exp
))
1266 && ((size_t) TREE_STRING_LENGTH (exp
)
1267 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1268 return darwin_sections
[cstring_section
];
1270 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1271 && TREE_CODE (exp
) == STRING_CST
1272 && TREE_STRING_LENGTH (exp
) == 0)
1273 return darwin_sections
[zobj_const_section
];
1275 return readonly_data_section
;
1278 #ifndef HAVE_GAS_LITERAL16
1279 #define HAVE_GAS_LITERAL16 0
1283 darwin_mergeable_constant_section (tree exp
,
1284 unsigned HOST_WIDE_INT align
,
1287 machine_mode mode
= DECL_MODE (exp
);
1288 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1290 if (DARWIN_SECTION_ANCHORS
1291 && flag_section_anchors
1293 return darwin_sections
[zobj_const_section
];
1295 if (flag_merge_constants
1298 && modesize
<= align
1301 && (align
& (align
-1)) == 0)
1303 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1305 if (TREE_CODE (size
) == INTEGER_CST
)
1307 if (wi::eq_p (size
, 4))
1308 return darwin_sections
[literal4_section
];
1309 else if (wi::eq_p (size
, 8))
1310 return darwin_sections
[literal8_section
];
1311 else if (HAVE_GAS_LITERAL16
1313 && wi::eq_p (size
, 16))
1314 return darwin_sections
[literal16_section
];
1318 return readonly_data_section
;
1322 darwin_tm_clone_table_section (void)
1324 return get_named_section (NULL
,
1325 "__DATA,__tm_clone_table,regular,no_dead_strip",
1330 machopic_reloc_rw_mask (void)
1332 return MACHOPIC_INDIRECT
? 3 : 0;
1335 /* We have to deal with ObjC/C++ metadata section placement in the common
1336 code, since it will also be called from LTO.
1338 Return metadata attributes, if present (searching for ABI=2 first)
1339 Return NULL_TREE if no such attributes are found. */
1342 is_objc_metadata (tree decl
)
1345 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1346 && DECL_ATTRIBUTES (decl
))
1348 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1351 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1358 static int classes_seen
;
1359 static int objc_metadata_seen
;
1361 /* Return the section required for Objective C ABI 2 metadata. */
1363 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1366 tree ident
= TREE_VALUE (meta
);
1367 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1368 p
= IDENTIFIER_POINTER (ident
);
1370 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
== 2);
1372 objc_metadata_seen
= 1;
1374 if (base
== data_section
)
1375 base
= darwin_sections
[objc2_metadata_section
];
1377 /* Most of the OBJC2 META-data end up in the base section, so check it
1379 if (!strncmp (p
, "V2_BASE", 7))
1381 else if (!strncmp (p
, "V2_STRG", 7))
1382 return darwin_sections
[cstring_section
];
1384 else if (!strncmp (p
, "G2_META", 7) || !strncmp (p
, "G2_CLAS", 7))
1385 return darwin_sections
[objc2_classdefs_section
];
1386 else if (!strncmp (p
, "V2_MREF", 7))
1387 return darwin_sections
[objc2_message_refs_section
];
1388 else if (!strncmp (p
, "V2_CLRF", 7))
1389 return darwin_sections
[objc2_classrefs_section
];
1390 else if (!strncmp (p
, "V2_SURF", 7))
1391 return darwin_sections
[objc2_super_classrefs_section
];
1392 else if (!strncmp (p
, "V2_NLCL", 7))
1393 return darwin_sections
[objc2_nonlazy_class_section
];
1394 else if (!strncmp (p
, "V2_CLAB", 7))
1397 return darwin_sections
[objc2_classlist_section
];
1399 else if (!strncmp (p
, "V2_SRFS", 7))
1400 return darwin_sections
[objc2_selector_refs_section
];
1401 else if (!strncmp (p
, "V2_NLCA", 7))
1402 return darwin_sections
[objc2_nonlazy_category_section
];
1403 else if (!strncmp (p
, "V2_CALA", 7))
1404 return darwin_sections
[objc2_categorylist_section
];
1406 else if (!strncmp (p
, "V2_PLST", 7))
1407 return darwin_sections
[objc2_protocollist_section
];
1408 else if (!strncmp (p
, "V2_PRFS", 7))
1409 return darwin_sections
[objc2_protocolrefs_section
];
1411 else if (!strncmp (p
, "V2_INFO", 7))
1412 return darwin_sections
[objc2_image_info_section
];
1414 else if (!strncmp (p
, "V2_EHTY", 7))
1415 return darwin_sections
[data_coal_section
];
1417 else if (!strncmp (p
, "V2_CSTR", 7))
1418 return darwin_sections
[objc2_constant_string_object_section
];
1420 /* Not recognized, default. */
1424 /* Return the section required for Objective C ABI 0/1 metadata. */
1426 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1429 tree ident
= TREE_VALUE (meta
);
1430 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1431 p
= IDENTIFIER_POINTER (ident
);
1433 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
< 2);
1435 objc_metadata_seen
= 1;
1437 /* String sections first, cos there are lots of strings. */
1438 if (!strncmp (p
, "V1_STRG", 7))
1439 return darwin_sections
[cstring_section
];
1440 else if (!strncmp (p
, "V1_CLSN", 7))
1441 return darwin_sections
[objc_class_names_section
];
1442 else if (!strncmp (p
, "V1_METN", 7))
1443 return darwin_sections
[objc_meth_var_names_section
];
1444 else if (!strncmp (p
, "V1_METT", 7))
1445 return darwin_sections
[objc_meth_var_types_section
];
1447 else if (!strncmp (p
, "V1_CLAS", 7))
1450 return darwin_sections
[objc_class_section
];
1452 else if (!strncmp (p
, "V1_META", 7))
1453 return darwin_sections
[objc_meta_class_section
];
1454 else if (!strncmp (p
, "V1_CATG", 7))
1455 return darwin_sections
[objc_category_section
];
1456 else if (!strncmp (p
, "V1_PROT", 7))
1457 return darwin_sections
[objc_protocol_section
];
1459 else if (!strncmp (p
, "V1_CLCV", 7))
1460 return darwin_sections
[objc_class_vars_section
];
1461 else if (!strncmp (p
, "V1_CLIV", 7))
1462 return darwin_sections
[objc_instance_vars_section
];
1464 else if (!strncmp (p
, "V1_CLCM", 7))
1465 return darwin_sections
[objc_cls_meth_section
];
1466 else if (!strncmp (p
, "V1_CLIM", 7))
1467 return darwin_sections
[objc_inst_meth_section
];
1468 else if (!strncmp (p
, "V1_CACM", 7))
1469 return darwin_sections
[objc_cat_cls_meth_section
];
1470 else if (!strncmp (p
, "V1_CAIM", 7))
1471 return darwin_sections
[objc_cat_inst_meth_section
];
1472 else if (!strncmp (p
, "V1_PNSM", 7))
1473 return darwin_sections
[objc_cat_inst_meth_section
];
1474 else if (!strncmp (p
, "V1_PCLM", 7))
1475 return darwin_sections
[objc_cat_cls_meth_section
];
1477 else if (!strncmp (p
, "V1_CLPR", 7))
1478 return darwin_sections
[objc_cat_cls_meth_section
];
1479 else if (!strncmp (p
, "V1_CAPR", 7))
1480 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1482 else if (!strncmp (p
, "V1_PRFS", 7))
1483 return darwin_sections
[objc_cat_cls_meth_section
];
1484 else if (!strncmp (p
, "V1_CLRF", 7))
1485 return darwin_sections
[objc_cls_refs_section
];
1486 else if (!strncmp (p
, "V1_SRFS", 7))
1487 return darwin_sections
[objc_selector_refs_section
];
1489 else if (!strncmp (p
, "V1_MODU", 7))
1490 return darwin_sections
[objc_module_info_section
];
1491 else if (!strncmp (p
, "V1_SYMT", 7))
1492 return darwin_sections
[objc_symbols_section
];
1493 else if (!strncmp (p
, "V1_INFO", 7))
1494 return darwin_sections
[objc_image_info_section
];
1496 else if (!strncmp (p
, "V1_PLST", 7))
1497 return darwin_sections
[objc1_prop_list_section
];
1498 else if (!strncmp (p
, "V1_PEXT", 7))
1499 return darwin_sections
[objc1_protocol_ext_section
];
1500 else if (!strncmp (p
, "V1_CEXT", 7))
1501 return darwin_sections
[objc1_class_ext_section
];
1503 else if (!strncmp (p
, "V2_CSTR", 7))
1504 return darwin_sections
[objc_constant_string_object_section
];
1510 machopic_select_section (tree decl
,
1512 unsigned HOST_WIDE_INT align
)
1514 bool zsize
, one
, weak
, ro
;
1515 section
*base_section
= NULL
;
1517 weak
= (DECL_P (decl
)
1519 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1521 zsize
= (DECL_P (decl
)
1522 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1523 && tree_to_uhwi (DECL_SIZE_UNIT (decl
)) == 0);
1526 && TREE_CODE (decl
) == VAR_DECL
1527 && DECL_COMDAT_GROUP (decl
);
1529 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1531 switch (categorize_decl_for_section (decl
, reloc
))
1538 case SECCAT_SRODATA
:
1539 base_section
= darwin_rodata_section (weak
, zsize
);
1542 case SECCAT_RODATA_MERGE_STR
:
1543 base_section
= darwin_mergeable_string_section (decl
, align
);
1546 case SECCAT_RODATA_MERGE_STR_INIT
:
1547 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1550 case SECCAT_RODATA_MERGE_CONST
:
1551 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1555 case SECCAT_DATA_REL
:
1556 case SECCAT_DATA_REL_LOCAL
:
1557 case SECCAT_DATA_REL_RO
:
1558 case SECCAT_DATA_REL_RO_LOCAL
:
1564 base_section
= darwin_sections
[const_data_coal_section
];
1566 base_section
= darwin_sections
[data_coal_section
];
1568 else if (DARWIN_SECTION_ANCHORS
1569 && flag_section_anchors
1572 /* If we're doing section anchors, then punt zero-sized objects into
1573 their own sections so that they don't interfere with offset
1574 computation for the remaining vars. This does not need to be done
1575 for stuff in mergeable sections, since these are ineligible for
1578 base_section
= darwin_sections
[zobj_const_data_section
];
1580 base_section
= darwin_sections
[zobj_data_section
];
1583 base_section
= darwin_sections
[const_data_section
];
1585 base_section
= data_section
;
1591 base_section
= darwin_sections
[data_coal_section
];
1594 if (!TREE_PUBLIC (decl
))
1595 base_section
= lcomm_section
;
1596 else if (bss_noswitch_section
)
1597 base_section
= bss_noswitch_section
;
1599 base_section
= data_section
;
1607 /* Darwin weird special cases.
1608 a) OBJC Meta-data. */
1610 && (TREE_CODE (decl
) == VAR_DECL
1611 || TREE_CODE (decl
) == CONST_DECL
)
1612 && DECL_ATTRIBUTES (decl
))
1614 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1616 return darwin_objc2_section (decl
, meta
, base_section
);
1617 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1619 return darwin_objc1_section (decl
, meta
, base_section
);
1620 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1622 return base_section
; /* GNU runtime is happy with it all in one pot. */
1625 /* b) Constant string objects. */
1626 if (TREE_CODE (decl
) == CONSTRUCTOR
1628 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1629 && TYPE_NAME (TREE_TYPE (decl
)))
1631 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1632 if (TREE_CODE (name
) == TYPE_DECL
)
1633 name
= DECL_NAME (name
);
1635 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1637 if (flag_next_runtime
)
1639 if (flag_objc_abi
== 2)
1640 return darwin_sections
[objc2_constant_string_object_section
];
1642 return darwin_sections
[objc_constant_string_object_section
];
1645 return darwin_sections
[objc_string_object_section
];
1647 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1648 return darwin_sections
[cfstring_constant_object_section
];
1650 return base_section
;
1652 /* c) legacy meta-data selection. */
1653 else if (TREE_CODE (decl
) == VAR_DECL
1655 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1656 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1657 && flag_next_runtime
1658 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1660 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1661 static bool warned_objc_46
= false;
1662 /* We shall assert that zero-sized objects are an error in ObjC
1664 gcc_assert (tree_to_uhwi (DECL_SIZE_UNIT (decl
)) != 0);
1666 /* ??? This mechanism for determining the metadata section is
1667 broken when LTO is in use, since the frontend that generated
1668 the data is not identified. We will keep the capability for
1669 the short term - in case any non-Objective-C programs are using
1670 it to place data in specified sections. */
1671 if (!warned_objc_46
)
1673 location_t loc
= DECL_SOURCE_LOCATION (decl
);
1674 warning_at (loc
, 0, "the use of _OBJC_-prefixed variable names"
1675 " to select meta-data sections is deprecated at 4.6"
1676 " and will be removed in 4.7");
1677 warned_objc_46
= true;
1680 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1681 return darwin_sections
[objc_cls_meth_section
];
1682 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1683 return darwin_sections
[objc_inst_meth_section
];
1684 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 29))
1685 return darwin_sections
[objc_cat_cls_meth_section
];
1686 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 32))
1687 return darwin_sections
[objc_cat_inst_meth_section
];
1688 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1689 return darwin_sections
[objc_class_vars_section
];
1690 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1691 return darwin_sections
[objc_instance_vars_section
];
1692 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1693 return darwin_sections
[objc_cat_cls_meth_section
];
1694 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1695 return darwin_sections
[objc_class_names_section
];
1696 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1697 return darwin_sections
[objc_meth_var_names_section
];
1698 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1699 return darwin_sections
[objc_meth_var_types_section
];
1700 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1701 return darwin_sections
[objc_cls_refs_section
];
1702 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1703 return darwin_sections
[objc_class_section
];
1704 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1705 return darwin_sections
[objc_meta_class_section
];
1706 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1707 return darwin_sections
[objc_category_section
];
1708 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1709 return darwin_sections
[objc_selector_refs_section
];
1710 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1711 return darwin_sections
[objc_selector_fixup_section
];
1712 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1713 return darwin_sections
[objc_symbols_section
];
1714 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1715 return darwin_sections
[objc_module_info_section
];
1716 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1717 return darwin_sections
[objc_image_info_section
];
1718 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1719 return darwin_sections
[objc_cat_inst_meth_section
];
1720 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1721 return darwin_sections
[objc_cat_cls_meth_section
];
1722 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1723 return darwin_sections
[objc_cat_cls_meth_section
];
1724 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1725 return darwin_sections
[objc_protocol_section
];
1727 return base_section
;
1730 return base_section
;
1733 /* This can be called with address expressions as "rtx".
1734 They must go in "const". */
1737 machopic_select_rtx_section (machine_mode mode
, rtx x
,
1738 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1740 if (GET_MODE_SIZE (mode
) == 8
1741 && (GET_CODE (x
) == CONST_INT
1742 || GET_CODE (x
) == CONST_WIDE_INT
1743 || GET_CODE (x
) == CONST_DOUBLE
))
1744 return darwin_sections
[literal8_section
];
1745 else if (GET_MODE_SIZE (mode
) == 4
1746 && (GET_CODE (x
) == CONST_INT
1747 || GET_CODE (x
) == CONST_WIDE_INT
1748 || GET_CODE (x
) == CONST_DOUBLE
))
1749 return darwin_sections
[literal4_section
];
1750 else if (HAVE_GAS_LITERAL16
1752 && GET_MODE_SIZE (mode
) == 16
1753 && (GET_CODE (x
) == CONST_INT
1754 || GET_CODE (x
) == CONST_WIDE_INT
1755 || GET_CODE (x
) == CONST_DOUBLE
1756 || GET_CODE (x
) == CONST_VECTOR
))
1757 return darwin_sections
[literal16_section
];
1758 else if (MACHOPIC_INDIRECT
1759 && (GET_CODE (x
) == SYMBOL_REF
1760 || GET_CODE (x
) == CONST
1761 || GET_CODE (x
) == LABEL_REF
))
1762 return darwin_sections
[const_data_section
];
1764 return darwin_sections
[const_section
];
1768 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1770 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (ctors
)};
1772 vec_safe_push (ctors
, new_elt
);
1774 if (! MACHOPIC_INDIRECT
)
1775 fprintf (asm_out_file
, ".reference .constructors_used\n");
1779 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1781 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (dtors
)};
1783 vec_safe_push (dtors
, new_elt
);
1785 if (! MACHOPIC_INDIRECT
)
1786 fprintf (asm_out_file
, ".reference .destructors_used\n");
1790 sort_cdtor_records (const void * a
, const void * b
)
1792 const cdtor_record
*cda
= (const cdtor_record
*)a
;
1793 const cdtor_record
*cdb
= (const cdtor_record
*)b
;
1794 if (cda
->priority
> cdb
->priority
)
1796 if (cda
->priority
< cdb
->priority
)
1798 if (cda
->position
> cdb
->position
)
1800 if (cda
->position
< cdb
->position
)
1811 if (MACHOPIC_INDIRECT
)
1812 switch_to_section (darwin_sections
[mod_init_section
]);
1814 switch_to_section (darwin_sections
[constructor_section
]);
1816 if (vec_safe_length (ctors
) > 1)
1817 ctors
->qsort (sort_cdtor_records
);
1818 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
1820 assemble_align (POINTER_SIZE
);
1821 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1831 if (MACHOPIC_INDIRECT
)
1832 switch_to_section (darwin_sections
[mod_term_section
]);
1834 switch_to_section (darwin_sections
[destructor_section
]);
1836 if (vec_safe_length (dtors
) > 1)
1837 dtors
->qsort (sort_cdtor_records
);
1838 FOR_EACH_VEC_SAFE_ELT (dtors
, i
, elt
)
1840 assemble_align (POINTER_SIZE
);
1841 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1846 darwin_globalize_label (FILE *stream
, const char *name
)
1848 if (!!strncmp (name
, "_OBJC_", 6))
1849 default_globalize_label (stream
, name
);
1852 /* This routine returns non-zero if 'name' starts with the special objective-c
1853 anonymous file-scope static name. It accommodates c++'s mangling of such
1854 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1857 darwin_label_is_anonymous_local_objc_name (const char *name
)
1859 const unsigned char *p
= (const unsigned char *) name
;
1862 if (p
[1] == 'Z' && p
[2] == 'L')
1865 while (*p
>= '0' && *p
<= '9')
1868 return (!strncmp ((const char *)p
, "_OBJC_", 6));
1871 /* LTO support for Mach-O.
1873 This version uses three mach-o sections to encapsulate the (unlimited
1874 number of) lto sections.
1876 __GNU_LTO, __lto_sections contains the concatented GNU LTO section data.
1877 __GNU_LTO, __section_names contains the GNU LTO section names.
1878 __GNU_LTO, __section_index contains an array of values that index these.
1881 <section offset from the start of __GNU_LTO, __lto_sections>,
1883 <name offset from the start of __GNU_LTO, __section_names,
1886 At present, for both m32 and m64 mach-o files each of these fields is
1887 represented by a uint32_t. This is because, AFAICT, a mach-o object
1888 cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
1891 "offset An integer specifying the offset to this section in the file." */
1893 /* Count lto section numbers. */
1894 static unsigned int lto_section_num
= 0;
1896 /* A vector of information about LTO sections, at present, we only have
1897 the name. TODO: see if we can get the data length somehow. */
1898 typedef struct GTY (()) darwin_lto_section_e
{
1899 const char *sectname
;
1900 } darwin_lto_section_e
;
1902 static GTY (()) vec
<darwin_lto_section_e
, va_gc
> *lto_section_names
;
1904 /* Section wrapper scheme (used here to wrap the unlimited number of LTO
1905 sections into three Mach-O ones).
1906 NOTE: These names MUST be kept in sync with those in
1907 libiberty/simple-object-mach-o. */
1908 #define LTO_SECTS_SECTION "__wrapper_sects"
1909 #define LTO_NAMES_SECTION "__wrapper_names"
1910 #define LTO_INDEX_SECTION "__wrapper_index"
1912 /* File to temporarily store LTO data. This is appended to asm_out_file
1913 in darwin_end_file. */
1914 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
1915 static char *lto_asm_out_name
;
1917 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
1918 asm_out_file and switching to an alternative output file. */
1920 darwin_asm_lto_start (void)
1922 gcc_assert (! saved_asm_out_file
);
1923 saved_asm_out_file
= asm_out_file
;
1924 if (! lto_asm_out_name
)
1925 lto_asm_out_name
= make_temp_file (".lto.s");
1926 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
1927 if (lto_asm_out_file
== NULL
)
1928 fatal_error (input_location
,
1929 "failed to open temporary file %s for LTO output",
1931 asm_out_file
= lto_asm_out_file
;
1934 /* Restore asm_out_file. */
1936 darwin_asm_lto_end (void)
1938 gcc_assert (saved_asm_out_file
);
1939 fclose (lto_asm_out_file
);
1940 asm_out_file
= saved_asm_out_file
;
1941 saved_asm_out_file
= NULL
;
1945 darwin_asm_dwarf_section (const char *name
, unsigned int flags
, tree decl
);
1947 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
1950 darwin_asm_named_section (const char *name
,
1952 tree decl ATTRIBUTE_UNUSED
)
1954 /* LTO sections go in a special section that encapsulates the (unlimited)
1955 number of GNU LTO sections within a single mach-o one. */
1956 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
1957 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
1959 darwin_lto_section_e e
;
1960 /* We expect certain flags to be set... */
1961 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
1962 == (SECTION_DEBUG
| SECTION_NAMED
));
1964 /* Switch to our combined section. */
1965 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
1966 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
1967 /* Output a label for the start of this sub-section. */
1968 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# %s\n",
1969 lto_section_num
, name
);
1970 /* We have to jump through hoops to get the values of the intra-section
1972 fprintf (asm_out_file
, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
1973 lto_section_num
, lto_section_num
);
1974 fprintf (asm_out_file
,
1975 "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
1976 lto_section_num
, lto_section_num
+1, lto_section_num
);
1978 e
.sectname
= xstrdup (name
);
1979 /* Keep the names, we'll need to make a table later.
1980 TODO: check that we do not revisit sections, that would break
1981 the assumption of how this is done. */
1982 if (lto_section_names
== NULL
)
1983 vec_alloc (lto_section_names
, 16);
1984 vec_safe_push (lto_section_names
, e
);
1986 else if (strncmp (name
, "__DWARF,", 8) == 0)
1987 darwin_asm_dwarf_section (name
, flags
, decl
);
1989 fprintf (asm_out_file
, "\t.section %s\n", name
);
1993 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
1995 /* Darwin does not use unique sections. */
1998 /* Handle __attribute__ ((apple_kext_compatibility)).
1999 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
2000 vtable for classes with this attribute (and their descendants) by not
2001 outputting the new 3.0 nondeleting destructor. This means that such
2002 objects CANNOT be allocated on the stack or as globals UNLESS they have
2003 a completely empty `operator delete'.
2004 Luckily, this fits in with the Darwin kext model.
2006 This attribute also disables gcc3's potential overlaying of derived
2007 class data members on the padding at the end of the base class. */
2010 darwin_handle_kext_attribute (tree
*node
, tree name
,
2011 tree args ATTRIBUTE_UNUSED
,
2012 int flags ATTRIBUTE_UNUSED
,
2015 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
2016 if (! TARGET_KEXTABI
)
2018 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2019 "only when compiling a kext", name
);
2021 *no_add_attrs
= true;
2023 else if (TREE_CODE (*node
) != RECORD_TYPE
)
2025 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2026 "only to C++ classes", name
);
2028 *no_add_attrs
= true;
2034 /* Handle a "weak_import" attribute; arguments as in
2035 struct attribute_spec.handler. */
2038 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
2039 tree
ARG_UNUSED (args
),
2040 int ARG_UNUSED (flags
),
2041 bool * no_add_attrs
)
2043 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
2045 warning (OPT_Wattributes
, "%qE attribute ignored",
2047 *no_add_attrs
= true;
2050 declare_weak (*node
);
2055 /* Emit a label for an FDE, making it global and/or weak if appropriate.
2056 The third parameter is nonzero if this is for exception handling.
2057 The fourth parameter is nonzero if this is just a placeholder for an
2058 FDE that we are omitting. */
2061 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
2065 static int invok_count
= 0;
2066 static tree last_fun_decl
= NULL_TREE
;
2068 /* We use the linker to emit the .eh labels for Darwin 9 and above. */
2069 if (! for_eh
|| generating_for_darwin_version
>= 9)
2072 /* FIXME: This only works when the eh for all sections of a function is
2073 emitted at the same time. If that changes, we would need to use a lookup
2074 table of some form to determine what to do. Also, we should emit the
2075 unadorned label for the partition containing the public label for a
2076 function. This is of limited use, probably, since we do not currently
2077 enable partitioning. */
2078 strcpy (buf
, ".eh");
2079 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
2081 if (decl
== last_fun_decl
)
2084 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
2088 last_fun_decl
= decl
;
2093 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
2095 if (TREE_PUBLIC (decl
))
2097 targetm
.asm_out
.globalize_label (file
, lab
);
2098 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
2100 fputs ("\t.private_extern ", file
);
2101 assemble_name (file
, lab
);
2106 if (DECL_WEAK (decl
))
2108 fputs ("\t.weak_definition ", file
);
2109 assemble_name (file
, lab
);
2113 assemble_name (file
, lab
);
2116 fputs (" = 0\n", file
);
2118 /* Mark the absolute .eh and .eh1 style labels as needed to
2119 ensure that we don't dead code strip them and keep such
2120 labels from another instantiation point until we can fix this
2121 properly with group comdat support. */
2122 darwin_mark_decl_preserved (lab
);
2125 fputs (":\n", file
);
2130 static GTY(()) unsigned long except_table_label_num
;
2133 darwin_emit_except_table_label (FILE *file
)
2135 char section_start_label
[30];
2137 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
2138 except_table_label_num
++);
2139 ASM_OUTPUT_LABEL (file
, section_start_label
);
2141 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2144 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2146 const char *nlp_name
;
2148 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2150 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2151 fputs ("\t.long\t", file
);
2152 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2156 /* If this is uncommented, details of each allocation will be printed
2157 in the asm right before the actual code. WARNING - this will cause some
2158 test-suite fails (since the printout will contain items that some tests
2159 are not expecting) -- so don't leave it on by default (it bloats the
2161 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2163 /* The first two of these routines are ostensibly just intended to put
2164 names into the asm. However, they are both hijacked in order to ensure
2165 that zero-sized items do not make their way into the output. Consequently,
2166 we also need to make these participate in provisions for dealing with
2167 such items in section anchors. */
2169 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2170 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2171 but it does need to be referenced via indirect PIC data pointers.
2172 The machopic_define_symbol calls are telling the machopic subsystem
2173 that the name *is* defined in this module, so it doesn't need to
2174 make them indirect. */
2176 darwin_asm_declare_object_name (FILE *file
,
2177 const char *nam
, tree decl
)
2179 const char *xname
= nam
;
2180 unsigned HOST_WIDE_INT size
;
2181 bool local_def
, weak
;
2183 weak
= (DECL_P (decl
)
2185 && !lookup_attribute ("weak_import",
2186 DECL_ATTRIBUTES (decl
)));
2188 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2189 && (!DECL_COMMON (decl
)
2190 || !TREE_PUBLIC (decl
)));
2192 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2193 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2197 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2199 machopic_define_symbol (DECL_RTL (decl
));
2202 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2204 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2205 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2206 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2207 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2208 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2209 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2210 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2211 (unsigned long)DECL_INITIAL (decl
));
2214 /* Darwin needs help to support local zero-sized objects.
2215 They must be made at least one byte, and the section containing must be
2216 marked as unsuitable for section-anchors (see storage allocators below).
2218 For non-zero objects this output is handled by varasm.c.
2222 unsigned int l2align
= 0;
2224 /* The align must be honored, even for zero-sized. */
2225 if (DECL_ALIGN (decl
))
2227 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2228 fprintf (file
, "\t.align\t%u\n", l2align
);
2231 ASM_OUTPUT_LABEL (file
, xname
);
2233 fprintf (file
, "\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2235 /* Check that we've correctly picked up the zero-sized item and placed it
2237 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2239 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2242 ASM_OUTPUT_LABEL (file
, xname
);
2245 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2247 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2248 const_tree exp ATTRIBUTE_UNUSED
,
2251 assemble_label (file
, name
);
2252 /* As for other items, we need at least one byte. */
2255 fputs ("\t.space\t1\n", file
);
2256 /* Check that we've correctly picked up the zero-sized item and placed it
2258 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2260 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2264 /* Darwin storage allocators.
2266 Zerofill sections are desirable for large blank data since, otherwise, these
2267 data bloat objects (PR33210).
2269 However, section anchors don't work in .zerofill sections (one cannot switch
2270 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2271 to put (at least some) data into 'normal' switchable sections.
2273 Here we set a relatively arbitrary value for the size of an object to trigger
2274 zerofill when section anchors are enabled (anything bigger than a page for
2275 current Darwin implementations). FIXME: there ought to be some objective way
2276 to make this choice.
2278 When section anchor are off this is ignored anyway. */
2280 #define BYTES_ZFILL 4096
2282 /* Emit a chunk of data for items coalesced by the linker. */
2284 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2285 unsigned HOST_WIDE_INT size
,
2288 /* Since the sections used here are coalesed, they will not be eligible
2289 for section anchors, and therefore we don't need to break that out. */
2290 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2291 switch_to_section (darwin_sections
[const_data_coal_section
]);
2293 switch_to_section (darwin_sections
[data_coal_section
]);
2295 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2296 the align info for zero-sized items... but do it here otherwise. */
2298 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2300 if (TREE_PUBLIC (decl
))
2301 darwin_globalize_label (fp
, name
);
2303 /* ... and we let it deal with outputting one byte of zero for them too. */
2304 darwin_asm_declare_object_name (fp
, name
, decl
);
2306 assemble_zeros (size
);
2309 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2311 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2312 unsigned HOST_WIDE_INT size
,
2313 unsigned int align
, tree meta
)
2315 section
*ocs
= data_section
;
2317 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2318 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2320 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2322 switch_to_section (ocs
);
2324 /* We shall declare that zero-sized meta-data are not valid (yet). */
2326 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2328 /* ... and we let it deal with outputting one byte of zero for them too. */
2329 darwin_asm_declare_object_name (fp
, name
, decl
);
2330 assemble_zeros (size
);
2333 /* This routine emits 'local' storage:
2335 When Section Anchors are off this routine emits .zerofill commands in
2336 sections named for their alignment.
2338 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2339 the .static_data section so that the section anchoring system can see them.
2340 Larger items are still placed in .zerofill sections, addressing PR33210.
2341 The routine has no checking - it is all assumed to be done by the caller.
2344 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2345 unsigned HOST_WIDE_INT size
,
2346 unsigned int l2align
)
2348 /* FIXME: We have a fudge to make this work with Java even when the target does
2349 not use sections anchors -- Java seems to need at least one small item in a
2350 non-zerofill segment. */
2351 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2352 || (size
&& size
<= 2))
2354 /* Put smaller objects in _static_data, where the section anchors system
2356 However, if they are zero-sized punt them to yet a different section
2357 (that is not allowed to participate in anchoring). */
2360 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2361 in_section
= darwin_sections
[zobj_bss_section
];
2366 fputs ("\t.static_data\n", fp
);
2367 in_section
= darwin_sections
[static_data_section
];
2371 fprintf (fp
, "\t.align\t%u\n", l2align
);
2373 assemble_name (fp
, name
);
2374 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2378 /* When we are on a non-section anchor target, we can get zero-sized
2379 items here. However, all we need to do is to bump them to one byte
2380 and the section alignment will take care of the rest. */
2382 unsigned int flags
;
2383 snprintf (secnam
, 64, "__DATA,__%sbss%u", ((size
)?"":"zo_"),
2384 (unsigned) l2align
);
2385 /* We can't anchor (yet, if ever) in zerofill sections, because we can't
2386 switch to them and emit a label. */
2387 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2388 in_section
= get_section (secnam
, flags
, NULL
);
2389 fprintf (fp
, "\t.zerofill %s,", secnam
);
2390 assemble_name (fp
, name
);
2395 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2396 size
, (unsigned) l2align
);
2398 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2401 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2402 /* This is defined as a file-scope var, so we know to notify machopic. */
2403 machopic_define_symbol (DECL_RTL (decl
));
2406 /* Emit a chunk of common. */
2408 darwin_emit_common (FILE *fp
, const char *name
,
2409 unsigned HOST_WIDE_INT size
, unsigned int align
)
2411 unsigned HOST_WIDE_INT rounded
;
2412 unsigned int l2align
;
2414 /* Earlier systems complain if the alignment exceeds the page size.
2415 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2416 if (!emit_aligned_common
&& (align
> 32768UL))
2417 align
= 4096UL; /* In units. */
2419 align
/= BITS_PER_UNIT
;
2421 /* Make sure we have a meaningful align. */
2425 /* For earlier toolchains, we need to emit the var as a rounded size to
2426 tell ld the alignment. */
2430 rounded
= (size
+ (align
-1)) & ~(align
-1);
2432 l2align
= floor_log2 (align
);
2433 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2435 in_section
= comm_section
;
2436 /* We mustn't allow multiple public symbols to share an address when using
2437 the normal OSX toolchain. */
2440 /* Put at least one byte. */
2442 /* This section can no longer participate in section anchoring. */
2443 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2446 fputs ("\t.comm\t", fp
);
2447 assemble_name (fp
, name
);
2448 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2449 emit_aligned_common
?size
:rounded
);
2450 if (l2align
&& emit_aligned_common
)
2451 fprintf (fp
, ",%u", l2align
);
2455 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2456 or coalescable data sections (for weak or comdat) as appropriate. */
2459 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2460 unsigned HOST_WIDE_INT size
, unsigned int align
)
2462 unsigned int l2align
;
2463 bool one
, pub
, weak
;
2466 pub
= TREE_PUBLIC (decl
);
2467 one
= DECL_ONE_ONLY (decl
);
2468 weak
= (DECL_P (decl
)
2470 && !lookup_attribute ("weak_import",
2471 DECL_ATTRIBUTES (decl
)));
2473 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2474 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2475 " pub %d weak %d one %d init %lx\n",
2476 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2477 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2478 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2481 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2482 before the target has a chance to comment. */
2483 if ((meta
= is_objc_metadata (decl
)))
2485 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2489 /* Check that any initializer is valid. */
2490 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2491 || (DECL_INITIAL (decl
) == error_mark_node
)
2492 || initializer_zerop (DECL_INITIAL (decl
)));
2494 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2495 gcc_assert (!DECL_COMMON (decl
));
2497 /* Pick up the correct alignment. */
2498 if (!size
|| !align
)
2499 align
= DECL_ALIGN (decl
);
2501 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2502 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2504 last_assemble_variable_decl
= decl
;
2506 /* We would rather not have to check this here - but it seems that we might
2507 be passed a decl that should be in coalesced space. */
2510 /* Weak or COMDAT objects are put in mergeable sections. */
2511 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2516 /* If this is not public, then emit according to local rules. */
2519 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2523 /* So we have a public symbol (small item fudge for Java, see above). */
2524 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2525 || (size
&& size
<= 2))
2527 /* Put smaller objects in data, where the section anchors system can get
2528 them. However, if they are zero-sized punt them to yet a different
2529 section (that is not allowed to participate in anchoring). */
2532 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2533 in_section
= darwin_sections
[zobj_data_section
];
2538 fputs ("\t.data\n", fp
);
2539 in_section
= data_section
;
2543 fprintf (fp
, "\t.align\t%u\n", l2align
);
2545 assemble_name (fp
, name
);
2546 fprintf (fp
, ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2551 unsigned int flags
;
2552 /* When we are on a non-section anchor target, we can get zero-sized
2553 items here. However, all we need to do is to bump them to one byte
2554 and the section alignment will take care of the rest. */
2555 snprintf (secnam
, 64, "__DATA,__%spu_bss%u", ((size
)?"":"zo_"), l2align
);
2557 /* We can't anchor in zerofill sections, because we can't switch
2558 to them and emit a label. */
2559 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2560 in_section
= get_section (secnam
, flags
, NULL
);
2561 fprintf (fp
, "\t.zerofill %s,", secnam
);
2562 assemble_name (fp
, name
);
2567 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2569 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2571 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2574 /* Output a chunk of common, with alignment specified (where the target
2577 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2578 unsigned HOST_WIDE_INT size
,
2581 unsigned int l2align
;
2585 /* No corresponding var. */
2588 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2589 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2591 darwin_emit_common (fp
, name
, size
, align
);
2595 one
= DECL_ONE_ONLY (decl
);
2596 weak
= (DECL_P (decl
)
2598 && !lookup_attribute ("weak_import",
2599 DECL_ATTRIBUTES (decl
)));
2601 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2602 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2603 " weak %d one %d init %lx\n",
2604 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2605 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2606 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2609 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2610 before the target has a chance to comment. */
2611 if ((meta
= is_objc_metadata (decl
)))
2613 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2617 /* We shouldn't be messing with this if the decl has a section name. */
2618 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2620 /* We would rather not have to check this here - but it seems that we might
2621 be passed a decl that should be in coalesced space. */
2624 /* Weak or COMDAT objects are put in mergable sections. */
2625 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2630 /* We should only get here for DECL_COMMON, with a zero init (and, in
2631 principle, only for public symbols too - although we deal with local
2634 /* Check the initializer is OK. */
2635 gcc_assert (DECL_COMMON (decl
)
2636 && ((DECL_INITIAL (decl
) == NULL
)
2637 || (DECL_INITIAL (decl
) == error_mark_node
)
2638 || initializer_zerop (DECL_INITIAL (decl
))));
2640 last_assemble_variable_decl
= decl
;
2642 if (!size
|| !align
)
2643 align
= DECL_ALIGN (decl
);
2645 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2646 /* Check we aren't asking for more aligment than the platform allows. */
2647 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2649 if (TREE_PUBLIC (decl
) != 0)
2650 darwin_emit_common (fp
, name
, size
, align
);
2652 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2655 /* Output a chunk of BSS with alignment specfied. */
2657 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2658 unsigned HOST_WIDE_INT size
,
2661 unsigned long l2align
;
2665 one
= DECL_ONE_ONLY (decl
);
2666 weak
= (DECL_P (decl
)
2668 && !lookup_attribute ("weak_import",
2669 DECL_ATTRIBUTES (decl
)));
2671 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2672 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2673 " weak %d init %lx\n",
2674 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2675 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2676 weak
, (unsigned long)DECL_INITIAL (decl
));
2679 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2680 before the target has a chance to comment. */
2681 if ((meta
= is_objc_metadata (decl
)))
2683 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2687 /* We shouldn't be messing with this if the decl has a section name. */
2688 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2690 /* We would rather not have to check this here - but it seems that we might
2691 be passed a decl that should be in coalesced space. */
2694 /* Weak or COMDAT objects are put in mergable sections. */
2695 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2700 /* .. and it should be suitable for placement in local mem. */
2701 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2702 /* .. and any initializer must be all-zero. */
2703 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2704 || (DECL_INITIAL (decl
) == error_mark_node
)
2705 || initializer_zerop (DECL_INITIAL (decl
)));
2707 last_assemble_variable_decl
= decl
;
2709 if (!size
|| !align
)
2710 align
= DECL_ALIGN (decl
);
2712 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2713 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2715 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2718 /* Emit an assembler directive to set visibility for a symbol. The
2719 only supported visibilities are VISIBILITY_DEFAULT and
2720 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2721 extern". There is no MACH-O equivalent of ELF's
2722 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2725 darwin_assemble_visibility (tree decl
, int vis
)
2727 if (vis
== VISIBILITY_DEFAULT
)
2729 else if (vis
== VISIBILITY_HIDDEN
|| vis
== VISIBILITY_INTERNAL
)
2731 fputs ("\t.private_extern ", asm_out_file
);
2732 assemble_name (asm_out_file
,
2733 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2734 fputs ("\n", asm_out_file
);
2737 warning (OPT_Wattributes
, "protected visibility attribute "
2738 "not supported in this configuration; ignored");
2741 /* vec used by darwin_asm_dwarf_section.
2742 Maybe a hash tab would be better here - but the intention is that this is
2743 a very short list (fewer than 16 items) and each entry should (ideally,
2744 eventually) only be presented once.
2746 A structure to hold a dwarf debug section used entry. */
2748 typedef struct GTY(()) dwarf_sect_used_entry
{
2752 dwarf_sect_used_entry
;
2755 /* A list of used __DWARF sections. */
2756 static GTY (()) vec
<dwarf_sect_used_entry
, va_gc
> *dwarf_sect_names_table
;
2758 /* This is called when we are asked to assemble a named section and the
2759 name begins with __DWARF,. We keep a list of the section names (without
2760 the __DWARF, prefix) and use this to emit our required start label on the
2761 first switch to each section. */
2764 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2765 tree
ARG_UNUSED (decl
))
2770 dwarf_sect_used_entry
*ref
;
2772 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2773 == (SECTION_DEBUG
| SECTION_NAMED
));
2774 /* We know that the name starts with __DWARF, */
2776 namelen
= strchr (sname
, ',') - sname
;
2777 gcc_assert (namelen
);
2778 if (dwarf_sect_names_table
== NULL
)
2779 vec_alloc (dwarf_sect_names_table
, 16);
2782 dwarf_sect_names_table
->iterate (i
, &ref
);
2787 if (!strcmp (ref
->name
, sname
))
2795 fprintf (asm_out_file
, "\t.section %s\n", name
);
2798 dwarf_sect_used_entry e
;
2799 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
2801 e
.name
= xstrdup (sname
);
2802 vec_safe_push (dwarf_sect_names_table
, e
);
2806 /* Output a difference of two labels that will be an assembly time
2807 constant if the two labels are local. (.long lab1-lab2 will be
2808 very different if lab1 is at the boundary between two sections; it
2809 will be relocated according to the second section, not the first,
2810 so one ends up with a difference between labels in different
2811 sections, which is bad in the dwarf2 eh context for instance.) */
2813 static int darwin_dwarf_label_counter
;
2816 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
2817 const char *lab1
, const char *lab2
)
2819 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
2820 && lab2
[0] == '*' && lab2
[1] == 'L');
2821 const char *directive
= (size
== 8 ? ".quad" : ".long");
2824 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
2826 fprintf (file
, "\t%s\t", directive
);
2828 assemble_name_raw (file
, lab1
);
2829 fprintf (file
, "-");
2830 assemble_name_raw (file
, lab2
);
2832 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
2835 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
2836 offsets are not represented using relocs in .o files; either the
2837 section never leaves the .o file, or the linker or other tool is
2838 responsible for parsing the DWARF and updating the offsets. */
2841 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
2847 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
2848 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
2849 gcc_assert (strchr (base
->named
.name
+ 8, ','));
2851 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
2852 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
2853 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
2856 /* Called from the within the TARGET_ASM_FILE_START for each target. */
2859 darwin_file_start (void)
2861 /* Nothing to do. */
2864 /* Called for the TARGET_ASM_FILE_END hook.
2865 Emit the mach-o pic indirection data, the lto data and, finally a flag
2866 to tell the linker that it can break the file object into sections and
2867 move those around for efficiency. */
2870 darwin_file_end (void)
2872 if (!vec_safe_is_empty (ctors
))
2874 if (!vec_safe_is_empty (dtors
))
2877 /* If we are expecting to output NeXT ObjC meta-data, (and we actually see
2878 some) then we output the fix-and-continue marker (Image Info).
2879 This applies to Objective C, Objective C++ and LTO with either language
2880 as part of the input. */
2881 if (flag_next_runtime
&& objc_metadata_seen
)
2883 unsigned int flags
= 0;
2884 if (flag_objc_abi
>= 2)
2887 output_section_asm_op
2888 (darwin_sections
[objc2_image_info_section
]->unnamed
.data
);
2891 output_section_asm_op
2892 (darwin_sections
[objc_image_info_section
]->unnamed
.data
);
2894 ASM_OUTPUT_ALIGN (asm_out_file
, 2);
2895 fputs ("L_OBJC_ImageInfo:\n", asm_out_file
);
2897 flags
|= (flag_replace_objc_classes
&& classes_seen
) ? 1 : 0;
2898 flags
|= flag_objc_gc
? 2 : 0;
2900 fprintf (asm_out_file
, "\t.long\t0\n\t.long\t%u\n", flags
);
2903 machopic_finish (asm_out_file
);
2904 if (lang_GNU_CXX ())
2906 switch_to_section (darwin_sections
[constructor_section
]);
2907 switch_to_section (darwin_sections
[destructor_section
]);
2908 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
2911 /* If there was LTO assembler output, append it to asm_out_file. */
2912 if (lto_asm_out_name
)
2915 char *buf
, *lto_asm_txt
;
2917 /* Shouldn't be here if we failed to switch back. */
2918 gcc_assert (! saved_asm_out_file
);
2920 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
2921 if (lto_asm_out_file
== NULL
)
2922 fatal_error (input_location
,
2923 "failed to open temporary file %s with LTO output",
2925 fseek (lto_asm_out_file
, 0, SEEK_END
);
2926 n
= ftell (lto_asm_out_file
);
2929 fseek (lto_asm_out_file
, 0, SEEK_SET
);
2930 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
2931 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
2932 fputs (lto_asm_txt
, asm_out_file
);
2933 /* Put a termination label. */
2934 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2935 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
2936 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# end of lto\n",
2938 /* Make sure our termination label stays in this section. */
2939 fputs ("\t.space\t1\n", asm_out_file
);
2942 /* Remove the temporary file. */
2943 fclose (lto_asm_out_file
);
2944 unlink_if_ordinary (lto_asm_out_name
);
2945 free (lto_asm_out_name
);
2948 /* Output the names and indices. */
2949 if (lto_section_names
&& lto_section_names
->length ())
2952 darwin_lto_section_e
*ref
;
2953 /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
2954 the latter up ourselves. */
2955 const char *op
= integer_asm_op (4,0);
2957 /* Emit the names. */
2958 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2959 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
2960 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
2962 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\n", count
);
2963 /* We have to jump through hoops to get the values of the intra-section
2965 fprintf (asm_out_file
,
2966 "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
2968 fprintf (asm_out_file
,
2969 "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
2970 count
, count
+1, count
);
2971 fprintf (asm_out_file
, "\t.asciz\t\"%s\"\n", ref
->sectname
);
2973 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num
);
2974 /* make sure our termination label stays in this section. */
2975 fputs ("\t.space\t1\n", asm_out_file
);
2977 /* Emit the Index. */
2978 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2979 LTO_SEGMENT_NAME
, LTO_INDEX_SECTION
);
2980 fputs ("\t.align\t2\n", asm_out_file
);
2981 fputs ("# Section offset, Section length, Name offset, Name length\n",
2983 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
2985 fprintf (asm_out_file
, "%s L$gnu$lto$offs%d\t;# %s\n",
2986 op
, count
, ref
->sectname
);
2987 fprintf (asm_out_file
, "%s L$gnu$lto$size%d\n", op
, count
);
2988 fprintf (asm_out_file
, "%s L$gnu$lto$noff%d\n", op
, count
);
2989 fprintf (asm_out_file
, "%s L$gnu$lto$nsiz%d\n", op
, count
);
2993 /* If we have section anchors, then we must prevent the linker from
2994 re-arranging data. */
2995 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2996 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
2999 /* TODO: Add a language hook for identifying if a decl is a vtable. */
3000 #define DARWIN_VTABLE_P(DECL) 0
3002 /* Cross-module name binding. Darwin does not support overriding
3003 functions at dynamic-link time, except for vtables in kexts. */
3006 darwin_binds_local_p (const_tree decl
)
3008 return default_binds_local_p_1 (decl
,
3009 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
3012 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
3013 anchor relative to ".", the current section position. We cannot use
3014 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
3016 darwin_asm_output_anchor (rtx symbol
)
3018 fprintf (asm_out_file
, "\t.set\t");
3019 assemble_name (asm_out_file
, XSTR (symbol
, 0));
3020 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
3021 SYMBOL_REF_BLOCK_OFFSET (symbol
));
3024 /* Disable section anchoring on any section containing a zero-sized
3027 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
3029 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
3032 /* If the section contains a zero-sized object it's ineligible. */
3033 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
3034 /* This should have the effect of disabling anchors for vars that follow
3035 any zero-sized one, in a given section. */
3036 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
3039 /* Also check the normal reasons for suppressing. */
3040 return default_use_anchors_for_symbol_p (symbol
);
3046 /* Set the darwin specific attributes on TYPE. */
3048 darwin_set_default_type_attributes (tree type
)
3050 if (darwin_ms_struct
3051 && TREE_CODE (type
) == RECORD_TYPE
)
3052 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
3054 TYPE_ATTRIBUTES (type
));
3057 /* True, iff we're generating code for loadable kernel extensions. */
3060 darwin_kextabi_p (void) {
3061 return flag_apple_kext
;
3065 darwin_override_options (void)
3067 /* Keep track of which (major) version we're generating code for. */
3068 if (darwin_macosx_version_min
)
3070 if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
3071 generating_for_darwin_version
= 10;
3072 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
3073 generating_for_darwin_version
= 9;
3075 /* Earlier versions are not specifically accounted, until required. */
3078 /* In principle, this should be c-family only. However, we really need to
3079 set sensible defaults for LTO as well, since the section selection stuff
3080 should check for correctness re. the ABI. TODO: check and provide the
3081 flags (runtime & ABI) from the lto wrapper). */
3083 /* Unless set, force ABI=2 for NeXT and m64, 0 otherwise. */
3084 if (!global_options_set
.x_flag_objc_abi
)
3085 global_options
.x_flag_objc_abi
3086 = (!flag_next_runtime
)
3089 : (generating_for_darwin_version
>= 9) ? 1
3092 /* Objective-C family ABI 2 is only valid for next/m64 at present. */
3093 if (global_options_set
.x_flag_objc_abi
&& flag_next_runtime
)
3095 if (TARGET_64BIT
&& global_options
.x_flag_objc_abi
< 2)
3096 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 must be"
3097 " used for %<-m64%> targets with"
3098 " %<-fnext-runtime%>");
3099 if (!TARGET_64BIT
&& global_options
.x_flag_objc_abi
>= 2)
3100 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 is not"
3101 " supported on %<-m32%> targets with"
3102 " %<-fnext-runtime%>");
3105 /* Don't emit DWARF3/4 unless specifically selected. This is a
3106 workaround for tool bugs. */
3107 if (!global_options_set
.x_dwarf_strict
)
3109 if (!global_options_set
.x_dwarf_version
)
3112 /* Do not allow unwind tables to be generated by default for m32.
3113 fnon-call-exceptions will override this, regardless of what we do. */
3114 if (generating_for_darwin_version
< 10
3115 && !global_options_set
.x_flag_asynchronous_unwind_tables
3117 global_options
.x_flag_asynchronous_unwind_tables
= 0;
3119 /* Disable -freorder-blocks-and-partition when unwind tables are being
3120 emitted for Darwin < 9 (OSX 10.5).
3121 The strategy is, "Unless the User has specifically set/unset an unwind
3122 flag we will switch off -freorder-blocks-and-partition when unwind tables
3123 will be generated". If the User specifically sets flags... we assume
3124 (s)he knows why... */
3125 if (generating_for_darwin_version
< 9
3126 && global_options_set
.x_flag_reorder_blocks_and_partition
3127 && ((global_options
.x_flag_exceptions
/* User, c++, java */
3128 && !global_options_set
.x_flag_exceptions
) /* User specified... */
3129 || (global_options
.x_flag_unwind_tables
3130 && !global_options_set
.x_flag_unwind_tables
)
3131 || (global_options
.x_flag_non_call_exceptions
3132 && !global_options_set
.x_flag_non_call_exceptions
)
3133 || (global_options
.x_flag_asynchronous_unwind_tables
3134 && !global_options_set
.x_flag_asynchronous_unwind_tables
)))
3136 inform (input_location
,
3137 "-freorder-blocks-and-partition does not work with exceptions "
3138 "on this architecture");
3139 flag_reorder_blocks_and_partition
= 0;
3140 flag_reorder_blocks
= 1;
3143 /* FIXME: flag_objc_sjlj_exceptions is no longer needed since there is only
3144 one valid choice of exception scheme for each runtime. */
3145 if (!global_options_set
.x_flag_objc_sjlj_exceptions
)
3146 global_options
.x_flag_objc_sjlj_exceptions
=
3147 flag_next_runtime
&& !TARGET_64BIT
;
3149 /* FIXME: and this could be eliminated then too. */
3150 if (!global_options_set
.x_flag_exceptions
3151 && flag_objc_exceptions
3153 flag_exceptions
= 1;
3155 if (flag_mkernel
|| flag_apple_kext
)
3157 /* -mkernel implies -fapple-kext for C++ */
3158 if (lang_GNU_CXX ())
3159 flag_apple_kext
= 1;
3163 /* No EH in kexts. */
3164 flag_exceptions
= 0;
3165 /* No -fnon-call-exceptions data in kexts. */
3166 flag_non_call_exceptions
= 0;
3167 /* so no tables either.. */
3168 flag_unwind_tables
= 0;
3169 flag_asynchronous_unwind_tables
= 0;
3170 /* We still need to emit branch islands for kernel context. */
3171 darwin_emit_branch_islands
= true;
3174 if (flag_var_tracking_uninit
== 0
3175 && generating_for_darwin_version
>= 9
3176 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
3177 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
3178 && write_symbols
== DWARF2_DEBUG
)
3179 flag_var_tracking_uninit
= flag_var_tracking
;
3181 if (MACHO_DYNAMIC_NO_PIC_P
)
3184 warning_at (UNKNOWN_LOCATION
, 0,
3185 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
3186 " %<-fpie%> or %<-fPIE%>");
3189 else if (flag_pic
== 1)
3191 /* Darwin's -fpic is -fPIC. */
3195 /* It is assumed that branch island stubs are needed for earlier systems. */
3196 if (generating_for_darwin_version
< 9)
3197 darwin_emit_branch_islands
= true;
3199 emit_aligned_common
= true; /* Later systems can support aligned common. */
3201 /* The c_dialect...() macros are not available to us here. */
3202 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
3206 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
3209 darwin_patch_builtin (enum built_in_function fncode
)
3211 tree fn
= builtin_decl_explicit (fncode
);
3218 sym
= DECL_ASSEMBLER_NAME (fn
);
3219 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
3221 set_user_assembler_name (fn
, newname
);
3223 fn
= builtin_decl_implicit (fncode
);
3225 set_user_assembler_name (fn
, newname
);
3229 darwin_patch_builtins (void)
3231 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
3234 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
3235 #define PATCH_BUILTIN_NO64(fncode) \
3236 if (!TARGET_64BIT) \
3237 darwin_patch_builtin (fncode);
3238 #define PATCH_BUILTIN_VARIADIC(fncode) \
3240 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
3241 darwin_patch_builtin (fncode);
3242 #include "darwin-ppc-ldouble-patch.def"
3243 #undef PATCH_BUILTIN
3244 #undef PATCH_BUILTIN_NO64
3245 #undef PATCH_BUILTIN_VARIADIC
3249 /* CFStrings implementation. */
3250 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3251 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3252 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3253 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3254 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3255 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3257 static enum built_in_function darwin_builtin_cfstring
;
3259 /* Store all constructed constant CFStrings in a hash table so that
3260 they get uniqued properly. */
3262 typedef struct GTY ((for_user
)) cfstring_descriptor
{
3263 /* The string literal. */
3265 /* The resulting constant CFString. */
3267 } cfstring_descriptor
;
3269 struct cfstring_hasher
: ggc_ptr_hash
<cfstring_descriptor
>
3271 static hashval_t
hash (cfstring_descriptor
*);
3272 static bool equal (cfstring_descriptor
*, cfstring_descriptor
*);
3275 static GTY (()) hash_table
<cfstring_hasher
> *cfstring_htab
;
3278 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3280 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3281 get_identifier (name
), type
);
3285 *chain
= &DECL_CHAIN (field
);
3291 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3293 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3296 darwin_builtin_cfstring
=
3297 (enum built_in_function
) builtin_cfstring
;
3299 /* struct __builtin_CFString {
3300 const int *isa; (will point at
3301 int flags; __CFConstantStringClassReference)
3306 pcint_type_node
= build_pointer_type
3307 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3309 pcchar_type_node
= build_pointer_type
3310 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3312 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3314 /* Have to build backwards for finish struct. */
3315 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3316 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3317 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3318 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3319 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3322 /* const struct __builtin_CFstring *
3323 __builtin___CFStringMakeConstantString (const char *); */
3325 ccfstring_type_node
= build_qualified_type
3326 (cfstring_type_node
, TYPE_QUAL_CONST
);
3327 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3328 pccfstring_ftype_pcchar
= build_function_type_list
3329 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3331 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3332 get_identifier ("__builtin___CFStringMakeConstantString"),
3333 pccfstring_ftype_pcchar
);
3335 TREE_PUBLIC (cfsfun
) = 1;
3336 DECL_EXTERNAL (cfsfun
) = 1;
3337 DECL_ARTIFICIAL (cfsfun
) = 1;
3338 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3339 in place of the existing, which may be NULL. */
3340 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3341 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3342 DECL_BUILT_IN_CLASS (cfsfun
) = BUILT_IN_MD
;
3343 DECL_FUNCTION_CODE (cfsfun
) = darwin_builtin_cfstring
;
3344 lang_hooks
.builtin_function (cfsfun
);
3346 /* extern int __CFConstantStringClassReference[]; */
3347 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3348 get_identifier ("__CFConstantStringClassReference"),
3349 build_array_type (integer_type_node
, NULL_TREE
));
3351 TREE_PUBLIC (cfstring_class_reference
) = 1;
3352 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3353 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3354 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3355 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3357 /* Initialize the hash table used to hold the constant CFString objects. */
3358 cfstring_htab
= hash_table
<cfstring_hasher
>::create_ggc (31);
3360 return cfstring_type_node
;
3364 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3365 bool ARG_UNUSED (ignore
))
3367 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3369 if (fcode
== darwin_builtin_cfstring
)
3371 if (!darwin_constant_cfstrings
)
3373 error ("built-in function %qD requires the"
3374 " %<-mconstant-cfstrings%> flag", fndecl
);
3375 return error_mark_node
;
3380 error ("built-in function %qD takes one argument only", fndecl
);
3381 return error_mark_node
;
3384 return darwin_build_constant_cfstring (*argp
);
3391 darwin_rename_builtins (void)
3393 /* The system ___divdc3 routine in libSystem on darwin10 is not
3394 accurate to 1ulp, ours is, so we avoid ever using the system name
3395 for this routine and instead install a non-conflicting name that
3398 When -ffast-math or -funsafe-math-optimizations is given, we can
3399 use the faster version. */
3400 if (!flag_unsafe_math_optimizations
)
3402 enum built_in_function dcode
3403 = (enum built_in_function
)(BUILT_IN_COMPLEX_DIV_MIN
3404 + DCmode
- MIN_MODE_COMPLEX_FLOAT
);
3405 tree fn
= builtin_decl_explicit (dcode
);
3406 /* Fortran and c call TARGET_INIT_BUILTINS and
3407 TARGET_INIT_LIBFUNCS at different times, so we have to put a
3408 call into each to ensure that at least one of them is called
3409 after build_common_builtin_nodes. A better fix is to add a
3410 new hook to run after build_common_builtin_nodes runs. */
3412 set_user_assembler_name (fn
, "___ieee_divdc3");
3413 fn
= builtin_decl_implicit (dcode
);
3415 set_user_assembler_name (fn
, "___ieee_divdc3");
3420 darwin_libc_has_function (enum function_class fn_class
)
3422 if (fn_class
== function_sincos
)
3424 if (fn_class
== function_c99_math_complex
3425 || fn_class
== function_c99_misc
)
3426 return (TARGET_64BIT
3427 || strverscmp (darwin_macosx_version_min
, "10.3") >= 0);
3433 cfstring_hasher::hash (cfstring_descriptor
*ptr
)
3435 tree str
= ptr
->literal
;
3436 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3437 int i
, len
= TREE_STRING_LENGTH (str
);
3440 for (i
= 0; i
< len
; i
++)
3441 h
= ((h
* 613) + p
[i
]);
3447 cfstring_hasher::equal (cfstring_descriptor
*ptr1
, cfstring_descriptor
*ptr2
)
3449 tree str1
= ptr1
->literal
;
3450 tree str2
= ptr2
->literal
;
3451 int len1
= TREE_STRING_LENGTH (str1
);
3453 return (len1
== TREE_STRING_LENGTH (str2
)
3454 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3459 darwin_build_constant_cfstring (tree str
)
3461 struct cfstring_descriptor
*desc
, key
;
3466 error ("CFString literal is missing");
3467 return error_mark_node
;
3472 if (TREE_CODE (str
) == ADDR_EXPR
)
3473 str
= TREE_OPERAND (str
, 0);
3475 if (TREE_CODE (str
) != STRING_CST
)
3477 error ("CFString literal expression is not a string constant");
3478 return error_mark_node
;
3481 /* Perhaps we already constructed a constant CFString just like this one? */
3483 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3488 tree var
, constructor
, field
;
3489 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3490 int length
= TREE_STRING_LENGTH (str
) - 1;
3492 if (darwin_warn_nonportable_cfstrings
)
3494 const char *s
= TREE_STRING_POINTER (str
);
3497 for (l
= 0; l
< length
; l
++)
3498 if (!s
[l
] || !isascii (s
[l
]))
3500 warning (darwin_warn_nonportable_cfstrings
, "%s in CFString literal",
3501 s
[l
] ? "non-ASCII character" : "embedded NUL");
3506 *loc
= desc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3507 desc
->literal
= str
;
3510 field
= TYPE_FIELDS (ccfstring_type_node
);
3511 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3512 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3513 cfstring_class_reference
));
3515 field
= DECL_CHAIN (field
);
3516 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3517 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3519 field
= DECL_CHAIN (field
);
3520 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3521 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3523 field
= DECL_CHAIN (field
);
3524 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3525 build_int_cst (TREE_TYPE (field
), length
));
3527 constructor
= build_constructor (ccfstring_type_node
, v
);
3528 TREE_READONLY (constructor
) = 1;
3529 TREE_CONSTANT (constructor
) = 1;
3530 TREE_STATIC (constructor
) = 1;
3532 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3533 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3534 being built without any knowledge of C++ tree accessors; hence, we shall
3535 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3536 if (darwin_running_cxx
)
3537 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3539 /* Create an anonymous global variable for this CFString. */
3540 var
= build_decl (input_location
, CONST_DECL
,
3541 NULL
, TREE_TYPE (constructor
));
3542 DECL_ARTIFICIAL (var
) = 1;
3543 TREE_STATIC (var
) = 1;
3544 DECL_INITIAL (var
) = constructor
;
3545 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3546 DECL_CONTEXT (var
) = NULL_TREE
;
3547 desc
->constructor
= var
;
3550 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3551 TREE_CONSTANT (addr
) = 1;
3557 darwin_cfstring_p (tree str
)
3559 struct cfstring_descriptor key
;
3566 if (TREE_CODE (str
) == ADDR_EXPR
)
3567 str
= TREE_OPERAND (str
, 0);
3569 if (TREE_CODE (str
) != STRING_CST
)
3573 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, NO_INSERT
);
3582 darwin_enter_string_into_cfstring_table (tree str
)
3584 struct cfstring_descriptor key
;
3587 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3591 *loc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3592 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3596 /* Choose named function section based on its frequency. */
3599 darwin_function_section (tree decl
, enum node_frequency freq
,
3600 bool startup
, bool exit
)
3602 /* Decide if we need to put this in a coalescable section. */
3605 && (!DECL_ATTRIBUTES (decl
)
3606 || !lookup_attribute ("weak_import",
3607 DECL_ATTRIBUTES (decl
))));
3609 /* If there is a specified section name, we should not be trying to
3611 if (decl
&& DECL_SECTION_NAME (decl
) != NULL
)
3612 return get_named_section (decl
, NULL
, 0);
3614 /* We always put unlikely executed stuff in the cold section. */
3615 if (freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3616 return (weak
) ? darwin_sections
[text_cold_coal_section
]
3617 : darwin_sections
[text_cold_section
];
3619 /* If we have LTO *and* feedback information, then let LTO handle
3620 the function ordering, it makes a better job (for normal, hot,
3621 startup and exit - hence the bailout for cold above). */
3622 if (in_lto_p
&& flag_profile_values
)
3623 goto default_function_sections
;
3625 /* Non-cold startup code should go to startup subsection. */
3627 return (weak
) ? darwin_sections
[text_startup_coal_section
]
3628 : darwin_sections
[text_startup_section
];
3630 /* Similarly for exit. */
3632 return (weak
) ? darwin_sections
[text_exit_coal_section
]
3633 : darwin_sections
[text_exit_section
];
3635 /* Place hot code. */
3636 if (freq
== NODE_FREQUENCY_HOT
)
3637 return (weak
) ? darwin_sections
[text_hot_coal_section
]
3638 : darwin_sections
[text_hot_section
];
3640 /* Otherwise, default to the 'normal' non-reordered sections. */
3641 default_function_sections
:
3642 return (weak
) ? darwin_sections
[text_coal_section
]
3646 /* When a function is partitioned between sections, we need to insert a label
3647 at the start of each new chunk - so that it may become a valid 'atom' for
3648 eh and debug purposes. Without this the linker will emit warnings if one
3649 tries to add line location information (since the switched fragment will
3653 darwin_function_switched_text_sections (FILE *fp
, tree decl
, bool new_is_cold
)
3656 snprintf (buf
, 128, "%s%s",new_is_cold
?"__cold_sect_of_":"__hot_sect_of_",
3657 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3658 /* Make sure we pick up all the relevant quotes etc. */
3659 assemble_name_raw (fp
, (const char *) buf
);
3663 #include "gt-darwin.h"