1 /* Functions for generic Darwin as target machine for GNU C compiler.
2 Copyright (C) 1989-2014 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"
35 #include "stringpool.h"
37 #include "stor-layout.h"
42 #include "langhooks.h"
45 #include "diagnostic-core.h"
51 #include "pointer-set.h"
52 #include "hash-table.h"
54 #include "basic-block.h"
55 #include "tree-ssa-alias.h"
56 #include "internal-fn.h"
57 #include "gimple-fold.h"
59 #include "gimple-expr.h"
63 #include "lto-streamer.h"
65 /* Darwin supports a feature called fix-and-continue, which is used
66 for rapid turn around debugging. When code is compiled with the
67 -mfix-and-continue flag, two changes are made to the generated code
68 that allow the system to do things that it would normally not be
69 able to do easily. These changes allow gdb to load in
70 recompilation of a translation unit that has been changed into a
71 running program and replace existing functions and methods of that
72 translation unit with versions of those functions and methods
73 from the newly compiled translation unit. The new functions access
74 the existing static symbols from the old translation unit, if the
75 symbol existed in the unit to be replaced, and from the new
76 translation unit, otherwise.
78 The changes are to insert 5 nops at the beginning of all functions
79 and to use indirection to get at static symbols. The 5 nops
80 are required by consumers of the generated code. Currently, gdb
81 uses this to patch in a jump to the overriding function, this
82 allows all uses of the old name to forward to the replacement,
83 including existing function pointers and virtual methods. See
84 rs6000_emit_prologue for the code that handles the nop insertions.
86 The added indirection allows gdb to redirect accesses to static
87 symbols from the newly loaded translation unit to the existing
88 symbol, if any. @code{static} symbols are special and are handled by
89 setting the second word in the .non_lazy_symbol_pointer data
90 structure to symbol. See indirect_data for the code that handles
91 the extra indirection, and machopic_output_indirection and its use
92 of MACHO_SYMBOL_STATIC for the code that handles @code{static}
93 symbol indirection. */
95 /* For darwin >= 9 (OSX 10.5) the linker is capable of making the necessary
96 branch islands and we no longer need to emit darwin stubs.
97 However, if we are generating code for earlier systems (or for use in the
98 kernel) the stubs might still be required, and this will be set true. */
99 int darwin_emit_branch_islands
= false;
101 typedef struct GTY(()) cdtor_record
{
103 int priority
; /* [con/de]structor priority */
104 int position
; /* original position */
107 static GTY(()) vec
<cdtor_record
, va_gc
> *ctors
= NULL
;
108 static GTY(()) vec
<cdtor_record
, va_gc
> *dtors
= NULL
;
110 /* A flag to determine whether we are running c++ or obj-c++. This has to be
111 settable from non-c-family contexts too (i.e. we can't use the c_dialect_
113 int darwin_running_cxx
;
115 /* Some code-gen now depends on OS major version numbers (at least). */
116 int generating_for_darwin_version
;
119 section
* darwin_sections
[NUM_DARWIN_SECTIONS
];
121 /* While we transition to using in-tests instead of ifdef'd code. */
123 #define HAVE_lo_sum 0
124 #define gen_macho_high(a,b) (a)
125 #define gen_macho_low(a,b,c) (a)
128 /* True if we're setting __attribute__ ((ms_struct)). */
129 int darwin_ms_struct
= false;
131 /* Earlier versions of Darwin as do not recognize an alignment field in
132 .comm directives, this should be set for versions that allow it. */
133 int emit_aligned_common
= false;
135 /* A get_unnamed_section callback used to switch to an ObjC section.
136 DIRECTIVE is as for output_section_asm_op. */
139 output_objc_section_asm_op (const void *directive
)
141 static bool been_here
= false;
143 /* The NeXT ObjC Runtime requires these sections to be present and in
144 order in the object. The code below implements this by emitting
145 a section header for each ObjC section the first time that an ObjC
146 section is requested. */
149 section
*saved_in_section
= in_section
;
150 static const enum darwin_section_enum tomark
[] =
152 /* written, cold -> hot */
153 objc_cat_cls_meth_section
,
154 objc_cat_inst_meth_section
,
155 objc_string_object_section
,
156 objc_constant_string_object_section
,
157 objc_selector_refs_section
,
158 objc_selector_fixup_section
,
159 objc_cls_refs_section
,
161 objc_meta_class_section
,
162 /* shared, hot -> cold */
163 objc_cls_meth_section
,
164 objc_inst_meth_section
,
165 objc_protocol_section
,
166 objc_class_names_section
,
167 objc_meth_var_types_section
,
168 objc_meth_var_names_section
,
169 objc_category_section
,
170 objc_class_vars_section
,
171 objc_instance_vars_section
,
172 objc_module_info_section
,
173 objc_symbols_section
,
176 static const enum darwin_section_enum tomarkv1
[] =
178 objc1_protocol_ext_section
,
179 objc1_class_ext_section
,
180 objc1_prop_list_section
183 static const enum darwin_section_enum tomarkv2
[] =
185 objc2_message_refs_section
,
186 objc2_classdefs_section
,
187 objc2_metadata_section
,
188 objc2_classrefs_section
,
189 objc2_classlist_section
,
190 objc2_categorylist_section
,
191 objc2_selector_refs_section
,
192 objc2_nonlazy_class_section
,
193 objc2_nonlazy_category_section
,
194 objc2_protocollist_section
,
195 objc2_protocolrefs_section
,
196 objc2_super_classrefs_section
,
197 objc2_image_info_section
,
198 objc2_constant_string_object_section
203 if (flag_objc_abi
< 2)
205 for (i
= 0; i
< ARRAY_SIZE (tomark
); i
++)
206 switch_to_section (darwin_sections
[tomark
[i
]]);
207 if (flag_objc_abi
== 1)
208 for (i
= 0; i
< ARRAY_SIZE (tomarkv1
); i
++)
209 switch_to_section (darwin_sections
[tomarkv1
[i
]]);
212 for (i
= 0; i
< ARRAY_SIZE (tomarkv2
); i
++)
213 switch_to_section (darwin_sections
[tomarkv2
[i
]]);
214 /* Make sure we don't get varasm.c out of sync with us. */
215 switch_to_section (saved_in_section
);
217 output_section_asm_op (directive
);
221 /* Private flag applied to disable section-anchors in a particular section. */
222 #define SECTION_NO_ANCHOR SECTION_MACH_DEP
225 /* Implement TARGET_ASM_INIT_SECTIONS. */
228 darwin_init_sections (void)
230 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC) \
231 darwin_sections[NAME] = \
232 get_unnamed_section (FLAGS, (OBJC \
233 ? output_objc_section_asm_op \
234 : output_section_asm_op), \
236 #include "config/darwin-sections.def"
239 readonly_data_section
= darwin_sections
[const_section
];
240 exception_section
= darwin_sections
[darwin_exception_section
];
241 eh_frame_section
= darwin_sections
[darwin_eh_frame_section
];
245 name_needs_quotes (const char *name
)
248 while ((c
= *name
++) != '\0')
250 && c
!= '.' && c
!= '$' && c
!= '_' )
255 /* Return true if SYM_REF can be used without an indirection. */
257 machopic_symbol_defined_p (rtx sym_ref
)
259 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
262 /* If a symbol references local and is not an extern to this
263 file, then the symbol might be able to declared as defined. */
264 if (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
))
266 /* If the symbol references a variable and the variable is a
267 common symbol, then this symbol is not defined. */
268 if (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_VARIABLE
)
270 tree decl
= SYMBOL_REF_DECL (sym_ref
);
273 if (DECL_COMMON (decl
))
281 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
282 reference, which will not be changed. */
284 enum machopic_addr_class
285 machopic_classify_symbol (rtx sym_ref
)
289 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
290 if (machopic_symbol_defined_p (sym_ref
))
292 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
295 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
298 #ifndef TARGET_FIX_AND_CONTINUE
299 #define TARGET_FIX_AND_CONTINUE 0
302 /* Indicate when fix-and-continue style code generation is being used
303 and when a reference to data should be indirected so that it can be
304 rebound in a new translation unit to reference the original instance
305 of that data. Symbol names that are for code generation local to
306 the translation unit are bound to the new translation unit;
307 currently this means symbols that begin with L or _OBJC_;
308 otherwise, we indicate that an indirect reference should be made to
309 permit the runtime to rebind new instances of the translation unit
310 to the original instance of the data. */
313 indirect_data (rtx sym_ref
)
318 /* If we aren't generating fix-and-continue code, don't do anything
320 if (TARGET_FIX_AND_CONTINUE
== 0)
323 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
324 are indirected. Symbols that begin with L and _OBJC_ are always
325 bound to the current translation unit as they are used for
326 generated local data of the translation unit. */
328 name
= XSTR (sym_ref
, 0);
330 lprefix
= (((name
[0] == '*' || name
[0] == '&')
331 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
332 || (strncmp (name
, "_OBJC_", 6) == 0));
338 machopic_data_defined_p (rtx sym_ref
)
340 if (indirect_data (sym_ref
))
343 switch (machopic_classify_symbol (sym_ref
))
345 case MACHOPIC_DEFINED_DATA
:
346 case MACHOPIC_DEFINED_FUNCTION
:
354 machopic_define_symbol (rtx mem
)
358 gcc_assert (GET_CODE (mem
) == MEM
);
359 sym_ref
= XEXP (mem
, 0);
360 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
363 /* Return either ORIG or:
365 (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
367 depending on MACHO_DYNAMIC_NO_PIC_P. */
369 machopic_gen_offset (rtx orig
)
371 if (MACHO_DYNAMIC_NO_PIC_P
)
375 /* Play games to avoid marking the function as needing pic if we
376 are being called as part of the cost-estimation process. */
377 if (current_ir_type () != IR_GIMPLE
|| currently_expanding_to_rtl
)
378 crtl
->uses_pic_offset_table
= 1;
379 orig
= gen_rtx_UNSPEC (Pmode
, gen_rtvec (1, orig
),
380 UNSPEC_MACHOPIC_OFFSET
);
381 return gen_rtx_CONST (Pmode
, orig
);
385 static GTY(()) const char * function_base_func_name
;
386 static GTY(()) int current_pic_label_num
;
387 static GTY(()) int emitted_pic_label_num
;
390 update_pic_label_number_if_needed (void)
392 const char *current_name
;
394 /* When we are generating _get_pc thunks within stubs, there is no current
396 if (current_function_decl
)
399 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
400 if (function_base_func_name
!= current_name
)
402 ++current_pic_label_num
;
403 function_base_func_name
= current_name
;
408 ++current_pic_label_num
;
409 function_base_func_name
= "L_machopic_stub_dummy";
414 machopic_output_function_base_name (FILE *file
)
416 /* If dynamic-no-pic is on, we should not get here. */
417 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
419 update_pic_label_number_if_needed ();
420 fprintf (file
, "L%d$pb", current_pic_label_num
);
423 char curr_picbasename
[32];
426 machopic_get_function_picbase (void)
428 /* If dynamic-no-pic is on, we should not get here. */
429 gcc_assert (!MACHO_DYNAMIC_NO_PIC_P
);
431 update_pic_label_number_if_needed ();
432 snprintf (curr_picbasename
, 32, "L%d$pb", current_pic_label_num
);
433 return (const char *) curr_picbasename
;
437 machopic_should_output_picbase_label (void)
439 update_pic_label_number_if_needed ();
441 if (current_pic_label_num
== emitted_pic_label_num
)
444 emitted_pic_label_num
= current_pic_label_num
;
448 /* The suffix attached to non-lazy pointer symbols. */
449 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
450 /* The suffix attached to stub symbols. */
451 #define STUB_SUFFIX "$stub"
453 typedef struct GTY (()) machopic_indirection
455 /* The SYMBOL_REF for the entity referenced. */
457 /* The name of the stub or non-lazy pointer. */
458 const char * ptr_name
;
459 /* True iff this entry is for a stub (as opposed to a non-lazy
462 /* True iff this stub or pointer pointer has been referenced. */
464 } machopic_indirection
;
466 /* A table mapping stub names and non-lazy pointer names to
467 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
469 static GTY ((param_is (struct machopic_indirection
))) htab_t
470 machopic_indirections
;
472 /* Return a hash value for a SLOT in the indirections hash table. */
475 machopic_indirection_hash (const void *slot
)
477 const machopic_indirection
*p
= (const machopic_indirection
*) slot
;
478 return htab_hash_string (p
->ptr_name
);
481 /* Returns true if the KEY is the same as that associated with
485 machopic_indirection_eq (const void *slot
, const void *key
)
487 return strcmp (((const machopic_indirection
*) slot
)->ptr_name
,
488 (const char *) key
) == 0;
491 /* Return the name of the non-lazy pointer (if STUB_P is false) or
492 stub (if STUB_B is true) corresponding to the given name. */
495 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
498 const char *name
= XSTR (sym_ref
, 0);
499 size_t namelen
= strlen (name
);
500 machopic_indirection
*p
;
504 const char *prefix
= user_label_prefix
;
505 const char *quote
= "";
508 id
= maybe_get_identifier (name
);
513 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
514 id
= TREE_CHAIN (id
);
517 name
= IDENTIFIER_POINTER (id
);
518 namelen
= strlen (name
);
529 needs_quotes
= name_needs_quotes (name
);
536 suffix
= STUB_SUFFIX
;
538 suffix
= NON_LAZY_POINTER_SUFFIX
;
540 buffer
= XALLOCAVEC (char, strlen ("&L")
547 /* Construct the name of the non-lazy pointer or stub. */
548 sprintf (buffer
, "&%sL%s%s%s%s", quote
, prefix
, name
, suffix
, quote
);
550 if (!machopic_indirections
)
551 machopic_indirections
= htab_create_ggc (37,
552 machopic_indirection_hash
,
553 machopic_indirection_eq
,
556 slot
= htab_find_slot_with_hash (machopic_indirections
, buffer
,
557 htab_hash_string (buffer
), INSERT
);
560 p
= (machopic_indirection
*) *slot
;
564 p
= ggc_alloc_machopic_indirection ();
566 p
->ptr_name
= xstrdup (buffer
);
575 /* Return the name of the stub for the mcount function. */
578 machopic_mcount_stub_name (void)
580 rtx symbol
= gen_rtx_SYMBOL_REF (Pmode
, "*mcount");
581 return machopic_indirection_name (symbol
, /*stub_p=*/true);
584 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
585 or non-lazy pointer as used -- and mark the object to which the
586 pointer/stub refers as used as well, since the pointer/stub will
587 emit a reference to it. */
590 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
592 machopic_indirection
*p
;
594 p
= ((machopic_indirection
*)
595 (htab_find_with_hash (machopic_indirections
, name
,
596 htab_hash_string (name
))));
599 const char *real_name
;
604 /* Do what output_addr_const will do when we actually call it. */
605 if (SYMBOL_REF_DECL (p
->symbol
))
606 mark_decl_referenced (SYMBOL_REF_DECL (p
->symbol
));
608 real_name
= targetm
.strip_name_encoding (XSTR (p
->symbol
, 0));
610 id
= maybe_get_identifier (real_name
);
612 mark_referenced (id
);
616 /* Transform ORIG, which may be any data source, to the corresponding
617 source using indirections. */
620 machopic_indirect_data_reference (rtx orig
, rtx reg
)
624 if (! MACHOPIC_INDIRECT
)
627 if (GET_CODE (orig
) == SYMBOL_REF
)
629 int defined
= machopic_data_defined_p (orig
);
631 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
635 /* Create a new register for CSE opportunities. */
636 rtx hi_reg
= (!can_create_pseudo_p () ? reg
: gen_reg_rtx (Pmode
));
637 emit_insn (gen_macho_high (hi_reg
, orig
));
638 emit_insn (gen_macho_low (reg
, hi_reg
, orig
));
644 /* some other cpu -- writeme! */
650 if (DARWIN_PPC
|| HAVE_lo_sum
)
651 offset
= machopic_gen_offset (orig
);
655 rtx hi_sum_reg
= (!can_create_pseudo_p ()
657 : gen_reg_rtx (Pmode
));
661 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
662 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
663 gen_rtx_HIGH (Pmode
, offset
))));
664 emit_insn (gen_rtx_SET (Pmode
, reg
,
665 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
,
666 copy_rtx (offset
))));
670 else if (HAVE_lo_sum
)
674 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
675 gen_rtx_HIGH (Pmode
, offset
)));
676 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
677 gen_rtx_LO_SUM (Pmode
, reg
,
678 copy_rtx (offset
))));
679 emit_use (pic_offset_table_rtx
);
681 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
686 ptr_ref
= (gen_rtx_SYMBOL_REF
688 machopic_indirection_name (orig
, /*stub_p=*/false)));
690 SYMBOL_REF_DATA (ptr_ref
) = SYMBOL_REF_DATA (orig
);
692 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
693 machopic_define_symbol (ptr_ref
);
697 && MACHO_DYNAMIC_NO_PIC_P
)
699 emit_insn (gen_rtx_SET (Pmode
, reg
, ptr_ref
));
705 else if (GET_CODE (orig
) == CONST
)
707 /* If "(const (plus ...", walk the PLUS and return that result.
708 PLUS processing (below) will restore the "(const ..." if
710 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
711 return machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
715 else if (GET_CODE (orig
) == MEM
)
718 machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
721 else if (GET_CODE (orig
) == PLUS
)
724 /* When the target is i386, this code prevents crashes due to the
725 compiler's ignorance on how to move the PIC base register to
726 other registers. (The reload phase sometimes introduces such
728 if (GET_CODE (XEXP (orig
, 0)) == REG
729 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
730 /* Prevent the same register from being erroneously used
731 as both the base and index registers. */
732 && (DARWIN_X86
&& (GET_CODE (XEXP (orig
, 1)) == CONST
))
735 emit_move_insn (reg
, XEXP (orig
, 0));
736 XEXP (ptr_ref
, 0) = reg
;
740 /* Legitimize both operands of the PLUS. */
741 base
= machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
742 orig
= machopic_indirect_data_reference (XEXP (orig
, 1),
743 (base
== reg
? 0 : reg
));
744 if (MACHOPIC_INDIRECT
&& (GET_CODE (orig
) == CONST_INT
))
745 result
= plus_constant (Pmode
, base
, INTVAL (orig
));
747 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
749 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
753 emit_move_insn (reg
, result
);
758 result
= force_reg (GET_MODE (result
), result
);
767 /* Transform TARGET (a MEM), which is a function call target, to the
768 corresponding symbol_stub if necessary. Return a new MEM. */
771 machopic_indirect_call_target (rtx target
)
773 if (! darwin_emit_branch_islands
)
776 if (GET_CODE (target
) != MEM
)
779 if (MACHOPIC_INDIRECT
780 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
781 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
782 & MACHO_SYMBOL_FLAG_DEFINED
))
784 rtx sym_ref
= XEXP (target
, 0);
785 const char *stub_name
= machopic_indirection_name (sym_ref
,
787 enum machine_mode mode
= GET_MODE (sym_ref
);
789 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
790 SYMBOL_REF_DATA (XEXP (target
, 0)) = SYMBOL_REF_DATA (sym_ref
);
791 MEM_READONLY_P (target
) = 1;
792 MEM_NOTRAP_P (target
) = 1;
799 machopic_legitimize_pic_address (rtx orig
, enum machine_mode mode
, rtx reg
)
803 if (! MACHOPIC_INDIRECT
)
806 /* First handle a simple SYMBOL_REF or LABEL_REF */
807 if (GET_CODE (orig
) == LABEL_REF
808 || (GET_CODE (orig
) == SYMBOL_REF
811 /* addr(foo) = &func+(foo-func) */
812 orig
= machopic_indirect_data_reference (orig
, reg
);
814 if (GET_CODE (orig
) == PLUS
815 && GET_CODE (XEXP (orig
, 0)) == REG
)
818 return force_reg (mode
, orig
);
820 emit_move_insn (reg
, orig
);
824 if (GET_CODE (orig
) == MEM
)
828 gcc_assert (!reload_in_progress
);
829 reg
= gen_reg_rtx (Pmode
);
833 if (MACHO_DYNAMIC_NO_PIC_P
834 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
835 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
837 #if defined (TARGET_TOC) /* ppc */
838 rtx temp_reg
= (!can_create_pseudo_p ()
840 gen_reg_rtx (Pmode
));
841 rtx asym
= XEXP (orig
, 0);
844 emit_insn (gen_macho_high (temp_reg
, asym
));
845 mem
= gen_const_mem (GET_MODE (orig
),
846 gen_rtx_LO_SUM (Pmode
, temp_reg
,
848 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
850 /* Some other CPU -- WriteMe! but right now there are no other
851 platforms that can use dynamic-no-pic */
857 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
858 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
860 rtx offset
= machopic_gen_offset (XEXP (orig
, 0));
861 #if defined (TARGET_TOC) /* i.e., PowerPC */
862 /* Generating a new reg may expose opportunities for
863 common subexpression elimination. */
864 rtx hi_sum_reg
= (!can_create_pseudo_p ()
866 : gen_reg_rtx (Pmode
));
871 sum
= gen_rtx_HIGH (Pmode
, offset
);
872 if (! MACHO_DYNAMIC_NO_PIC_P
)
873 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
875 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
877 mem
= gen_const_mem (GET_MODE (orig
),
878 gen_rtx_LO_SUM (Pmode
,
881 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
882 set_unique_reg_note (insn
, REG_EQUAL
, pic_ref
);
886 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
888 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
890 gen_rtx_CONST (Pmode
,
892 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
893 gen_rtx_LO_SUM (Pmode
, reg
,
894 gen_rtx_CONST (Pmode
,
895 copy_rtx (offset
)))));
896 pic_ref
= gen_rtx_PLUS (Pmode
,
897 pic_offset_table_rtx
, reg
);
901 #endif /* HAVE_lo_sum */
903 rtx pic
= pic_offset_table_rtx
;
904 if (GET_CODE (pic
) != REG
)
906 emit_move_insn (reg
, pic
);
910 emit_use (gen_rtx_REG (Pmode
, PIC_OFFSET_TABLE_REGNUM
));
913 if (reload_in_progress
)
914 df_set_regs_ever_live (REGNO (pic
), true);
915 pic_ref
= gen_rtx_PLUS (Pmode
, pic
,
916 machopic_gen_offset (XEXP (orig
, 0)));
919 #if !defined (TARGET_TOC)
920 emit_move_insn (reg
, pic_ref
);
921 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
928 if (GET_CODE (orig
) == SYMBOL_REF
929 || GET_CODE (orig
) == LABEL_REF
)
931 rtx offset
= machopic_gen_offset (orig
);
932 #if defined (TARGET_TOC) /* i.e., PowerPC */
937 gcc_assert (!reload_in_progress
);
938 reg
= gen_reg_rtx (Pmode
);
943 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
944 (MACHO_DYNAMIC_NO_PIC_P
)
945 ? gen_rtx_HIGH (Pmode
, offset
)
946 : gen_rtx_PLUS (Pmode
,
947 pic_offset_table_rtx
,
950 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
951 gen_rtx_LO_SUM (Pmode
,
953 copy_rtx (offset
))));
956 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
957 gen_rtx_HIGH (Pmode
, offset
)));
958 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
959 gen_rtx_LO_SUM (Pmode
, reg
,
960 copy_rtx (offset
))));
961 pic_ref
= gen_rtx_PLUS (Pmode
,
962 pic_offset_table_rtx
, reg
);
966 #endif /* HAVE_lo_sum */
969 || GET_CODE (orig
) == SUBREG
)
975 rtx pic
= pic_offset_table_rtx
;
976 if (GET_CODE (pic
) != REG
)
978 emit_move_insn (reg
, pic
);
982 emit_use (pic_offset_table_rtx
);
984 if (reload_in_progress
)
985 df_set_regs_ever_live (REGNO (pic
), true);
986 pic_ref
= gen_rtx_PLUS (Pmode
,
988 machopic_gen_offset (orig
));
993 if (GET_CODE (pic_ref
) != REG
)
997 emit_move_insn (reg
, pic_ref
);
1002 return force_reg (mode
, pic_ref
);
1011 else if (GET_CODE (orig
) == SYMBOL_REF
)
1014 else if (GET_CODE (orig
) == PLUS
1015 && (GET_CODE (XEXP (orig
, 0)) == MEM
1016 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
1017 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
1018 && XEXP (orig
, 0) != pic_offset_table_rtx
1019 && GET_CODE (XEXP (orig
, 1)) != REG
)
1023 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
1025 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1026 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
1027 Pmode
, (base
== reg
? 0 : reg
));
1028 if (GET_CODE (orig
) == CONST_INT
)
1030 pic_ref
= plus_constant (Pmode
, base
, INTVAL (orig
));
1034 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
1036 if (reg
&& is_complex
)
1038 emit_move_insn (reg
, pic_ref
);
1041 /* Likewise, should we set special REG_NOTEs here? */
1044 else if (GET_CODE (orig
) == CONST
)
1046 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1049 else if (GET_CODE (orig
) == MEM
1050 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
1052 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
1053 addr
= replace_equiv_address (orig
, addr
);
1054 emit_move_insn (reg
, addr
);
1061 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
1062 DATA is the FILE* for assembly output. Called from
1066 machopic_output_indirection (void **slot
, void *data
)
1068 machopic_indirection
*p
= *((machopic_indirection
**) slot
);
1069 FILE *asm_out_file
= (FILE *) data
;
1071 const char *sym_name
;
1072 const char *ptr_name
;
1078 sym_name
= XSTR (symbol
, 0);
1079 ptr_name
= p
->ptr_name
;
1087 id
= maybe_get_identifier (sym_name
);
1092 while (IDENTIFIER_TRANSPARENT_ALIAS (id
))
1093 id
= TREE_CHAIN (id
);
1095 sym_name
= IDENTIFIER_POINTER (id
);
1098 sym
= XALLOCAVEC (char, strlen (sym_name
) + 2);
1099 if (sym_name
[0] == '*' || sym_name
[0] == '&')
1100 strcpy (sym
, sym_name
+ 1);
1101 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
1102 strcpy (sym
, sym_name
);
1104 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
1106 stub
= XALLOCAVEC (char, strlen (ptr_name
) + 2);
1107 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
1108 strcpy (stub
, ptr_name
+ 1);
1110 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
1112 machopic_output_stub (asm_out_file
, sym
, stub
);
1114 else if (! indirect_data (symbol
)
1115 && (machopic_symbol_defined_p (symbol
)
1116 || SYMBOL_REF_LOCAL_P (symbol
)))
1118 switch_to_section (data_section
);
1119 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
1120 assemble_label (asm_out_file
, ptr_name
);
1121 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
1122 GET_MODE_SIZE (Pmode
),
1123 GET_MODE_ALIGNMENT (Pmode
), 1);
1127 rtx init
= const0_rtx
;
1129 switch_to_section (darwin_sections
[machopic_nl_symbol_ptr_section
]);
1131 /* Mach-O symbols are passed around in code through indirect
1132 references and the original symbol_ref hasn't passed through
1133 the generic handling and reference-catching in
1134 output_operand, so we need to manually mark weak references
1136 if (SYMBOL_REF_WEAK (symbol
))
1138 tree decl
= SYMBOL_REF_DECL (symbol
);
1139 gcc_assert (DECL_P (decl
));
1141 if (decl
!= NULL_TREE
1142 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
)
1143 /* Handle only actual external-only definitions, not
1144 e.g. extern inline code or variables for which
1145 storage has been allocated. */
1146 && !TREE_STATIC (decl
))
1148 fputs ("\t.weak_reference ", asm_out_file
);
1149 assemble_name (asm_out_file
, sym_name
);
1150 fputc ('\n', asm_out_file
);
1154 assemble_name (asm_out_file
, ptr_name
);
1155 fprintf (asm_out_file
, ":\n");
1157 fprintf (asm_out_file
, "\t.indirect_symbol ");
1158 assemble_name (asm_out_file
, sym_name
);
1159 fprintf (asm_out_file
, "\n");
1161 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1162 have their symbol name instead of 0 in the second entry of
1163 the non-lazy symbol pointer data structure when they are
1164 defined. This allows the runtime to rebind newer instances
1165 of the translation unit with the original instance of the
1168 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
1169 && machopic_symbol_defined_p (symbol
))
1170 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
1172 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
1173 GET_MODE_ALIGNMENT (Pmode
), 1);
1180 machopic_finish (FILE *asm_out_file
)
1182 if (machopic_indirections
)
1183 htab_traverse_noresize (machopic_indirections
,
1184 machopic_output_indirection
,
1189 machopic_operand_p (rtx op
)
1191 if (MACHOPIC_JUST_INDIRECT
)
1192 return (GET_CODE (op
) == SYMBOL_REF
1193 && machopic_symbol_defined_p (op
));
1195 return (GET_CODE (op
) == CONST
1196 && GET_CODE (XEXP (op
, 0)) == UNSPEC
1197 && XINT (XEXP (op
, 0), 1) == UNSPEC_MACHOPIC_OFFSET
);
1200 /* This function records whether a given name corresponds to a defined
1201 or undefined function or variable, for machopic_classify_ident to
1205 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
1209 /* Do the standard encoding things first. */
1210 default_encode_section_info (decl
, rtl
, first
);
1212 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
1215 sym_ref
= XEXP (rtl
, 0);
1216 if (TREE_CODE (decl
) == VAR_DECL
)
1217 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
1219 if (!DECL_EXTERNAL (decl
)
1220 && (!TREE_PUBLIC (decl
) || !DECL_WEAK (decl
))
1221 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1222 && ((TREE_STATIC (decl
)
1223 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
1224 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
1225 && DECL_INITIAL (decl
) != error_mark_node
)))
1226 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
1228 if (! TREE_PUBLIC (decl
))
1229 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
1233 darwin_mark_decl_preserved (const char *name
)
1235 fprintf (asm_out_file
, "\t.no_dead_strip ");
1236 assemble_name (asm_out_file
, name
);
1237 fputc ('\n', asm_out_file
);
1241 darwin_rodata_section (int weak
, bool zsize
)
1244 ? darwin_sections
[const_coal_section
]
1245 : (zsize
? darwin_sections
[zobj_const_section
]
1246 : darwin_sections
[const_section
]));
1250 darwin_mergeable_string_section (tree exp
,
1251 unsigned HOST_WIDE_INT align
)
1253 /* Darwin's ld expects to see non-writable string literals in the .cstring
1254 section. Later versions of ld check and complain when CFStrings are
1255 enabled. Therefore we shall force the strings into .cstring since we
1256 don't support writable ones anyway. */
1257 if ((darwin_constant_cfstrings
|| flag_merge_constants
)
1258 && TREE_CODE (exp
) == STRING_CST
1259 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1261 && (int_size_in_bytes (TREE_TYPE (exp
))
1262 == TREE_STRING_LENGTH (exp
))
1263 && ((size_t) TREE_STRING_LENGTH (exp
)
1264 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1265 return darwin_sections
[cstring_section
];
1267 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
1268 && TREE_CODE (exp
) == STRING_CST
1269 && TREE_STRING_LENGTH (exp
) == 0)
1270 return darwin_sections
[zobj_const_section
];
1272 return readonly_data_section
;
1275 #ifndef HAVE_GAS_LITERAL16
1276 #define HAVE_GAS_LITERAL16 0
1280 darwin_mergeable_constant_section (tree exp
,
1281 unsigned HOST_WIDE_INT align
,
1284 enum machine_mode mode
= DECL_MODE (exp
);
1285 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
1287 if (DARWIN_SECTION_ANCHORS
1288 && flag_section_anchors
1290 return darwin_sections
[zobj_const_section
];
1292 if (flag_merge_constants
1295 && modesize
<= align
1298 && (align
& (align
-1)) == 0)
1300 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (exp
));
1302 if (TREE_CODE (size
) == INTEGER_CST
)
1304 if (wi::eq_p (size
, 4))
1305 return darwin_sections
[literal4_section
];
1306 else if (wi::eq_p (size
, 8))
1307 return darwin_sections
[literal8_section
];
1308 else if (HAVE_GAS_LITERAL16
1310 && wi::eq_p (size
, 16))
1311 return darwin_sections
[literal16_section
];
1315 return readonly_data_section
;
1319 darwin_tm_clone_table_section (void)
1321 return get_named_section (NULL
,
1322 "__DATA,__tm_clone_table,regular,no_dead_strip",
1327 machopic_reloc_rw_mask (void)
1329 return MACHOPIC_INDIRECT
? 3 : 0;
1332 /* We have to deal with ObjC/C++ metadata section placement in the common
1333 code, since it will also be called from LTO.
1335 Return metadata attributes, if present (searching for ABI=2 first)
1336 Return NULL_TREE if no such attributes are found. */
1339 is_objc_metadata (tree decl
)
1342 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1343 && DECL_ATTRIBUTES (decl
))
1345 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1348 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1355 static int classes_seen
;
1356 static int objc_metadata_seen
;
1358 /* Return the section required for Objective C ABI 2 metadata. */
1360 darwin_objc2_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1363 tree ident
= TREE_VALUE (meta
);
1364 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1365 p
= IDENTIFIER_POINTER (ident
);
1367 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
== 2);
1369 objc_metadata_seen
= 1;
1371 if (base
== data_section
)
1372 base
= darwin_sections
[objc2_metadata_section
];
1374 /* Most of the OBJC2 META-data end up in the base section, so check it
1376 if (!strncmp (p
, "V2_BASE", 7))
1378 else if (!strncmp (p
, "V2_STRG", 7))
1379 return darwin_sections
[cstring_section
];
1381 else if (!strncmp (p
, "G2_META", 7) || !strncmp (p
, "G2_CLAS", 7))
1382 return darwin_sections
[objc2_classdefs_section
];
1383 else if (!strncmp (p
, "V2_MREF", 7))
1384 return darwin_sections
[objc2_message_refs_section
];
1385 else if (!strncmp (p
, "V2_CLRF", 7))
1386 return darwin_sections
[objc2_classrefs_section
];
1387 else if (!strncmp (p
, "V2_SURF", 7))
1388 return darwin_sections
[objc2_super_classrefs_section
];
1389 else if (!strncmp (p
, "V2_NLCL", 7))
1390 return darwin_sections
[objc2_nonlazy_class_section
];
1391 else if (!strncmp (p
, "V2_CLAB", 7))
1394 return darwin_sections
[objc2_classlist_section
];
1396 else if (!strncmp (p
, "V2_SRFS", 7))
1397 return darwin_sections
[objc2_selector_refs_section
];
1398 else if (!strncmp (p
, "V2_NLCA", 7))
1399 return darwin_sections
[objc2_nonlazy_category_section
];
1400 else if (!strncmp (p
, "V2_CALA", 7))
1401 return darwin_sections
[objc2_categorylist_section
];
1403 else if (!strncmp (p
, "V2_PLST", 7))
1404 return darwin_sections
[objc2_protocollist_section
];
1405 else if (!strncmp (p
, "V2_PRFS", 7))
1406 return darwin_sections
[objc2_protocolrefs_section
];
1408 else if (!strncmp (p
, "V2_INFO", 7))
1409 return darwin_sections
[objc2_image_info_section
];
1411 else if (!strncmp (p
, "V2_EHTY", 7))
1412 return darwin_sections
[data_coal_section
];
1414 else if (!strncmp (p
, "V2_CSTR", 7))
1415 return darwin_sections
[objc2_constant_string_object_section
];
1417 /* Not recognized, default. */
1421 /* Return the section required for Objective C ABI 0/1 metadata. */
1423 darwin_objc1_section (tree decl ATTRIBUTE_UNUSED
, tree meta
, section
* base
)
1426 tree ident
= TREE_VALUE (meta
);
1427 gcc_assert (TREE_CODE (ident
) == IDENTIFIER_NODE
);
1428 p
= IDENTIFIER_POINTER (ident
);
1430 gcc_checking_assert (flag_next_runtime
== 1 && flag_objc_abi
< 2);
1432 objc_metadata_seen
= 1;
1434 /* String sections first, cos there are lots of strings. */
1435 if (!strncmp (p
, "V1_STRG", 7))
1436 return darwin_sections
[cstring_section
];
1437 else if (!strncmp (p
, "V1_CLSN", 7))
1438 return darwin_sections
[objc_class_names_section
];
1439 else if (!strncmp (p
, "V1_METN", 7))
1440 return darwin_sections
[objc_meth_var_names_section
];
1441 else if (!strncmp (p
, "V1_METT", 7))
1442 return darwin_sections
[objc_meth_var_types_section
];
1444 else if (!strncmp (p
, "V1_CLAS", 7))
1447 return darwin_sections
[objc_class_section
];
1449 else if (!strncmp (p
, "V1_META", 7))
1450 return darwin_sections
[objc_meta_class_section
];
1451 else if (!strncmp (p
, "V1_CATG", 7))
1452 return darwin_sections
[objc_category_section
];
1453 else if (!strncmp (p
, "V1_PROT", 7))
1454 return darwin_sections
[objc_protocol_section
];
1456 else if (!strncmp (p
, "V1_CLCV", 7))
1457 return darwin_sections
[objc_class_vars_section
];
1458 else if (!strncmp (p
, "V1_CLIV", 7))
1459 return darwin_sections
[objc_instance_vars_section
];
1461 else if (!strncmp (p
, "V1_CLCM", 7))
1462 return darwin_sections
[objc_cls_meth_section
];
1463 else if (!strncmp (p
, "V1_CLIM", 7))
1464 return darwin_sections
[objc_inst_meth_section
];
1465 else if (!strncmp (p
, "V1_CACM", 7))
1466 return darwin_sections
[objc_cat_cls_meth_section
];
1467 else if (!strncmp (p
, "V1_CAIM", 7))
1468 return darwin_sections
[objc_cat_inst_meth_section
];
1469 else if (!strncmp (p
, "V1_PNSM", 7))
1470 return darwin_sections
[objc_cat_inst_meth_section
];
1471 else if (!strncmp (p
, "V1_PCLM", 7))
1472 return darwin_sections
[objc_cat_cls_meth_section
];
1474 else if (!strncmp (p
, "V1_CLPR", 7))
1475 return darwin_sections
[objc_cat_cls_meth_section
];
1476 else if (!strncmp (p
, "V1_CAPR", 7))
1477 return darwin_sections
[objc_category_section
]; /* ??? CHECK me. */
1479 else if (!strncmp (p
, "V1_PRFS", 7))
1480 return darwin_sections
[objc_cat_cls_meth_section
];
1481 else if (!strncmp (p
, "V1_CLRF", 7))
1482 return darwin_sections
[objc_cls_refs_section
];
1483 else if (!strncmp (p
, "V1_SRFS", 7))
1484 return darwin_sections
[objc_selector_refs_section
];
1486 else if (!strncmp (p
, "V1_MODU", 7))
1487 return darwin_sections
[objc_module_info_section
];
1488 else if (!strncmp (p
, "V1_SYMT", 7))
1489 return darwin_sections
[objc_symbols_section
];
1490 else if (!strncmp (p
, "V1_INFO", 7))
1491 return darwin_sections
[objc_image_info_section
];
1493 else if (!strncmp (p
, "V1_PLST", 7))
1494 return darwin_sections
[objc1_prop_list_section
];
1495 else if (!strncmp (p
, "V1_PEXT", 7))
1496 return darwin_sections
[objc1_protocol_ext_section
];
1497 else if (!strncmp (p
, "V1_CEXT", 7))
1498 return darwin_sections
[objc1_class_ext_section
];
1500 else if (!strncmp (p
, "V2_CSTR", 7))
1501 return darwin_sections
[objc_constant_string_object_section
];
1507 machopic_select_section (tree decl
,
1509 unsigned HOST_WIDE_INT align
)
1511 bool zsize
, one
, weak
, ro
;
1512 section
*base_section
= NULL
;
1514 weak
= (DECL_P (decl
)
1516 && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl
)));
1518 zsize
= (DECL_P (decl
)
1519 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
1520 && tree_to_uhwi (DECL_SIZE_UNIT (decl
)) == 0);
1523 && TREE_CODE (decl
) == VAR_DECL
1524 && DECL_ONE_ONLY (decl
);
1526 ro
= TREE_READONLY (decl
) || TREE_CONSTANT (decl
) ;
1528 switch (categorize_decl_for_section (decl
, reloc
))
1535 case SECCAT_SRODATA
:
1536 base_section
= darwin_rodata_section (weak
, zsize
);
1539 case SECCAT_RODATA_MERGE_STR
:
1540 base_section
= darwin_mergeable_string_section (decl
, align
);
1543 case SECCAT_RODATA_MERGE_STR_INIT
:
1544 base_section
= darwin_mergeable_string_section (DECL_INITIAL (decl
), align
);
1547 case SECCAT_RODATA_MERGE_CONST
:
1548 base_section
= darwin_mergeable_constant_section (decl
, align
, zsize
);
1552 case SECCAT_DATA_REL
:
1553 case SECCAT_DATA_REL_LOCAL
:
1554 case SECCAT_DATA_REL_RO
:
1555 case SECCAT_DATA_REL_RO_LOCAL
:
1561 base_section
= darwin_sections
[const_data_coal_section
];
1563 base_section
= darwin_sections
[data_coal_section
];
1565 else if (DARWIN_SECTION_ANCHORS
1566 && flag_section_anchors
1569 /* If we're doing section anchors, then punt zero-sized objects into
1570 their own sections so that they don't interfere with offset
1571 computation for the remaining vars. This does not need to be done
1572 for stuff in mergeable sections, since these are ineligible for
1575 base_section
= darwin_sections
[zobj_const_data_section
];
1577 base_section
= darwin_sections
[zobj_data_section
];
1580 base_section
= darwin_sections
[const_data_section
];
1582 base_section
= data_section
;
1588 base_section
= darwin_sections
[data_coal_section
];
1591 if (!TREE_PUBLIC (decl
))
1592 base_section
= lcomm_section
;
1593 else if (bss_noswitch_section
)
1594 base_section
= bss_noswitch_section
;
1596 base_section
= data_section
;
1604 /* Darwin weird special cases.
1605 a) OBJC Meta-data. */
1607 && (TREE_CODE (decl
) == VAR_DECL
1608 || TREE_CODE (decl
) == CONST_DECL
)
1609 && DECL_ATTRIBUTES (decl
))
1611 tree meta
= lookup_attribute ("OBJC2META", DECL_ATTRIBUTES (decl
));
1613 return darwin_objc2_section (decl
, meta
, base_section
);
1614 meta
= lookup_attribute ("OBJC1META", DECL_ATTRIBUTES (decl
));
1616 return darwin_objc1_section (decl
, meta
, base_section
);
1617 meta
= lookup_attribute ("OBJC1METG", DECL_ATTRIBUTES (decl
));
1619 return base_section
; /* GNU runtime is happy with it all in one pot. */
1622 /* b) Constant string objects. */
1623 if (TREE_CODE (decl
) == CONSTRUCTOR
1625 && TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
1626 && TYPE_NAME (TREE_TYPE (decl
)))
1628 tree name
= TYPE_NAME (TREE_TYPE (decl
));
1629 if (TREE_CODE (name
) == TYPE_DECL
)
1630 name
= DECL_NAME (name
);
1632 if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_ObjCString"))
1634 if (flag_next_runtime
)
1636 if (flag_objc_abi
== 2)
1637 return darwin_sections
[objc2_constant_string_object_section
];
1639 return darwin_sections
[objc_constant_string_object_section
];
1642 return darwin_sections
[objc_string_object_section
];
1644 else if (!strcmp (IDENTIFIER_POINTER (name
), "__builtin_CFString"))
1645 return darwin_sections
[cfstring_constant_object_section
];
1647 return base_section
;
1649 /* c) legacy meta-data selection. */
1650 else if (TREE_CODE (decl
) == VAR_DECL
1652 && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
1653 && IDENTIFIER_POINTER (DECL_NAME (decl
))
1654 && flag_next_runtime
1655 && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), "_OBJC_", 6))
1657 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1658 static bool warned_objc_46
= false;
1659 /* We shall assert that zero-sized objects are an error in ObjC
1661 gcc_assert (tree_to_uhwi (DECL_SIZE_UNIT (decl
)) != 0);
1663 /* ??? This mechanism for determining the metadata section is
1664 broken when LTO is in use, since the frontend that generated
1665 the data is not identified. We will keep the capability for
1666 the short term - in case any non-Objective-C programs are using
1667 it to place data in specified sections. */
1668 if (!warned_objc_46
)
1670 location_t loc
= DECL_SOURCE_LOCATION (decl
);
1671 warning_at (loc
, 0, "the use of _OBJC_-prefixed variable names"
1672 " to select meta-data sections is deprecated at 4.6"
1673 " and will be removed in 4.7");
1674 warned_objc_46
= true;
1677 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1678 return darwin_sections
[objc_cls_meth_section
];
1679 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1680 return darwin_sections
[objc_inst_meth_section
];
1681 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 29))
1682 return darwin_sections
[objc_cat_cls_meth_section
];
1683 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 32))
1684 return darwin_sections
[objc_cat_inst_meth_section
];
1685 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1686 return darwin_sections
[objc_class_vars_section
];
1687 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1688 return darwin_sections
[objc_instance_vars_section
];
1689 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1690 return darwin_sections
[objc_cat_cls_meth_section
];
1691 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1692 return darwin_sections
[objc_class_names_section
];
1693 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1694 return darwin_sections
[objc_meth_var_names_section
];
1695 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1696 return darwin_sections
[objc_meth_var_types_section
];
1697 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1698 return darwin_sections
[objc_cls_refs_section
];
1699 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1700 return darwin_sections
[objc_class_section
];
1701 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1702 return darwin_sections
[objc_meta_class_section
];
1703 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1704 return darwin_sections
[objc_category_section
];
1705 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1706 return darwin_sections
[objc_selector_refs_section
];
1707 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1708 return darwin_sections
[objc_selector_fixup_section
];
1709 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1710 return darwin_sections
[objc_symbols_section
];
1711 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1712 return darwin_sections
[objc_module_info_section
];
1713 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1714 return darwin_sections
[objc_image_info_section
];
1715 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1716 return darwin_sections
[objc_cat_inst_meth_section
];
1717 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1718 return darwin_sections
[objc_cat_cls_meth_section
];
1719 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1720 return darwin_sections
[objc_cat_cls_meth_section
];
1721 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1722 return darwin_sections
[objc_protocol_section
];
1724 return base_section
;
1727 return base_section
;
1730 /* This can be called with address expressions as "rtx".
1731 They must go in "const". */
1734 machopic_select_rtx_section (enum machine_mode mode
, rtx x
,
1735 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1737 if (GET_MODE_SIZE (mode
) == 8
1738 && (GET_CODE (x
) == CONST_INT
1739 || GET_CODE (x
) == CONST_WIDE_INT
1740 || GET_CODE (x
) == CONST_DOUBLE
))
1741 return darwin_sections
[literal8_section
];
1742 else if (GET_MODE_SIZE (mode
) == 4
1743 && (GET_CODE (x
) == CONST_INT
1744 || GET_CODE (x
) == CONST_WIDE_INT
1745 || GET_CODE (x
) == CONST_DOUBLE
))
1746 return darwin_sections
[literal4_section
];
1747 else if (HAVE_GAS_LITERAL16
1749 && GET_MODE_SIZE (mode
) == 16
1750 && (GET_CODE (x
) == CONST_INT
1751 || GET_CODE (x
) == CONST_WIDE_INT
1752 || GET_CODE (x
) == CONST_DOUBLE
1753 || GET_CODE (x
) == CONST_VECTOR
))
1754 return darwin_sections
[literal16_section
];
1755 else if (MACHOPIC_INDIRECT
1756 && (GET_CODE (x
) == SYMBOL_REF
1757 || GET_CODE (x
) == CONST
1758 || GET_CODE (x
) == LABEL_REF
))
1759 return darwin_sections
[const_data_section
];
1761 return darwin_sections
[const_section
];
1765 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1767 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (ctors
)};
1769 vec_safe_push (ctors
, new_elt
);
1771 if (! MACHOPIC_INDIRECT
)
1772 fprintf (asm_out_file
, ".reference .constructors_used\n");
1776 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1778 cdtor_record new_elt
= {symbol
, priority
, vec_safe_length (dtors
)};
1780 vec_safe_push (dtors
, new_elt
);
1782 if (! MACHOPIC_INDIRECT
)
1783 fprintf (asm_out_file
, ".reference .destructors_used\n");
1787 sort_cdtor_records (const void * a
, const void * b
)
1789 const cdtor_record
*cda
= (const cdtor_record
*)a
;
1790 const cdtor_record
*cdb
= (const cdtor_record
*)b
;
1791 if (cda
->priority
> cdb
->priority
)
1793 if (cda
->priority
< cdb
->priority
)
1795 if (cda
->position
> cdb
->position
)
1797 if (cda
->position
< cdb
->position
)
1808 if (MACHOPIC_INDIRECT
)
1809 switch_to_section (darwin_sections
[mod_init_section
]);
1811 switch_to_section (darwin_sections
[constructor_section
]);
1813 if (vec_safe_length (ctors
) > 1)
1814 ctors
->qsort (sort_cdtor_records
);
1815 FOR_EACH_VEC_SAFE_ELT (ctors
, i
, elt
)
1817 assemble_align (POINTER_SIZE
);
1818 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1828 if (MACHOPIC_INDIRECT
)
1829 switch_to_section (darwin_sections
[mod_term_section
]);
1831 switch_to_section (darwin_sections
[destructor_section
]);
1833 if (vec_safe_length (dtors
) > 1)
1834 dtors
->qsort (sort_cdtor_records
);
1835 FOR_EACH_VEC_SAFE_ELT (dtors
, i
, elt
)
1837 assemble_align (POINTER_SIZE
);
1838 assemble_integer (elt
->symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1843 darwin_globalize_label (FILE *stream
, const char *name
)
1845 if (!!strncmp (name
, "_OBJC_", 6))
1846 default_globalize_label (stream
, name
);
1849 /* This routine returns non-zero if 'name' starts with the special objective-c
1850 anonymous file-scope static name. It accommodates c++'s mangling of such
1851 symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit). */
1854 darwin_label_is_anonymous_local_objc_name (const char *name
)
1856 const unsigned char *p
= (const unsigned char *) name
;
1859 if (p
[1] == 'Z' && p
[2] == 'L')
1862 while (*p
>= '0' && *p
<= '9')
1865 return (!strncmp ((const char *)p
, "_OBJC_", 6));
1868 /* LTO support for Mach-O.
1870 This version uses three mach-o sections to encapsulate the (unlimited
1871 number of) lto sections.
1873 __GNU_LTO, __lto_sections contains the concatented GNU LTO section data.
1874 __GNU_LTO, __section_names contains the GNU LTO section names.
1875 __GNU_LTO, __section_index contains an array of values that index these.
1878 <section offset from the start of __GNU_LTO, __lto_sections>,
1880 <name offset from the start of __GNU_LTO, __section_names,
1883 At present, for both m32 and m64 mach-o files each of these fields is
1884 represented by a uint32_t. This is because, AFAICT, a mach-o object
1885 cannot exceed 4Gb because the section_64 offset field (see below) is 32bits.
1888 "offset An integer specifying the offset to this section in the file." */
1890 /* Count lto section numbers. */
1891 static unsigned int lto_section_num
= 0;
1893 /* A vector of information about LTO sections, at present, we only have
1894 the name. TODO: see if we can get the data length somehow. */
1895 typedef struct GTY (()) darwin_lto_section_e
{
1896 const char *sectname
;
1897 } darwin_lto_section_e
;
1899 static GTY (()) vec
<darwin_lto_section_e
, va_gc
> *lto_section_names
;
1901 /* Segment for LTO data. */
1902 #define LTO_SEGMENT_NAME "__GNU_LTO"
1904 /* Section wrapper scheme (used here to wrap the unlimited number of LTO
1905 sections into three Mach-O ones).
1906 NOTE: These names MUST be kept in sync with those in
1907 libiberty/simple-object-mach-o. */
1908 #define LTO_SECTS_SECTION "__wrapper_sects"
1909 #define LTO_NAMES_SECTION "__wrapper_names"
1910 #define LTO_INDEX_SECTION "__wrapper_index"
1912 /* File to temporarily store LTO data. This is appended to asm_out_file
1913 in darwin_end_file. */
1914 static FILE *lto_asm_out_file
, *saved_asm_out_file
;
1915 static char *lto_asm_out_name
;
1917 /* Prepare asm_out_file for LTO output. For darwin, this means hiding
1918 asm_out_file and switching to an alternative output file. */
1920 darwin_asm_lto_start (void)
1922 gcc_assert (! saved_asm_out_file
);
1923 saved_asm_out_file
= asm_out_file
;
1924 if (! lto_asm_out_name
)
1925 lto_asm_out_name
= make_temp_file (".lto.s");
1926 lto_asm_out_file
= fopen (lto_asm_out_name
, "a");
1927 if (lto_asm_out_file
== NULL
)
1928 fatal_error ("failed to open temporary file %s for LTO output",
1930 asm_out_file
= lto_asm_out_file
;
1933 /* Restore asm_out_file. */
1935 darwin_asm_lto_end (void)
1937 gcc_assert (saved_asm_out_file
);
1938 fclose (lto_asm_out_file
);
1939 asm_out_file
= saved_asm_out_file
;
1940 saved_asm_out_file
= NULL
;
1944 darwin_asm_dwarf_section (const char *name
, unsigned int flags
, tree decl
);
1946 /* Called for the TARGET_ASM_NAMED_SECTION hook. */
1949 darwin_asm_named_section (const char *name
,
1951 tree decl ATTRIBUTE_UNUSED
)
1953 /* LTO sections go in a special section that encapsulates the (unlimited)
1954 number of GNU LTO sections within a single mach-o one. */
1955 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
1956 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
1958 darwin_lto_section_e e
;
1959 /* We expect certain flags to be set... */
1960 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
1961 == (SECTION_DEBUG
| SECTION_NAMED
));
1963 /* Switch to our combined section. */
1964 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
1965 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
1966 /* Output a label for the start of this sub-section. */
1967 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# %s\n",
1968 lto_section_num
, name
);
1969 /* We have to jump through hoops to get the values of the intra-section
1971 fprintf (asm_out_file
, "\t.set L$gnu$lto$offs%d,L_GNU_LTO%d-L_GNU_LTO0\n",
1972 lto_section_num
, lto_section_num
);
1973 fprintf (asm_out_file
,
1974 "\t.set L$gnu$lto$size%d,L_GNU_LTO%d-L_GNU_LTO%d\n",
1975 lto_section_num
, lto_section_num
+1, lto_section_num
);
1977 e
.sectname
= xstrdup (name
);
1978 /* Keep the names, we'll need to make a table later.
1979 TODO: check that we do not revisit sections, that would break
1980 the assumption of how this is done. */
1981 if (lto_section_names
== NULL
)
1982 vec_alloc (lto_section_names
, 16);
1983 vec_safe_push (lto_section_names
, e
);
1985 else if (strncmp (name
, "__DWARF,", 8) == 0)
1986 darwin_asm_dwarf_section (name
, flags
, decl
);
1988 fprintf (asm_out_file
, "\t.section %s\n", name
);
1992 darwin_unique_section (tree decl ATTRIBUTE_UNUSED
, int reloc ATTRIBUTE_UNUSED
)
1994 /* Darwin does not use unique sections. */
1997 /* Handle __attribute__ ((apple_kext_compatibility)).
1998 This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1999 vtable for classes with this attribute (and their descendants) by not
2000 outputting the new 3.0 nondeleting destructor. This means that such
2001 objects CANNOT be allocated on the stack or as globals UNLESS they have
2002 a completely empty `operator delete'.
2003 Luckily, this fits in with the Darwin kext model.
2005 This attribute also disables gcc3's potential overlaying of derived
2006 class data members on the padding at the end of the base class. */
2009 darwin_handle_kext_attribute (tree
*node
, tree name
,
2010 tree args ATTRIBUTE_UNUSED
,
2011 int flags ATTRIBUTE_UNUSED
,
2014 /* APPLE KEXT stuff -- only applies with pure static C++ code. */
2015 if (! TARGET_KEXTABI
)
2017 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2018 "only when compiling a kext", name
);
2020 *no_add_attrs
= true;
2022 else if (TREE_CODE (*node
) != RECORD_TYPE
)
2024 warning (0, "%qE 2.95 vtable-compatibility attribute applies "
2025 "only to C++ classes", name
);
2027 *no_add_attrs
= true;
2033 /* Handle a "weak_import" attribute; arguments as in
2034 struct attribute_spec.handler. */
2037 darwin_handle_weak_import_attribute (tree
*node
, tree name
,
2038 tree
ARG_UNUSED (args
),
2039 int ARG_UNUSED (flags
),
2040 bool * no_add_attrs
)
2042 if (TREE_CODE (*node
) != FUNCTION_DECL
&& TREE_CODE (*node
) != VAR_DECL
)
2044 warning (OPT_Wattributes
, "%qE attribute ignored",
2046 *no_add_attrs
= true;
2049 declare_weak (*node
);
2054 /* Emit a label for an FDE, making it global and/or weak if appropriate.
2055 The third parameter is nonzero if this is for exception handling.
2056 The fourth parameter is nonzero if this is just a placeholder for an
2057 FDE that we are omitting. */
2060 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
2064 static int invok_count
= 0;
2065 static tree last_fun_decl
= NULL_TREE
;
2067 /* We use the linker to emit the .eh labels for Darwin 9 and above. */
2068 if (! for_eh
|| generating_for_darwin_version
>= 9)
2071 /* FIXME: This only works when the eh for all sections of a function is
2072 emitted at the same time. If that changes, we would need to use a lookup
2073 table of some form to determine what to do. Also, we should emit the
2074 unadorned label for the partition containing the public label for a
2075 function. This is of limited use, probably, since we do not currently
2076 enable partitioning. */
2077 strcpy (buf
, ".eh");
2078 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
2080 if (decl
== last_fun_decl
)
2083 snprintf (buf
, 31, "$$part$$%d.eh", invok_count
);
2087 last_fun_decl
= decl
;
2092 lab
= concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), buf
, NULL
);
2094 if (TREE_PUBLIC (decl
))
2096 targetm
.asm_out
.globalize_label (file
, lab
);
2097 if (DECL_VISIBILITY (decl
) == VISIBILITY_HIDDEN
)
2099 fputs ("\t.private_extern ", file
);
2100 assemble_name (file
, lab
);
2105 if (DECL_WEAK (decl
))
2107 fputs ("\t.weak_definition ", file
);
2108 assemble_name (file
, lab
);
2112 assemble_name (file
, lab
);
2115 fputs (" = 0\n", file
);
2117 /* Mark the absolute .eh and .eh1 style labels as needed to
2118 ensure that we don't dead code strip them and keep such
2119 labels from another instantiation point until we can fix this
2120 properly with group comdat support. */
2121 darwin_mark_decl_preserved (lab
);
2124 fputs (":\n", file
);
2129 static GTY(()) unsigned long except_table_label_num
;
2132 darwin_emit_except_table_label (FILE *file
)
2134 char section_start_label
[30];
2136 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, "GCC_except_table",
2137 except_table_label_num
++);
2138 ASM_OUTPUT_LABEL (file
, section_start_label
);
2140 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
2143 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
2145 const char *nlp_name
;
2147 gcc_assert (GET_CODE (addr
) == SYMBOL_REF
);
2149 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
2150 fputs ("\t.long\t", file
);
2151 ASM_OUTPUT_LABELREF (file
, nlp_name
);
2155 /* If this is uncommented, details of each allocation will be printed
2156 in the asm right before the actual code. WARNING - this will cause some
2157 test-suite fails (since the printout will contain items that some tests
2158 are not expecting) -- so don't leave it on by default (it bloats the
2160 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
2162 /* The first two of these routines are ostensibly just intended to put
2163 names into the asm. However, they are both hijacked in order to ensure
2164 that zero-sized items do not make their way into the output. Consequently,
2165 we also need to make these participate in provisions for dealing with
2166 such items in section anchors. */
2168 /* The implementation of ASM_DECLARE_OBJECT_NAME. */
2169 /* The RTTI data (e.g., __ti4name) is common and public (and static),
2170 but it does need to be referenced via indirect PIC data pointers.
2171 The machopic_define_symbol calls are telling the machopic subsystem
2172 that the name *is* defined in this module, so it doesn't need to
2173 make them indirect. */
2175 darwin_asm_declare_object_name (FILE *file
,
2176 const char *nam
, tree decl
)
2178 const char *xname
= nam
;
2179 unsigned HOST_WIDE_INT size
;
2180 bool local_def
, weak
;
2182 weak
= (DECL_P (decl
)
2184 && !lookup_attribute ("weak_import",
2185 DECL_ATTRIBUTES (decl
)));
2187 local_def
= DECL_INITIAL (decl
) || (TREE_STATIC (decl
)
2188 && (!DECL_COMMON (decl
)
2189 || !TREE_PUBLIC (decl
)));
2191 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2192 xname
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2196 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2198 machopic_define_symbol (DECL_RTL (decl
));
2201 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2203 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2204 fprintf (file
, "# dadon: %s %s (%llu, %u) local %d weak %d"
2205 " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
2206 xname
, (TREE_CODE (decl
) == VAR_DECL
?"var":"const"),
2207 (unsigned long long)size
, DECL_ALIGN (decl
), local_def
,
2208 DECL_WEAK (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2209 TREE_PUBLIC (decl
), TREE_CONSTANT (decl
), TREE_READONLY (decl
),
2210 (unsigned long)DECL_INITIAL (decl
));
2213 /* Darwin needs help to support local zero-sized objects.
2214 They must be made at least one byte, and the section containing must be
2215 marked as unsuitable for section-anchors (see storage allocators below).
2217 For non-zero objects this output is handled by varasm.c.
2221 unsigned int l2align
= 0;
2223 /* The align must be honored, even for zero-sized. */
2224 if (DECL_ALIGN (decl
))
2226 l2align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
2227 fprintf (file
, "\t.align\t%u\n", l2align
);
2230 ASM_OUTPUT_LABEL (file
, xname
);
2232 fprintf (file
, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2234 /* Check that we've correctly picked up the zero-sized item and placed it
2236 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2238 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2241 ASM_OUTPUT_LABEL (file
, xname
);
2244 /* The implementation of ASM_DECLARE_CONSTANT_NAME. */
2246 darwin_asm_declare_constant_name (FILE *file
, const char *name
,
2247 const_tree exp ATTRIBUTE_UNUSED
,
2250 assemble_label (file
, name
);
2251 /* As for other items, we need at least one byte. */
2254 fputs ("\t.space\t1\n", file
);
2255 /* Check that we've correctly picked up the zero-sized item and placed it
2257 gcc_assert ((!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2259 && (in_section
->common
.flags
& SECTION_NO_ANCHOR
)));
2263 /* Darwin storage allocators.
2265 Zerofill sections are desirable for large blank data since, otherwise, these
2266 data bloat objects (PR33210).
2268 However, section anchors don't work in .zerofill sections (one cannot switch
2269 to a zerofill section). Ergo, for Darwin targets using section anchors we need
2270 to put (at least some) data into 'normal' switchable sections.
2272 Here we set a relatively arbitrary value for the size of an object to trigger
2273 zerofill when section anchors are enabled (anything bigger than a page for
2274 current Darwin implementations). FIXME: there ought to be some objective way
2275 to make this choice.
2277 When section anchor are off this is ignored anyway. */
2279 #define BYTES_ZFILL 4096
2281 /* Emit a chunk of data for items coalesced by the linker. */
2283 darwin_emit_weak_or_comdat (FILE *fp
, tree decl
, const char *name
,
2284 unsigned HOST_WIDE_INT size
,
2287 /* Since the sections used here are coalesed, they will not be eligible
2288 for section anchors, and therefore we don't need to break that out. */
2289 if (TREE_READONLY (decl
) || TREE_CONSTANT (decl
))
2290 switch_to_section (darwin_sections
[const_data_coal_section
]);
2292 switch_to_section (darwin_sections
[data_coal_section
]);
2294 /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
2295 the align info for zero-sized items... but do it here otherwise. */
2297 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2299 if (TREE_PUBLIC (decl
))
2300 darwin_globalize_label (fp
, name
);
2302 /* ... and we let it deal with outputting one byte of zero for them too. */
2303 darwin_asm_declare_object_name (fp
, name
, decl
);
2305 assemble_zeros (size
);
2308 /* Emit a chunk of data for ObjC meta-data that got placed in BSS erroneously. */
2310 darwin_emit_objc_zeroed (FILE *fp
, tree decl
, const char *name
,
2311 unsigned HOST_WIDE_INT size
,
2312 unsigned int align
, tree meta
)
2314 section
*ocs
= data_section
;
2316 if (TREE_PURPOSE (meta
) == get_identifier("OBJC2META"))
2317 ocs
= darwin_objc2_section (decl
, meta
, ocs
);
2319 ocs
= darwin_objc1_section (decl
, meta
, ocs
);
2321 switch_to_section (ocs
);
2323 /* We shall declare that zero-sized meta-data are not valid (yet). */
2325 fprintf (fp
, "\t.align\t%d\n", floor_log2 (align
/ BITS_PER_UNIT
));
2327 /* ... and we let it deal with outputting one byte of zero for them too. */
2328 darwin_asm_declare_object_name (fp
, name
, decl
);
2329 assemble_zeros (size
);
2332 /* This routine emits 'local' storage:
2334 When Section Anchors are off this routine emits .zerofill commands in
2335 sections named for their alignment.
2337 When Section Anchors are on, smaller (non-zero-sized) items are placed in
2338 the .static_data section so that the section anchoring system can see them.
2339 Larger items are still placed in .zerofill sections, addressing PR33210.
2340 The routine has no checking - it is all assumed to be done by the caller.
2343 darwin_emit_local_bss (FILE *fp
, tree decl
, const char *name
,
2344 unsigned HOST_WIDE_INT size
,
2345 unsigned int l2align
)
2347 /* FIXME: We have a fudge to make this work with Java even when the target does
2348 not use sections anchors -- Java seems to need at least one small item in a
2349 non-zerofill segment. */
2350 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2351 || (size
&& size
<= 2))
2353 /* Put smaller objects in _static_data, where the section anchors system
2355 However, if they are zero-sized punt them to yet a different section
2356 (that is not allowed to participate in anchoring). */
2359 fputs ("\t.section\t__DATA,__zobj_bss\n", fp
);
2360 in_section
= darwin_sections
[zobj_bss_section
];
2365 fputs ("\t.static_data\n", fp
);
2366 in_section
= darwin_sections
[static_data_section
];
2370 fprintf (fp
, "\t.align\t%u\n", l2align
);
2372 assemble_name (fp
, name
);
2373 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2377 /* When we are on a non-section anchor target, we can get zero-sized
2378 items here. However, all we need to do is to bump them to one byte
2379 and the section alignment will take care of the rest. */
2381 unsigned int flags
;
2382 snprintf (secnam
, 64, "__DATA,__%sbss%u", ((size
)?"":"zo_"),
2383 (unsigned) l2align
);
2384 /* We can't anchor (yet, if ever) in zerofill sections, because we can't
2385 switch to them and emit a label. */
2386 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2387 in_section
= get_section (secnam
, flags
, NULL
);
2388 fprintf (fp
, "\t.zerofill %s,", secnam
);
2389 assemble_name (fp
, name
);
2394 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n",
2395 size
, (unsigned) l2align
);
2397 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2400 (*targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2401 /* This is defined as a file-scope var, so we know to notify machopic. */
2402 machopic_define_symbol (DECL_RTL (decl
));
2405 /* Emit a chunk of common. */
2407 darwin_emit_common (FILE *fp
, const char *name
,
2408 unsigned HOST_WIDE_INT size
, unsigned int align
)
2410 unsigned HOST_WIDE_INT rounded
;
2411 unsigned int l2align
;
2413 /* Earlier systems complain if the alignment exceeds the page size.
2414 The magic number is 4096 * 8 - hard-coded for legacy systems. */
2415 if (!emit_aligned_common
&& (align
> 32768UL))
2416 align
= 4096UL; /* In units. */
2418 align
/= BITS_PER_UNIT
;
2420 /* Make sure we have a meaningful align. */
2424 /* For earlier toolchains, we need to emit the var as a rounded size to
2425 tell ld the alignment. */
2429 rounded
= (size
+ (align
-1)) & ~(align
-1);
2431 l2align
= floor_log2 (align
);
2432 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2434 in_section
= comm_section
;
2435 /* We mustn't allow multiple public symbols to share an address when using
2436 the normal OSX toolchain. */
2439 /* Put at least one byte. */
2441 /* This section can no longer participate in section anchoring. */
2442 comm_section
->common
.flags
|= SECTION_NO_ANCHOR
;
2445 fputs ("\t.comm\t", fp
);
2446 assemble_name (fp
, name
);
2447 fprintf (fp
, "," HOST_WIDE_INT_PRINT_UNSIGNED
,
2448 emit_aligned_common
?size
:rounded
);
2449 if (l2align
&& emit_aligned_common
)
2450 fprintf (fp
, ",%u", l2align
);
2454 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2455 or coalescable data sections (for weak or comdat) as appropriate. */
2458 darwin_output_aligned_bss (FILE *fp
, tree decl
, const char *name
,
2459 unsigned HOST_WIDE_INT size
, unsigned int align
)
2461 unsigned int l2align
;
2462 bool one
, pub
, weak
;
2465 pub
= TREE_PUBLIC (decl
);
2466 one
= DECL_ONE_ONLY (decl
);
2467 weak
= (DECL_P (decl
)
2469 && !lookup_attribute ("weak_import",
2470 DECL_ATTRIBUTES (decl
)));
2472 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2473 fprintf (fp
, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2474 " pub %d weak %d one %d init %lx\n",
2475 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2476 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2477 pub
, weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2480 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2481 before the target has a chance to comment. */
2482 if ((meta
= is_objc_metadata (decl
)))
2484 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2488 /* Check that any initializer is valid. */
2489 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2490 || (DECL_INITIAL (decl
) == error_mark_node
)
2491 || initializer_zerop (DECL_INITIAL (decl
)));
2493 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2494 gcc_assert (!DECL_COMMON (decl
));
2496 /* Pick up the correct alignment. */
2497 if (!size
|| !align
)
2498 align
= DECL_ALIGN (decl
);
2500 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2501 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2503 last_assemble_variable_decl
= decl
;
2505 /* We would rather not have to check this here - but it seems that we might
2506 be passed a decl that should be in coalesced space. */
2509 /* Weak or COMDAT objects are put in mergeable sections. */
2510 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2515 /* If this is not public, then emit according to local rules. */
2518 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2522 /* So we have a public symbol (small item fudge for Java, see above). */
2523 if ((DARWIN_SECTION_ANCHORS
&& flag_section_anchors
&& size
< BYTES_ZFILL
)
2524 || (size
&& size
<= 2))
2526 /* Put smaller objects in data, where the section anchors system can get
2527 them. However, if they are zero-sized punt them to yet a different
2528 section (that is not allowed to participate in anchoring). */
2531 fputs ("\t.section\t__DATA,__zobj_data\n", fp
);
2532 in_section
= darwin_sections
[zobj_data_section
];
2537 fputs ("\t.data\n", fp
);
2538 in_section
= data_section
;
2542 fprintf (fp
, "\t.align\t%u\n", l2align
);
2544 assemble_name (fp
, name
);
2545 fprintf (fp
, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2550 unsigned int flags
;
2551 /* When we are on a non-section anchor target, we can get zero-sized
2552 items here. However, all we need to do is to bump them to one byte
2553 and the section alignment will take care of the rest. */
2554 snprintf (secnam
, 64, "__DATA,__%spu_bss%u", ((size
)?"":"zo_"), l2align
);
2556 /* We can't anchor in zerofill sections, because we can't switch
2557 to them and emit a label. */
2558 flags
= SECTION_BSS
|SECTION_WRITE
|SECTION_NO_ANCHOR
;
2559 in_section
= get_section (secnam
, flags
, NULL
);
2560 fprintf (fp
, "\t.zerofill %s,", secnam
);
2561 assemble_name (fp
, name
);
2566 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
",%u\n", size
, l2align
);
2568 fprintf (fp
, ","HOST_WIDE_INT_PRINT_UNSIGNED
"\n", size
);
2570 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
2573 /* Output a chunk of common, with alignment specified (where the target
2576 darwin_asm_output_aligned_decl_common (FILE *fp
, tree decl
, const char *name
,
2577 unsigned HOST_WIDE_INT size
,
2580 unsigned int l2align
;
2584 /* No corresponding var. */
2587 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2588 fprintf (fp
, "# adcom: %s (%d,%d) decl=0x0\n", name
, (int)size
, (int)align
);
2590 darwin_emit_common (fp
, name
, size
, align
);
2594 one
= DECL_ONE_ONLY (decl
);
2595 weak
= (DECL_P (decl
)
2597 && !lookup_attribute ("weak_import",
2598 DECL_ATTRIBUTES (decl
)));
2600 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2601 fprintf (fp
, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2602 " weak %d one %d init %lx\n",
2603 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2604 TREE_CONSTANT (decl
), TREE_STATIC (decl
), DECL_COMMON (decl
),
2605 TREE_PUBLIC (decl
), weak
, one
, (unsigned long)DECL_INITIAL (decl
));
2608 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2609 before the target has a chance to comment. */
2610 if ((meta
= is_objc_metadata (decl
)))
2612 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2616 /* We shouldn't be messing with this if the decl has a section name. */
2617 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2619 /* We would rather not have to check this here - but it seems that we might
2620 be passed a decl that should be in coalesced space. */
2623 /* Weak or COMDAT objects are put in mergable sections. */
2624 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2629 /* We should only get here for DECL_COMMON, with a zero init (and, in
2630 principle, only for public symbols too - although we deal with local
2633 /* Check the initializer is OK. */
2634 gcc_assert (DECL_COMMON (decl
)
2635 && ((DECL_INITIAL (decl
) == NULL
)
2636 || (DECL_INITIAL (decl
) == error_mark_node
)
2637 || initializer_zerop (DECL_INITIAL (decl
))));
2639 last_assemble_variable_decl
= decl
;
2641 if (!size
|| !align
)
2642 align
= DECL_ALIGN (decl
);
2644 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2645 /* Check we aren't asking for more aligment than the platform allows. */
2646 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2648 if (TREE_PUBLIC (decl
) != 0)
2649 darwin_emit_common (fp
, name
, size
, align
);
2651 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2654 /* Output a chunk of BSS with alignment specfied. */
2656 darwin_asm_output_aligned_decl_local (FILE *fp
, tree decl
, const char *name
,
2657 unsigned HOST_WIDE_INT size
,
2660 unsigned long l2align
;
2664 one
= DECL_ONE_ONLY (decl
);
2665 weak
= (DECL_P (decl
)
2667 && !lookup_attribute ("weak_import",
2668 DECL_ATTRIBUTES (decl
)));
2670 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2671 fprintf (fp
, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2672 " weak %d init %lx\n",
2673 name
, (long long)size
, (int)align
, TREE_READONLY (decl
),
2674 TREE_CONSTANT (decl
), TREE_STATIC (decl
), one
, TREE_PUBLIC (decl
),
2675 weak
, (unsigned long)DECL_INITIAL (decl
));
2678 /* ObjC metadata can get put in BSS because varasm.c decides it's BSS
2679 before the target has a chance to comment. */
2680 if ((meta
= is_objc_metadata (decl
)))
2682 darwin_emit_objc_zeroed (fp
, decl
, name
, size
, DECL_ALIGN (decl
), meta
);
2686 /* We shouldn't be messing with this if the decl has a section name. */
2687 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
);
2689 /* We would rather not have to check this here - but it seems that we might
2690 be passed a decl that should be in coalesced space. */
2693 /* Weak or COMDAT objects are put in mergable sections. */
2694 darwin_emit_weak_or_comdat (fp
, decl
, name
, size
,
2699 /* .. and it should be suitable for placement in local mem. */
2700 gcc_assert(!TREE_PUBLIC (decl
) && !DECL_COMMON (decl
));
2701 /* .. and any initializer must be all-zero. */
2702 gcc_assert ((DECL_INITIAL (decl
) == NULL
)
2703 || (DECL_INITIAL (decl
) == error_mark_node
)
2704 || initializer_zerop (DECL_INITIAL (decl
)));
2706 last_assemble_variable_decl
= decl
;
2708 if (!size
|| !align
)
2709 align
= DECL_ALIGN (decl
);
2711 l2align
= floor_log2 (align
/ BITS_PER_UNIT
);
2712 gcc_assert (l2align
<= L2_MAX_OFILE_ALIGNMENT
);
2714 darwin_emit_local_bss (fp
, decl
, name
, size
, l2align
);
2717 /* Emit an assembler directive to set visibility for a symbol. The
2718 only supported visibilities are VISIBILITY_DEFAULT and
2719 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2720 extern". There is no MACH-O equivalent of ELF's
2721 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2724 darwin_assemble_visibility (tree decl
, int vis
)
2726 if (vis
== VISIBILITY_DEFAULT
)
2728 else if (vis
== VISIBILITY_HIDDEN
|| vis
== VISIBILITY_INTERNAL
)
2730 fputs ("\t.private_extern ", asm_out_file
);
2731 assemble_name (asm_out_file
,
2732 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
2733 fputs ("\n", asm_out_file
);
2736 warning (OPT_Wattributes
, "protected visibility attribute "
2737 "not supported in this configuration; ignored");
2740 /* vec used by darwin_asm_dwarf_section.
2741 Maybe a hash tab would be better here - but the intention is that this is
2742 a very short list (fewer than 16 items) and each entry should (ideally,
2743 eventually) only be presented once.
2745 A structure to hold a dwarf debug section used entry. */
2747 typedef struct GTY(()) dwarf_sect_used_entry
{
2751 dwarf_sect_used_entry
;
2754 /* A list of used __DWARF sections. */
2755 static GTY (()) vec
<dwarf_sect_used_entry
, va_gc
> *dwarf_sect_names_table
;
2757 /* This is called when we are asked to assemble a named section and the
2758 name begins with __DWARF,. We keep a list of the section names (without
2759 the __DWARF, prefix) and use this to emit our required start label on the
2760 first switch to each section. */
2763 darwin_asm_dwarf_section (const char *name
, unsigned int flags
,
2764 tree
ARG_UNUSED (decl
))
2769 dwarf_sect_used_entry
*ref
;
2771 gcc_assert ((flags
& (SECTION_DEBUG
| SECTION_NAMED
))
2772 == (SECTION_DEBUG
| SECTION_NAMED
));
2773 /* We know that the name starts with __DWARF, */
2775 namelen
= strchr (sname
, ',') - sname
;
2776 gcc_assert (namelen
);
2777 if (dwarf_sect_names_table
== NULL
)
2778 vec_alloc (dwarf_sect_names_table
, 16);
2781 dwarf_sect_names_table
->iterate (i
, &ref
);
2786 if (!strcmp (ref
->name
, sname
))
2794 fprintf (asm_out_file
, "\t.section %s\n", name
);
2797 dwarf_sect_used_entry e
;
2798 fprintf (asm_out_file
, "Lsection%.*s:\n", namelen
, sname
);
2800 e
.name
= xstrdup (sname
);
2801 vec_safe_push (dwarf_sect_names_table
, e
);
2805 /* Output a difference of two labels that will be an assembly time
2806 constant if the two labels are local. (.long lab1-lab2 will be
2807 very different if lab1 is at the boundary between two sections; it
2808 will be relocated according to the second section, not the first,
2809 so one ends up with a difference between labels in different
2810 sections, which is bad in the dwarf2 eh context for instance.) */
2812 static int darwin_dwarf_label_counter
;
2815 darwin_asm_output_dwarf_delta (FILE *file
, int size
,
2816 const char *lab1
, const char *lab2
)
2818 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
2819 && lab2
[0] == '*' && lab2
[1] == 'L');
2820 const char *directive
= (size
== 8 ? ".quad" : ".long");
2823 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
2825 fprintf (file
, "\t%s\t", directive
);
2827 assemble_name_raw (file
, lab1
);
2828 fprintf (file
, "-");
2829 assemble_name_raw (file
, lab2
);
2831 fprintf (file
, "\n\t%s L$set$%d", directive
, darwin_dwarf_label_counter
++);
2834 /* Output an offset in a DWARF section on Darwin. On Darwin, DWARF section
2835 offsets are not represented using relocs in .o files; either the
2836 section never leaves the .o file, or the linker or other tool is
2837 responsible for parsing the DWARF and updating the offsets. */
2840 darwin_asm_output_dwarf_offset (FILE *file
, int size
, const char * lab
,
2846 gcc_assert (base
->common
.flags
& SECTION_NAMED
);
2847 gcc_assert (strncmp (base
->named
.name
, "__DWARF,", 8) == 0);
2848 gcc_assert (strchr (base
->named
.name
+ 8, ','));
2850 namelen
= strchr (base
->named
.name
+ 8, ',') - (base
->named
.name
+ 8);
2851 sprintf (sname
, "*Lsection%.*s", namelen
, base
->named
.name
+ 8);
2852 darwin_asm_output_dwarf_delta (file
, size
, lab
, sname
);
2855 /* Called from the within the TARGET_ASM_FILE_START for each target. */
2858 darwin_file_start (void)
2860 /* Nothing to do. */
2863 /* Called for the TARGET_ASM_FILE_END hook.
2864 Emit the mach-o pic indirection data, the lto data and, finally a flag
2865 to tell the linker that it can break the file object into sections and
2866 move those around for efficiency. */
2869 darwin_file_end (void)
2871 if (!vec_safe_is_empty (ctors
))
2873 if (!vec_safe_is_empty (dtors
))
2876 /* If we are expecting to output NeXT ObjC meta-data, (and we actually see
2877 some) then we output the fix-and-continue marker (Image Info).
2878 This applies to Objective C, Objective C++ and LTO with either language
2879 as part of the input. */
2880 if (flag_next_runtime
&& objc_metadata_seen
)
2882 unsigned int flags
= 0;
2883 if (flag_objc_abi
>= 2)
2886 output_section_asm_op
2887 (darwin_sections
[objc2_image_info_section
]->unnamed
.data
);
2890 output_section_asm_op
2891 (darwin_sections
[objc_image_info_section
]->unnamed
.data
);
2893 ASM_OUTPUT_ALIGN (asm_out_file
, 2);
2894 fputs ("L_OBJC_ImageInfo:\n", asm_out_file
);
2896 flags
|= (flag_replace_objc_classes
&& classes_seen
) ? 1 : 0;
2897 flags
|= flag_objc_gc
? 2 : 0;
2899 fprintf (asm_out_file
, "\t.long\t0\n\t.long\t%u\n", flags
);
2902 machopic_finish (asm_out_file
);
2903 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
2905 switch_to_section (darwin_sections
[constructor_section
]);
2906 switch_to_section (darwin_sections
[destructor_section
]);
2907 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
2910 /* If there was LTO assembler output, append it to asm_out_file. */
2911 if (lto_asm_out_name
)
2914 char *buf
, *lto_asm_txt
;
2916 /* Shouldn't be here if we failed to switch back. */
2917 gcc_assert (! saved_asm_out_file
);
2919 lto_asm_out_file
= fopen (lto_asm_out_name
, "r");
2920 if (lto_asm_out_file
== NULL
)
2921 fatal_error ("failed to open temporary file %s with LTO output",
2923 fseek (lto_asm_out_file
, 0, SEEK_END
);
2924 n
= ftell (lto_asm_out_file
);
2927 fseek (lto_asm_out_file
, 0, SEEK_SET
);
2928 lto_asm_txt
= buf
= (char *) xmalloc (n
+ 1);
2929 while (fgets (lto_asm_txt
, n
, lto_asm_out_file
))
2930 fputs (lto_asm_txt
, asm_out_file
);
2931 /* Put a termination label. */
2932 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2933 LTO_SEGMENT_NAME
, LTO_SECTS_SECTION
);
2934 fprintf (asm_out_file
, "L_GNU_LTO%d:\t;# end of lto\n",
2936 /* Make sure our termination label stays in this section. */
2937 fputs ("\t.space\t1\n", asm_out_file
);
2940 /* Remove the temporary file. */
2941 fclose (lto_asm_out_file
);
2942 unlink_if_ordinary (lto_asm_out_name
);
2943 free (lto_asm_out_name
);
2946 /* Output the names and indices. */
2947 if (lto_section_names
&& lto_section_names
->length ())
2950 darwin_lto_section_e
*ref
;
2951 /* For now, we'll make the offsets 4 bytes and unaligned - we'll fix
2952 the latter up ourselves. */
2953 const char *op
= integer_asm_op (4,0);
2955 /* Emit the names. */
2956 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2957 LTO_SEGMENT_NAME
, LTO_NAMES_SECTION
);
2958 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
2960 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\n", count
);
2961 /* We have to jump through hoops to get the values of the intra-section
2963 fprintf (asm_out_file
,
2964 "\t.set L$gnu$lto$noff%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME0\n",
2966 fprintf (asm_out_file
,
2967 "\t.set L$gnu$lto$nsiz%d,L_GNU_LTO_NAME%d-L_GNU_LTO_NAME%d\n",
2968 count
, count
+1, count
);
2969 fprintf (asm_out_file
, "\t.asciz\t\"%s\"\n", ref
->sectname
);
2971 fprintf (asm_out_file
, "L_GNU_LTO_NAME%d:\t;# end\n", lto_section_num
);
2972 /* make sure our termination label stays in this section. */
2973 fputs ("\t.space\t1\n", asm_out_file
);
2975 /* Emit the Index. */
2976 fprintf (asm_out_file
, "\t.section %s,%s,regular,debug\n",
2977 LTO_SEGMENT_NAME
, LTO_INDEX_SECTION
);
2978 fputs ("\t.align\t2\n", asm_out_file
);
2979 fputs ("# Section offset, Section length, Name offset, Name length\n",
2981 FOR_EACH_VEC_ELT (*lto_section_names
, count
, ref
)
2983 fprintf (asm_out_file
, "%s L$gnu$lto$offs%d\t;# %s\n",
2984 op
, count
, ref
->sectname
);
2985 fprintf (asm_out_file
, "%s L$gnu$lto$size%d\n", op
, count
);
2986 fprintf (asm_out_file
, "%s L$gnu$lto$noff%d\n", op
, count
);
2987 fprintf (asm_out_file
, "%s L$gnu$lto$nsiz%d\n", op
, count
);
2991 /* If we have section anchors, then we must prevent the linker from
2992 re-arranging data. */
2993 if (!DARWIN_SECTION_ANCHORS
|| !flag_section_anchors
)
2994 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
2997 /* TODO: Add a language hook for identifying if a decl is a vtable. */
2998 #define DARWIN_VTABLE_P(DECL) 0
3000 /* Cross-module name binding. Darwin does not support overriding
3001 functions at dynamic-link time, except for vtables in kexts. */
3004 darwin_binds_local_p (const_tree decl
)
3006 return default_binds_local_p_1 (decl
,
3007 TARGET_KEXTABI
&& DARWIN_VTABLE_P (decl
));
3010 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
3011 anchor relative to ".", the current section position. We cannot use
3012 the default one because ASM_OUTPUT_DEF is wrong for Darwin. */
3014 darwin_asm_output_anchor (rtx symbol
)
3016 fprintf (asm_out_file
, "\t.set\t");
3017 assemble_name (asm_out_file
, XSTR (symbol
, 0));
3018 fprintf (asm_out_file
, ", . + " HOST_WIDE_INT_PRINT_DEC
"\n",
3019 SYMBOL_REF_BLOCK_OFFSET (symbol
));
3022 /* Disable section anchoring on any section containing a zero-sized
3025 darwin_use_anchors_for_symbol_p (const_rtx symbol
)
3027 if (DARWIN_SECTION_ANCHORS
&& flag_section_anchors
)
3030 /* If the section contains a zero-sized object it's ineligible. */
3031 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
3032 /* This should have the effect of disabling anchors for vars that follow
3033 any zero-sized one, in a given section. */
3034 if (sect
->common
.flags
& SECTION_NO_ANCHOR
)
3037 /* Also check the normal reasons for suppressing. */
3038 return default_use_anchors_for_symbol_p (symbol
);
3044 /* Set the darwin specific attributes on TYPE. */
3046 darwin_set_default_type_attributes (tree type
)
3048 if (darwin_ms_struct
3049 && TREE_CODE (type
) == RECORD_TYPE
)
3050 TYPE_ATTRIBUTES (type
) = tree_cons (get_identifier ("ms_struct"),
3052 TYPE_ATTRIBUTES (type
));
3055 /* True, iff we're generating code for loadable kernel extensions. */
3058 darwin_kextabi_p (void) {
3059 return flag_apple_kext
;
3063 darwin_override_options (void)
3065 /* Keep track of which (major) version we're generating code for. */
3066 if (darwin_macosx_version_min
)
3068 if (strverscmp (darwin_macosx_version_min
, "10.6") >= 0)
3069 generating_for_darwin_version
= 10;
3070 else if (strverscmp (darwin_macosx_version_min
, "10.5") >= 0)
3071 generating_for_darwin_version
= 9;
3073 /* Earlier versions are not specifically accounted, until required. */
3076 /* In principle, this should be c-family only. However, we really need to
3077 set sensible defaults for LTO as well, since the section selection stuff
3078 should check for correctness re. the ABI. TODO: check and provide the
3079 flags (runtime & ABI) from the lto wrapper). */
3081 /* Unless set, force ABI=2 for NeXT and m64, 0 otherwise. */
3082 if (!global_options_set
.x_flag_objc_abi
)
3083 global_options
.x_flag_objc_abi
3084 = (!flag_next_runtime
)
3087 : (generating_for_darwin_version
>= 9) ? 1
3090 /* Objective-C family ABI 2 is only valid for next/m64 at present. */
3091 if (global_options_set
.x_flag_objc_abi
&& flag_next_runtime
)
3093 if (TARGET_64BIT
&& global_options
.x_flag_objc_abi
< 2)
3094 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 must be"
3095 " used for %<-m64%> targets with"
3096 " %<-fnext-runtime%>");
3097 if (!TARGET_64BIT
&& global_options
.x_flag_objc_abi
>= 2)
3098 error_at (UNKNOWN_LOCATION
, "%<-fobjc-abi-version%> >= 2 is not"
3099 " supported on %<-m32%> targets with"
3100 " %<-fnext-runtime%>");
3103 /* Don't emit DWARF3/4 unless specifically selected. This is a
3104 workaround for tool bugs. */
3105 if (!global_options_set
.x_dwarf_strict
)
3107 if (!global_options_set
.x_dwarf_version
)
3110 /* Do not allow unwind tables to be generated by default for m32.
3111 fnon-call-exceptions will override this, regardless of what we do. */
3112 if (generating_for_darwin_version
< 10
3113 && !global_options_set
.x_flag_asynchronous_unwind_tables
3115 global_options
.x_flag_asynchronous_unwind_tables
= 0;
3117 /* Disable -freorder-blocks-and-partition when unwind tables are being
3118 emitted for Darwin < 9 (OSX 10.5).
3119 The strategy is, "Unless the User has specifically set/unset an unwind
3120 flag we will switch off -freorder-blocks-and-partition when unwind tables
3121 will be generated". If the User specifically sets flags... we assume
3122 (s)he knows why... */
3123 if (generating_for_darwin_version
< 9
3124 && global_options_set
.x_flag_reorder_blocks_and_partition
3125 && ((global_options
.x_flag_exceptions
/* User, c++, java */
3126 && !global_options_set
.x_flag_exceptions
) /* User specified... */
3127 || (global_options
.x_flag_unwind_tables
3128 && !global_options_set
.x_flag_unwind_tables
)
3129 || (global_options
.x_flag_non_call_exceptions
3130 && !global_options_set
.x_flag_non_call_exceptions
)
3131 || (global_options
.x_flag_asynchronous_unwind_tables
3132 && !global_options_set
.x_flag_asynchronous_unwind_tables
)))
3134 inform (input_location
,
3135 "-freorder-blocks-and-partition does not work with exceptions "
3136 "on this architecture");
3137 flag_reorder_blocks_and_partition
= 0;
3138 flag_reorder_blocks
= 1;
3141 /* FIXME: flag_objc_sjlj_exceptions is no longer needed since there is only
3142 one valid choice of exception scheme for each runtime. */
3143 if (!global_options_set
.x_flag_objc_sjlj_exceptions
)
3144 global_options
.x_flag_objc_sjlj_exceptions
=
3145 flag_next_runtime
&& !TARGET_64BIT
;
3147 /* FIXME: and this could be eliminated then too. */
3148 if (!global_options_set
.x_flag_exceptions
3149 && flag_objc_exceptions
3151 flag_exceptions
= 1;
3153 if (flag_mkernel
|| flag_apple_kext
)
3155 /* -mkernel implies -fapple-kext for C++ */
3156 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
3157 flag_apple_kext
= 1;
3161 /* No EH in kexts. */
3162 flag_exceptions
= 0;
3163 /* No -fnon-call-exceptions data in kexts. */
3164 flag_non_call_exceptions
= 0;
3165 /* so no tables either.. */
3166 flag_unwind_tables
= 0;
3167 flag_asynchronous_unwind_tables
= 0;
3168 /* We still need to emit branch islands for kernel context. */
3169 darwin_emit_branch_islands
= true;
3172 if (flag_var_tracking_uninit
== 0
3173 && generating_for_darwin_version
>= 9
3174 && (flag_gtoggle
? (debug_info_level
== DINFO_LEVEL_NONE
)
3175 : (debug_info_level
>= DINFO_LEVEL_NORMAL
))
3176 && write_symbols
== DWARF2_DEBUG
)
3177 flag_var_tracking_uninit
= flag_var_tracking
;
3179 if (MACHO_DYNAMIC_NO_PIC_P
)
3182 warning_at (UNKNOWN_LOCATION
, 0,
3183 "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>,"
3184 " %<-fpie%> or %<-fPIE%>");
3187 else if (flag_pic
== 1)
3189 /* Darwin's -fpic is -fPIC. */
3193 /* It is assumed that branch island stubs are needed for earlier systems. */
3194 if (generating_for_darwin_version
< 9)
3195 darwin_emit_branch_islands
= true;
3197 emit_aligned_common
= true; /* Later systems can support aligned common. */
3199 /* The c_dialect...() macros are not available to us here. */
3200 darwin_running_cxx
= (strstr (lang_hooks
.name
, "C++") != 0);
3204 /* Add $LDBL128 suffix to long double builtins for ppc darwin. */
3207 darwin_patch_builtin (enum built_in_function fncode
)
3209 tree fn
= builtin_decl_explicit (fncode
);
3216 sym
= DECL_ASSEMBLER_NAME (fn
);
3217 newname
= ACONCAT (("_", IDENTIFIER_POINTER (sym
), "$LDBL128", NULL
));
3219 set_user_assembler_name (fn
, newname
);
3221 fn
= builtin_decl_implicit (fncode
);
3223 set_user_assembler_name (fn
, newname
);
3227 darwin_patch_builtins (void)
3229 if (LONG_DOUBLE_TYPE_SIZE
!= 128)
3232 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
3233 #define PATCH_BUILTIN_NO64(fncode) \
3234 if (!TARGET_64BIT) \
3235 darwin_patch_builtin (fncode);
3236 #define PATCH_BUILTIN_VARIADIC(fncode) \
3238 && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
3239 darwin_patch_builtin (fncode);
3240 #include "darwin-ppc-ldouble-patch.def"
3241 #undef PATCH_BUILTIN
3242 #undef PATCH_BUILTIN_NO64
3243 #undef PATCH_BUILTIN_VARIADIC
3247 /* CFStrings implementation. */
3248 static GTY(()) tree cfstring_class_reference
= NULL_TREE
;
3249 static GTY(()) tree cfstring_type_node
= NULL_TREE
;
3250 static GTY(()) tree ccfstring_type_node
= NULL_TREE
;
3251 static GTY(()) tree pccfstring_type_node
= NULL_TREE
;
3252 static GTY(()) tree pcint_type_node
= NULL_TREE
;
3253 static GTY(()) tree pcchar_type_node
= NULL_TREE
;
3255 static enum built_in_function darwin_builtin_cfstring
;
3257 /* Store all constructed constant CFStrings in a hash table so that
3258 they get uniqued properly. */
3260 typedef struct GTY (()) cfstring_descriptor
{
3261 /* The string literal. */
3263 /* The resulting constant CFString. */
3265 } cfstring_descriptor
;
3267 static GTY ((param_is (struct cfstring_descriptor
))) htab_t cfstring_htab
;
3269 static hashval_t
cfstring_hash (const void *);
3270 static int cfstring_eq (const void *, const void *);
3273 add_builtin_field_decl (tree type
, const char *name
, tree
**chain
)
3275 tree field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
3276 get_identifier (name
), type
);
3280 *chain
= &DECL_CHAIN (field
);
3286 darwin_init_cfstring_builtins (unsigned builtin_cfstring
)
3288 tree cfsfun
, fields
, pccfstring_ftype_pcchar
;
3291 darwin_builtin_cfstring
=
3292 (enum built_in_function
) builtin_cfstring
;
3294 /* struct __builtin_CFString {
3295 const int *isa; (will point at
3296 int flags; __CFConstantStringClassReference)
3301 pcint_type_node
= build_pointer_type
3302 (build_qualified_type (integer_type_node
, TYPE_QUAL_CONST
));
3304 pcchar_type_node
= build_pointer_type
3305 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
));
3307 cfstring_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3309 /* Have to build backwards for finish struct. */
3310 fields
= add_builtin_field_decl (long_integer_type_node
, "length", &chain
);
3311 add_builtin_field_decl (pcchar_type_node
, "str", &chain
);
3312 add_builtin_field_decl (integer_type_node
, "flags", &chain
);
3313 add_builtin_field_decl (pcint_type_node
, "isa", &chain
);
3314 finish_builtin_struct (cfstring_type_node
, "__builtin_CFString",
3317 /* const struct __builtin_CFstring *
3318 __builtin___CFStringMakeConstantString (const char *); */
3320 ccfstring_type_node
= build_qualified_type
3321 (cfstring_type_node
, TYPE_QUAL_CONST
);
3322 pccfstring_type_node
= build_pointer_type (ccfstring_type_node
);
3323 pccfstring_ftype_pcchar
= build_function_type_list
3324 (pccfstring_type_node
, pcchar_type_node
, NULL_TREE
);
3326 cfsfun
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
3327 get_identifier ("__builtin___CFStringMakeConstantString"),
3328 pccfstring_ftype_pcchar
);
3330 TREE_PUBLIC (cfsfun
) = 1;
3331 DECL_EXTERNAL (cfsfun
) = 1;
3332 DECL_ARTIFICIAL (cfsfun
) = 1;
3333 /* Make a lang-specific section - dup_lang_specific_decl makes a new node
3334 in place of the existing, which may be NULL. */
3335 DECL_LANG_SPECIFIC (cfsfun
) = NULL
;
3336 (*lang_hooks
.dup_lang_specific_decl
) (cfsfun
);
3337 DECL_BUILT_IN_CLASS (cfsfun
) = BUILT_IN_MD
;
3338 DECL_FUNCTION_CODE (cfsfun
) = darwin_builtin_cfstring
;
3339 lang_hooks
.builtin_function (cfsfun
);
3341 /* extern int __CFConstantStringClassReference[]; */
3342 cfstring_class_reference
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
3343 get_identifier ("__CFConstantStringClassReference"),
3344 build_array_type (integer_type_node
, NULL_TREE
));
3346 TREE_PUBLIC (cfstring_class_reference
) = 1;
3347 DECL_ARTIFICIAL (cfstring_class_reference
) = 1;
3348 (*lang_hooks
.decls
.pushdecl
) (cfstring_class_reference
);
3349 DECL_EXTERNAL (cfstring_class_reference
) = 1;
3350 rest_of_decl_compilation (cfstring_class_reference
, 0, 0);
3352 /* Initialize the hash table used to hold the constant CFString objects. */
3353 cfstring_htab
= htab_create_ggc (31, cfstring_hash
, cfstring_eq
, NULL
);
3355 return cfstring_type_node
;
3359 darwin_fold_builtin (tree fndecl
, int n_args
, tree
*argp
,
3360 bool ARG_UNUSED (ignore
))
3362 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3364 if (fcode
== darwin_builtin_cfstring
)
3366 if (!darwin_constant_cfstrings
)
3368 error ("built-in function %qD requires the"
3369 " %<-mconstant-cfstrings%> flag", fndecl
);
3370 return error_mark_node
;
3375 error ("built-in function %qD takes one argument only", fndecl
);
3376 return error_mark_node
;
3379 return darwin_build_constant_cfstring (*argp
);
3386 darwin_rename_builtins (void)
3388 /* The system ___divdc3 routine in libSystem on darwin10 is not
3389 accurate to 1ulp, ours is, so we avoid ever using the system name
3390 for this routine and instead install a non-conflicting name that
3393 When -ffast-math or -funsafe-math-optimizations is given, we can
3394 use the faster version. */
3395 if (!flag_unsafe_math_optimizations
)
3397 enum built_in_function dcode
3398 = (enum built_in_function
)(BUILT_IN_COMPLEX_DIV_MIN
3399 + DCmode
- MIN_MODE_COMPLEX_FLOAT
);
3400 tree fn
= builtin_decl_explicit (dcode
);
3401 /* Fortran and c call TARGET_INIT_BUILTINS and
3402 TARGET_INIT_LIBFUNCS at different times, so we have to put a
3403 call into each to ensure that at least one of them is called
3404 after build_common_builtin_nodes. A better fix is to add a
3405 new hook to run after build_common_builtin_nodes runs. */
3407 set_user_assembler_name (fn
, "___ieee_divdc3");
3408 fn
= builtin_decl_implicit (dcode
);
3410 set_user_assembler_name (fn
, "___ieee_divdc3");
3415 darwin_libc_has_function (enum function_class fn_class
)
3417 if (fn_class
== function_sincos
)
3419 if (fn_class
== function_c99_math_complex
3420 || fn_class
== function_c99_misc
)
3421 return (TARGET_64BIT
3422 || strverscmp (darwin_macosx_version_min
, "10.3") >= 0);
3428 cfstring_hash (const void *ptr
)
3430 tree str
= ((const struct cfstring_descriptor
*)ptr
)->literal
;
3431 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3432 int i
, len
= TREE_STRING_LENGTH (str
);
3435 for (i
= 0; i
< len
; i
++)
3436 h
= ((h
* 613) + p
[i
]);
3442 cfstring_eq (const void *ptr1
, const void *ptr2
)
3444 tree str1
= ((const struct cfstring_descriptor
*)ptr1
)->literal
;
3445 tree str2
= ((const struct cfstring_descriptor
*)ptr2
)->literal
;
3446 int len1
= TREE_STRING_LENGTH (str1
);
3448 return (len1
== TREE_STRING_LENGTH (str2
)
3449 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3454 darwin_build_constant_cfstring (tree str
)
3456 struct cfstring_descriptor
*desc
, key
;
3462 error ("CFString literal is missing");
3463 return error_mark_node
;
3468 if (TREE_CODE (str
) == ADDR_EXPR
)
3469 str
= TREE_OPERAND (str
, 0);
3471 if (TREE_CODE (str
) != STRING_CST
)
3473 error ("CFString literal expression is not a string constant");
3474 return error_mark_node
;
3477 /* Perhaps we already constructed a constant CFString just like this one? */
3479 loc
= htab_find_slot (cfstring_htab
, &key
, INSERT
);
3480 desc
= (struct cfstring_descriptor
*) *loc
;
3484 tree var
, constructor
, field
;
3485 vec
<constructor_elt
, va_gc
> *v
= NULL
;
3486 int length
= TREE_STRING_LENGTH (str
) - 1;
3488 if (darwin_warn_nonportable_cfstrings
)
3490 const char *s
= TREE_STRING_POINTER (str
);
3493 for (l
= 0; l
< length
; l
++)
3494 if (!s
[l
] || !isascii (s
[l
]))
3496 warning (darwin_warn_nonportable_cfstrings
, "%s in CFString literal",
3497 s
[l
] ? "non-ASCII character" : "embedded NUL");
3502 *loc
= desc
= ggc_alloc_cleared_cfstring_descriptor ();
3503 desc
->literal
= str
;
3506 field
= TYPE_FIELDS (ccfstring_type_node
);
3507 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3508 build1 (ADDR_EXPR
, TREE_TYPE (field
),
3509 cfstring_class_reference
));
3511 field
= DECL_CHAIN (field
);
3512 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3513 build_int_cst (TREE_TYPE (field
), 0x000007c8));
3515 field
= DECL_CHAIN (field
);
3516 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3517 build1 (ADDR_EXPR
, TREE_TYPE (field
), str
));
3519 field
= DECL_CHAIN (field
);
3520 CONSTRUCTOR_APPEND_ELT(v
, NULL_TREE
,
3521 build_int_cst (TREE_TYPE (field
), length
));
3523 constructor
= build_constructor (ccfstring_type_node
, v
);
3524 TREE_READONLY (constructor
) = 1;
3525 TREE_CONSTANT (constructor
) = 1;
3526 TREE_STATIC (constructor
) = 1;
3528 /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
3529 to have the TREE_HAS_CONSTRUCTOR (...) bit set. However, this file is
3530 being built without any knowledge of C++ tree accessors; hence, we shall
3531 use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to! */
3532 if (darwin_running_cxx
)
3533 TREE_LANG_FLAG_4 (constructor
) = 1; /* TREE_HAS_CONSTRUCTOR */
3535 /* Create an anonymous global variable for this CFString. */
3536 var
= build_decl (input_location
, CONST_DECL
,
3537 NULL
, TREE_TYPE (constructor
));
3538 DECL_ARTIFICIAL (var
) = 1;
3539 TREE_STATIC (var
) = 1;
3540 DECL_INITIAL (var
) = constructor
;
3541 /* FIXME: This should use a translation_unit_decl to indicate file scope. */
3542 DECL_CONTEXT (var
) = NULL_TREE
;
3543 desc
->constructor
= var
;
3546 addr
= build1 (ADDR_EXPR
, pccfstring_type_node
, desc
->constructor
);
3547 TREE_CONSTANT (addr
) = 1;
3553 darwin_cfstring_p (tree str
)
3555 struct cfstring_descriptor key
;
3563 if (TREE_CODE (str
) == ADDR_EXPR
)
3564 str
= TREE_OPERAND (str
, 0);
3566 if (TREE_CODE (str
) != STRING_CST
)
3570 loc
= htab_find_slot (cfstring_htab
, &key
, NO_INSERT
);
3579 darwin_enter_string_into_cfstring_table (tree str
)
3581 struct cfstring_descriptor key
;
3585 loc
= htab_find_slot (cfstring_htab
, &key
, INSERT
);
3589 *loc
= ggc_alloc_cleared_cfstring_descriptor ();
3590 ((struct cfstring_descriptor
*)*loc
)->literal
= str
;
3594 /* Choose named function section based on its frequency. */
3597 darwin_function_section (tree decl
, enum node_frequency freq
,
3598 bool startup
, bool exit
)
3600 /* Decide if we need to put this in a coalescable section. */
3603 && (!DECL_ATTRIBUTES (decl
)
3604 || !lookup_attribute ("weak_import",
3605 DECL_ATTRIBUTES (decl
))));
3607 /* If there is a specified section name, we should not be trying to
3609 if (decl
&& DECL_SECTION_NAME (decl
) != NULL_TREE
)
3610 return get_named_section (decl
, NULL
, 0);
3612 /* We always put unlikely executed stuff in the cold section. */
3613 if (freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3614 return (weak
) ? darwin_sections
[text_cold_coal_section
]
3615 : darwin_sections
[text_cold_section
];
3617 /* If we have LTO *and* feedback information, then let LTO handle
3618 the function ordering, it makes a better job (for normal, hot,
3619 startup and exit - hence the bailout for cold above). */
3620 if (in_lto_p
&& flag_profile_values
)
3621 goto default_function_sections
;
3623 /* Non-cold startup code should go to startup subsection. */
3625 return (weak
) ? darwin_sections
[text_startup_coal_section
]
3626 : darwin_sections
[text_startup_section
];
3628 /* Similarly for exit. */
3630 return (weak
) ? darwin_sections
[text_exit_coal_section
]
3631 : darwin_sections
[text_exit_section
];
3633 /* Place hot code. */
3634 if (freq
== NODE_FREQUENCY_HOT
)
3635 return (weak
) ? darwin_sections
[text_hot_coal_section
]
3636 : darwin_sections
[text_hot_section
];
3638 /* Otherwise, default to the 'normal' non-reordered sections. */
3639 default_function_sections
:
3640 return (weak
) ? darwin_sections
[text_coal_section
]
3644 /* When a function is partitioned between sections, we need to insert a label
3645 at the start of each new chunk - so that it may become a valid 'atom' for
3646 eh and debug purposes. Without this the linker will emit warnings if one
3647 tries to add line location information (since the switched fragment will
3651 darwin_function_switched_text_sections (FILE *fp
, tree decl
, bool new_is_cold
)
3654 snprintf (buf
, 128, "%s%s",new_is_cold
?"__cold_sect_of_":"__hot_sect_of_",
3655 IDENTIFIER_POINTER (DECL_NAME (decl
)));
3656 /* Make sure we pick up all the relevant quotes etc. */
3657 assemble_name_raw (fp
, (const char *) buf
);
3661 #include "gt-darwin.h"