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"
27 #include "hard-reg-set.h"
28 #include "insn-config.h"
29 #include "conditions.h"
30 #include "insn-flags.h"
32 #include "insn-attr.h"
37 #include "double-int.h"
44 #include "fold-const.h"
45 #include "stringpool.h"
47 #include "stor-layout.h"
50 #include "statistics.h"
52 #include "fixed-value.h"
62 #include "langhooks.h"
65 #include "diagnostic-core.h"
67 #include "dominance.h"
73 #include "cfgcleanup.h"
75 #include "basic-block.h"
79 #include "hash-table.h"
80 #include "tree-ssa-alias.h"
81 #include "internal-fn.h"
82 #include "gimple-fold.h"
84 #include "gimple-expr.h"
89 #include "plugin-api.h"
92 #include "lto-streamer.h"
93 #include "lto-section-names.h"
95 /* Darwin supports a feature called fix-and-continue, which is used
96 for rapid turn around debugging. When code is compiled with the
97 -mfix-and-continue flag, two changes are made to the generated code
98 that allow the system to do things that it would normally not be
99 able to do easily. These changes allow gdb to load in
100 recompilation of a translation unit that has been changed into a
101 running program and replace existing functions and methods of that
102 translation unit with versions of those functions and methods
103 from the newly compiled translation unit. The new functions access
104 the existing static symbols from the old translation unit, if the
105 symbol existed in the unit to be replaced, and from the new
106 translation unit, otherwise.
108 The changes are to insert 5 nops at the beginning of all functions
109 and to use indirection to get at static symbols. The 5 nops
110 are required by consumers of the generated code. Currently, gdb
111 uses this to patch in a jump to the overriding function, this
112 allows all uses of the old name to forward to the replacement,
113 including existing function pointers and virtual methods. See
114 rs6000_emit_prologue for the code that handles the nop insertions.
116 The added indirection allows gdb to redirect accesses to static
117 symbols from the newly loaded translation unit to the existing
118 symbol, if any. @code{static} symbols are special and are handled by
119 setting the second word in the .non_lazy_symbol_pointer data
120 structure to symbol. See indirect_data for the code that handles
121 the extra indirection, and machopic_output_indirection and its use
122 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
123 symbol indirection. */
125 /* For darwin >= 9 (OSX 10.5) the linker is capable of making the necessary
126 branch islands and we no longer need to emit darwin stubs.
127 However, if we are generating code for earlier systems (or for use in the
128 kernel) the stubs might still be required, and this will be set true. */
129 int darwin_emit_branch_islands
= false;
131 typedef struct GTY(()) cdtor_record
{
133 int priority
; /* [con/de]structor priority */
134 int position
; /* original position */
137 static GTY(()) vec
<cdtor_record
, va_gc
> *ctors
= NULL
;
138 static GTY(()) vec
<cdtor_record
, va_gc
> *dtors
= NULL
;
140 /* A flag to determine whether we are running c++ or obj-c++. This has to be
141 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
143 int darwin_running_cxx
;
145 /* Some code-gen now depends on OS major version numbers (at least). */
146 int generating_for_darwin_version
;
149 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
151 /* While we transition to using in-tests instead of ifdef'd code. */
153 #define HAVE_lo_sum 0
154 #define gen_macho_high(a,b) (a)
155 #define gen_macho_low(a,b,c) (a)
158 /* True if we're setting __attribute__ ((ms_struct)). */
159 int darwin_ms_struct
= false;
161 /* Earlier versions of Darwin as do not recognize an alignment field in
162 .comm directives, this should be set for versions that allow it. */
163 int emit_aligned_common
= false;
165 /* A get_unnamed_section callback used to switch to an ObjC section.
166 DIRECTIVE is as for output_section_asm_op. */
169 output_objc_section_asm_op (const void *directive
)
171 static bool been_here
= false;
173 /* The NeXT ObjC Runtime requires these sections to be present and in
174 order in the object. The code below implements this by emitting
175 a section header for each ObjC section the first time that an ObjC
176 section is requested. */
179 section
*saved_in_section
= in_section
;
180 static const enum darwin_section_enum tomark
[] =
182 /* written, cold -> hot */
183 objc_cat_cls_meth_section
,
184 objc_cat_inst_meth_section
,
185 objc_string_object_section
,
186 objc_constant_string_object_section
,
187 objc_selector_refs_section
,
188 objc_selector_fixup_section
,
189 objc_cls_refs_section
,
191 objc_meta_class_section
,
192 /* shared, hot -> cold */
193 objc_cls_meth_section
,
194 objc_inst_meth_section
,
195 objc_protocol_section
,
196 objc_class_names_section
,
197 objc_meth_var_types_section
,
198 objc_meth_var_names_section
,
199 objc_category_section
,
200 objc_class_vars_section
,
201 objc_instance_vars_section
,
202 objc_module_info_section
,
203 objc_symbols_section
,
206 static const enum darwin_section_enum tomarkv1
[] =
208 objc1_protocol_ext_section
,
209 objc1_class_ext_section
,
210 objc1_prop_list_section
213 static const enum darwin_section_enum tomarkv2
[] =
215 objc2_message_refs_section
,
216 objc2_classdefs_section
,
217 objc2_metadata_section
,
218 objc2_classrefs_section
,
219 objc2_classlist_section
,
220 objc2_categorylist_section
,
221 objc2_selector_refs_section
,
222 objc2_nonlazy_class_section
,
223 objc2_nonlazy_category_section
,
224 objc2_protocollist_section
,
225 objc2_protocolrefs_section
,
226 objc2_super_classrefs_section
,
227 objc2_image_info_section
,
228 objc2_constant_string_object_section
233 if (flag_objc_abi
< 2)
235 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
236 switch_to_section (darwin_sections
[tomark
[i
]]);
237 if (flag_objc_abi
== 1)
238 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
239 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
242 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
243 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
244 /* Make sure we don't get varasm.c out of sync with us. */
245 switch_to_section (saved_in_section
);
247 output_section_asm_op (directive
);
251 /* Private flag applied to disable section-anchors in a particular section. */
252 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
255 /* Implement TARGET_ASM_INIT_SECTIONS. */
258 darwin_init_sections (void)
260 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
261 darwin_sections[NAME] = \
262 get_unnamed_section (FLAGS, (OBJC \
263 ? output_objc_section_asm_op \
264 : output_section_asm_op), \
266 #include "config/darwin-sections.def"
269 readonly_data_section
= darwin_sections
[const_section
];
270 exception_section
= darwin_sections
[darwin_exception_section
];
271 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
275 name_needs_quotes (const char *name
)
278 while ((c
= *name
++) != '\0')
280 && c
!= '.' && c
!= '$' && c
!= '_' )
285 /* Return true if SYM_REF can be used without an indirection. */
287 machopic_symbol_defined_p (rtx sym_ref
)
289 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
292 /* If a symbol references local and is not an extern to this
293 file, then the symbol might be able to declared as defined. */
294 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
296 /* If the symbol references a variable and the variable is a
297 common symbol, then this symbol is not defined. */
298 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
300 tree decl
= SYMBOL_REF_DECL (sym_ref
);
303 if (DECL_COMMON (decl
))
311 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
312 reference, which will not be changed. */
314 enum machopic_addr_class
315 machopic_classify_symbol (rtx sym_ref
)
319 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
320 if (machopic_symbol_defined_p (sym_ref
))
322 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
325 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
328 #ifndef TARGET_FIX_AND_CONTINUE
329 #define TARGET_FIX_AND_CONTINUE 0
332 /* Indicate when fix-and-continue style code generation is being used
333 and when a reference to data should be indirected so that it can be
334 rebound in a new translation unit to reference the original instance
335 of that data. Symbol names that are for code generation local to
336 the translation unit are bound to the new translation unit;
337 currently this means symbols that begin with L or _OBJC_;
338 otherwise, we indicate that an indirect reference should be made to
339 permit the runtime to rebind new instances of the translation unit
340 to the original instance of the data. */
343 indirect_data (rtx sym_ref
)
348 /* If we aren't generating fix-and-continue code, don't do anything
350 if (TARGET_FIX_AND_CONTINUE
== 0)
353 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
354 are indirected. Symbols that begin with L and _OBJC_ are always
355 bound to the current translation unit as they are used for
356 generated local data of the translation unit. */
358 name
= XSTR (sym_ref
, 0);
360 lprefix
= (((name
[0] == '*' || name
[0] == '&')
361 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
362 || (strncmp (name
, "_OBJC_", 6) == 0));
368 machopic_data_defined_p (rtx sym_ref
)
370 if (indirect_data (sym_ref
))
373 switch (machopic_classify_symbol (sym_ref
))
375 case MACHOPIC_DEFINED_DATA
:
376 case MACHOPIC_DEFINED_FUNCTION
:
384 machopic_define_symbol (rtx mem
)
388 gcc_assert (GET_CODE (mem
) == MEM
);
389 sym_ref
= XEXP (mem
, 0);
390 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
393 /* Return either ORIG or:
395 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
397 depending on MACHO_DYNAMIC_NO_PIC_P. */
399 machopic_gen_offset (rtx orig
)
401 if (MACHO_DYNAMIC_NO_PIC_P
)
405 /* Play games to avoid marking the function as needing pic if we
406 are being called as part of the cost-estimation process. */
407 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
408 crtl
->uses_pic_offset_table
= 1;
409 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
410 UNSPEC_MACHOPIC_OFFSET
);
411 return gen_rtx_CONST (Pmode
, orig
);
415 static GTY(()) const char * function_base_func_name
;
416 static GTY(()) int current_pic_label_num
;
417 static GTY(()) int emitted_pic_label_num
;
420 update_pic_label_number_if_needed (void)
422 const char *current_name
;
424 /* When we are generating _get_pc thunks within stubs, there is no current
426 if (current_function_decl
)
429 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
430 if (function_base_func_name
!= current_name
)
432 ++current_pic_label_num
;
433 function_base_func_name
= current_name
;
438 ++current_pic_label_num
;
439 function_base_func_name
= "L_machopic_stub_dummy";
444 machopic_output_function_base_name (FILE *file
)
446 /* If dynamic-no-pic is on, we should not get here. */
447 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
449 update_pic_label_number_if_needed ();
450 fprintf (file
, "L%d$pb", current_pic_label_num
);
453 char curr_picbasename
[32];
456 machopic_get_function_picbase (void)
458 /* If dynamic-no-pic is on, we should not get here. */
459 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
461 update_pic_label_number_if_needed ();
462 snprintf (curr_picbasename
, 32, "L%d$pb", current_pic_label_num
);
463 return (const char *) curr_picbasename
;
467 machopic_should_output_picbase_label (void)
469 update_pic_label_number_if_needed ();
471 if (current_pic_label_num
== emitted_pic_label_num
)
474 emitted_pic_label_num
= current_pic_label_num
;
478 /* The suffix attached to non-lazy pointer symbols. */
479 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
480 /* The suffix attached to stub symbols. */
481 #define STUB_SUFFIX "$stub"
483 typedef struct GTY ((for_user
)) machopic_indirection
485 /* The SYMBOL_REF for the entity referenced. */
487 /* The name of the stub or non-lazy pointer. */
488 const char * ptr_name
;
489 /* True iff this entry is for a stub (as opposed to a non-lazy
492 /* True iff this stub or pointer pointer has been referenced. */
494 } machopic_indirection
;
496 struct indirection_hasher
: ggc_hasher
<machopic_indirection
*>
498 typedef const char *compare_type
;
499 static hashval_t
hash (machopic_indirection
*);
500 static bool equal (machopic_indirection
*, const char *);
503 /* A table mapping stub names and non-lazy pointer names to
504 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
506 static GTY (()) hash_table
<indirection_hasher
> *machopic_indirections
;
508 /* Return a hash value for a SLOT in the indirections hash table. */
511 indirection_hasher::hash (machopic_indirection
*p
)
513 return htab_hash_string (p
->ptr_name
);
516 /* Returns true if the KEY is the same as that associated with
520 indirection_hasher::equal (machopic_indirection
*s
, const char *k
)
522 return strcmp (s
->ptr_name
, k
) == 0;
525 /* Return the name of the non-lazy pointer (if STUB_P is false) or
526 stub (if STUB_B is true) corresponding to the given name. */
529 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
532 const char *name
= XSTR (sym_ref
, 0);
533 size_t namelen
= strlen (name
);
534 machopic_indirection
*p
;
537 const char *prefix
= user_label_prefix
;
538 const char *quote
= "";
541 id
= maybe_get_identifier (name
);
546 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
547 id
= TREE_CHAIN (id
);
550 name
= IDENTIFIER_POINTER (id
);
551 namelen
= strlen (name
);
562 needs_quotes
= name_needs_quotes (name
);
569 suffix
= STUB_SUFFIX
;
571 suffix
= NON_LAZY_POINTER_SUFFIX
;
573 buffer
= XALLOCAVEC (char, strlen ("&L")
580 /* Construct the name of the non-lazy pointer or stub. */
581 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
583 if (!machopic_indirections
)
584 machopic_indirections
= hash_table
<indirection_hasher
>::create_ggc (37);
586 machopic_indirection
**slot
587 = machopic_indirections
->find_slot_with_hash (buffer
,
588 htab_hash_string (buffer
),
596 p
= ggc_alloc
<machopic_indirection
> ();
598 p
->ptr_name
= xstrdup (buffer
);
607 /* Return the name of the stub for the mcount function. */
610 machopic_mcount_stub_name (void)
612 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
613 return machopic_indirection_name (symbol
, /*stub_p=*/true);
616 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
617 or non-lazy pointer as used -- and mark the object to which the
618 pointer/stub refers as used as well, since the pointer/stub will
619 emit a reference to it. */
622 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
624 machopic_indirection
*p
625 = machopic_indirections
->find_with_hash (name
, htab_hash_string (name
));
628 const char *real_name
;
633 /* Do what output_addr_const will do when we actually call it. */
634 if (SYMBOL_REF_DECL (p
->symbol
))
635 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
637 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
639 id
= maybe_get_identifier (real_name
);
641 mark_referenced (id
);
645 /* Transform ORIG, which may be any data source, to the corresponding
646 source using indirections. */
649 machopic_indirect_data_reference (rtx orig
, rtx reg
)
653 if (! MACHOPIC_INDIRECT
)
656 if (GET_CODE (orig
) == SYMBOL_REF
)
658 int defined
= machopic_data_defined_p (orig
);
660 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
664 /* Create a new register for CSE opportunities. */
665 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
666 emit_insn (gen_macho_high (hi_reg
, orig
));
667 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
673 /* some other cpu -- writeme! */
679 if (DARWIN_PPC
|| HAVE_lo_sum
)
680 offset
= machopic_gen_offset (orig
);
684 rtx hi_sum_reg
= (!can_create_pseudo_p ()
686 : gen_reg_rtx (Pmode
));
690 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
691 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
692 gen_rtx_HIGH (Pmode
, offset
))));
693 emit_insn (gen_rtx_SET (Pmode
, reg
,
694 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
695 copy_rtx (offset
))));
699 else if (HAVE_lo_sum
)
703 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
704 gen_rtx_HIGH (Pmode
, offset
)));
705 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
706 gen_rtx_LO_SUM (Pmode
, reg
,
707 copy_rtx (offset
))));
708 emit_use (pic_offset_table_rtx
);
710 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
715 ptr_ref
= (gen_rtx_SYMBOL_REF
717 machopic_indirection_name (orig
, /*stub_p=*/false)));
719 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
721 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
722 machopic_define_symbol (ptr_ref
);
726 && MACHO_DYNAMIC_NO_PIC_P
)
728 emit_insn (gen_rtx_SET (Pmode
, reg
, ptr_ref
));
734 else if (GET_CODE (orig
) == CONST
)
736 /* If "(const (plus ...", walk the PLUS and return that result.
737 PLUS processing (below) will restore the "(const ..." if
739 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
740 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
744 else if (GET_CODE (orig
) == MEM
)
747 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
750 else if (GET_CODE (orig
) == PLUS
)
753 /* When the target is i386, this code prevents crashes due to the
754 compiler's ignorance on how to move the PIC base register to
755 other registers. (The reload phase sometimes introduces such
757 if (GET_CODE (XEXP (orig
, 0)) == REG
758 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
759 /* Prevent the same register from being erroneously used
760 as both the base and index registers. */
761 && (DARWIN_X86
&& (GET_CODE (XEXP (orig
, 1)) == CONST
))
764 emit_move_insn (reg
, XEXP (orig
, 0));
765 XEXP (ptr_ref
, 0) = reg
;
769 /* Legitimize both operands of the PLUS. */
770 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
771 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
772 (base
== reg
? 0 : reg
));
773 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
774 result
= plus_constant (Pmode
, base
, INTVAL (orig
));
776 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
778 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
782 emit_move_insn (reg
, result
);
787 result
= force_reg (GET_MODE (result
), result
);
796 /* Transform TARGET (a MEM), which is a function call target, to the
797 corresponding symbol_stub if necessary. Return a new MEM. */
800 machopic_indirect_call_target (rtx target
)
802 if (! darwin_emit_branch_islands
)
805 if (GET_CODE (target
) != MEM
)
808 if (MACHOPIC_INDIRECT
809 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
810 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
811 & MACHO_SYMBOL_FLAG_DEFINED
))
813 rtx sym_ref
= XEXP (target
, 0);
814 const char *stub_name
= machopic_indirection_name (sym_ref
,
816 machine_mode mode
= GET_MODE (sym_ref
);
818 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
819 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
820 MEM_READONLY_P (target
) = 1;
821 MEM_NOTRAP_P (target
) = 1;
828 machopic_legitimize_pic_address (rtx orig
, machine_mode mode
, rtx reg
)
832 if (! MACHOPIC_INDIRECT
)
835 /* First handle a simple SYMBOL_REF or LABEL_REF */
836 if (GET_CODE (orig
) == LABEL_REF
837 || (GET_CODE (orig
) == SYMBOL_REF
840 /* addr(foo) = &func+(foo-func) */
841 orig
= machopic_indirect_data_reference (orig
, reg
);
843 if (GET_CODE (orig
) == PLUS
844 && GET_CODE (XEXP (orig
, 0)) == REG
)
847 return force_reg (mode
, orig
);
849 emit_move_insn (reg
, orig
);
853 if (GET_CODE (orig
) == MEM
)
857 gcc_assert (!reload_in_progress
);
858 reg
= gen_reg_rtx (Pmode
);
862 if (MACHO_DYNAMIC_NO_PIC_P
863 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
864 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
866 #if defined (TARGET_TOC) /* ppc */
867 rtx temp_reg
= (!can_create_pseudo_p ()
869 gen_reg_rtx (Pmode
));
870 rtx asym
= XEXP (orig
, 0);
873 emit_insn (gen_macho_high (temp_reg
, asym
));
874 mem
= gen_const_mem (GET_MODE (orig
),
875 gen_rtx_LO_SUM (Pmode
, temp_reg
,
877 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
879 /* Some other CPU -- WriteMe! but right now there are no other
880 platforms that can use dynamic-no-pic */
886 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
887 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
889 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
890 #if defined (TARGET_TOC) /* i.e., PowerPC */
891 /* Generating a new reg may expose opportunities for
892 common subexpression elimination. */
893 rtx hi_sum_reg
= (!can_create_pseudo_p ()
895 : gen_reg_rtx (Pmode
));
900 sum
= gen_rtx_HIGH (Pmode
, offset
);
901 if (! MACHO_DYNAMIC_NO_PIC_P
)
902 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
904 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
906 mem
= gen_const_mem (GET_MODE (orig
),
907 gen_rtx_LO_SUM (Pmode
,
910 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
911 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
915 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
917 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
919 gen_rtx_CONST (Pmode
,
921 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
922 gen_rtx_LO_SUM (Pmode
, reg
,
923 gen_rtx_CONST (Pmode
,
924 copy_rtx (offset
)))));
925 pic_ref
= gen_rtx_PLUS (Pmode
,
926 pic_offset_table_rtx
, reg
);
930 #endif /* HAVE_lo_sum */
932 rtx pic
= pic_offset_table_rtx
;
933 if (GET_CODE (pic
) != REG
)
935 emit_move_insn (reg
, pic
);
939 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
942 if (reload_in_progress
)
943 df_set_regs_ever_live (REGNO (pic
), true);
944 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
945 machopic_gen_offset (XEXP (orig
, 0)));
948 #if !defined (TARGET_TOC)
949 emit_move_insn (reg
, pic_ref
);
950 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
957 if (GET_CODE (orig
) == SYMBOL_REF
958 || GET_CODE (orig
) == LABEL_REF
)
960 rtx offset
= machopic_gen_offset (orig
);
961 #if defined (TARGET_TOC) /* i.e., PowerPC */
966 gcc_assert (!reload_in_progress
);
967 reg
= gen_reg_rtx (Pmode
);
972 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
973 (MACHO_DYNAMIC_NO_PIC_P
)
974 ? gen_rtx_HIGH (Pmode
, offset
)
975 : gen_rtx_PLUS (Pmode
,
976 pic_offset_table_rtx
,
979 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
980 gen_rtx_LO_SUM (Pmode
,
982 copy_rtx (offset
))));
985 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
986 gen_rtx_HIGH (Pmode
, offset
)));
987 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
988 gen_rtx_LO_SUM (Pmode
, reg
,
989 copy_rtx (offset
))));
990 pic_ref
= gen_rtx_PLUS (Pmode
,
991 pic_offset_table_rtx
, reg
);
995 #endif /* HAVE_lo_sum */
998 || GET_CODE (orig
) == SUBREG
)
1004 rtx pic
= pic_offset_table_rtx
;
1005 if (GET_CODE (pic
) != REG
)
1007 emit_move_insn (reg
, pic
);
1011 emit_use (pic_offset_table_rtx
);
1013 if (reload_in_progress
)
1014 df_set_regs_ever_live (REGNO (pic
), true);
1015 pic_ref
= gen_rtx_PLUS (Pmode
,
1017 machopic_gen_offset (orig
));
1022 if (GET_CODE (pic_ref
) != REG
)
1026 emit_move_insn (reg
, pic_ref
);
1031 return force_reg (mode
, pic_ref
);
1040 else if (GET_CODE (orig
) == SYMBOL_REF
)
1043 else if (GET_CODE (orig
) == PLUS
1044 && (GET_CODE (XEXP (orig
, 0)) == MEM
1045 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
1046 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
1047 && XEXP (orig
, 0) != pic_offset_table_rtx
1048 && GET_CODE (XEXP (orig
, 1)) != REG
)
1052 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
1054 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1055 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
1056 Pmode
, (base
== reg
? 0 : reg
));
1057 if (GET_CODE (orig
) == CONST_INT
)
1059 pic_ref
= plus_constant (Pmode
, base
, INTVAL (orig
));
1063 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
1065 if (reg
&& is_complex
)
1067 emit_move_insn (reg
, pic_ref
);
1070 /* Likewise, should we set special REG_NOTEs here? */
1073 else if (GET_CODE (orig
) == CONST
)
1075 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1078 else if (GET_CODE (orig
) == MEM
1079 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
1081 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1082 addr
= replace_equiv_address (orig
, addr
);
1083 emit_move_insn (reg
, addr
);
1090 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
1091 DATA is the FILE* for assembly output. Called from
1095 machopic_output_indirection (machopic_indirection
**slot
, FILE *asm_out_file
)
1097 machopic_indirection
*p
= *slot
;
1099 const char *sym_name
;
1100 const char *ptr_name
;
1106 sym_name
= XSTR (symbol
, 0);
1107 ptr_name
= p
->ptr_name
;
1115 id
= maybe_get_identifier (sym_name
);
1120 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1121 id
= TREE_CHAIN (id
);
1123 sym_name
= IDENTIFIER_POINTER (id
);
1126 sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1127 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1128 strcpy (sym
, sym_name
+ 1);
1129 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1130 strcpy (sym
, sym_name
);
1132 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1134 stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1135 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1136 strcpy (stub
, ptr_name
+ 1);
1138 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1140 machopic_output_stub (asm_out_file
, sym
, stub
);
1142 else if (! indirect_data (symbol
)
1143 && (machopic_symbol_defined_p (symbol
)
1144 || SYMBOL_REF_LOCAL_P (symbol
)))
1146 switch_to_section (data_section
);
1147 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1148 assemble_label (asm_out_file
, ptr_name
);
1149 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1150 GET_MODE_SIZE (Pmode
),
1151 GET_MODE_ALIGNMENT (Pmode
), 1);
1155 rtx init
= const0_rtx
;
1157 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1159 /* Mach-O symbols are passed around in code through indirect
1160 references and the original symbol_ref hasn't passed through
1161 the generic handling and reference-catching in
1162 output_operand, so we need to manually mark weak references
1164 if (SYMBOL_REF_WEAK (symbol
))
1166 tree decl
= SYMBOL_REF_DECL (symbol
);
1167 gcc_assert (DECL_P (decl
));
1169 if (decl
!= NULL_TREE
1170 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1171 /* Handle only actual external-only definitions, not
1172 e.g. extern inline code or variables for which
1173 storage has been allocated. */
1174 && !TREE_STATIC (decl
))
1176 fputs ("\t.weak_reference ", asm_out_file
);
1177 assemble_name (asm_out_file
, sym_name
);
1178 fputc ('\n', asm_out_file
);
1182 assemble_name (asm_out_file
, ptr_name
);
1183 fprintf (asm_out_file
, ":\n");
1185 fprintf (asm_out_file
, "\t.indirect_symbol ");
1186 assemble_name (asm_out_file
, sym_name
);
1187 fprintf (asm_out_file
, "\n");
1189 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1190 have their symbol name instead of 0 in the second entry of
1191 the non-lazy symbol pointer data structure when they are
1192 defined. This allows the runtime to rebind newer instances
1193 of the translation unit with the original instance of the
1196 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1197 && machopic_symbol_defined_p (symbol
))
1198 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1200 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1201 GET_MODE_ALIGNMENT (Pmode
), 1);
1208 machopic_finish (FILE *asm_out_file
)
1210 if (machopic_indirections
)
1211 machopic_indirections
1212 ->traverse_noresize
<FILE *, machopic_output_indirection
> (asm_out_file
);
1216 machopic_operand_p (rtx op
)
1218 if (MACHOPIC_JUST_INDIRECT
)
1219 return (GET_CODE (op
) == SYMBOL_REF
1220 && machopic_symbol_defined_p (op
));
1222 return (GET_CODE (op
) == CONST
1223 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1224 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1227 /* This function records whether a given name corresponds to a defined
1228 or undefined function or variable, for machopic_classify_ident to
1232 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1236 /* Do the standard encoding things first. */
1237 default_encode_section_info (decl
, rtl
, first
);
1239 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1242 sym_ref
= XEXP (rtl
, 0);
1243 if (TREE_CODE (decl
) == VAR_DECL
)
1244 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1246 if (!DECL_EXTERNAL (decl
)
1247 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1248 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1249 && ((TREE_STATIC (decl
)
1250 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1251 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1252 && DECL_INITIAL (decl
) != error_mark_node
)))
1253 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1255 if (! TREE_PUBLIC (decl
))
1256 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1260 darwin_mark_decl_preserved (const char *name
)
1262 fprintf (asm_out_file
, "\t.no_dead_strip ");
1263 assemble_name (asm_out_file
, name
);
1264 fputc ('\n', asm_out_file
);
1268 darwin_rodata_section (int weak
, bool zsize
)
1271 ? darwin_sections
[const_coal_section
]
1272 : (zsize
? darwin_sections
[zobj_const_section
]
1273 : darwin_sections
[const_section
]));
1277 darwin_mergeable_string_section (tree exp
,
1278 unsigned HOST_WIDE_INT align
)
1280 /* Darwin's ld expects to see non-writable string literals in the .cstring
1281 section. Later versions of ld check and complain when CFStrings are
1282 enabled. Therefore we shall force the strings into .cstring since we
1283 don't support writable ones anyway. */
1284 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1285 && TREE_CODE (exp
) == STRING_CST
1286 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1288 && (int_size_in_bytes (TREE_TYPE (exp
))
1289 == TREE_STRING_LENGTH (exp
))
1290 && ((size_t) TREE_STRING_LENGTH (exp
)
1291 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1292 return darwin_sections
[cstring_section
];
1294 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1295 && TREE_CODE (exp
) == STRING_CST
1296 && TREE_STRING_LENGTH (exp
) == 0)
1297 return darwin_sections
[zobj_const_section
];
1299 return readonly_data_section
;
1302 #ifndef HAVE_GAS_LITERAL16
1303 #define HAVE_GAS_LITERAL16 0
1307 darwin_mergeable_constant_section (tree exp
,
1308 unsigned HOST_WIDE_INT align
,
1311 machine_mode mode
= DECL_MODE (exp
);
1312 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1314 if (DARWIN_SECTION_ANCHORS
1315 && flag_section_anchors
1317 return darwin_sections
[zobj_const_section
];
1319 if (flag_merge_constants
1322 && modesize
<= align
1325 && (align
& (align
-1)) == 0)
1327 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1329 if (TREE_CODE (size
) == INTEGER_CST
)
1331 if (wi::eq_p (size
, 4))
1332 return darwin_sections
[literal4_section
];
1333 else if (wi::eq_p (size
, 8))
1334 return darwin_sections
[literal8_section
];
1335 else if (HAVE_GAS_LITERAL16
1337 && wi::eq_p (size
, 16))
1338 return darwin_sections
[literal16_section
];
1342 return readonly_data_section
;
1346 darwin_tm_clone_table_section (void)
1348 return get_named_section (NULL
,
1349 "__DATA,__tm_clone_table,regular,no_dead_strip",
1354 machopic_reloc_rw_mask (void)
1356 return MACHOPIC_INDIRECT
? 3 : 0;
1359 /* We have to deal with ObjC/C++ metadata section placement in the common
1360 code, since it will also be called from LTO.
1362 Return metadata attributes, if present (searching for ABI=2 first)
1363 Return NULL_TREE if no such attributes are found. */
1366 is_objc_metadata (tree decl
)
1369 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1370 && DECL_ATTRIBUTES (decl
))
1372 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1375 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1382 static int classes_seen
;
1383 static int objc_metadata_seen
;
1385 /* Return the section required for Objective C ABI 2 metadata. */
1387 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1390 tree ident
= TREE_VALUE (meta
);
1391 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1392 p
= IDENTIFIER_POINTER (ident
);
1394 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
== 2);
1396 objc_metadata_seen
= 1;
1398 if (base
== data_section
)
1399 base
= darwin_sections
[objc2_metadata_section
];
1401 /* Most of the OBJC2 META-data end up in the base section, so check it
1403 if (!strncmp (p
, "V2_BASE", 7))
1405 else if (!strncmp (p
, "V2_STRG", 7))
1406 return darwin_sections
[cstring_section
];
1408 else if (!strncmp (p
, "G2_META", 7) || !strncmp (p
, "G2_CLAS", 7))
1409 return darwin_sections
[objc2_classdefs_section
];
1410 else if (!strncmp (p
, "V2_MREF", 7))
1411 return darwin_sections
[objc2_message_refs_section
];
1412 else if (!strncmp (p
, "V2_CLRF", 7))
1413 return darwin_sections
[objc2_classrefs_section
];
1414 else if (!strncmp (p
, "V2_SURF", 7))
1415 return darwin_sections
[objc2_super_classrefs_section
];
1416 else if (!strncmp (p
, "V2_NLCL", 7))
1417 return darwin_sections
[objc2_nonlazy_class_section
];
1418 else if (!strncmp (p
, "V2_CLAB", 7))
1421 return darwin_sections
[objc2_classlist_section
];
1423 else if (!strncmp (p
, "V2_SRFS", 7))
1424 return darwin_sections
[objc2_selector_refs_section
];
1425 else if (!strncmp (p
, "V2_NLCA", 7))
1426 return darwin_sections
[objc2_nonlazy_category_section
];
1427 else if (!strncmp (p
, "V2_CALA", 7))
1428 return darwin_sections
[objc2_categorylist_section
];
1430 else if (!strncmp (p
, "V2_PLST", 7))
1431 return darwin_sections
[objc2_protocollist_section
];
1432 else if (!strncmp (p
, "V2_PRFS", 7))
1433 return darwin_sections
[objc2_protocolrefs_section
];
1435 else if (!strncmp (p
, "V2_INFO", 7))
1436 return darwin_sections
[objc2_image_info_section
];
1438 else if (!strncmp (p
, "V2_EHTY", 7))
1439 return darwin_sections
[data_coal_section
];
1441 else if (!strncmp (p
, "V2_CSTR", 7))
1442 return darwin_sections
[objc2_constant_string_object_section
];
1444 /* Not recognized, default. */
1448 /* Return the section required for Objective C ABI 0/1 metadata. */
1450 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1453 tree ident
= TREE_VALUE (meta
);
1454 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1455 p
= IDENTIFIER_POINTER (ident
);
1457 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
< 2);
1459 objc_metadata_seen
= 1;
1461 /* String sections first, cos there are lots of strings. */
1462 if (!strncmp (p
, "V1_STRG", 7))
1463 return darwin_sections
[cstring_section
];
1464 else if (!strncmp (p
, "V1_CLSN", 7))
1465 return darwin_sections
[objc_class_names_section
];
1466 else if (!strncmp (p
, "V1_METN", 7))
1467 return darwin_sections
[objc_meth_var_names_section
];
1468 else if (!strncmp (p
, "V1_METT", 7))
1469 return darwin_sections
[objc_meth_var_types_section
];
1471 else if (!strncmp (p
, "V1_CLAS", 7))
1474 return darwin_sections
[objc_class_section
];
1476 else if (!strncmp (p
, "V1_META", 7))
1477 return darwin_sections
[objc_meta_class_section
];
1478 else if (!strncmp (p
, "V1_CATG", 7))
1479 return darwin_sections
[objc_category_section
];
1480 else if (!strncmp (p
, "V1_PROT", 7))
1481 return darwin_sections
[objc_protocol_section
];
1483 else if (!strncmp (p
, "V1_CLCV", 7))
1484 return darwin_sections
[objc_class_vars_section
];
1485 else if (!strncmp (p
, "V1_CLIV", 7))
1486 return darwin_sections
[objc_instance_vars_section
];
1488 else if (!strncmp (p
, "V1_CLCM", 7))
1489 return darwin_sections
[objc_cls_meth_section
];
1490 else if (!strncmp (p
, "V1_CLIM", 7))
1491 return darwin_sections
[objc_inst_meth_section
];
1492 else if (!strncmp (p
, "V1_CACM", 7))
1493 return darwin_sections
[objc_cat_cls_meth_section
];
1494 else if (!strncmp (p
, "V1_CAIM", 7))
1495 return darwin_sections
[objc_cat_inst_meth_section
];
1496 else if (!strncmp (p
, "V1_PNSM", 7))
1497 return darwin_sections
[objc_cat_inst_meth_section
];
1498 else if (!strncmp (p
, "V1_PCLM", 7))
1499 return darwin_sections
[objc_cat_cls_meth_section
];
1501 else if (!strncmp (p
, "V1_CLPR", 7))
1502 return darwin_sections
[objc_cat_cls_meth_section
];
1503 else if (!strncmp (p
, "V1_CAPR", 7))
1504 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1506 else if (!strncmp (p
, "V1_PRFS", 7))
1507 return darwin_sections
[objc_cat_cls_meth_section
];
1508 else if (!strncmp (p
, "V1_CLRF", 7))
1509 return darwin_sections
[objc_cls_refs_section
];
1510 else if (!strncmp (p
, "V1_SRFS", 7))
1511 return darwin_sections
[objc_selector_refs_section
];
1513 else if (!strncmp (p
, "V1_MODU", 7))
1514 return darwin_sections
[objc_module_info_section
];
1515 else if (!strncmp (p
, "V1_SYMT", 7))
1516 return darwin_sections
[objc_symbols_section
];
1517 else if (!strncmp (p
, "V1_INFO", 7))
1518 return darwin_sections
[objc_image_info_section
];
1520 else if (!strncmp (p
, "V1_PLST", 7))
1521 return darwin_sections
[objc1_prop_list_section
];
1522 else if (!strncmp (p
, "V1_PEXT", 7))
1523 return darwin_sections
[objc1_protocol_ext_section
];
1524 else if (!strncmp (p
, "V1_CEXT", 7))
1525 return darwin_sections
[objc1_class_ext_section
];
1527 else if (!strncmp (p
, "V2_CSTR", 7))
1528 return darwin_sections
[objc_constant_string_object_section
];
1534 machopic_select_section (tree decl
,
1536 unsigned HOST_WIDE_INT align
)
1538 bool zsize
, one
, weak
, ro
;
1539 section
*base_section
= NULL
;
1541 weak
= (DECL_P (decl
)
1543 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1545 zsize
= (DECL_P (decl
)
1546 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1547 && tree_to_uhwi (DECL_SIZE_UNIT (decl
)) == 0);
1550 && TREE_CODE (decl
) == VAR_DECL
1551 && DECL_COMDAT_GROUP (decl
);
1553 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1555 switch (categorize_decl_for_section (decl
, reloc
))
1562 case SECCAT_SRODATA
:
1563 base_section
= darwin_rodata_section (weak
, zsize
);
1566 case SECCAT_RODATA_MERGE_STR
:
1567 base_section
= darwin_mergeable_string_section (decl
, align
);
1570 case SECCAT_RODATA_MERGE_STR_INIT
:
1571 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1574 case SECCAT_RODATA_MERGE_CONST
:
1575 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1579 case SECCAT_DATA_REL
:
1580 case SECCAT_DATA_REL_LOCAL
:
1581 case SECCAT_DATA_REL_RO
:
1582 case SECCAT_DATA_REL_RO_LOCAL
:
1588 base_section
= darwin_sections
[const_data_coal_section
];
1590 base_section
= darwin_sections
[data_coal_section
];
1592 else if (DARWIN_SECTION_ANCHORS
1593 && flag_section_anchors
1596 /* If we're doing section anchors, then punt zero-sized objects into
1597 their own sections so that they don't interfere with offset
1598 computation for the remaining vars. This does not need to be done
1599 for stuff in mergeable sections, since these are ineligible for
1602 base_section
= darwin_sections
[zobj_const_data_section
];
1604 base_section
= darwin_sections
[zobj_data_section
];
1607 base_section
= darwin_sections
[const_data_section
];
1609 base_section
= data_section
;
1615 base_section
= darwin_sections
[data_coal_section
];
1618 if (!TREE_PUBLIC (decl
))
1619 base_section
= lcomm_section
;
1620 else if (bss_noswitch_section
)
1621 base_section
= bss_noswitch_section
;
1623 base_section
= data_section
;
1631 /* Darwin weird special cases.
1632 a) OBJC Meta-data. */
1634 && (TREE_CODE (decl
) == VAR_DECL
1635 || TREE_CODE (decl
) == CONST_DECL
)
1636 && DECL_ATTRIBUTES (decl
))
1638 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1640 return darwin_objc2_section (decl
, meta
, base_section
);
1641 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1643 return darwin_objc1_section (decl
, meta
, base_section
);
1644 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1646 return base_section
; /* GNU runtime is happy with it all in one pot. */
1649 /* b) Constant string objects. */
1650 if (TREE_CODE (decl
) == CONSTRUCTOR
1652 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1653 && TYPE_NAME (TREE_TYPE (decl
)))
1655 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1656 if (TREE_CODE (name
) == TYPE_DECL
)
1657 name
= DECL_NAME (name
);
1659 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1661 if (flag_next_runtime
)
1663 if (flag_objc_abi
== 2)
1664 return darwin_sections
[objc2_constant_string_object_section
];
1666 return darwin_sections
[objc_constant_string_object_section
];
1669 return darwin_sections
[objc_string_object_section
];
1671 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1672 return darwin_sections
[cfstring_constant_object_section
];
1674 return base_section
;
1676 /* c) legacy meta-data selection. */
1677 else if (TREE_CODE (decl
) == VAR_DECL
1679 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1680 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1681 && flag_next_runtime
1682 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1684 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1685 static bool warned_objc_46
= false;
1686 /* We shall assert that zero-sized objects are an error in ObjC
1688 gcc_assert (tree_to_uhwi (DECL_SIZE_UNIT (decl
)) != 0);
1690 /* ??? This mechanism for determining the metadata section is
1691 broken when LTO is in use, since the frontend that generated
1692 the data is not identified. We will keep the capability for
1693 the short term - in case any non-Objective-C programs are using
1694 it to place data in specified sections. */
1695 if (!warned_objc_46
)
1697 location_t loc
= DECL_SOURCE_LOCATION (decl
);
1698 warning_at (loc
, 0, "the use of _OBJC_-prefixed variable names"
1699 " to select meta-data sections is deprecated at 4.6"
1700 " and will be removed in 4.7");
1701 warned_objc_46
= true;
1704 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1705 return darwin_sections
[objc_cls_meth_section
];
1706 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1707 return darwin_sections
[objc_inst_meth_section
];
1708 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 29))
1709 return darwin_sections
[objc_cat_cls_meth_section
];
1710 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 32))
1711 return darwin_sections
[objc_cat_inst_meth_section
];
1712 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1713 return darwin_sections
[objc_class_vars_section
];
1714 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1715 return darwin_sections
[objc_instance_vars_section
];
1716 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1717 return darwin_sections
[objc_cat_cls_meth_section
];
1718 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1719 return darwin_sections
[objc_class_names_section
];
1720 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1721 return darwin_sections
[objc_meth_var_names_section
];
1722 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1723 return darwin_sections
[objc_meth_var_types_section
];
1724 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1725 return darwin_sections
[objc_cls_refs_section
];
1726 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1727 return darwin_sections
[objc_class_section
];
1728 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1729 return darwin_sections
[objc_meta_class_section
];
1730 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1731 return darwin_sections
[objc_category_section
];
1732 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1733 return darwin_sections
[objc_selector_refs_section
];
1734 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1735 return darwin_sections
[objc_selector_fixup_section
];
1736 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1737 return darwin_sections
[objc_symbols_section
];
1738 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1739 return darwin_sections
[objc_module_info_section
];
1740 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1741 return darwin_sections
[objc_image_info_section
];
1742 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1743 return darwin_sections
[objc_cat_inst_meth_section
];
1744 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1745 return darwin_sections
[objc_cat_cls_meth_section
];
1746 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1747 return darwin_sections
[objc_cat_cls_meth_section
];
1748 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1749 return darwin_sections
[objc_protocol_section
];
1751 return base_section
;
1754 return base_section
;
1757 /* This can be called with address expressions as "rtx".
1758 They must go in "const". */
1761 machopic_select_rtx_section (machine_mode mode
, rtx x
,
1762 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1764 if (GET_MODE_SIZE (mode
) == 8
1765 && (GET_CODE (x
) == CONST_INT
1766 || GET_CODE (x
) == CONST_WIDE_INT
1767 || GET_CODE (x
) == CONST_DOUBLE
))
1768 return darwin_sections
[literal8_section
];
1769 else if (GET_MODE_SIZE (mode
) == 4
1770 && (GET_CODE (x
) == CONST_INT
1771 || GET_CODE (x
) == CONST_WIDE_INT
1772 || GET_CODE (x
) == CONST_DOUBLE
))
1773 return darwin_sections
[literal4_section
];
1774 else if (HAVE_GAS_LITERAL16
1776 && GET_MODE_SIZE (mode
) == 16
1777 && (GET_CODE (x
) == CONST_INT
1778 || GET_CODE (x
) == CONST_WIDE_INT
1779 || GET_CODE (x
) == CONST_DOUBLE
1780 || GET_CODE (x
) == CONST_VECTOR
))
1781 return darwin_sections
[literal16_section
];
1782 else if (MACHOPIC_INDIRECT
1783 && (GET_CODE (x
) == SYMBOL_REF
1784 || GET_CODE (x
) == CONST
1785 || GET_CODE (x
) == LABEL_REF
))
1786 return darwin_sections
[const_data_section
];
1788 return darwin_sections
[const_section
];
1792 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1794 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (ctors
)};
1796 vec_safe_push (ctors
, new_elt
);
1798 if (! MACHOPIC_INDIRECT
)
1799 fprintf (asm_out_file
, ".reference .constructors_used\n");
1803 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1805 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (dtors
)};
1807 vec_safe_push (dtors
, new_elt
);
1809 if (! MACHOPIC_INDIRECT
)
1810 fprintf (asm_out_file
, ".reference .destructors_used\n");
1814 sort_cdtor_records (const void * a
, const void * b
)
1816 const cdtor_record
*cda
= (const cdtor_record
*)a
;
1817 const cdtor_record
*cdb
= (const cdtor_record
*)b
;
1818 if (cda
->priority
> cdb
->priority
)
1820 if (cda
->priority
< cdb
->priority
)
1822 if (cda
->position
> cdb
->position
)
1824 if (cda
->position
< cdb
->position
)
1835 if (MACHOPIC_INDIRECT
)
1836 switch_to_section (darwin_sections
[mod_init_section
]);
1838 switch_to_section (darwin_sections
[constructor_section
]);
1840 if (vec_safe_length (ctors
) > 1)
1841 ctors
->qsort (sort_cdtor_records
);
1842 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
1844 assemble_align (POINTER_SIZE
);
1845 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1855 if (MACHOPIC_INDIRECT
)
1856 switch_to_section (darwin_sections
[mod_term_section
]);
1858 switch_to_section (darwin_sections
[destructor_section
]);
1860 if (vec_safe_length (dtors
) > 1)
1861 dtors
->qsort (sort_cdtor_records
);
1862 FOR_EACH_VEC_SAFE_ELT (dtors
, i
, elt
)
1864 assemble_align (POINTER_SIZE
);
1865 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1870 darwin_globalize_label (FILE *stream
, const char *name
)
1872 if (!!strncmp (name
, "_OBJC_", 6))
1873 default_globalize_label (stream
, name
);
1876 /* This routine returns non-zero if 'name' starts with the special objective-c
1877 anonymous file-scope static name. It accommodates c++'s mangling of such
1878 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1881 darwin_label_is_anonymous_local_objc_name (const char *name
)
1883 const unsigned char *p
= (const unsigned char *) name
;
1886 if (p
[1] == 'Z' && p
[2] == 'L')
1889 while (*p
>= '0' && *p
<= '9')
1892 return (!strncmp ((const char *)p
, "_OBJC_", 6));
1895 /* LTO support for Mach-O.
1897 This version uses three mach-o sections to encapsulate the (unlimited
1898 number of) lto sections.
1900 __GNU_LTO, __lto_sections contains the concatented GNU LTO section data.
1901 __GNU_LTO, __section_names contains the GNU LTO section names.
1902 __GNU_LTO, __section_index contains an array of values that index these.
1905 <section offset from the start of __GNU_LTO, __lto_sections>,
1907 <name offset from the start of __GNU_LTO, __section_names,
1910 At present, for both m32 and m64 mach-o files each of these fields is
1911 represented by a uint32_t. This is because, AFAICT, a mach-o object
1912 cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
1915 "offset An integer specifying the offset to this section in the file." */
1917 /* Count lto section numbers. */
1918 static unsigned int lto_section_num
= 0;
1920 /* A vector of information about LTO sections, at present, we only have
1921 the name. TODO: see if we can get the data length somehow. */
1922 typedef struct GTY (()) darwin_lto_section_e
{
1923 const char *sectname
;
1924 } darwin_lto_section_e
;
1926 static GTY (()) vec
<darwin_lto_section_e
, va_gc
> *lto_section_names
;
1928 /* Section wrapper scheme (used here to wrap the unlimited number of LTO
1929 sections into three Mach-O ones).
1930 NOTE: These names MUST be kept in sync with those in
1931 libiberty/simple-object-mach-o. */
1932 #define LTO_SECTS_SECTION "__wrapper_sects"
1933 #define LTO_NAMES_SECTION "__wrapper_names"
1934 #define LTO_INDEX_SECTION "__wrapper_index"
1936 /* File to temporarily store LTO data. This is appended to asm_out_file
1937 in darwin_end_file. */
1938 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
1939 static char *lto_asm_out_name
;
1941 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
1942 asm_out_file and switching to an alternative output file. */
1944 darwin_asm_lto_start (void)
1946 gcc_assert (! saved_asm_out_file
);
1947 saved_asm_out_file
= asm_out_file
;
1948 if (! lto_asm_out_name
)
1949 lto_asm_out_name
= make_temp_file (".lto.s");
1950 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
1951 if (lto_asm_out_file
== NULL
)
1952 fatal_error ("failed to open temporary file %s for LTO output",
1954 asm_out_file
= lto_asm_out_file
;
1957 /* Restore asm_out_file. */
1959 darwin_asm_lto_end (void)
1961 gcc_assert (saved_asm_out_file
);
1962 fclose (lto_asm_out_file
);
1963 asm_out_file
= saved_asm_out_file
;
1964 saved_asm_out_file
= NULL
;
1968 darwin_asm_dwarf_section (const char *name
, unsigned int flags
, tree decl
);
1970 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
1973 darwin_asm_named_section (const char *name
,
1975 tree decl ATTRIBUTE_UNUSED
)
1977 /* LTO sections go in a special section that encapsulates the (unlimited)
1978 number of GNU LTO sections within a single mach-o one. */
1979 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
1980 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
1982 darwin_lto_section_e e
;
1983 /* We expect certain flags to be set... */
1984 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
1985 == (SECTION_DEBUG
| SECTION_NAMED
));
1987 /* Switch to our combined section. */
1988 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
1989 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
1990 /* Output a label for the start of this sub-section. */
1991 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# %s\n",
1992 lto_section_num
, name
);
1993 /* We have to jump through hoops to get the values of the intra-section
1995 fprintf (asm_out_file
, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
1996 lto_section_num
, lto_section_num
);
1997 fprintf (asm_out_file
,
1998 "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
1999 lto_section_num
, lto_section_num
+1, lto_section_num
);
2001 e
.sectname
= xstrdup (name
);
2002 /* Keep the names, we'll need to make a table later.
2003 TODO: check that we do not revisit sections, that would break
2004 the assumption of how this is done. */
2005 if (lto_section_names
== NULL
)
2006 vec_alloc (lto_section_names
, 16);
2007 vec_safe_push (lto_section_names
, e
);
2009 else if (strncmp (name
, "__DWARF,", 8) == 0)
2010 darwin_asm_dwarf_section (name
, flags
, decl
);
2012 fprintf (asm_out_file
, "\t.section %s\n", name
);
2016 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
2018 /* Darwin does not use unique sections. */
2021 /* Handle __attribute__ ((apple_kext_compatibility)).
2022 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
2023 vtable for classes with this attribute (and their descendants) by not
2024 outputting the new 3.0 nondeleting destructor. This means that such
2025 objects CANNOT be allocated on the stack or as globals UNLESS they have
2026 a completely empty `operator delete'.
2027 Luckily, this fits in with the Darwin kext model.
2029 This attribute also disables gcc3's potential overlaying of derived
2030 class data members on the padding at the end of the base class. */
2033 darwin_handle_kext_attribute (tree
*node
, tree name
,
2034 tree args ATTRIBUTE_UNUSED
,
2035 int flags ATTRIBUTE_UNUSED
,
2038 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
2039 if (! TARGET_KEXTABI
)
2041 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2042 "only when compiling a kext", name
);
2044 *no_add_attrs
= true;
2046 else if (TREE_CODE (*node
) != RECORD_TYPE
)
2048 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2049 "only to C++ classes", name
);
2051 *no_add_attrs
= true;
2057 /* Handle a "weak_import" attribute; arguments as in
2058 struct attribute_spec.handler. */
2061 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
2062 tree
ARG_UNUSED (args
),
2063 int ARG_UNUSED (flags
),
2064 bool * no_add_attrs
)
2066 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
2068 warning (OPT_Wattributes
, "%qE attribute ignored",
2070 *no_add_attrs
= true;
2073 declare_weak (*node
);
2078 /* Emit a label for an FDE, making it global and/or weak if appropriate.
2079 The third parameter is nonzero if this is for exception handling.
2080 The fourth parameter is nonzero if this is just a placeholder for an
2081 FDE that we are omitting. */
2084 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
2088 static int invok_count
= 0;
2089 static tree last_fun_decl
= NULL_TREE
;
2091 /* We use the linker to emit the .eh labels for Darwin 9 and above. */
2092 if (! for_eh
|| generating_for_darwin_version
>= 9)
2095 /* FIXME: This only works when the eh for all sections of a function is
2096 emitted at the same time. If that changes, we would need to use a lookup
2097 table of some form to determine what to do. Also, we should emit the
2098 unadorned label for the partition containing the public label for a
2099 function. This is of limited use, probably, since we do not currently
2100 enable partitioning. */
2101 strcpy (buf
, ".eh");
2102 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
2104 if (decl
== last_fun_decl
)
2107 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
2111 last_fun_decl
= decl
;
2116 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
2118 if (TREE_PUBLIC (decl
))
2120 targetm
.asm_out
.globalize_label (file
, lab
);
2121 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
2123 fputs ("\t.private_extern ", file
);
2124 assemble_name (file
, lab
);
2129 if (DECL_WEAK (decl
))
2131 fputs ("\t.weak_definition ", file
);
2132 assemble_name (file
, lab
);
2136 assemble_name (file
, lab
);
2139 fputs (" = 0\n", file
);
2141 /* Mark the absolute .eh and .eh1 style labels as needed to
2142 ensure that we don't dead code strip them and keep such
2143 labels from another instantiation point until we can fix this
2144 properly with group comdat support. */
2145 darwin_mark_decl_preserved (lab
);
2148 fputs (":\n", file
);
2153 static GTY(()) unsigned long except_table_label_num
;
2156 darwin_emit_except_table_label (FILE *file
)
2158 char section_start_label
[30];
2160 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
2161 except_table_label_num
++);
2162 ASM_OUTPUT_LABEL (file
, section_start_label
);
2164 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2167 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2169 const char *nlp_name
;
2171 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2173 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2174 fputs ("\t.long\t", file
);
2175 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2179 /* If this is uncommented, details of each allocation will be printed
2180 in the asm right before the actual code. WARNING - this will cause some
2181 test-suite fails (since the printout will contain items that some tests
2182 are not expecting) -- so don't leave it on by default (it bloats the
2184 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2186 /* The first two of these routines are ostensibly just intended to put
2187 names into the asm. However, they are both hijacked in order to ensure
2188 that zero-sized items do not make their way into the output. Consequently,
2189 we also need to make these participate in provisions for dealing with
2190 such items in section anchors. */
2192 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2193 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2194 but it does need to be referenced via indirect PIC data pointers.
2195 The machopic_define_symbol calls are telling the machopic subsystem
2196 that the name *is* defined in this module, so it doesn't need to
2197 make them indirect. */
2199 darwin_asm_declare_object_name (FILE *file
,
2200 const char *nam
, tree decl
)
2202 const char *xname
= nam
;
2203 unsigned HOST_WIDE_INT size
;
2204 bool local_def
, weak
;
2206 weak
= (DECL_P (decl
)
2208 && !lookup_attribute ("weak_import",
2209 DECL_ATTRIBUTES (decl
)));
2211 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2212 && (!DECL_COMMON (decl
)
2213 || !TREE_PUBLIC (decl
)));
2215 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2216 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2220 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2222 machopic_define_symbol (DECL_RTL (decl
));
2225 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2227 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2228 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2229 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2230 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2231 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2232 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2233 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2234 (unsigned long)DECL_INITIAL (decl
));
2237 /* Darwin needs help to support local zero-sized objects.
2238 They must be made at least one byte, and the section containing must be
2239 marked as unsuitable for section-anchors (see storage allocators below).
2241 For non-zero objects this output is handled by varasm.c.
2245 unsigned int l2align
= 0;
2247 /* The align must be honored, even for zero-sized. */
2248 if (DECL_ALIGN (decl
))
2250 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2251 fprintf (file
, "\t.align\t%u\n", l2align
);
2254 ASM_OUTPUT_LABEL (file
, xname
);
2256 fprintf (file
, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2258 /* Check that we've correctly picked up the zero-sized item and placed it
2260 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2262 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2265 ASM_OUTPUT_LABEL (file
, xname
);
2268 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2270 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2271 const_tree exp ATTRIBUTE_UNUSED
,
2274 assemble_label (file
, name
);
2275 /* As for other items, we need at least one byte. */
2278 fputs ("\t.space\t1\n", file
);
2279 /* Check that we've correctly picked up the zero-sized item and placed it
2281 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2283 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2287 /* Darwin storage allocators.
2289 Zerofill sections are desirable for large blank data since, otherwise, these
2290 data bloat objects (PR33210).
2292 However, section anchors don't work in .zerofill sections (one cannot switch
2293 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2294 to put (at least some) data into 'normal' switchable sections.
2296 Here we set a relatively arbitrary value for the size of an object to trigger
2297 zerofill when section anchors are enabled (anything bigger than a page for
2298 current Darwin implementations). FIXME: there ought to be some objective way
2299 to make this choice.
2301 When section anchor are off this is ignored anyway. */
2303 #define BYTES_ZFILL 4096
2305 /* Emit a chunk of data for items coalesced by the linker. */
2307 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2308 unsigned HOST_WIDE_INT size
,
2311 /* Since the sections used here are coalesed, they will not be eligible
2312 for section anchors, and therefore we don't need to break that out. */
2313 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2314 switch_to_section (darwin_sections
[const_data_coal_section
]);
2316 switch_to_section (darwin_sections
[data_coal_section
]);
2318 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2319 the align info for zero-sized items... but do it here otherwise. */
2321 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2323 if (TREE_PUBLIC (decl
))
2324 darwin_globalize_label (fp
, name
);
2326 /* ... and we let it deal with outputting one byte of zero for them too. */
2327 darwin_asm_declare_object_name (fp
, name
, decl
);
2329 assemble_zeros (size
);
2332 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2334 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2335 unsigned HOST_WIDE_INT size
,
2336 unsigned int align
, tree meta
)
2338 section
*ocs
= data_section
;
2340 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2341 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2343 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2345 switch_to_section (ocs
);
2347 /* We shall declare that zero-sized meta-data are not valid (yet). */
2349 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2351 /* ... and we let it deal with outputting one byte of zero for them too. */
2352 darwin_asm_declare_object_name (fp
, name
, decl
);
2353 assemble_zeros (size
);
2356 /* This routine emits 'local' storage:
2358 When Section Anchors are off this routine emits .zerofill commands in
2359 sections named for their alignment.
2361 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2362 the .static_data section so that the section anchoring system can see them.
2363 Larger items are still placed in .zerofill sections, addressing PR33210.
2364 The routine has no checking - it is all assumed to be done by the caller.
2367 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2368 unsigned HOST_WIDE_INT size
,
2369 unsigned int l2align
)
2371 /* FIXME: We have a fudge to make this work with Java even when the target does
2372 not use sections anchors -- Java seems to need at least one small item in a
2373 non-zerofill segment. */
2374 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2375 || (size
&& size
<= 2))
2377 /* Put smaller objects in _static_data, where the section anchors system
2379 However, if they are zero-sized punt them to yet a different section
2380 (that is not allowed to participate in anchoring). */
2383 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2384 in_section
= darwin_sections
[zobj_bss_section
];
2389 fputs ("\t.static_data\n", fp
);
2390 in_section
= darwin_sections
[static_data_section
];
2394 fprintf (fp
, "\t.align\t%u\n", l2align
);
2396 assemble_name (fp
, name
);
2397 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2401 /* When we are on a non-section anchor target, we can get zero-sized
2402 items here. However, all we need to do is to bump them to one byte
2403 and the section alignment will take care of the rest. */
2405 unsigned int flags
;
2406 snprintf (secnam
, 64, "__DATA,__%sbss%u", ((size
)?"":"zo_"),
2407 (unsigned) l2align
);
2408 /* We can't anchor (yet, if ever) in zerofill sections, because we can't
2409 switch to them and emit a label. */
2410 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2411 in_section
= get_section (secnam
, flags
, NULL
);
2412 fprintf (fp
, "\t.zerofill %s,", secnam
);
2413 assemble_name (fp
, name
);
2418 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2419 size
, (unsigned) l2align
);
2421 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2424 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2425 /* This is defined as a file-scope var, so we know to notify machopic. */
2426 machopic_define_symbol (DECL_RTL (decl
));
2429 /* Emit a chunk of common. */
2431 darwin_emit_common (FILE *fp
, const char *name
,
2432 unsigned HOST_WIDE_INT size
, unsigned int align
)
2434 unsigned HOST_WIDE_INT rounded
;
2435 unsigned int l2align
;
2437 /* Earlier systems complain if the alignment exceeds the page size.
2438 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2439 if (!emit_aligned_common
&& (align
> 32768UL))
2440 align
= 4096UL; /* In units. */
2442 align
/= BITS_PER_UNIT
;
2444 /* Make sure we have a meaningful align. */
2448 /* For earlier toolchains, we need to emit the var as a rounded size to
2449 tell ld the alignment. */
2453 rounded
= (size
+ (align
-1)) & ~(align
-1);
2455 l2align
= floor_log2 (align
);
2456 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2458 in_section
= comm_section
;
2459 /* We mustn't allow multiple public symbols to share an address when using
2460 the normal OSX toolchain. */
2463 /* Put at least one byte. */
2465 /* This section can no longer participate in section anchoring. */
2466 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2469 fputs ("\t.comm\t", fp
);
2470 assemble_name (fp
, name
);
2471 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2472 emit_aligned_common
?size
:rounded
);
2473 if (l2align
&& emit_aligned_common
)
2474 fprintf (fp
, ",%u", l2align
);
2478 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2479 or coalescable data sections (for weak or comdat) as appropriate. */
2482 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2483 unsigned HOST_WIDE_INT size
, unsigned int align
)
2485 unsigned int l2align
;
2486 bool one
, pub
, weak
;
2489 pub
= TREE_PUBLIC (decl
);
2490 one
= DECL_ONE_ONLY (decl
);
2491 weak
= (DECL_P (decl
)
2493 && !lookup_attribute ("weak_import",
2494 DECL_ATTRIBUTES (decl
)));
2496 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2497 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2498 " pub %d weak %d one %d init %lx\n",
2499 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2500 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2501 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2504 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2505 before the target has a chance to comment. */
2506 if ((meta
= is_objc_metadata (decl
)))
2508 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2512 /* Check that any initializer is valid. */
2513 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2514 || (DECL_INITIAL (decl
) == error_mark_node
)
2515 || initializer_zerop (DECL_INITIAL (decl
)));
2517 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2518 gcc_assert (!DECL_COMMON (decl
));
2520 /* Pick up the correct alignment. */
2521 if (!size
|| !align
)
2522 align
= DECL_ALIGN (decl
);
2524 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2525 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2527 last_assemble_variable_decl
= decl
;
2529 /* We would rather not have to check this here - but it seems that we might
2530 be passed a decl that should be in coalesced space. */
2533 /* Weak or COMDAT objects are put in mergeable sections. */
2534 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2539 /* If this is not public, then emit according to local rules. */
2542 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2546 /* So we have a public symbol (small item fudge for Java, see above). */
2547 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2548 || (size
&& size
<= 2))
2550 /* Put smaller objects in data, where the section anchors system can get
2551 them. However, if they are zero-sized punt them to yet a different
2552 section (that is not allowed to participate in anchoring). */
2555 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2556 in_section
= darwin_sections
[zobj_data_section
];
2561 fputs ("\t.data\n", fp
);
2562 in_section
= data_section
;
2566 fprintf (fp
, "\t.align\t%u\n", l2align
);
2568 assemble_name (fp
, name
);
2569 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2574 unsigned int flags
;
2575 /* When we are on a non-section anchor target, we can get zero-sized
2576 items here. However, all we need to do is to bump them to one byte
2577 and the section alignment will take care of the rest. */
2578 snprintf (secnam
, 64, "__DATA,__%spu_bss%u", ((size
)?"":"zo_"), l2align
);
2580 /* We can't anchor in zerofill sections, because we can't switch
2581 to them and emit a label. */
2582 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2583 in_section
= get_section (secnam
, flags
, NULL
);
2584 fprintf (fp
, "\t.zerofill %s,", secnam
);
2585 assemble_name (fp
, name
);
2590 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2592 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2594 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2597 /* Output a chunk of common, with alignment specified (where the target
2600 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2601 unsigned HOST_WIDE_INT size
,
2604 unsigned int l2align
;
2608 /* No corresponding var. */
2611 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2612 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2614 darwin_emit_common (fp
, name
, size
, align
);
2618 one
= DECL_ONE_ONLY (decl
);
2619 weak
= (DECL_P (decl
)
2621 && !lookup_attribute ("weak_import",
2622 DECL_ATTRIBUTES (decl
)));
2624 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2625 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2626 " weak %d one %d init %lx\n",
2627 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2628 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2629 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2632 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2633 before the target has a chance to comment. */
2634 if ((meta
= is_objc_metadata (decl
)))
2636 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2640 /* We shouldn't be messing with this if the decl has a section name. */
2641 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2643 /* We would rather not have to check this here - but it seems that we might
2644 be passed a decl that should be in coalesced space. */
2647 /* Weak or COMDAT objects are put in mergable sections. */
2648 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2653 /* We should only get here for DECL_COMMON, with a zero init (and, in
2654 principle, only for public symbols too - although we deal with local
2657 /* Check the initializer is OK. */
2658 gcc_assert (DECL_COMMON (decl
)
2659 && ((DECL_INITIAL (decl
) == NULL
)
2660 || (DECL_INITIAL (decl
) == error_mark_node
)
2661 || initializer_zerop (DECL_INITIAL (decl
))));
2663 last_assemble_variable_decl
= decl
;
2665 if (!size
|| !align
)
2666 align
= DECL_ALIGN (decl
);
2668 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2669 /* Check we aren't asking for more aligment than the platform allows. */
2670 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2672 if (TREE_PUBLIC (decl
) != 0)
2673 darwin_emit_common (fp
, name
, size
, align
);
2675 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2678 /* Output a chunk of BSS with alignment specfied. */
2680 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2681 unsigned HOST_WIDE_INT size
,
2684 unsigned long l2align
;
2688 one
= DECL_ONE_ONLY (decl
);
2689 weak
= (DECL_P (decl
)
2691 && !lookup_attribute ("weak_import",
2692 DECL_ATTRIBUTES (decl
)));
2694 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2695 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2696 " weak %d init %lx\n",
2697 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2698 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2699 weak
, (unsigned long)DECL_INITIAL (decl
));
2702 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2703 before the target has a chance to comment. */
2704 if ((meta
= is_objc_metadata (decl
)))
2706 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2710 /* We shouldn't be messing with this if the decl has a section name. */
2711 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2713 /* We would rather not have to check this here - but it seems that we might
2714 be passed a decl that should be in coalesced space. */
2717 /* Weak or COMDAT objects are put in mergable sections. */
2718 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2723 /* .. and it should be suitable for placement in local mem. */
2724 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2725 /* .. and any initializer must be all-zero. */
2726 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2727 || (DECL_INITIAL (decl
) == error_mark_node
)
2728 || initializer_zerop (DECL_INITIAL (decl
)));
2730 last_assemble_variable_decl
= decl
;
2732 if (!size
|| !align
)
2733 align
= DECL_ALIGN (decl
);
2735 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2736 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2738 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2741 /* Emit an assembler directive to set visibility for a symbol. The
2742 only supported visibilities are VISIBILITY_DEFAULT and
2743 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2744 extern". There is no MACH-O equivalent of ELF's
2745 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2748 darwin_assemble_visibility (tree decl
, int vis
)
2750 if (vis
== VISIBILITY_DEFAULT
)
2752 else if (vis
== VISIBILITY_HIDDEN
|| vis
== VISIBILITY_INTERNAL
)
2754 fputs ("\t.private_extern ", asm_out_file
);
2755 assemble_name (asm_out_file
,
2756 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2757 fputs ("\n", asm_out_file
);
2760 warning (OPT_Wattributes
, "protected visibility attribute "
2761 "not supported in this configuration; ignored");
2764 /* vec used by darwin_asm_dwarf_section.
2765 Maybe a hash tab would be better here - but the intention is that this is
2766 a very short list (fewer than 16 items) and each entry should (ideally,
2767 eventually) only be presented once.
2769 A structure to hold a dwarf debug section used entry. */
2771 typedef struct GTY(()) dwarf_sect_used_entry
{
2775 dwarf_sect_used_entry
;
2778 /* A list of used __DWARF sections. */
2779 static GTY (()) vec
<dwarf_sect_used_entry
, va_gc
> *dwarf_sect_names_table
;
2781 /* This is called when we are asked to assemble a named section and the
2782 name begins with __DWARF,. We keep a list of the section names (without
2783 the __DWARF, prefix) and use this to emit our required start label on the
2784 first switch to each section. */
2787 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2788 tree
ARG_UNUSED (decl
))
2793 dwarf_sect_used_entry
*ref
;
2795 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2796 == (SECTION_DEBUG
| SECTION_NAMED
));
2797 /* We know that the name starts with __DWARF, */
2799 namelen
= strchr (sname
, ',') - sname
;
2800 gcc_assert (namelen
);
2801 if (dwarf_sect_names_table
== NULL
)
2802 vec_alloc (dwarf_sect_names_table
, 16);
2805 dwarf_sect_names_table
->iterate (i
, &ref
);
2810 if (!strcmp (ref
->name
, sname
))
2818 fprintf (asm_out_file
, "\t.section %s\n", name
);
2821 dwarf_sect_used_entry e
;
2822 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
2824 e
.name
= xstrdup (sname
);
2825 vec_safe_push (dwarf_sect_names_table
, e
);
2829 /* Output a difference of two labels that will be an assembly time
2830 constant if the two labels are local. (.long lab1-lab2 will be
2831 very different if lab1 is at the boundary between two sections; it
2832 will be relocated according to the second section, not the first,
2833 so one ends up with a difference between labels in different
2834 sections, which is bad in the dwarf2 eh context for instance.) */
2836 static int darwin_dwarf_label_counter
;
2839 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
2840 const char *lab1
, const char *lab2
)
2842 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
2843 && lab2
[0] == '*' && lab2
[1] == 'L');
2844 const char *directive
= (size
== 8 ? ".quad" : ".long");
2847 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
2849 fprintf (file
, "\t%s\t", directive
);
2851 assemble_name_raw (file
, lab1
);
2852 fprintf (file
, "-");
2853 assemble_name_raw (file
, lab2
);
2855 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
2858 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
2859 offsets are not represented using relocs in .o files; either the
2860 section never leaves the .o file, or the linker or other tool is
2861 responsible for parsing the DWARF and updating the offsets. */
2864 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
2870 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
2871 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
2872 gcc_assert (strchr (base
->named
.name
+ 8, ','));
2874 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
2875 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
2876 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
2879 /* Called from the within the TARGET_ASM_FILE_START for each target. */
2882 darwin_file_start (void)
2884 /* Nothing to do. */
2887 /* Called for the TARGET_ASM_FILE_END hook.
2888 Emit the mach-o pic indirection data, the lto data and, finally a flag
2889 to tell the linker that it can break the file object into sections and
2890 move those around for efficiency. */
2893 darwin_file_end (void)
2895 if (!vec_safe_is_empty (ctors
))
2897 if (!vec_safe_is_empty (dtors
))
2900 /* If we are expecting to output NeXT ObjC meta-data, (and we actually see
2901 some) then we output the fix-and-continue marker (Image Info).
2902 This applies to Objective C, Objective C++ and LTO with either language
2903 as part of the input. */
2904 if (flag_next_runtime
&& objc_metadata_seen
)
2906 unsigned int flags
= 0;
2907 if (flag_objc_abi
>= 2)
2910 output_section_asm_op
2911 (darwin_sections
[objc2_image_info_section
]->unnamed
.data
);
2914 output_section_asm_op
2915 (darwin_sections
[objc_image_info_section
]->unnamed
.data
);
2917 ASM_OUTPUT_ALIGN (asm_out_file
, 2);
2918 fputs ("L_OBJC_ImageInfo:\n", asm_out_file
);
2920 flags
|= (flag_replace_objc_classes
&& classes_seen
) ? 1 : 0;
2921 flags
|= flag_objc_gc
? 2 : 0;
2923 fprintf (asm_out_file
, "\t.long\t0\n\t.long\t%u\n", flags
);
2926 machopic_finish (asm_out_file
);
2927 if (lang_GNU_CXX ())
2929 switch_to_section (darwin_sections
[constructor_section
]);
2930 switch_to_section (darwin_sections
[destructor_section
]);
2931 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
2934 /* If there was LTO assembler output, append it to asm_out_file. */
2935 if (lto_asm_out_name
)
2938 char *buf
, *lto_asm_txt
;
2940 /* Shouldn't be here if we failed to switch back. */
2941 gcc_assert (! saved_asm_out_file
);
2943 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
2944 if (lto_asm_out_file
== NULL
)
2945 fatal_error ("failed to open temporary file %s with LTO output",
2947 fseek (lto_asm_out_file
, 0, SEEK_END
);
2948 n
= ftell (lto_asm_out_file
);
2951 fseek (lto_asm_out_file
, 0, SEEK_SET
);
2952 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
2953 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
2954 fputs (lto_asm_txt
, asm_out_file
);
2955 /* Put a termination label. */
2956 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2957 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
2958 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# end of lto\n",
2960 /* Make sure our termination label stays in this section. */
2961 fputs ("\t.space\t1\n", asm_out_file
);
2964 /* Remove the temporary file. */
2965 fclose (lto_asm_out_file
);
2966 unlink_if_ordinary (lto_asm_out_name
);
2967 free (lto_asm_out_name
);
2970 /* Output the names and indices. */
2971 if (lto_section_names
&& lto_section_names
->length ())
2974 darwin_lto_section_e
*ref
;
2975 /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
2976 the latter up ourselves. */
2977 const char *op
= integer_asm_op (4,0);
2979 /* Emit the names. */
2980 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2981 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
2982 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
2984 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\n", count
);
2985 /* We have to jump through hoops to get the values of the intra-section
2987 fprintf (asm_out_file
,
2988 "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
2990 fprintf (asm_out_file
,
2991 "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
2992 count
, count
+1, count
);
2993 fprintf (asm_out_file
, "\t.asciz\t\"%s\"\n", ref
->sectname
);
2995 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num
);
2996 /* make sure our termination label stays in this section. */
2997 fputs ("\t.space\t1\n", asm_out_file
);
2999 /* Emit the Index. */
3000 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
3001 LTO_SEGMENT_NAME
, LTO_INDEX_SECTION
);
3002 fputs ("\t.align\t2\n", asm_out_file
);
3003 fputs ("# Section offset, Section length, Name offset, Name length\n",
3005 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
3007 fprintf (asm_out_file
, "%s L$gnu$lto$offs%d\t;# %s\n",
3008 op
, count
, ref
->sectname
);
3009 fprintf (asm_out_file
, "%s L$gnu$lto$size%d\n", op
, count
);
3010 fprintf (asm_out_file
, "%s L$gnu$lto$noff%d\n", op
, count
);
3011 fprintf (asm_out_file
, "%s L$gnu$lto$nsiz%d\n", op
, count
);
3015 /* If we have section anchors, then we must prevent the linker from
3016 re-arranging data. */
3017 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
3018 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
3021 /* TODO: Add a language hook for identifying if a decl is a vtable. */
3022 #define DARWIN_VTABLE_P(DECL) 0
3024 /* Cross-module name binding. Darwin does not support overriding
3025 functions at dynamic-link time, except for vtables in kexts. */
3028 darwin_binds_local_p (const_tree decl
)
3030 return default_binds_local_p_1 (decl
,
3031 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
3034 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
3035 anchor relative to ".", the current section position. We cannot use
3036 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
3038 darwin_asm_output_anchor (rtx symbol
)
3040 fprintf (asm_out_file
, "\t.set\t");
3041 assemble_name (asm_out_file
, XSTR (symbol
, 0));
3042 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
3043 SYMBOL_REF_BLOCK_OFFSET (symbol
));
3046 /* Disable section anchoring on any section containing a zero-sized
3049 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
3051 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
3054 /* If the section contains a zero-sized object it's ineligible. */
3055 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
3056 /* This should have the effect of disabling anchors for vars that follow
3057 any zero-sized one, in a given section. */
3058 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
3061 /* Also check the normal reasons for suppressing. */
3062 return default_use_anchors_for_symbol_p (symbol
);
3068 /* Set the darwin specific attributes on TYPE. */
3070 darwin_set_default_type_attributes (tree type
)
3072 if (darwin_ms_struct
3073 && TREE_CODE (type
) == RECORD_TYPE
)
3074 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
3076 TYPE_ATTRIBUTES (type
));
3079 /* True, iff we're generating code for loadable kernel extensions. */
3082 darwin_kextabi_p (void) {
3083 return flag_apple_kext
;
3087 darwin_override_options (void)
3089 /* Keep track of which (major) version we're generating code for. */
3090 if (darwin_macosx_version_min
)
3092 if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
3093 generating_for_darwin_version
= 10;
3094 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
3095 generating_for_darwin_version
= 9;
3097 /* Earlier versions are not specifically accounted, until required. */
3100 /* In principle, this should be c-family only. However, we really need to
3101 set sensible defaults for LTO as well, since the section selection stuff
3102 should check for correctness re. the ABI. TODO: check and provide the
3103 flags (runtime & ABI) from the lto wrapper). */
3105 /* Unless set, force ABI=2 for NeXT and m64, 0 otherwise. */
3106 if (!global_options_set
.x_flag_objc_abi
)
3107 global_options
.x_flag_objc_abi
3108 = (!flag_next_runtime
)
3111 : (generating_for_darwin_version
>= 9) ? 1
3114 /* Objective-C family ABI 2 is only valid for next/m64 at present. */
3115 if (global_options_set
.x_flag_objc_abi
&& flag_next_runtime
)
3117 if (TARGET_64BIT
&& global_options
.x_flag_objc_abi
< 2)
3118 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 must be"
3119 " used for %<-m64%> targets with"
3120 " %<-fnext-runtime%>");
3121 if (!TARGET_64BIT
&& global_options
.x_flag_objc_abi
>= 2)
3122 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 is not"
3123 " supported on %<-m32%> targets with"
3124 " %<-fnext-runtime%>");
3127 /* Don't emit DWARF3/4 unless specifically selected. This is a
3128 workaround for tool bugs. */
3129 if (!global_options_set
.x_dwarf_strict
)
3131 if (!global_options_set
.x_dwarf_version
)
3134 /* Do not allow unwind tables to be generated by default for m32.
3135 fnon-call-exceptions will override this, regardless of what we do. */
3136 if (generating_for_darwin_version
< 10
3137 && !global_options_set
.x_flag_asynchronous_unwind_tables
3139 global_options
.x_flag_asynchronous_unwind_tables
= 0;
3141 /* Disable -freorder-blocks-and-partition when unwind tables are being
3142 emitted for Darwin < 9 (OSX 10.5).
3143 The strategy is, "Unless the User has specifically set/unset an unwind
3144 flag we will switch off -freorder-blocks-and-partition when unwind tables
3145 will be generated". If the User specifically sets flags... we assume
3146 (s)he knows why... */
3147 if (generating_for_darwin_version
< 9
3148 && global_options_set
.x_flag_reorder_blocks_and_partition
3149 && ((global_options
.x_flag_exceptions
/* User, c++, java */
3150 && !global_options_set
.x_flag_exceptions
) /* User specified... */
3151 || (global_options
.x_flag_unwind_tables
3152 && !global_options_set
.x_flag_unwind_tables
)
3153 || (global_options
.x_flag_non_call_exceptions
3154 && !global_options_set
.x_flag_non_call_exceptions
)
3155 || (global_options
.x_flag_asynchronous_unwind_tables
3156 && !global_options_set
.x_flag_asynchronous_unwind_tables
)))
3158 inform (input_location
,
3159 "-freorder-blocks-and-partition does not work with exceptions "
3160 "on this architecture");
3161 flag_reorder_blocks_and_partition
= 0;
3162 flag_reorder_blocks
= 1;
3165 /* FIXME: flag_objc_sjlj_exceptions is no longer needed since there is only
3166 one valid choice of exception scheme for each runtime. */
3167 if (!global_options_set
.x_flag_objc_sjlj_exceptions
)
3168 global_options
.x_flag_objc_sjlj_exceptions
=
3169 flag_next_runtime
&& !TARGET_64BIT
;
3171 /* FIXME: and this could be eliminated then too. */
3172 if (!global_options_set
.x_flag_exceptions
3173 && flag_objc_exceptions
3175 flag_exceptions
= 1;
3177 if (flag_mkernel
|| flag_apple_kext
)
3179 /* -mkernel implies -fapple-kext for C++ */
3180 if (lang_GNU_CXX ())
3181 flag_apple_kext
= 1;
3185 /* No EH in kexts. */
3186 flag_exceptions
= 0;
3187 /* No -fnon-call-exceptions data in kexts. */
3188 flag_non_call_exceptions
= 0;
3189 /* so no tables either.. */
3190 flag_unwind_tables
= 0;
3191 flag_asynchronous_unwind_tables
= 0;
3192 /* We still need to emit branch islands for kernel context. */
3193 darwin_emit_branch_islands
= true;
3196 if (flag_var_tracking_uninit
== 0
3197 && generating_for_darwin_version
>= 9
3198 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
3199 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
3200 && write_symbols
== DWARF2_DEBUG
)
3201 flag_var_tracking_uninit
= flag_var_tracking
;
3203 if (MACHO_DYNAMIC_NO_PIC_P
)
3206 warning_at (UNKNOWN_LOCATION
, 0,
3207 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
3208 " %<-fpie%> or %<-fPIE%>");
3211 else if (flag_pic
== 1)
3213 /* Darwin's -fpic is -fPIC. */
3217 /* It is assumed that branch island stubs are needed for earlier systems. */
3218 if (generating_for_darwin_version
< 9)
3219 darwin_emit_branch_islands
= true;
3221 emit_aligned_common
= true; /* Later systems can support aligned common. */
3223 /* The c_dialect...() macros are not available to us here. */
3224 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
3228 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
3231 darwin_patch_builtin (enum built_in_function fncode
)
3233 tree fn
= builtin_decl_explicit (fncode
);
3240 sym
= DECL_ASSEMBLER_NAME (fn
);
3241 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
3243 set_user_assembler_name (fn
, newname
);
3245 fn
= builtin_decl_implicit (fncode
);
3247 set_user_assembler_name (fn
, newname
);
3251 darwin_patch_builtins (void)
3253 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
3256 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
3257 #define PATCH_BUILTIN_NO64(fncode) \
3258 if (!TARGET_64BIT) \
3259 darwin_patch_builtin (fncode);
3260 #define PATCH_BUILTIN_VARIADIC(fncode) \
3262 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
3263 darwin_patch_builtin (fncode);
3264 #include "darwin-ppc-ldouble-patch.def"
3265 #undef PATCH_BUILTIN
3266 #undef PATCH_BUILTIN_NO64
3267 #undef PATCH_BUILTIN_VARIADIC
3271 /* CFStrings implementation. */
3272 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3273 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3274 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3275 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3276 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3277 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3279 static enum built_in_function darwin_builtin_cfstring
;
3281 /* Store all constructed constant CFStrings in a hash table so that
3282 they get uniqued properly. */
3284 typedef struct GTY ((for_user
)) cfstring_descriptor
{
3285 /* The string literal. */
3287 /* The resulting constant CFString. */
3289 } cfstring_descriptor
;
3291 struct cfstring_hasher
: ggc_hasher
<cfstring_descriptor
*>
3293 static hashval_t
hash (cfstring_descriptor
*);
3294 static bool equal (cfstring_descriptor
*, cfstring_descriptor
*);
3297 static GTY (()) hash_table
<cfstring_hasher
> *cfstring_htab
;
3300 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3302 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3303 get_identifier (name
), type
);
3307 *chain
= &DECL_CHAIN (field
);
3313 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3315 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3318 darwin_builtin_cfstring
=
3319 (enum built_in_function
) builtin_cfstring
;
3321 /* struct __builtin_CFString {
3322 const int *isa; (will point at
3323 int flags; __CFConstantStringClassReference)
3328 pcint_type_node
= build_pointer_type
3329 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3331 pcchar_type_node
= build_pointer_type
3332 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3334 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3336 /* Have to build backwards for finish struct. */
3337 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3338 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3339 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3340 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3341 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3344 /* const struct __builtin_CFstring *
3345 __builtin___CFStringMakeConstantString (const char *); */
3347 ccfstring_type_node
= build_qualified_type
3348 (cfstring_type_node
, TYPE_QUAL_CONST
);
3349 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3350 pccfstring_ftype_pcchar
= build_function_type_list
3351 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3353 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3354 get_identifier ("__builtin___CFStringMakeConstantString"),
3355 pccfstring_ftype_pcchar
);
3357 TREE_PUBLIC (cfsfun
) = 1;
3358 DECL_EXTERNAL (cfsfun
) = 1;
3359 DECL_ARTIFICIAL (cfsfun
) = 1;
3360 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3361 in place of the existing, which may be NULL. */
3362 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3363 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3364 DECL_BUILT_IN_CLASS (cfsfun
) = BUILT_IN_MD
;
3365 DECL_FUNCTION_CODE (cfsfun
) = darwin_builtin_cfstring
;
3366 lang_hooks
.builtin_function (cfsfun
);
3368 /* extern int __CFConstantStringClassReference[]; */
3369 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3370 get_identifier ("__CFConstantStringClassReference"),
3371 build_array_type (integer_type_node
, NULL_TREE
));
3373 TREE_PUBLIC (cfstring_class_reference
) = 1;
3374 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3375 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3376 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3377 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3379 /* Initialize the hash table used to hold the constant CFString objects. */
3380 cfstring_htab
= hash_table
<cfstring_hasher
>::create_ggc (31);
3382 return cfstring_type_node
;
3386 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3387 bool ARG_UNUSED (ignore
))
3389 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3391 if (fcode
== darwin_builtin_cfstring
)
3393 if (!darwin_constant_cfstrings
)
3395 error ("built-in function %qD requires the"
3396 " %<-mconstant-cfstrings%> flag", fndecl
);
3397 return error_mark_node
;
3402 error ("built-in function %qD takes one argument only", fndecl
);
3403 return error_mark_node
;
3406 return darwin_build_constant_cfstring (*argp
);
3413 darwin_rename_builtins (void)
3415 /* The system ___divdc3 routine in libSystem on darwin10 is not
3416 accurate to 1ulp, ours is, so we avoid ever using the system name
3417 for this routine and instead install a non-conflicting name that
3420 When -ffast-math or -funsafe-math-optimizations is given, we can
3421 use the faster version. */
3422 if (!flag_unsafe_math_optimizations
)
3424 enum built_in_function dcode
3425 = (enum built_in_function
)(BUILT_IN_COMPLEX_DIV_MIN
3426 + DCmode
- MIN_MODE_COMPLEX_FLOAT
);
3427 tree fn
= builtin_decl_explicit (dcode
);
3428 /* Fortran and c call TARGET_INIT_BUILTINS and
3429 TARGET_INIT_LIBFUNCS at different times, so we have to put a
3430 call into each to ensure that at least one of them is called
3431 after build_common_builtin_nodes. A better fix is to add a
3432 new hook to run after build_common_builtin_nodes runs. */
3434 set_user_assembler_name (fn
, "___ieee_divdc3");
3435 fn
= builtin_decl_implicit (dcode
);
3437 set_user_assembler_name (fn
, "___ieee_divdc3");
3442 darwin_libc_has_function (enum function_class fn_class
)
3444 if (fn_class
== function_sincos
)
3446 if (fn_class
== function_c99_math_complex
3447 || fn_class
== function_c99_misc
)
3448 return (TARGET_64BIT
3449 || strverscmp (darwin_macosx_version_min
, "10.3") >= 0);
3455 cfstring_hasher::hash (cfstring_descriptor
*ptr
)
3457 tree str
= ptr
->literal
;
3458 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3459 int i
, len
= TREE_STRING_LENGTH (str
);
3462 for (i
= 0; i
< len
; i
++)
3463 h
= ((h
* 613) + p
[i
]);
3469 cfstring_hasher::equal (cfstring_descriptor
*ptr1
, cfstring_descriptor
*ptr2
)
3471 tree str1
= ptr1
->literal
;
3472 tree str2
= ptr2
->literal
;
3473 int len1
= TREE_STRING_LENGTH (str1
);
3475 return (len1
== TREE_STRING_LENGTH (str2
)
3476 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3481 darwin_build_constant_cfstring (tree str
)
3483 struct cfstring_descriptor
*desc
, key
;
3488 error ("CFString literal is missing");
3489 return error_mark_node
;
3494 if (TREE_CODE (str
) == ADDR_EXPR
)
3495 str
= TREE_OPERAND (str
, 0);
3497 if (TREE_CODE (str
) != STRING_CST
)
3499 error ("CFString literal expression is not a string constant");
3500 return error_mark_node
;
3503 /* Perhaps we already constructed a constant CFString just like this one? */
3505 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3510 tree var
, constructor
, field
;
3511 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3512 int length
= TREE_STRING_LENGTH (str
) - 1;
3514 if (darwin_warn_nonportable_cfstrings
)
3516 const char *s
= TREE_STRING_POINTER (str
);
3519 for (l
= 0; l
< length
; l
++)
3520 if (!s
[l
] || !isascii (s
[l
]))
3522 warning (darwin_warn_nonportable_cfstrings
, "%s in CFString literal",
3523 s
[l
] ? "non-ASCII character" : "embedded NUL");
3528 *loc
= desc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3529 desc
->literal
= str
;
3532 field
= TYPE_FIELDS (ccfstring_type_node
);
3533 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3534 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3535 cfstring_class_reference
));
3537 field
= DECL_CHAIN (field
);
3538 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3539 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3541 field
= DECL_CHAIN (field
);
3542 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3543 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3545 field
= DECL_CHAIN (field
);
3546 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3547 build_int_cst (TREE_TYPE (field
), length
));
3549 constructor
= build_constructor (ccfstring_type_node
, v
);
3550 TREE_READONLY (constructor
) = 1;
3551 TREE_CONSTANT (constructor
) = 1;
3552 TREE_STATIC (constructor
) = 1;
3554 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3555 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3556 being built without any knowledge of C++ tree accessors; hence, we shall
3557 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3558 if (darwin_running_cxx
)
3559 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3561 /* Create an anonymous global variable for this CFString. */
3562 var
= build_decl (input_location
, CONST_DECL
,
3563 NULL
, TREE_TYPE (constructor
));
3564 DECL_ARTIFICIAL (var
) = 1;
3565 TREE_STATIC (var
) = 1;
3566 DECL_INITIAL (var
) = constructor
;
3567 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3568 DECL_CONTEXT (var
) = NULL_TREE
;
3569 desc
->constructor
= var
;
3572 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3573 TREE_CONSTANT (addr
) = 1;
3579 darwin_cfstring_p (tree str
)
3581 struct cfstring_descriptor key
;
3588 if (TREE_CODE (str
) == ADDR_EXPR
)
3589 str
= TREE_OPERAND (str
, 0);
3591 if (TREE_CODE (str
) != STRING_CST
)
3595 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, NO_INSERT
);
3604 darwin_enter_string_into_cfstring_table (tree str
)
3606 struct cfstring_descriptor key
;
3609 cfstring_descriptor
**loc
= cfstring_htab
->find_slot (&key
, INSERT
);
3613 *loc
= ggc_cleared_alloc
<cfstring_descriptor
> ();
3614 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3618 /* Choose named function section based on its frequency. */
3621 darwin_function_section (tree decl
, enum node_frequency freq
,
3622 bool startup
, bool exit
)
3624 /* Decide if we need to put this in a coalescable section. */
3627 && (!DECL_ATTRIBUTES (decl
)
3628 || !lookup_attribute ("weak_import",
3629 DECL_ATTRIBUTES (decl
))));
3631 /* If there is a specified section name, we should not be trying to
3633 if (decl
&& DECL_SECTION_NAME (decl
) != NULL
)
3634 return get_named_section (decl
, NULL
, 0);
3636 /* We always put unlikely executed stuff in the cold section. */
3637 if (freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3638 return (weak
) ? darwin_sections
[text_cold_coal_section
]
3639 : darwin_sections
[text_cold_section
];
3641 /* If we have LTO *and* feedback information, then let LTO handle
3642 the function ordering, it makes a better job (for normal, hot,
3643 startup and exit - hence the bailout for cold above). */
3644 if (in_lto_p
&& flag_profile_values
)
3645 goto default_function_sections
;
3647 /* Non-cold startup code should go to startup subsection. */
3649 return (weak
) ? darwin_sections
[text_startup_coal_section
]
3650 : darwin_sections
[text_startup_section
];
3652 /* Similarly for exit. */
3654 return (weak
) ? darwin_sections
[text_exit_coal_section
]
3655 : darwin_sections
[text_exit_section
];
3657 /* Place hot code. */
3658 if (freq
== NODE_FREQUENCY_HOT
)
3659 return (weak
) ? darwin_sections
[text_hot_coal_section
]
3660 : darwin_sections
[text_hot_section
];
3662 /* Otherwise, default to the 'normal' non-reordered sections. */
3663 default_function_sections
:
3664 return (weak
) ? darwin_sections
[text_coal_section
]
3668 /* When a function is partitioned between sections, we need to insert a label
3669 at the start of each new chunk - so that it may become a valid 'atom' for
3670 eh and debug purposes. Without this the linker will emit warnings if one
3671 tries to add line location information (since the switched fragment will
3675 darwin_function_switched_text_sections (FILE *fp
, tree decl
, bool new_is_cold
)
3678 snprintf (buf
, 128, "%s%s",new_is_cold
?"__cold_sect_of_":"__hot_sect_of_",
3679 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3680 /* Make sure we pick up all the relevant quotes etc. */
3681 assemble_name_raw (fp
, (const char *) buf
);
3685 #include "gt-darwin.h"