OSDN Git Service

PR target/26427
[pf3gnuchains/gcc-fork.git] / gcc / config / darwin.c
1 /* Functions for generic Darwin as target machine for GNU C compiler.
2    Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Apple Computer Inc.
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
33 #include "output.h"
34 #include "insn-attr.h"
35 #include "flags.h"
36 #include "tree.h"
37 #include "expr.h"
38 #include "reload.h"
39 #include "function.h"
40 #include "ggc.h"
41 #include "langhooks.h"
42 #include "target.h"
43 #include "tm_p.h"
44 #include "c-tree.h"
45 #include "c-lang.h"
46 #include "diagnostic-core.h"
47 #include "toplev.h"
48 #include "hashtab.h"
49 #include "df.h"
50 #include "debug.h"
51 #include "obstack.h"
52 #include "lto-streamer.h"
53
54 /* Darwin supports a feature called fix-and-continue, which is used
55    for rapid turn around debugging.  When code is compiled with the
56    -mfix-and-continue flag, two changes are made to the generated code
57    that allow the system to do things that it would normally not be
58    able to do easily.  These changes allow gdb to load in
59    recompilation of a translation unit that has been changed into a
60    running program and replace existing functions and methods of that
61    translation unit with versions of those functions and methods
62    from the newly compiled translation unit.  The new functions access
63    the existing static symbols from the old translation unit, if the
64    symbol existed in the unit to be replaced, and from the new
65    translation unit, otherwise.
66
67    The changes are to insert 5 nops at the beginning of all functions
68    and to use indirection to get at static symbols.  The 5 nops
69    are required by consumers of the generated code.  Currently, gdb
70    uses this to patch in a jump to the overriding function, this
71    allows all uses of the old name to forward to the replacement,
72    including existing function pointers and virtual methods.  See
73    rs6000_emit_prologue for the code that handles the nop insertions.
74
75    The added indirection allows gdb to redirect accesses to static
76    symbols from the newly loaded translation unit to the existing
77    symbol, if any.  @code{static} symbols are special and are handled by
78    setting the second word in the .non_lazy_symbol_pointer data
79    structure to symbol.  See indirect_data for the code that handles
80    the extra indirection, and machopic_output_indirection and its use
81    of MACHO_SYMBOL_STATIC for the code that handles @code{static}
82    symbol indirection.  */
83
84 /* For darwin >= 9  (OSX 10.5) the linker is capable of making the necessary
85    branch islands and we no longer need to emit darwin stubs.
86    However, if we are generating code for earlier systems (or for use in the 
87    kernel) the stubs might still be required, and this will be set true.  */
88 int darwin_emit_branch_islands = false;
89
90 /* A flag to determine whether we are running c++ or obj-c++.  This has to be
91    settable from non-c-family contexts too (i.e. we can't use the c_dialect_
92    functions).  */
93 int darwin_running_cxx;
94
95 /* Section names.  */
96 section * darwin_sections[NUM_DARWIN_SECTIONS];
97
98 /* While we transition to using in-tests instead of ifdef'd code.  */
99 #ifndef HAVE_lo_sum
100 #define HAVE_lo_sum 0
101 #define gen_macho_high(a,b) (a)
102 #define gen_macho_low(a,b,c) (a)
103 #endif
104
105 /* True if we're setting __attribute__ ((ms_struct)).  */
106 int darwin_ms_struct = false;
107
108 /* Earlier versions of Darwin as do not recognize an alignment field in 
109    .comm directives, this should be set for versions that allow it.  */
110 int emit_aligned_common = false;
111
112 /* A get_unnamed_section callback used to switch to an ObjC section.
113    DIRECTIVE is as for output_section_asm_op.  */
114
115 static void
116 output_objc_section_asm_op (const void *directive)
117 {
118   static bool been_here = false;
119
120   /* The NeXT ObjC Runtime requires these sections to be present and in 
121      order in the object.  The code below implements this by emitting 
122      a section header for each ObjC section the first time that an ObjC
123      section is requested.  */
124   if (! been_here)
125     {
126       section *saved_in_section = in_section;
127       static const enum darwin_section_enum tomark[] =
128         {
129           /* written, cold -> hot */
130           objc_cat_cls_meth_section,
131           objc_cat_inst_meth_section,
132           objc_string_object_section,
133           objc_constant_string_object_section,
134           objc_selector_refs_section,
135           objc_selector_fixup_section,
136           objc_cls_refs_section,
137           objc_class_section,
138           objc_meta_class_section,
139           /* shared, hot -> cold */
140           objc_cls_meth_section,
141           objc_inst_meth_section,
142           objc_protocol_section,
143           objc_class_names_section,
144           objc_meth_var_types_section,
145           objc_meth_var_names_section,
146           objc_category_section,
147           objc_class_vars_section,
148           objc_instance_vars_section,
149           objc_module_info_section,
150           objc_symbols_section
151         };
152       size_t i;
153
154       been_here = true;
155       for (i = 0; i < ARRAY_SIZE (tomark); i++)
156         switch_to_section (darwin_sections[tomark[i]]);
157       switch_to_section (saved_in_section);
158     }
159   output_section_asm_op (directive);
160 }
161
162 /* Implement TARGET_ASM_INIT_SECTIONS.  */
163
164 void
165 darwin_init_sections (void)
166 {
167 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC)               \
168   darwin_sections[NAME] =                                       \
169     get_unnamed_section (FLAGS, (OBJC                           \
170                                  ? output_objc_section_asm_op   \
171                                  : output_section_asm_op),      \
172                          "\t" DIRECTIVE);
173 #include "config/darwin-sections.def"
174 #undef DEF_SECTION
175
176   readonly_data_section = darwin_sections[const_section];
177   exception_section = darwin_sections[darwin_exception_section];
178   eh_frame_section = darwin_sections[darwin_eh_frame_section];
179
180   /* Make sure that there is no conflict between the 'no anchor' section
181      flag declared in darwin.h and the section flags declared in output.h.  */
182   gcc_assert (SECTION_NO_ANCHOR > SECTION_MACH_DEP);
183 }
184
185 int
186 name_needs_quotes (const char *name)
187 {
188   int c;
189   while ((c = *name++) != '\0')
190     if (! ISIDNUM (c) 
191           && c != '.' && c != '$' && c != '_' )
192       return 1;
193   return 0;
194 }
195
196 /* Return true if SYM_REF can be used without an indirection.  */
197 int
198 machopic_symbol_defined_p (rtx sym_ref)
199 {
200   if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
201     return true;
202
203   /* If a symbol references local and is not an extern to this
204      file, then the symbol might be able to declared as defined.  */
205   if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
206     {
207       /* If the symbol references a variable and the variable is a
208          common symbol, then this symbol is not defined.  */
209       if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
210         {
211           tree decl = SYMBOL_REF_DECL (sym_ref);
212           if (!decl)
213             return true;
214           if (DECL_COMMON (decl))
215             return false;
216         }
217       return true;
218     }
219   return false;
220 }
221
222 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
223    reference, which will not be changed.  */
224
225 enum machopic_addr_class
226 machopic_classify_symbol (rtx sym_ref)
227 {
228   bool function_p;
229
230   function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
231   if (machopic_symbol_defined_p (sym_ref))
232     return (function_p
233             ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
234   else
235     return (function_p
236             ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
237 }
238
239 #ifndef TARGET_FIX_AND_CONTINUE
240 #define TARGET_FIX_AND_CONTINUE 0
241 #endif
242
243 /* Indicate when fix-and-continue style code generation is being used
244    and when a reference to data should be indirected so that it can be
245    rebound in a new translation unit to reference the original instance
246    of that data.  Symbol names that are for code generation local to
247    the translation unit are bound to the new translation unit;
248    currently this means symbols that begin with L or _OBJC_;
249    otherwise, we indicate that an indirect reference should be made to
250    permit the runtime to rebind new instances of the translation unit
251    to the original instance of the data.  */
252
253 static int
254 indirect_data (rtx sym_ref)
255 {
256   int lprefix;
257   const char *name;
258
259   /* If we aren't generating fix-and-continue code, don't do anything
260      special.  */
261   if (TARGET_FIX_AND_CONTINUE == 0)
262     return 0;
263
264   /* Otherwise, all symbol except symbols that begin with L or _OBJC_
265      are indirected.  Symbols that begin with L and _OBJC_ are always
266      bound to the current translation unit as they are used for
267      generated local data of the translation unit.  */
268
269   name = XSTR (sym_ref, 0);
270
271   lprefix = (((name[0] == '*' || name[0] == '&')
272               && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
273              || (strncmp (name, "_OBJC_", 6) == 0));
274
275   return ! lprefix;
276 }
277
278
279 static int
280 machopic_data_defined_p (rtx sym_ref)
281 {
282   if (indirect_data (sym_ref))
283     return 0;
284
285   switch (machopic_classify_symbol (sym_ref))
286     {
287     case MACHOPIC_DEFINED_DATA:
288     case MACHOPIC_DEFINED_FUNCTION:
289       return 1;
290     default:
291       return 0;
292     }
293 }
294
295 void
296 machopic_define_symbol (rtx mem)
297 {
298   rtx sym_ref;
299
300   gcc_assert (GET_CODE (mem) == MEM);
301   sym_ref = XEXP (mem, 0);
302   SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
303 }
304
305 /* Return either ORIG or:
306
307      (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
308
309    depending on MACHO_DYNAMIC_NO_PIC_P.  */
310 rtx
311 machopic_gen_offset (rtx orig)
312 {
313   if (MACHO_DYNAMIC_NO_PIC_P)
314     return orig;
315   else
316     {
317       /* Play games to avoid marking the function as needing pic if we
318          are being called as part of the cost-estimation process.  */
319       if (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)
320         crtl->uses_pic_offset_table = 1;
321       orig = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig),
322                              UNSPEC_MACHOPIC_OFFSET);
323       return gen_rtx_CONST (Pmode, orig);
324     }
325 }
326
327 static GTY(()) const char * function_base_func_name;
328 static GTY(()) int current_pic_label_num;
329
330 void
331 machopic_output_function_base_name (FILE *file)
332 {
333   const char *current_name;
334
335   /* If dynamic-no-pic is on, we should not get here.  */
336   gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
337   /* When we are generating _get_pc thunks within stubs, there is no current
338      function.  */
339   if (current_function_decl)
340     {
341       current_name =
342         IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
343       if (function_base_func_name != current_name)
344         {
345           ++current_pic_label_num;
346           function_base_func_name = current_name;
347         }
348     }
349   else
350     {
351       ++current_pic_label_num;
352       function_base_func_name = "L_machopic_stub_dummy";
353     }
354   fprintf (file, "L%011d$pb", current_pic_label_num);
355 }
356
357 /* The suffix attached to non-lazy pointer symbols.  */
358 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
359 /* The suffix attached to stub symbols.  */
360 #define STUB_SUFFIX "$stub"
361
362 typedef struct GTY (()) machopic_indirection
363 {
364   /* The SYMBOL_REF for the entity referenced.  */
365   rtx symbol;
366   /* The name of the stub or non-lazy pointer.  */
367   const char * ptr_name;
368   /* True iff this entry is for a stub (as opposed to a non-lazy
369      pointer).  */
370   bool stub_p;
371   /* True iff this stub or pointer pointer has been referenced.  */
372   bool used;
373 } machopic_indirection;
374
375 /* A table mapping stub names and non-lazy pointer names to
376    SYMBOL_REFs for the stubbed-to and pointed-to entities.  */
377
378 static GTY ((param_is (struct machopic_indirection))) htab_t
379   machopic_indirections;
380
381 /* Return a hash value for a SLOT in the indirections hash table.  */
382
383 static hashval_t
384 machopic_indirection_hash (const void *slot)
385 {
386   const machopic_indirection *p = (const machopic_indirection *) slot;
387   return htab_hash_string (p->ptr_name);
388 }
389
390 /* Returns true if the KEY is the same as that associated with
391    SLOT.  */
392
393 static int
394 machopic_indirection_eq (const void *slot, const void *key)
395 {
396   return strcmp (((const machopic_indirection *) slot)->ptr_name,
397                  (const char *) key) == 0;
398 }
399
400 /* Return the name of the non-lazy pointer (if STUB_P is false) or
401    stub (if STUB_B is true) corresponding to the given name.  */
402
403 const char *
404 machopic_indirection_name (rtx sym_ref, bool stub_p)
405 {
406   char *buffer;
407   const char *name = XSTR (sym_ref, 0);
408   size_t namelen = strlen (name);
409   machopic_indirection *p;
410   void ** slot;
411   bool needs_quotes;
412   const char *suffix;
413   const char *prefix = user_label_prefix;
414   const char *quote = "";
415   tree id;
416
417   id = maybe_get_identifier (name);
418   if (id)
419     {
420       tree id_orig = id;
421
422       while (IDENTIFIER_TRANSPARENT_ALIAS (id))
423         id = TREE_CHAIN (id);
424       if (id != id_orig)
425         {
426           name = IDENTIFIER_POINTER (id);
427           namelen = strlen (name);
428         }
429     }
430
431   if (name[0] == '*')
432     {
433       prefix = "";
434       ++name;
435       --namelen;
436     }
437
438   needs_quotes = name_needs_quotes (name);
439   if (needs_quotes)
440     {
441       quote = "\"";
442     }
443
444   if (stub_p)
445     suffix = STUB_SUFFIX;
446   else
447     suffix = NON_LAZY_POINTER_SUFFIX;
448
449   buffer = XALLOCAVEC (char, strlen ("&L")
450                    + strlen (prefix)
451                    + namelen
452                    + strlen (suffix)
453                    + 2 * strlen (quote)
454                    + 1 /* '\0' */);
455
456   /* Construct the name of the non-lazy pointer or stub.  */
457   sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
458
459   if (!machopic_indirections)
460     machopic_indirections = htab_create_ggc (37,
461                                              machopic_indirection_hash,
462                                              machopic_indirection_eq,
463                                              /*htab_del=*/NULL);
464
465   slot = htab_find_slot_with_hash (machopic_indirections, buffer,
466                                    htab_hash_string (buffer), INSERT);
467   if (*slot)
468     {
469       p = (machopic_indirection *) *slot;
470     }
471   else
472     {
473       p = ggc_alloc_machopic_indirection ();
474       p->symbol = sym_ref;
475       p->ptr_name = xstrdup (buffer);
476       p->stub_p = stub_p;
477       p->used = false;
478       *slot = p;
479     }
480
481   return p->ptr_name;
482 }
483
484 /* Return the name of the stub for the mcount function.  */
485
486 const char*
487 machopic_mcount_stub_name (void)
488 {
489   rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
490   return machopic_indirection_name (symbol, /*stub_p=*/true);
491 }
492
493 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
494    or non-lazy pointer as used -- and mark the object to which the
495    pointer/stub refers as used as well, since the pointer/stub will
496    emit a reference to it.  */
497
498 void
499 machopic_validate_stub_or_non_lazy_ptr (const char *name)
500 {
501   machopic_indirection *p;
502
503   p = ((machopic_indirection *)
504        (htab_find_with_hash (machopic_indirections, name,
505                              htab_hash_string (name))));
506   if (p && ! p->used)
507     {
508       const char *real_name;
509       tree id;
510
511       p->used = true;
512
513       /* Do what output_addr_const will do when we actually call it.  */
514       if (SYMBOL_REF_DECL (p->symbol))
515         mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
516
517       real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
518
519       id = maybe_get_identifier (real_name);
520       if (id)
521         mark_referenced (id);
522     }
523 }
524
525 /* Transform ORIG, which may be any data source, to the corresponding
526    source using indirections.  */
527
528 rtx
529 machopic_indirect_data_reference (rtx orig, rtx reg)
530 {
531   rtx ptr_ref = orig;
532
533   if (! MACHOPIC_INDIRECT)
534     return orig;
535
536   if (GET_CODE (orig) == SYMBOL_REF)
537     {
538       int defined = machopic_data_defined_p (orig);
539
540       if (defined && MACHO_DYNAMIC_NO_PIC_P)
541         {
542           if (DARWIN_PPC)
543             {
544           /* Create a new register for CSE opportunities.  */
545           rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));
546           emit_insn (gen_macho_high (hi_reg, orig));
547           emit_insn (gen_macho_low (reg, hi_reg, orig));
548               return reg;
549             }
550           else if (DARWIN_X86)
551             return orig;
552           else
553            /* some other cpu -- writeme!  */
554            gcc_unreachable ();
555         }
556       else if (defined)
557         {
558           rtx offset = NULL;
559           if (DARWIN_PPC || HAVE_lo_sum)
560             offset = machopic_gen_offset (orig);
561
562           if (DARWIN_PPC)
563             {
564           rtx hi_sum_reg = (!can_create_pseudo_p ()
565                             ? reg
566                             : gen_reg_rtx (Pmode));
567
568           gcc_assert (reg);
569
570           emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
571                               gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
572                                        gen_rtx_HIGH (Pmode, offset))));
573           emit_insn (gen_rtx_SET (Pmode, reg,
574                                   gen_rtx_LO_SUM (Pmode, hi_sum_reg,
575                                                   copy_rtx (offset))));
576
577           orig = reg;
578             }
579           else if (HAVE_lo_sum)
580             {
581           gcc_assert (reg);
582
583           emit_insn (gen_rtx_SET (VOIDmode, reg,
584                                   gen_rtx_HIGH (Pmode, offset)));
585           emit_insn (gen_rtx_SET (VOIDmode, reg,
586                                   gen_rtx_LO_SUM (Pmode, reg,
587                                                   copy_rtx (offset))));
588           emit_use (pic_offset_table_rtx);
589
590           orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
591             }
592           return orig;
593         }
594
595       ptr_ref = (gen_rtx_SYMBOL_REF
596                  (Pmode,
597                   machopic_indirection_name (orig, /*stub_p=*/false)));
598
599       SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
600
601       ptr_ref = gen_const_mem (Pmode, ptr_ref);
602       machopic_define_symbol (ptr_ref);
603
604       if (DARWIN_X86 
605           && reg 
606           && MACHO_DYNAMIC_NO_PIC_P)
607         {
608             emit_insn (gen_rtx_SET (Pmode, reg, ptr_ref));
609             ptr_ref = reg;
610         }
611
612       return ptr_ref;
613     }
614   else if (GET_CODE (orig) == CONST)
615     {
616       /* If "(const (plus ...", walk the PLUS and return that result.
617          PLUS processing (below) will restore the "(const ..." if
618          appropriate.  */
619       if (GET_CODE (XEXP (orig, 0)) == PLUS)
620         return machopic_indirect_data_reference (XEXP (orig, 0), reg);
621       else 
622         return orig;
623     }
624   else if (GET_CODE (orig) == MEM)
625     {
626       XEXP (ptr_ref, 0) = 
627                 machopic_indirect_data_reference (XEXP (orig, 0), reg);
628       return ptr_ref;
629     }
630   else if (GET_CODE (orig) == PLUS)
631     {
632       rtx base, result;
633       /* When the target is i386, this code prevents crashes due to the
634         compiler's ignorance on how to move the PIC base register to
635         other registers.  (The reload phase sometimes introduces such
636         insns.)  */
637       if (GET_CODE (XEXP (orig, 0)) == REG
638            && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
639            /* Prevent the same register from being erroneously used
640               as both the base and index registers.  */
641            && (DARWIN_X86 && (GET_CODE (XEXP (orig, 1)) == CONST))
642            && reg)
643         {
644           emit_move_insn (reg, XEXP (orig, 0));
645           XEXP (ptr_ref, 0) = reg;
646           return ptr_ref;
647         }
648
649       /* Legitimize both operands of the PLUS.  */
650       base = machopic_indirect_data_reference (XEXP (orig, 0), reg);
651       orig = machopic_indirect_data_reference (XEXP (orig, 1),
652                                                (base == reg ? 0 : reg));
653       if (MACHOPIC_INDIRECT && (GET_CODE (orig) == CONST_INT))
654         result = plus_constant (base, INTVAL (orig));
655       else
656         result = gen_rtx_PLUS (Pmode, base, orig);
657
658       if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
659         {
660           if (reg)
661             {
662               emit_move_insn (reg, result);
663               result = reg;
664             }
665           else
666             {
667               result = force_reg (GET_MODE (result), result);
668             }
669         }
670
671       return result;
672     }
673   return ptr_ref;
674 }
675
676 /* Transform TARGET (a MEM), which is a function call target, to the
677    corresponding symbol_stub if necessary.  Return a new MEM.  */
678
679 rtx
680 machopic_indirect_call_target (rtx target)
681 {
682   if (! darwin_emit_branch_islands)
683     return target;
684
685   if (GET_CODE (target) != MEM)
686     return target;
687
688   if (MACHOPIC_INDIRECT
689       && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
690       && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
691            & MACHO_SYMBOL_FLAG_DEFINED))
692     {
693       rtx sym_ref = XEXP (target, 0);
694       const char *stub_name = machopic_indirection_name (sym_ref,
695                                                          /*stub_p=*/true);
696       enum machine_mode mode = GET_MODE (sym_ref);
697
698       XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
699       SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
700       MEM_READONLY_P (target) = 1;
701       MEM_NOTRAP_P (target) = 1;
702     }
703
704   return target;
705 }
706
707 rtx
708 machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
709 {
710   rtx pic_ref = orig;
711
712   if (! MACHOPIC_INDIRECT)
713     return orig;
714
715   /* First handle a simple SYMBOL_REF or LABEL_REF */
716   if (GET_CODE (orig) == LABEL_REF
717       || (GET_CODE (orig) == SYMBOL_REF
718           ))
719     {
720       /* addr(foo) = &func+(foo-func) */
721       orig = machopic_indirect_data_reference (orig, reg);
722
723       if (GET_CODE (orig) == PLUS
724           && GET_CODE (XEXP (orig, 0)) == REG)
725         {
726           if (reg == 0)
727             return force_reg (mode, orig);
728
729           emit_move_insn (reg, orig);
730           return reg;
731         }
732
733       if (GET_CODE (orig) == MEM)
734         {
735           if (reg == 0)
736             {
737               gcc_assert (!reload_in_progress);
738               reg = gen_reg_rtx (Pmode);
739             }
740
741 #if HAVE_lo_sum
742           if (MACHO_DYNAMIC_NO_PIC_P
743               && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
744                   || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
745             {
746 #if defined (TARGET_TOC)        /* ppc  */
747               rtx temp_reg = (!can_create_pseudo_p ()
748                               ? reg :
749                               gen_reg_rtx (Pmode));
750               rtx asym = XEXP (orig, 0);
751               rtx mem;
752
753               emit_insn (gen_macho_high (temp_reg, asym));
754               mem = gen_const_mem (GET_MODE (orig),
755                                    gen_rtx_LO_SUM (Pmode, temp_reg,
756                                                    copy_rtx (asym)));
757               emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
758 #else
759               /* Some other CPU -- WriteMe! but right now there are no other
760                  platforms that can use dynamic-no-pic  */
761               gcc_unreachable ();
762 #endif
763               pic_ref = reg;
764             }
765           else
766           if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
767               || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
768             {
769               rtx offset = machopic_gen_offset (XEXP (orig, 0));
770 #if defined (TARGET_TOC) /* i.e., PowerPC */
771               /* Generating a new reg may expose opportunities for
772                  common subexpression elimination.  */
773               rtx hi_sum_reg = (!can_create_pseudo_p ()
774                                 ? reg
775                                 : gen_reg_rtx (Pmode));
776               rtx mem;
777               rtx insn;
778               rtx sum;
779
780               sum = gen_rtx_HIGH (Pmode, offset);
781               if (! MACHO_DYNAMIC_NO_PIC_P)
782                 sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
783
784               emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
785
786               mem = gen_const_mem (GET_MODE (orig),
787                                   gen_rtx_LO_SUM (Pmode,
788                                                   hi_sum_reg,
789                                                   copy_rtx (offset)));
790               insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
791               set_unique_reg_note (insn, REG_EQUAL, pic_ref);
792
793               pic_ref = reg;
794 #else
795               emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
796
797               emit_insn (gen_rtx_SET (VOIDmode, reg,
798                                       gen_rtx_HIGH (Pmode,
799                                                     gen_rtx_CONST (Pmode,
800                                                                    offset))));
801               emit_insn (gen_rtx_SET (VOIDmode, reg,
802                                   gen_rtx_LO_SUM (Pmode, reg,
803                                            gen_rtx_CONST (Pmode,
804                                                           copy_rtx (offset)))));
805               pic_ref = gen_rtx_PLUS (Pmode,
806                                       pic_offset_table_rtx, reg);
807 #endif
808             }
809           else
810 #endif  /* HAVE_lo_sum */
811             {
812               rtx pic = pic_offset_table_rtx;
813               if (GET_CODE (pic) != REG)
814                 {
815                   emit_move_insn (reg, pic);
816                   pic = reg;
817                 }
818 #if 0
819               emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
820 #endif
821
822               if (reload_in_progress)
823                 df_set_regs_ever_live (REGNO (pic), true);
824               pic_ref = gen_rtx_PLUS (Pmode, pic,
825                                       machopic_gen_offset (XEXP (orig, 0)));
826             }
827
828 #if !defined (TARGET_TOC)
829           emit_move_insn (reg, pic_ref);
830           pic_ref = gen_const_mem (GET_MODE (orig), reg);
831 #endif
832         }
833       else
834         {
835
836 #if HAVE_lo_sum
837           if (GET_CODE (orig) == SYMBOL_REF
838               || GET_CODE (orig) == LABEL_REF)
839             {
840               rtx offset = machopic_gen_offset (orig);
841 #if defined (TARGET_TOC) /* i.e., PowerPC */
842               rtx hi_sum_reg;
843
844               if (reg == 0)
845                 {
846                   gcc_assert (!reload_in_progress);
847                   reg = gen_reg_rtx (Pmode);
848                 }
849
850               hi_sum_reg = reg;
851
852               emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
853                                       (MACHO_DYNAMIC_NO_PIC_P)
854                                       ? gen_rtx_HIGH (Pmode, offset)
855                                       : gen_rtx_PLUS (Pmode,
856                                                       pic_offset_table_rtx,
857                                                       gen_rtx_HIGH (Pmode,
858                                                                     offset))));
859               emit_insn (gen_rtx_SET (VOIDmode, reg,
860                                       gen_rtx_LO_SUM (Pmode,
861                                                       hi_sum_reg,
862                                                       copy_rtx (offset))));
863               pic_ref = reg;
864 #else
865               emit_insn (gen_rtx_SET (VOIDmode, reg,
866                                       gen_rtx_HIGH (Pmode, offset)));
867               emit_insn (gen_rtx_SET (VOIDmode, reg,
868                                       gen_rtx_LO_SUM (Pmode, reg,
869                                                       copy_rtx (offset))));
870               pic_ref = gen_rtx_PLUS (Pmode,
871                                       pic_offset_table_rtx, reg);
872 #endif
873             }
874           else
875 #endif  /*  HAVE_lo_sum  */
876             {
877               if (REG_P (orig)
878                   || GET_CODE (orig) == SUBREG)
879                 {
880                   return orig;
881                 }
882               else
883                 {
884                   rtx pic = pic_offset_table_rtx;
885                   if (GET_CODE (pic) != REG)
886                     {
887                       emit_move_insn (reg, pic);
888                       pic = reg;
889                     }
890 #if 0
891                   emit_use (pic_offset_table_rtx);
892 #endif
893                   if (reload_in_progress)
894                     df_set_regs_ever_live (REGNO (pic), true);
895                   pic_ref = gen_rtx_PLUS (Pmode,
896                                           pic,
897                                           machopic_gen_offset (orig));
898                 }
899             }
900         }
901
902       if (GET_CODE (pic_ref) != REG)
903         {
904           if (reg != 0)
905             {
906               emit_move_insn (reg, pic_ref);
907               return reg;
908             }
909           else
910             {
911               return force_reg (mode, pic_ref);
912             }
913         }
914       else
915         {
916           return pic_ref;
917         }
918     }
919
920   else if (GET_CODE (orig) == SYMBOL_REF)
921     return orig;
922
923   else if (GET_CODE (orig) == PLUS
924            && (GET_CODE (XEXP (orig, 0)) == MEM
925                || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
926                || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
927            && XEXP (orig, 0) != pic_offset_table_rtx
928            && GET_CODE (XEXP (orig, 1)) != REG)
929
930     {
931       rtx base;
932       int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
933
934       base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
935       orig = machopic_legitimize_pic_address (XEXP (orig, 1),
936                                               Pmode, (base == reg ? 0 : reg));
937       if (GET_CODE (orig) == CONST_INT)
938         {
939           pic_ref = plus_constant (base, INTVAL (orig));
940           is_complex = 1;
941         }
942       else
943         pic_ref = gen_rtx_PLUS (Pmode, base, orig);
944
945       if (reg && is_complex)
946         {
947           emit_move_insn (reg, pic_ref);
948           pic_ref = reg;
949         }
950       /* Likewise, should we set special REG_NOTEs here?  */
951     }
952
953   else if (GET_CODE (orig) == CONST)
954     {
955       return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
956     }
957
958   else if (GET_CODE (orig) == MEM
959            && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
960     {
961       rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
962       addr = replace_equiv_address (orig, addr);
963       emit_move_insn (reg, addr);
964       pic_ref = reg;
965     }
966
967   return pic_ref;
968 }
969
970 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
971    DATA is the FILE* for assembly output.  Called from
972    htab_traverse.  */
973
974 static int
975 machopic_output_indirection (void **slot, void *data)
976 {
977   machopic_indirection *p = *((machopic_indirection **) slot);
978   FILE *asm_out_file = (FILE *) data;
979   rtx symbol;
980   const char *sym_name;
981   const char *ptr_name;
982
983   if (!p->used)
984     return 1;
985
986   symbol = p->symbol;
987   sym_name = XSTR (symbol, 0);
988   ptr_name = p->ptr_name;
989
990   if (p->stub_p)
991     {
992       char *sym;
993       char *stub;
994       tree id;
995
996       id = maybe_get_identifier (sym_name);
997       if (id)
998         {
999           tree id_orig = id;
1000
1001           while (IDENTIFIER_TRANSPARENT_ALIAS (id))
1002             id = TREE_CHAIN (id);
1003           if (id != id_orig)
1004             sym_name = IDENTIFIER_POINTER (id);
1005         }
1006
1007       sym = XALLOCAVEC (char, strlen (sym_name) + 2);
1008       if (sym_name[0] == '*' || sym_name[0] == '&')
1009         strcpy (sym, sym_name + 1);
1010       else if (sym_name[0] == '-' || sym_name[0] == '+')
1011         strcpy (sym, sym_name);
1012       else
1013         sprintf (sym, "%s%s", user_label_prefix, sym_name);
1014
1015       stub = XALLOCAVEC (char, strlen (ptr_name) + 2);
1016       if (ptr_name[0] == '*' || ptr_name[0] == '&')
1017         strcpy (stub, ptr_name + 1);
1018       else
1019         sprintf (stub, "%s%s", user_label_prefix, ptr_name);
1020
1021       machopic_output_stub (asm_out_file, sym, stub);
1022     }
1023   else if (! indirect_data (symbol)
1024            && (machopic_symbol_defined_p (symbol)
1025                || SYMBOL_REF_LOCAL_P (symbol)))
1026     {
1027       switch_to_section (data_section);
1028       assemble_align (GET_MODE_ALIGNMENT (Pmode));
1029       assemble_label (asm_out_file, ptr_name);
1030       assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
1031                         GET_MODE_SIZE (Pmode),
1032                         GET_MODE_ALIGNMENT (Pmode), 1);
1033     }
1034   else
1035     {
1036       rtx init = const0_rtx;
1037
1038       switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
1039
1040       /* Mach-O symbols are passed around in code through indirect
1041          references and the original symbol_ref hasn't passed through
1042          the generic handling and reference-catching in
1043          output_operand, so we need to manually mark weak references
1044          as such.  */
1045       if (SYMBOL_REF_WEAK (symbol))
1046         {
1047           tree decl = SYMBOL_REF_DECL (symbol);
1048           gcc_assert (DECL_P (decl));
1049
1050           if (decl != NULL_TREE
1051               && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
1052               /* Handle only actual external-only definitions, not
1053                  e.g. extern inline code or variables for which
1054                  storage has been allocated.  */
1055               && !TREE_STATIC (decl))
1056             {
1057               fputs ("\t.weak_reference ", asm_out_file);
1058               assemble_name (asm_out_file, sym_name);
1059               fputc ('\n', asm_out_file);
1060             }
1061         }
1062
1063       assemble_name (asm_out_file, ptr_name);
1064       fprintf (asm_out_file, ":\n");
1065
1066       fprintf (asm_out_file, "\t.indirect_symbol ");
1067       assemble_name (asm_out_file, sym_name);
1068       fprintf (asm_out_file, "\n");
1069
1070       /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1071          have their symbol name instead of 0 in the second entry of
1072          the non-lazy symbol pointer data structure when they are
1073          defined.  This allows the runtime to rebind newer instances
1074          of the translation unit with the original instance of the
1075          symbol.  */
1076
1077       if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
1078           && machopic_symbol_defined_p (symbol))
1079         init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
1080
1081       assemble_integer (init, GET_MODE_SIZE (Pmode),
1082                         GET_MODE_ALIGNMENT (Pmode), 1);
1083     }
1084
1085   return 1;
1086 }
1087
1088 void
1089 machopic_finish (FILE *asm_out_file)
1090 {
1091   if (machopic_indirections)
1092     htab_traverse_noresize (machopic_indirections,
1093                             machopic_output_indirection,
1094                             asm_out_file);
1095 }
1096
1097 int
1098 machopic_operand_p (rtx op)
1099 {
1100   if (MACHOPIC_JUST_INDIRECT)
1101     return (GET_CODE (op) == SYMBOL_REF
1102             && machopic_symbol_defined_p (op));
1103   else
1104     return (GET_CODE (op) == CONST
1105             && GET_CODE (XEXP (op, 0)) == UNSPEC
1106             && XINT (XEXP (op, 0), 1) == UNSPEC_MACHOPIC_OFFSET);
1107 }
1108
1109 /* This function records whether a given name corresponds to a defined
1110    or undefined function or variable, for machopic_classify_ident to
1111    use later.  */
1112
1113 void
1114 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
1115 {
1116   rtx sym_ref;
1117
1118   /* Do the standard encoding things first.  */
1119   default_encode_section_info (decl, rtl, first);
1120
1121   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
1122     return;
1123
1124   sym_ref = XEXP (rtl, 0);
1125   if (TREE_CODE (decl) == VAR_DECL)
1126     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
1127
1128   if (!DECL_EXTERNAL (decl)
1129       && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
1130       && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
1131       && ((TREE_STATIC (decl)
1132            && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
1133           || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
1134               && DECL_INITIAL (decl) != error_mark_node)))
1135     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
1136
1137   if (! TREE_PUBLIC (decl))
1138     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
1139 }
1140
1141 void
1142 darwin_mark_decl_preserved (const char *name)
1143 {
1144   fprintf (asm_out_file, "\t.no_dead_strip ");
1145   assemble_name (asm_out_file, name);
1146   fputc ('\n', asm_out_file);
1147 }
1148
1149 static section *
1150 darwin_text_section (int reloc, int weak)
1151 {
1152   if (reloc)
1153     return (weak
1154             ? darwin_sections[text_unlikely_coal_section]
1155             : unlikely_text_section ());
1156   else
1157     return (weak
1158             ? darwin_sections[text_coal_section]
1159             : text_section);
1160 }
1161
1162 static section *
1163 darwin_rodata_section (int weak, bool zsize)
1164 {
1165   return (weak
1166           ? darwin_sections[const_coal_section]
1167           : (zsize ? darwin_sections[zobj_const_section]
1168                    : darwin_sections[const_section]));
1169 }
1170
1171 static section *
1172 darwin_mergeable_string_section (tree exp,
1173                                  unsigned HOST_WIDE_INT align)
1174 {
1175
1176   if (flag_merge_constants
1177       && TREE_CODE (exp) == STRING_CST
1178       && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1179       && align <= 256
1180       && (int_size_in_bytes (TREE_TYPE (exp))
1181           == TREE_STRING_LENGTH (exp))
1182       && ((size_t) TREE_STRING_LENGTH (exp)
1183           == strlen (TREE_STRING_POINTER (exp)) + 1))
1184     return darwin_sections[cstring_section];
1185
1186   if (DARWIN_SECTION_ANCHORS && flag_section_anchors
1187       && TREE_CODE (exp) == STRING_CST
1188       && TREE_STRING_LENGTH (exp) == 0)
1189     return darwin_sections[zobj_const_section];
1190
1191   return readonly_data_section;
1192 }
1193
1194 #ifndef HAVE_GAS_LITERAL16
1195 #define HAVE_GAS_LITERAL16 0
1196 #endif
1197
1198 static section *
1199 darwin_mergeable_constant_section (tree exp,
1200                                    unsigned HOST_WIDE_INT align,
1201                                    bool zsize)
1202 {
1203   enum machine_mode mode = DECL_MODE (exp);
1204   unsigned int modesize = GET_MODE_BITSIZE (mode);
1205
1206   if (DARWIN_SECTION_ANCHORS 
1207       && flag_section_anchors 
1208       && zsize)
1209     return darwin_sections[zobj_const_section];
1210
1211   if (flag_merge_constants
1212       && mode != VOIDmode
1213       && mode != BLKmode
1214       && modesize <= align
1215       && align >= 8
1216       && align <= 256
1217       && (align & (align -1)) == 0)
1218     {
1219       tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1220
1221       if (TREE_CODE (size) == INTEGER_CST
1222           && TREE_INT_CST_LOW (size) == 4
1223           && TREE_INT_CST_HIGH (size) == 0)
1224         return darwin_sections[literal4_section];
1225       else if (TREE_CODE (size) == INTEGER_CST
1226                && TREE_INT_CST_LOW (size) == 8
1227                && TREE_INT_CST_HIGH (size) == 0)
1228         return darwin_sections[literal8_section];
1229       else if (HAVE_GAS_LITERAL16
1230                && TARGET_64BIT
1231                && TREE_CODE (size) == INTEGER_CST
1232                && TREE_INT_CST_LOW (size) == 16
1233                && TREE_INT_CST_HIGH (size) == 0)
1234         return darwin_sections[literal16_section];
1235       else
1236         return readonly_data_section;
1237     }
1238
1239   return readonly_data_section;
1240 }
1241
1242 int
1243 machopic_reloc_rw_mask (void)
1244 {
1245   return MACHOPIC_INDIRECT ? 3 : 0;
1246 }
1247
1248 section *
1249 machopic_select_section (tree decl,
1250                          int reloc,
1251                          unsigned HOST_WIDE_INT align)
1252 {
1253   bool zsize, one, weak, ro;
1254   section *base_section = NULL;
1255
1256   weak = (DECL_P (decl)
1257           && DECL_WEAK (decl)
1258           && !lookup_attribute ("weak_import", DECL_ATTRIBUTES (decl)));
1259
1260   zsize = (DECL_P (decl) 
1261            && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL) 
1262            && tree_low_cst (DECL_SIZE_UNIT (decl), 1) == 0);
1263
1264   one = DECL_P (decl) 
1265         && TREE_CODE (decl) == VAR_DECL 
1266         && DECL_ONE_ONLY (decl);
1267
1268   ro = TREE_READONLY (decl) || TREE_CONSTANT (decl) ;
1269
1270   switch (categorize_decl_for_section (decl, reloc))
1271     {
1272     case SECCAT_TEXT:
1273       {
1274         struct cgraph_node *node;
1275         if (decl && TREE_CODE (decl) == FUNCTION_DECL
1276             && (node = cgraph_get_node (decl)) != NULL)
1277           base_section = darwin_function_section (decl,
1278                                                   node->frequency,
1279                                                   node->only_called_at_startup,
1280                                                   node->only_called_at_exit);
1281         if (!base_section)
1282           base_section = darwin_text_section (reloc, weak);
1283       }
1284       break;
1285
1286     case SECCAT_RODATA:
1287     case SECCAT_SRODATA:
1288       base_section = darwin_rodata_section (weak, zsize);
1289       break;
1290
1291     case SECCAT_RODATA_MERGE_STR:
1292       base_section = darwin_mergeable_string_section (decl, align);
1293       break;
1294
1295     case SECCAT_RODATA_MERGE_STR_INIT:
1296       base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1297       break;
1298
1299     case SECCAT_RODATA_MERGE_CONST:
1300       base_section =  darwin_mergeable_constant_section (decl, align, zsize);
1301       break;
1302
1303     case SECCAT_DATA:
1304     case SECCAT_DATA_REL:
1305     case SECCAT_DATA_REL_LOCAL:
1306     case SECCAT_DATA_REL_RO:
1307     case SECCAT_DATA_REL_RO_LOCAL:
1308     case SECCAT_SDATA:
1309     case SECCAT_TDATA:
1310       if (weak || one)
1311         {
1312           if (ro)
1313             base_section = darwin_sections[const_data_coal_section];
1314           else 
1315             base_section = darwin_sections[data_coal_section];
1316         }
1317       else if (DARWIN_SECTION_ANCHORS 
1318                && flag_section_anchors
1319                && zsize)
1320         {
1321           /* If we're doing section anchors, then punt zero-sized objects into
1322              their own sections so that they don't interfere with offset
1323              computation for the remaining vars.  This does not need to be done
1324              for stuff in mergeable sections, since these are ineligible for 
1325              anchors.  */
1326           if (ro)
1327             base_section = darwin_sections[zobj_const_data_section];
1328           else
1329             base_section = darwin_sections[zobj_data_section];
1330         }
1331       else if (ro)
1332         base_section = darwin_sections[const_data_section];
1333       else
1334         base_section = data_section;
1335       break;
1336     case SECCAT_BSS:
1337     case SECCAT_SBSS:
1338     case SECCAT_TBSS:
1339       if (weak || one) 
1340         base_section = darwin_sections[data_coal_section];
1341       else
1342         {
1343           if (!TREE_PUBLIC (decl))
1344             base_section = lcomm_section;
1345           else if (bss_noswitch_section)
1346             base_section = bss_noswitch_section;
1347           else
1348             base_section = data_section;
1349         }
1350       break;
1351
1352     default:
1353       gcc_unreachable ();
1354     }
1355
1356   /* Darwin weird special cases.  */
1357   if (TREE_CODE (decl) == CONSTRUCTOR
1358       && TREE_TYPE (decl)
1359       && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1360       && TYPE_NAME (TREE_TYPE (decl)))
1361     {
1362       tree name = TYPE_NAME (TREE_TYPE (decl));
1363       if (TREE_CODE (name) == TYPE_DECL)
1364         name = DECL_NAME (name);
1365
1366       if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1367         {
1368           if (flag_next_runtime)
1369             return darwin_sections[objc_constant_string_object_section];
1370           else
1371             return darwin_sections[objc_string_object_section];
1372         }
1373       else if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_CFString"))
1374         return darwin_sections[cfstring_constant_object_section];
1375       else
1376         return base_section;
1377     }
1378   else if (TREE_CODE (decl) == VAR_DECL
1379            && DECL_NAME (decl)
1380            && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1381            && IDENTIFIER_POINTER (DECL_NAME (decl))
1382            && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1383     {
1384       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1385
1386       /* We shall assert that zero-sized objects are an error in ObjC 
1387          meta-data.  */
1388       gcc_assert (tree_low_cst (DECL_SIZE_UNIT (decl), 1) != 0);
1389       if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1390         return darwin_sections[objc_cls_meth_section];
1391       else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1392         return darwin_sections[objc_inst_meth_section];
1393       else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 29))
1394         return darwin_sections[objc_cat_cls_meth_section];
1395       else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 32))
1396         return darwin_sections[objc_cat_inst_meth_section];
1397       else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1398         return darwin_sections[objc_class_vars_section];
1399       else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1400         return darwin_sections[objc_instance_vars_section];
1401       else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1402         return darwin_sections[objc_cat_cls_meth_section];
1403       else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1404         return darwin_sections[objc_class_names_section];
1405       else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1406         return darwin_sections[objc_meth_var_names_section];
1407       else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1408         return darwin_sections[objc_meth_var_types_section];
1409       else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1410         return darwin_sections[objc_cls_refs_section];
1411       else if (!strncmp (name, "_OBJC_CLASS_", 12))
1412         return darwin_sections[objc_class_section];
1413       else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1414         return darwin_sections[objc_meta_class_section];
1415       else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1416         return darwin_sections[objc_category_section];
1417       else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1418         return darwin_sections[objc_selector_refs_section];
1419       else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1420         return darwin_sections[objc_selector_fixup_section];
1421       else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1422         return darwin_sections[objc_symbols_section];
1423       else if (!strncmp (name, "_OBJC_MODULES", 13))
1424         return darwin_sections[objc_module_info_section];
1425       else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1426         return darwin_sections[objc_image_info_section];
1427       else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1428         return darwin_sections[objc_cat_inst_meth_section];
1429       else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1430         return darwin_sections[objc_cat_cls_meth_section];
1431       else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1432         return darwin_sections[objc_cat_cls_meth_section];
1433       else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1434         return darwin_sections[objc_protocol_section];
1435       else
1436         return base_section;
1437     }
1438
1439   return base_section;
1440 }
1441
1442 /* This can be called with address expressions as "rtx".
1443    They must go in "const".  */
1444
1445 section *
1446 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1447                              unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1448 {
1449   if (GET_MODE_SIZE (mode) == 8
1450       && (GET_CODE (x) == CONST_INT
1451           || GET_CODE (x) == CONST_DOUBLE))
1452     return darwin_sections[literal8_section];
1453   else if (GET_MODE_SIZE (mode) == 4
1454            && (GET_CODE (x) == CONST_INT
1455                || GET_CODE (x) == CONST_DOUBLE))
1456     return darwin_sections[literal4_section];
1457   else if (HAVE_GAS_LITERAL16
1458            && TARGET_64BIT
1459            && GET_MODE_SIZE (mode) == 16
1460            && (GET_CODE (x) == CONST_INT
1461                || GET_CODE (x) == CONST_DOUBLE
1462                || GET_CODE (x) == CONST_VECTOR))
1463     return darwin_sections[literal16_section];
1464   else if (MACHOPIC_INDIRECT
1465            && (GET_CODE (x) == SYMBOL_REF
1466                || GET_CODE (x) == CONST
1467                || GET_CODE (x) == LABEL_REF))
1468     return darwin_sections[const_data_section];
1469   else
1470     return darwin_sections[const_section];
1471 }
1472
1473 void
1474 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1475 {
1476   if (MACHOPIC_INDIRECT)
1477     switch_to_section (darwin_sections[mod_init_section]);
1478   else
1479     switch_to_section (darwin_sections[constructor_section]);
1480   assemble_align (POINTER_SIZE);
1481   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1482
1483   if (! MACHOPIC_INDIRECT)
1484     fprintf (asm_out_file, ".reference .constructors_used\n");
1485 }
1486
1487 void
1488 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1489 {
1490   if (MACHOPIC_INDIRECT)
1491     switch_to_section (darwin_sections[mod_term_section]);
1492   else
1493     switch_to_section (darwin_sections[destructor_section]);
1494   assemble_align (POINTER_SIZE);
1495   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1496
1497   if (! MACHOPIC_INDIRECT)
1498     fprintf (asm_out_file, ".reference .destructors_used\n");
1499 }
1500
1501 void
1502 darwin_globalize_label (FILE *stream, const char *name)
1503 {
1504   if (!!strncmp (name, "_OBJC_", 6))
1505     default_globalize_label (stream, name);
1506 }
1507
1508 /* This routine returns non-zero if 'name' starts with the special objective-c 
1509    anonymous file-scope static name.  It accommodates c++'s mangling of such 
1510    symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit).  */
1511    
1512 int 
1513 darwin_label_is_anonymous_local_objc_name (const char *name)
1514 {
1515   const unsigned char *p = (const unsigned char *) name;
1516   if (*p != '_')
1517     return 0;
1518   if (p[1] == 'Z' && p[2] == 'L')
1519   {
1520     p += 3;
1521     while (*p >= '0' && *p <= '9')
1522       p++;
1523   }
1524   return (!strncmp ((const char *)p, "_OBJC_", 6));
1525 }
1526
1527 /* LTO support for Mach-O.  */
1528
1529 /* Section names for LTO sections.  */
1530 static unsigned int lto_section_names_offset = 0;
1531
1532 /* This is the obstack which we use to allocate the many strings.  */
1533 static struct obstack lto_section_names_obstack;
1534
1535 /* Segment name for LTO sections.  */
1536 #define LTO_SEGMENT_NAME "__GNU_LTO"
1537
1538 /* Section name for LTO section names section.  */
1539 #define LTO_NAMES_SECTION "__section_names"
1540
1541 /* File to temporarily store LTO data.  This is appended to asm_out_file
1542    in darwin_end_file.  */
1543 static FILE *lto_asm_out_file, *saved_asm_out_file;
1544 static char *lto_asm_out_name;
1545
1546 /* Prepare asm_out_file for LTO output.  For darwin, this means hiding
1547    asm_out_file and switching to an alternative output file.  */
1548 void
1549 darwin_asm_lto_start (void)
1550 {
1551   gcc_assert (! saved_asm_out_file);
1552   saved_asm_out_file = asm_out_file;
1553   if (! lto_asm_out_name)
1554     lto_asm_out_name = make_temp_file (".lto.s");
1555   lto_asm_out_file = fopen (lto_asm_out_name, "a");
1556   if (lto_asm_out_file == NULL)
1557     fatal_error ("failed to open temporary file %s for LTO output",
1558                  lto_asm_out_name);
1559   asm_out_file = lto_asm_out_file;
1560 }
1561
1562 /* Restore asm_out_file.  */
1563 void
1564 darwin_asm_lto_end (void)
1565 {
1566   gcc_assert (saved_asm_out_file);
1567   fclose (lto_asm_out_file);
1568   asm_out_file = saved_asm_out_file;
1569   saved_asm_out_file = NULL;
1570 }
1571
1572 static void
1573 darwin_asm_dwarf_section (const char *name, unsigned int flags, tree decl);
1574
1575 /*  Called for the TARGET_ASM_NAMED_SECTION hook.  */
1576
1577 void
1578 darwin_asm_named_section (const char *name,
1579                           unsigned int flags,
1580                           tree decl ATTRIBUTE_UNUSED)
1581 {
1582   /* LTO sections go in a special segment __GNU_LTO.  We want to replace the
1583      section name with something we can use to represent arbitrary-length
1584      names (section names in Mach-O are at most 16 characters long).  */
1585   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
1586                strlen (LTO_SECTION_NAME_PREFIX)) == 0)
1587     {
1588       /* We expect certain flags to be set...  */
1589       gcc_assert ((flags & (SECTION_DEBUG | SECTION_NAMED))
1590                   == (SECTION_DEBUG | SECTION_NAMED));
1591
1592       /* Add the section name to the things to output when we end the
1593          current assembler output file.
1594          This is all not very efficient, but that doesn't matter -- this
1595          shouldn't be a hot path in the compiler...  */
1596       obstack_1grow (&lto_section_names_obstack, '\t');
1597       obstack_grow (&lto_section_names_obstack, ".ascii ", 7);
1598       obstack_1grow (&lto_section_names_obstack, '"');
1599       obstack_grow (&lto_section_names_obstack, name, strlen (name));
1600       obstack_grow (&lto_section_names_obstack, "\\0\"\n", 4);
1601
1602       /* Output the dummy section name.  */
1603       fprintf (asm_out_file, "\t# %s\n", name);
1604       fprintf (asm_out_file, "\t.section %s,__%08X,regular,debug\n",
1605                LTO_SEGMENT_NAME, lto_section_names_offset);
1606
1607       /* Update the offset for the next section name.  Make sure we stay
1608          within reasonable length.  */  
1609       lto_section_names_offset += strlen (name) + 1;
1610       gcc_assert (lto_section_names_offset > 0
1611                   && lto_section_names_offset < ((unsigned) 1 << 31));
1612     }
1613   else if (strncmp (name, "__DWARF,", 8) == 0)
1614     darwin_asm_dwarf_section (name, flags, decl);
1615   else
1616     fprintf (asm_out_file, "\t.section %s\n", name);
1617 }
1618
1619 void
1620 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1621 {
1622   /* Darwin does not use unique sections.  */
1623 }
1624
1625 /* Handle __attribute__ ((apple_kext_compatibility)).
1626    This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1627    vtable for classes with this attribute (and their descendants) by not
1628    outputting the new 3.0 nondeleting destructor.  This means that such
1629    objects CANNOT be allocated on the stack or as globals UNLESS they have
1630    a completely empty `operator delete'.
1631    Luckily, this fits in with the Darwin kext model.
1632
1633    This attribute also disables gcc3's potential overlaying of derived
1634    class data members on the padding at the end of the base class.  */
1635
1636 tree
1637 darwin_handle_kext_attribute (tree *node, tree name,
1638                               tree args ATTRIBUTE_UNUSED,
1639                               int flags ATTRIBUTE_UNUSED,
1640                               bool *no_add_attrs)
1641 {
1642   /* APPLE KEXT stuff -- only applies with pure static C++ code.  */
1643   if (! TARGET_KEXTABI)
1644     {
1645       warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1646                "only when compiling a kext", name);
1647
1648       *no_add_attrs = true;
1649     }
1650   else if (TREE_CODE (*node) != RECORD_TYPE)
1651     {
1652       warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1653                "only to C++ classes", name);
1654
1655       *no_add_attrs = true;
1656     }
1657
1658   return NULL_TREE;
1659 }
1660
1661 /* Handle a "weak_import" attribute; arguments as in
1662    struct attribute_spec.handler.  */
1663
1664 tree
1665 darwin_handle_weak_import_attribute (tree *node, tree name,
1666                                      tree ARG_UNUSED (args),
1667                                      int ARG_UNUSED (flags),
1668                                      bool * no_add_attrs)
1669 {
1670   if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1671     {
1672       warning (OPT_Wattributes, "%qE attribute ignored",
1673                name);
1674       *no_add_attrs = true;
1675     }
1676   else
1677     declare_weak (*node);
1678
1679   return NULL_TREE;
1680 }
1681
1682 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1683    The third parameter is nonzero if this is for exception handling.
1684    The fourth parameter is nonzero if this is just a placeholder for an
1685    FDE that we are omitting. */
1686
1687 void
1688 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1689 {
1690   char *lab;
1691
1692   if (! for_eh)
1693     return;
1694
1695   lab = concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), ".eh", NULL);
1696
1697   if (TREE_PUBLIC (decl))
1698     {
1699       targetm.asm_out.globalize_label (file, lab);
1700       if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN)
1701         {
1702           fputs ("\t.private_extern ", file);
1703           assemble_name (file, lab);
1704           fputc ('\n', file);
1705         }
1706     }
1707
1708   if (DECL_WEAK (decl))
1709     {
1710       fputs ("\t.weak_definition ", file);
1711       assemble_name (file, lab);
1712       fputc ('\n', file);
1713     }
1714
1715   assemble_name (file, lab);
1716   if (empty)
1717     {
1718       fputs (" = 0\n", file);
1719
1720       /* Mark the absolute .eh and .eh1 style labels as needed to
1721          ensure that we don't dead code strip them and keep such
1722          labels from another instantiation point until we can fix this
1723          properly with group comdat support.  */
1724       darwin_mark_decl_preserved (lab);
1725     }
1726   else
1727     fputs (":\n", file);
1728
1729   free (lab);
1730 }
1731
1732 static GTY(()) unsigned long except_table_label_num;
1733
1734 void
1735 darwin_emit_except_table_label (FILE *file)
1736 {
1737   char section_start_label[30];
1738
1739   ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1740                                except_table_label_num++);
1741   ASM_OUTPUT_LABEL (file, section_start_label);
1742 }
1743 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
1744
1745 void
1746 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1747 {
1748   const char *nlp_name;
1749
1750   gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1751
1752   nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1753   fputs ("\t.long\t", file);
1754   ASM_OUTPUT_LABELREF (file, nlp_name);
1755   fputs ("-.", file);
1756 }
1757
1758 /* If this is uncommented, details of each allocation will be printed
1759    in the asm right before the actual code.  WARNING - this will cause some
1760    test-suite fails (since the printout will contain items that some tests
1761    are not expecting) -- so don't leave it on by default (it bloats the
1762    asm too).  */
1763 /*#define DEBUG_DARWIN_MEM_ALLOCATORS*/
1764
1765 /* The first two of these routines are ostensibly just intended to put
1766    names into the asm.  However, they are both hijacked in order to ensure
1767    that zero-sized items do not make their way into the output.  Consequently,
1768    we also need to make these participate in provisions for dealing with
1769    such items in section anchors.  */
1770
1771 /* The implementation of ASM_DECLARE_OBJECT_NAME.  */
1772 /* The RTTI data (e.g., __ti4name) is common and public (and static),
1773    but it does need to be referenced via indirect PIC data pointers.
1774    The machopic_define_symbol calls are telling the machopic subsystem
1775    that the name *is* defined in this module, so it doesn't need to
1776    make them indirect.  */
1777 void 
1778 darwin_asm_declare_object_name (FILE *file, 
1779                                 const char *nam, tree decl)
1780 {
1781   const char *xname = nam;
1782   unsigned HOST_WIDE_INT size;
1783   bool local_def, weak;
1784
1785   weak = (DECL_P (decl)
1786           && DECL_WEAK (decl)
1787           && !lookup_attribute ("weak_import", 
1788                                  DECL_ATTRIBUTES (decl)));
1789
1790   local_def = DECL_INITIAL (decl) || (TREE_STATIC (decl) 
1791                                       && (!DECL_COMMON (decl) 
1792                                           || !TREE_PUBLIC (decl)));
1793
1794   if (GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1795     xname = IDENTIFIER_POINTER (DECL_NAME (decl));
1796
1797   if (local_def)
1798     {
1799       (* targetm.encode_section_info) (decl, DECL_RTL (decl), false);
1800       if (!weak)
1801         machopic_define_symbol (DECL_RTL (decl));
1802     }
1803
1804   size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1805
1806 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
1807 fprintf (file, "# dadon: %s %s (%llu, %u) local %d weak %d"
1808                " stat %d com %d pub %d t-const %d t-ro %d init %lx\n",
1809         xname, (TREE_CODE (decl) == VAR_DECL?"var":"const"), 
1810         (unsigned long long)size, DECL_ALIGN (decl), local_def, 
1811         DECL_WEAK (decl), TREE_STATIC (decl), DECL_COMMON (decl),
1812         TREE_PUBLIC (decl), TREE_CONSTANT (decl), TREE_READONLY (decl),
1813         (unsigned long)DECL_INITIAL (decl)); 
1814 #endif
1815
1816   /* Darwin needs help to support local zero-sized objects. 
1817      They must be made at least one byte, and the section containing must be
1818      marked as unsuitable for section-anchors (see storage allocators below).
1819      
1820      For non-zero objects this output is handled by varasm.c.
1821   */
1822   if (!size)
1823     {
1824       unsigned int l2align = 0;
1825
1826       /* The align must be honoured, even for zero-sized.  */
1827       if (DECL_ALIGN (decl))
1828         {
1829           l2align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT);
1830           fprintf (file, "\t.align\t%u\n", l2align);
1831         }
1832
1833       ASM_OUTPUT_LABEL (file, xname);
1834       size = 1;
1835       fprintf (file, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
1836
1837       /* Check that we've correctly picked up the zero-sized item and placed it
1838          properly.  */
1839       gcc_assert ((!DARWIN_SECTION_ANCHORS || !flag_section_anchors)
1840                   || (in_section 
1841                       && (in_section->common.flags & SECTION_NO_ANCHOR)));
1842     }
1843   else
1844     ASM_OUTPUT_LABEL (file, xname);
1845 }
1846
1847 /* The implementation of ASM_DECLARE_CONSTANT_NAME.  */
1848 void
1849 darwin_asm_declare_constant_name (FILE *file, const char *name,
1850                                   const_tree exp ATTRIBUTE_UNUSED,
1851                                   HOST_WIDE_INT size)
1852 {
1853   assemble_label (file, name);
1854   /* As for other items, we need at least one byte.  */
1855   if (!size)
1856     {
1857       fputs ("\t.space\t1\n", file);
1858       /* Check that we've correctly picked up the zero-sized item and placed it
1859          properly.  */
1860       gcc_assert ((!DARWIN_SECTION_ANCHORS || !flag_section_anchors)
1861                   || (in_section 
1862                       && (in_section->common.flags & SECTION_NO_ANCHOR)));
1863     }
1864 }
1865
1866 /* Darwin storage allocators.
1867
1868    Zerofill sections are desirable for large blank data since, otherwise, these
1869    data bloat objects (PR33210).
1870
1871    However, section anchors don't work in .zerofill sections (one cannot switch
1872    to a zerofill section).  Ergo, for Darwin targets using section anchors we need
1873    to put (at least some) data into 'normal' switchable sections.
1874
1875    Here we set a relatively arbitrary value for the size of an object to trigger
1876    zerofill when section anchors are enabled (anything bigger than a page for
1877    current Darwin implementations).  FIXME: there ought to be some objective way
1878    to make this choice.
1879
1880    When section anchor are off this is ignored anyway.  */
1881
1882 #define BYTES_ZFILL 4096
1883
1884 /* Emit a chunk of data for items coalesced by the linker.  */
1885 static void
1886 darwin_emit_weak_or_comdat (FILE *fp, tree decl, const char *name,
1887                                   unsigned HOST_WIDE_INT size, 
1888                                   unsigned int align)
1889 {
1890   /* Since the sections used here are coalesed, they will not be eligible
1891      for section anchors, and therefore we don't need to break that out.  */
1892  if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1893     switch_to_section (darwin_sections[const_data_coal_section]);
1894   else
1895     switch_to_section (darwin_sections[data_coal_section]);
1896
1897   /* To be consistent, we'll allow darwin_asm_declare_object_name to assemble
1898      the align info for zero-sized items... but do it here otherwise.  */
1899   if (size && align)
1900     fprintf (fp, "\t.align\t%d\n", floor_log2 (align / BITS_PER_UNIT));
1901
1902   if (TREE_PUBLIC (decl))
1903     darwin_globalize_label (fp, name);
1904
1905   /* ... and we let it deal with outputting one byte of zero for them too.  */ 
1906   darwin_asm_declare_object_name (fp, name, decl);
1907   if (size)
1908     assemble_zeros (size);
1909 }
1910
1911 /* This routine emits 'local' storage:
1912
1913    When Section Anchors are off this routine emits .zerofill commands in 
1914    sections named for their alignment.
1915
1916    When Section Anchors are on, smaller (non-zero-sized) items are placed in
1917    the .static_data section so that the section anchoring system can see them.
1918    Larger items are still placed in .zerofill sections, addressing PR33210.
1919    The routine has no checking - it is all assumed to be done by the caller.
1920 */
1921 static void
1922 darwin_emit_local_bss (FILE *fp, tree decl, const char *name, 
1923                         unsigned HOST_WIDE_INT size, 
1924                         unsigned int l2align)
1925 {
1926    /* FIXME: We have a fudge to make this work with Java even when the target does
1927    not use sections anchors -- Java seems to need at least one small item in a
1928    non-zerofill segment.   */
1929    if ((DARWIN_SECTION_ANCHORS && flag_section_anchors && size < BYTES_ZFILL)
1930        || (size && size <= 2))
1931     {
1932       /* Put smaller objects in _static_data, where the section anchors system
1933          can get them.
1934          However, if they are zero-sized punt them to yet a different section
1935          (that is not allowed to participate in anchoring).  */
1936       if (!size)
1937         {
1938           fputs ("\t.section\t__DATA,__zobj_bss\n", fp);
1939           in_section = darwin_sections[zobj_bss_section];
1940           size = 1;
1941         }
1942       else
1943         {
1944           fputs ("\t.static_data\n", fp);
1945           in_section = darwin_sections[static_data_section];
1946         }
1947
1948       if (l2align)
1949         fprintf (fp, "\t.align\t%u\n", l2align);
1950
1951       assemble_name (fp, name);        
1952       fprintf (fp, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
1953     }
1954   else 
1955     {
1956       /* When we are on a non-section anchor target, we can get zero-sized
1957          items here.  However, all we need to do is to bump them to one byte
1958          and the section alignment will take care of the rest.  */
1959       char secnam[64];
1960       unsigned int flags ;
1961       snprintf (secnam, 64, "__DATA,__%sbss%u", ((size)?"":"zo_"), 
1962                                                 (unsigned) l2align);
1963       /* We can't anchor (yet, if ever) in zerofill sections, because we can't
1964          switch to them and emit a label.  */
1965       flags = SECTION_BSS|SECTION_WRITE|SECTION_NO_ANCHOR;
1966       in_section = get_section (secnam, flags, NULL);
1967       fprintf (fp, "\t.zerofill %s,", secnam);
1968       assemble_name (fp, name);
1969       if (!size)
1970         size = 1;
1971
1972       if (l2align)
1973         fprintf (fp, ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",
1974                  size, (unsigned) l2align);
1975       else
1976         fprintf (fp, ","HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
1977     }
1978
1979   (*targetm.encode_section_info) (decl, DECL_RTL (decl), false);
1980   /* This is defined as a file-scope var, so we know to notify machopic.  */
1981   machopic_define_symbol (DECL_RTL (decl));
1982 }
1983
1984 /* Emit a chunk of common.  */
1985 static void
1986 darwin_emit_common (FILE *fp, const char *name,
1987                     unsigned HOST_WIDE_INT size, unsigned int align) 
1988 {
1989   unsigned HOST_WIDE_INT rounded;
1990   unsigned int l2align;
1991
1992   /* Earlier systems complain if the alignment exceeds the page size. 
1993      The magic number is 4096 * 8 - hard-coded for legacy systems.  */
1994   if (!emit_aligned_common && (align > 32768UL))
1995     align = 4096UL; /* In units.  */
1996   else
1997     align /= BITS_PER_UNIT;
1998
1999   /* Make sure we have a meaningful align.  */
2000   if (!align)
2001     align = 1;
2002
2003   /* For earlier toolchains, we need to emit the var as a rounded size to 
2004      tell ld the alignment.  */
2005   if (size < align) 
2006     rounded = align;
2007   else
2008     rounded = (size + (align-1)) & ~(align-1);
2009
2010   l2align = floor_log2 (align);
2011   gcc_assert (l2align <= L2_MAX_OFILE_ALIGNMENT);
2012
2013   in_section = comm_section;
2014   /* We mustn't allow multiple public symbols to share an address when using
2015      the normal OSX toolchain.  */
2016   if (!size)
2017     {
2018       /* Put at least one byte.  */
2019       size = 1;
2020       /* This section can no longer participate in section anchoring.  */
2021       comm_section->common.flags |= SECTION_NO_ANCHOR;
2022     }
2023
2024   fputs ("\t.comm\t", fp);
2025   assemble_name (fp, name);
2026   fprintf (fp, "," HOST_WIDE_INT_PRINT_UNSIGNED, 
2027            emit_aligned_common?size:rounded);
2028   if (l2align && emit_aligned_common)
2029     fprintf (fp, ",%u", l2align);
2030   fputs ("\n", fp);
2031 }
2032
2033 /* Output a var which is all zero - into aligned BSS sections, common, lcomm
2034    or coalescable data sections (for weak or comdat) as appropriate.  */
2035
2036 void
2037 darwin_output_aligned_bss (FILE *fp, tree decl, const char *name,
2038                           unsigned HOST_WIDE_INT size, unsigned int align)
2039 {
2040   unsigned int l2align;
2041   bool one, pub, weak;
2042
2043   pub = TREE_PUBLIC (decl);
2044   one = DECL_ONE_ONLY (decl);
2045   weak = (DECL_P (decl)
2046           && DECL_WEAK (decl)
2047           && !lookup_attribute ("weak_import", 
2048                                  DECL_ATTRIBUTES (decl)));
2049
2050 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2051 fprintf (fp, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d"
2052              " pub %d weak %d one %d init %lx\n",
2053         name, (long long)size, (int)align, TREE_READONLY (decl), 
2054         TREE_CONSTANT (decl), TREE_STATIC (decl), DECL_COMMON (decl),
2055         pub, weak, one, (unsigned long)DECL_INITIAL (decl)); 
2056 #endif
2057
2058   /* Check that any initializer is valid.  */
2059   gcc_assert ((DECL_INITIAL (decl) == NULL) 
2060                || (DECL_INITIAL (decl) == error_mark_node) 
2061                || initializer_zerop (DECL_INITIAL (decl)));
2062
2063   gcc_assert (DECL_SECTION_NAME (decl) == NULL);
2064   gcc_assert (!DECL_COMMON (decl));
2065
2066   /*  Pick up the correct alignment.  */
2067   if (!size || !align)
2068     align = DECL_ALIGN (decl);
2069
2070   l2align = floor_log2 (align / BITS_PER_UNIT);
2071   gcc_assert (l2align <= L2_MAX_OFILE_ALIGNMENT);
2072   
2073   last_assemble_variable_decl = decl;
2074
2075   /* We would rather not have to check this here - but it seems that we might
2076      be passed a decl that should be in coalesced space.  */
2077   if (one || weak)
2078     {
2079       /* Weak or COMDAT objects are put in mergable sections.  */
2080       darwin_emit_weak_or_comdat (fp, decl, name, size, 
2081                                         DECL_ALIGN (decl));
2082       return;
2083     } 
2084
2085   /* If this is not public, then emit according to local rules.  */
2086   if (!pub)
2087     {
2088       darwin_emit_local_bss (fp, decl, name, size, l2align);    
2089       return;
2090     }
2091
2092   /* So we have a public symbol (small item fudge for Java, see above).  */
2093   if ((DARWIN_SECTION_ANCHORS && flag_section_anchors && size < BYTES_ZFILL) 
2094        || (size && size <= 2))
2095     {
2096       /* Put smaller objects in data, where the section anchors system can get
2097          them.  However, if they are zero-sized punt them to yet a different 
2098          section (that is not allowed to participate in anchoring).  */
2099       if (!size)
2100         {
2101           fputs ("\t.section\t__DATA,__zobj_data\n", fp);
2102           in_section = darwin_sections[zobj_data_section];
2103           size = 1;
2104         }
2105       else
2106         {
2107           fputs ("\t.data\n", fp);
2108           in_section = data_section;
2109         }
2110
2111       if (l2align)
2112         fprintf (fp, "\t.align\t%u\n", l2align);
2113
2114       assemble_name (fp, name);
2115       fprintf (fp, ":\n\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
2116     }
2117   else 
2118     {
2119       char secnam[64];
2120       unsigned int flags ;
2121       /* When we are on a non-section anchor target, we can get zero-sized
2122          items here.  However, all we need to do is to bump them to one byte
2123          and the section alignment will take care of the rest.  */
2124       snprintf (secnam, 64, "__DATA,__%spu_bss%u", ((size)?"":"zo_"), l2align);
2125
2126       /* We can't anchor in zerofill sections, because we can't switch
2127          to them and emit a label.  */
2128       flags = SECTION_BSS|SECTION_WRITE|SECTION_NO_ANCHOR;
2129       in_section = get_section (secnam, flags, NULL);
2130       fprintf (fp, "\t.zerofill %s,", secnam);
2131       assemble_name (fp, name);
2132       if (!size)
2133         size = 1;
2134
2135       if (l2align)
2136         fprintf (fp, ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", size, l2align);
2137       else
2138         fprintf (fp, ","HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
2139     }
2140   (* targetm.encode_section_info) (decl, DECL_RTL (decl), false);
2141 }
2142
2143 /* Output a chunk of common, with alignment specified (where the target
2144    supports this).  */
2145 void
2146 darwin_asm_output_aligned_decl_common (FILE *fp, tree decl, const char *name,
2147                                        unsigned HOST_WIDE_INT size, 
2148                                        unsigned int align)
2149 {
2150   unsigned int l2align;
2151   bool one, weak;
2152   /* No corresponding var.  */
2153   if (decl==NULL)
2154     {
2155 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2156 fprintf (fp, "# adcom: %s (%d,%d) decl=0x0\n", name, (int)size, (int)align); 
2157 #endif
2158       darwin_emit_common (fp, name, size, align);
2159       return;
2160     }
2161
2162   one = DECL_ONE_ONLY (decl);
2163   weak = (DECL_P (decl)
2164           && DECL_WEAK (decl)
2165           && !lookup_attribute ("weak_import", 
2166                                  DECL_ATTRIBUTES (decl)));
2167
2168 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2169 fprintf (fp, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d"
2170              " weak %d one %d init %lx\n",
2171         name,  (long long)size, (int)align, TREE_READONLY (decl), 
2172         TREE_CONSTANT (decl), TREE_STATIC (decl), DECL_COMMON (decl),
2173         TREE_PUBLIC (decl), weak, one, (unsigned long)DECL_INITIAL (decl)); 
2174 #endif
2175
2176   /* We shouldn't be messing with this if the decl has a section name.  */
2177   gcc_assert (DECL_SECTION_NAME (decl) == NULL);
2178
2179   /* We would rather not have to check this here - but it seems that we might
2180      be passed a decl that should be in coalesced space.  */
2181   if (one || weak)
2182     {
2183       /* Weak or COMDAT objects are put in mergable sections.  */
2184       darwin_emit_weak_or_comdat (fp, decl, name, size, 
2185                                         DECL_ALIGN (decl));
2186       return;
2187     } 
2188
2189   /* We should only get here for DECL_COMMON, with a zero init (and, in 
2190      principle, only for public symbols too - although we deal with local
2191      ones below).  */
2192
2193   /* Check the initializer is OK.  */
2194   gcc_assert (DECL_COMMON (decl) 
2195               && ((DECL_INITIAL (decl) == NULL) 
2196                || (DECL_INITIAL (decl) == error_mark_node) 
2197                || initializer_zerop (DECL_INITIAL (decl))));
2198
2199   last_assemble_variable_decl = decl;
2200
2201   if (!size || !align) 
2202     align = DECL_ALIGN (decl);
2203
2204   l2align = floor_log2 (align / BITS_PER_UNIT);
2205   /* Check we aren't asking for more aligment than the platform allows.  */
2206   gcc_assert (l2align <= L2_MAX_OFILE_ALIGNMENT);
2207
2208   if (TREE_PUBLIC (decl) != 0)
2209     darwin_emit_common (fp, name, size, align);
2210   else
2211     darwin_emit_local_bss (fp, decl, name, size, l2align);      
2212 }
2213
2214 /* Output a chunk of BSS with alignment specfied.  */
2215 void
2216 darwin_asm_output_aligned_decl_local (FILE *fp, tree decl, const char *name, 
2217                                       unsigned HOST_WIDE_INT size, 
2218                                       unsigned int align)
2219 {
2220   unsigned long l2align;
2221   bool one, weak;
2222
2223   one = DECL_ONE_ONLY (decl);
2224   weak = (DECL_P (decl)
2225           && DECL_WEAK (decl)
2226           && !lookup_attribute ("weak_import", 
2227                                  DECL_ATTRIBUTES (decl)));
2228
2229 #ifdef DEBUG_DARWIN_MEM_ALLOCATORS
2230 fprintf (fp, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d"
2231              " weak %d init %lx\n",
2232         name, (long long)size, (int)align, TREE_READONLY (decl), 
2233         TREE_CONSTANT (decl), TREE_STATIC (decl), one, TREE_PUBLIC (decl),
2234         weak , (unsigned long)DECL_INITIAL (decl)); 
2235 #endif
2236
2237   /* We shouldn't be messing with this if the decl has a section name.  */
2238   gcc_assert (DECL_SECTION_NAME (decl) == NULL);
2239
2240   /* We would rather not have to check this here - but it seems that we might
2241      be passed a decl that should be in coalesced space.  */
2242   if (one || weak)
2243     {
2244       /* Weak or COMDAT objects are put in mergable sections.  */
2245       darwin_emit_weak_or_comdat (fp, decl, name, size, 
2246                                         DECL_ALIGN (decl));
2247       return;
2248     } 
2249
2250   /* .. and it should be suitable for placement in local mem.  */
2251   gcc_assert(!TREE_PUBLIC (decl) && !DECL_COMMON (decl));
2252   /* .. and any initializer must be all-zero.  */
2253   gcc_assert ((DECL_INITIAL (decl) == NULL) 
2254                || (DECL_INITIAL (decl) == error_mark_node) 
2255                || initializer_zerop (DECL_INITIAL (decl)));
2256
2257   last_assemble_variable_decl = decl;
2258
2259   if (!size || !align)
2260     align = DECL_ALIGN (decl);
2261
2262   l2align = floor_log2 (align / BITS_PER_UNIT);
2263   gcc_assert (l2align <= L2_MAX_OFILE_ALIGNMENT);
2264
2265   darwin_emit_local_bss (fp, decl, name, size, l2align);
2266 }
2267
2268 /* Emit an assembler directive to set visibility for a symbol.  The
2269    only supported visibilities are VISIBILITY_DEFAULT and
2270    VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
2271    extern".  There is no MACH-O equivalent of ELF's
2272    VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
2273
2274 void
2275 darwin_assemble_visibility (tree decl, int vis)
2276 {
2277   if (vis == VISIBILITY_DEFAULT)
2278     ;
2279   else if (vis == VISIBILITY_HIDDEN)
2280     {
2281       fputs ("\t.private_extern ", asm_out_file);
2282       assemble_name (asm_out_file,
2283                      (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
2284       fputs ("\n", asm_out_file);
2285     }
2286   else
2287     warning (OPT_Wattributes, "internal and protected visibility attributes "
2288              "not supported in this configuration; ignored");
2289 }
2290
2291 /* VEC Used by darwin_asm_dwarf_section.
2292    Maybe a hash tab would be better here - but the intention is that this is
2293    a very short list (fewer than 16 items) and each entry should (ideally, 
2294    eventually) only be presented once.
2295
2296    A structure to hold a dwarf debug section used entry.  */
2297
2298 typedef struct GTY(()) dwarf_sect_used_entry {
2299   const char *name;
2300   unsigned count;
2301 }
2302 dwarf_sect_used_entry;
2303
2304 DEF_VEC_O(dwarf_sect_used_entry);
2305 DEF_VEC_ALLOC_O(dwarf_sect_used_entry, gc);
2306
2307 /* A list of used __DWARF sections.  */
2308 static GTY (()) VEC (dwarf_sect_used_entry, gc) * dwarf_sect_names_table;
2309
2310 /* This is called when we are asked to assemble a named section and the 
2311    name begins with __DWARF,.  We keep a list of the section names (without
2312    the __DWARF, prefix) and use this to emit our required start label on the
2313    first switch to each section.  */
2314
2315 static void
2316 darwin_asm_dwarf_section (const char *name, unsigned int flags,
2317                           tree ARG_UNUSED (decl))
2318 {
2319   unsigned i;
2320   int namelen;
2321   const char * sname;
2322   dwarf_sect_used_entry *ref;
2323   bool found = false;
2324   gcc_assert ((flags & (SECTION_DEBUG | SECTION_NAMED))
2325                     == (SECTION_DEBUG | SECTION_NAMED));
2326   /* We know that the name starts with __DWARF,  */
2327   sname = name + 8;
2328   namelen = strchr (sname, ',') - sname;
2329   gcc_assert (namelen);
2330   if (dwarf_sect_names_table == NULL)
2331     dwarf_sect_names_table = VEC_alloc (dwarf_sect_used_entry, gc, 16);
2332   else
2333     for (i = 0; 
2334          VEC_iterate (dwarf_sect_used_entry, dwarf_sect_names_table, i, ref);
2335          i++)
2336       {
2337         if (!ref)
2338           break;
2339         if (!strcmp (ref->name, sname))
2340           {
2341             found = true;
2342             ref->count++;
2343             break;
2344           }
2345       }
2346
2347   fprintf (asm_out_file, "\t.section %s\n", name);
2348   if (!found)
2349     {
2350       dwarf_sect_used_entry e;
2351       fprintf (asm_out_file, "Lsection%.*s:\n", namelen, sname);
2352       e.count = 1;
2353       e.name = xstrdup (sname);
2354       VEC_safe_push (dwarf_sect_used_entry, gc, dwarf_sect_names_table, &e);
2355     }
2356 }
2357
2358 /* Output a difference of two labels that will be an assembly time
2359    constant if the two labels are local.  (.long lab1-lab2 will be
2360    very different if lab1 is at the boundary between two sections; it
2361    will be relocated according to the second section, not the first,
2362    so one ends up with a difference between labels in different
2363    sections, which is bad in the dwarf2 eh context for instance.)  */
2364
2365 static int darwin_dwarf_label_counter;
2366
2367 void
2368 darwin_asm_output_dwarf_delta (FILE *file, int size,
2369                                const char *lab1, const char *lab2)
2370 {
2371   int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
2372                      && lab2[0] == '*' && lab2[1] == 'L');
2373   const char *directive = (size == 8 ? ".quad" : ".long");
2374
2375   if (islocaldiff)
2376     fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
2377   else
2378     fprintf (file, "\t%s\t", directive);
2379
2380   assemble_name_raw (file, lab1);
2381   fprintf (file, "-");
2382   assemble_name_raw (file, lab2);
2383   if (islocaldiff)
2384     fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
2385 }
2386
2387 /* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
2388    offsets are not represented using relocs in .o files; either the
2389    section never leaves the .o file, or the linker or other tool is
2390    responsible for parsing the DWARF and updating the offsets.  */
2391
2392 void
2393 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
2394                                 section *base)
2395 {
2396   char sname[64];
2397   int namelen;
2398
2399   gcc_assert (base->common.flags & SECTION_NAMED);
2400   gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
2401   gcc_assert (strchr (base->named.name + 8, ','));
2402
2403   namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
2404   sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
2405   darwin_asm_output_dwarf_delta (file, size, lab, sname);
2406 }
2407
2408 /* Called from the within the TARGET_ASM_FILE_START for each target. 
2409   Initialize the stuff we need for LTO long section names support.  */
2410
2411 void
2412 darwin_file_start (void)
2413 {
2414   /* We fill this obstack with the complete section text for the lto section
2415      names to write in darwin_file_end.  */
2416   obstack_init (&lto_section_names_obstack);
2417   lto_section_names_offset = 0;
2418 }
2419
2420 /* Called for the TARGET_ASM_FILE_END hook.
2421    Emit the mach-o pic indirection data, the lto data and, finally a flag
2422    to tell the linker that it can break the file object into sections and
2423    move those around for efficiency.  */
2424
2425 void
2426 darwin_file_end (void)
2427 {
2428   const char *lto_section_names;
2429
2430   machopic_finish (asm_out_file);
2431   if (strcmp (lang_hooks.name, "GNU C++") == 0)
2432     {
2433       switch_to_section (darwin_sections[constructor_section]);
2434       switch_to_section (darwin_sections[destructor_section]);
2435       ASM_OUTPUT_ALIGN (asm_out_file, 1);
2436     }
2437
2438   /* If there was LTO assembler output, append it to asm_out_file.  */
2439   if (lto_asm_out_name)
2440     {
2441       int n;
2442       char *buf, *lto_asm_txt;
2443
2444       /* Shouldn't be here if we failed to switch back.  */
2445       gcc_assert (! saved_asm_out_file);
2446
2447       lto_asm_out_file = fopen (lto_asm_out_name, "r");
2448       if (lto_asm_out_file == NULL)
2449         fatal_error ("failed to open temporary file %s with LTO output",
2450                      lto_asm_out_name);
2451       fseek (lto_asm_out_file, 0, SEEK_END);
2452       n = ftell (lto_asm_out_file);
2453       if (n > 0)
2454         {
2455           fseek (lto_asm_out_file, 0, SEEK_SET);
2456           lto_asm_txt = buf = (char *) xmalloc (n + 1);
2457           while (fgets (lto_asm_txt, n, lto_asm_out_file))
2458             fputs (lto_asm_txt, asm_out_file);
2459         }
2460
2461       /* Remove the temporary file.  */
2462       fclose (lto_asm_out_file);
2463       unlink_if_ordinary (lto_asm_out_name);
2464       free (lto_asm_out_name);
2465     }
2466
2467   /* Finish the LTO section names obstack.  Don't output anything if
2468      there are no recorded section names.  */
2469   obstack_1grow (&lto_section_names_obstack, '\0');
2470   lto_section_names = XOBFINISH (&lto_section_names_obstack, const char *);
2471   if (strlen (lto_section_names) > 0)
2472     {
2473       fprintf (asm_out_file,
2474                "\t.section %s,%s,regular,debug\n",
2475                LTO_SEGMENT_NAME, LTO_NAMES_SECTION);
2476       fprintf (asm_out_file,
2477                "\t# Section names in %s are offsets into this table\n",
2478                LTO_SEGMENT_NAME);
2479       fprintf (asm_out_file, "%s\n", lto_section_names);
2480     }
2481   obstack_free (&lto_section_names_obstack, NULL);
2482
2483   /* If we have section anchors, then we must prevent the linker from
2484      re-arranging data.  */
2485   if (!DARWIN_SECTION_ANCHORS || !flag_section_anchors)
2486     fprintf (asm_out_file, "\t.subsections_via_symbols\n");
2487 }
2488
2489 /* TODO: Add a language hook for identifying if a decl is a vtable.  */
2490 #define DARWIN_VTABLE_P(DECL) 0
2491
2492 /* Cross-module name binding.  Darwin does not support overriding
2493    functions at dynamic-link time, except for vtables in kexts.  */
2494
2495 bool
2496 darwin_binds_local_p (const_tree decl)
2497 {
2498   return default_binds_local_p_1 (decl,
2499                                   TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
2500 }
2501
2502 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
2503    anchor relative to ".", the current section position.  We cannot use
2504    the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
2505 void
2506 darwin_asm_output_anchor (rtx symbol)
2507 {
2508   fprintf (asm_out_file, "\t.set\t");
2509   assemble_name (asm_out_file, XSTR (symbol, 0));
2510   fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
2511            SYMBOL_REF_BLOCK_OFFSET (symbol));
2512 }
2513
2514 /* Disable section anchoring on any section containing a zero-sized 
2515    object.  */
2516 bool
2517 darwin_use_anchors_for_symbol_p (const_rtx symbol)
2518 {
2519   if (DARWIN_SECTION_ANCHORS && flag_section_anchors) 
2520     {
2521       section *sect;
2522       /* If the section contains a zero-sized object it's ineligible.  */
2523       sect = SYMBOL_REF_BLOCK (symbol)->sect;
2524       /* This should have the effect of disabling anchors for vars that follow
2525          any zero-sized one, in a given section.  */     
2526       if (sect->common.flags & SECTION_NO_ANCHOR)
2527         return false;
2528
2529         /* Also check the normal reasons for suppressing.  */
2530         return default_use_anchors_for_symbol_p (symbol);
2531     }
2532   else
2533     return false;
2534 }
2535
2536 /* Set the darwin specific attributes on TYPE.  */
2537 void
2538 darwin_set_default_type_attributes (tree type)
2539 {
2540   if (darwin_ms_struct
2541       && TREE_CODE (type) == RECORD_TYPE)
2542     TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
2543                                         NULL_TREE,
2544                                         TYPE_ATTRIBUTES (type));
2545 }
2546
2547 /* True, iff we're generating code for loadable kernel extensions.  */
2548
2549 bool
2550 darwin_kextabi_p (void) {
2551   return flag_apple_kext;
2552 }
2553
2554 void
2555 darwin_override_options (void)
2556 {
2557   bool darwin9plus = (darwin_macosx_version_min
2558                       && strverscmp (darwin_macosx_version_min, "10.5") >= 0);
2559
2560   /* Don't emit DWARF3/4 unless specifically selected.  This is a 
2561      workaround for tool bugs.  */
2562   if (!global_options_set.x_dwarf_strict) 
2563     dwarf_strict = 1;
2564
2565   /* Disable -freorder-blocks-and-partition for darwin_emit_unwind_label.  */
2566   if (flag_reorder_blocks_and_partition 
2567       && (targetm.asm_out.emit_unwind_label == darwin_emit_unwind_label))
2568     {
2569       inform (input_location,
2570               "-freorder-blocks-and-partition does not work with exceptions "
2571               "on this architecture");
2572       flag_reorder_blocks_and_partition = 0;
2573       flag_reorder_blocks = 1;
2574     }
2575
2576   if (flag_mkernel || flag_apple_kext)
2577     {
2578       /* -mkernel implies -fapple-kext for C++ */
2579       if (strcmp (lang_hooks.name, "GNU C++") == 0)
2580         flag_apple_kext = 1;
2581
2582       flag_no_common = 1;
2583
2584       /* No EH in kexts.  */
2585       flag_exceptions = 0;
2586       /* No -fnon-call-exceptions data in kexts.  */
2587       flag_non_call_exceptions = 0;
2588       /* so no tables either.. */
2589       flag_unwind_tables = 0;
2590       flag_asynchronous_unwind_tables = 0;
2591       /* We still need to emit branch islands for kernel context.  */
2592       darwin_emit_branch_islands = true;
2593     }
2594
2595   if (flag_var_tracking
2596       && darwin9plus
2597       && debug_info_level >= DINFO_LEVEL_NORMAL
2598       && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
2599     flag_var_tracking_uninit = 1;
2600
2601   if (MACHO_DYNAMIC_NO_PIC_P)
2602     {
2603       if (flag_pic)
2604         warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
2605       flag_pic = 0;
2606     }
2607   else if (flag_pic == 1)
2608     {
2609       /* Darwin's -fpic is -fPIC.  */
2610       flag_pic = 2;
2611     }
2612
2613   /* It is assumed that branch island stubs are needed for earlier systems.  */
2614   if (!darwin9plus)
2615     darwin_emit_branch_islands = true;
2616   else
2617     emit_aligned_common = true; /* Later systems can support aligned common.  */
2618
2619   /* The c_dialect...() macros are not available to us here.  */
2620   darwin_running_cxx = (strstr (lang_hooks.name, "C++") != 0);
2621 }
2622
2623 /* Add $LDBL128 suffix to long double builtins.  */
2624
2625 static void
2626 darwin_patch_builtin (int fncode)
2627 {
2628   tree fn = built_in_decls[fncode];
2629   tree sym;
2630   char *newname;
2631
2632   if (!fn)
2633     return;
2634
2635   sym = DECL_ASSEMBLER_NAME (fn);
2636   newname = ACONCAT (("_", IDENTIFIER_POINTER (sym), "$LDBL128", NULL));
2637
2638   set_user_assembler_name (fn, newname);
2639
2640   fn = implicit_built_in_decls[fncode];
2641   if (fn)
2642     set_user_assembler_name (fn, newname);
2643 }
2644
2645 void
2646 darwin_patch_builtins (void)
2647 {
2648   if (LONG_DOUBLE_TYPE_SIZE != 128)
2649     return;
2650
2651 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
2652 #define PATCH_BUILTIN_NO64(fncode)              \
2653   if (!TARGET_64BIT)                            \
2654     darwin_patch_builtin (fncode);
2655 #define PATCH_BUILTIN_VARIADIC(fncode)                            \
2656   if (!TARGET_64BIT                                               \
2657       && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
2658     darwin_patch_builtin (fncode);
2659 #include "darwin-ppc-ldouble-patch.def"
2660 #undef PATCH_BUILTIN
2661 #undef PATCH_BUILTIN_NO64
2662 #undef PATCH_BUILTIN_VARIADIC
2663 }
2664
2665 /*  CFStrings implementation.  */
2666 static GTY(()) tree cfstring_class_reference = NULL_TREE;
2667 static GTY(()) tree cfstring_type_node = NULL_TREE;
2668 static GTY(()) tree ccfstring_type_node = NULL_TREE;
2669 static GTY(()) tree pccfstring_type_node = NULL_TREE;
2670 static GTY(()) tree pcint_type_node = NULL_TREE;
2671 static GTY(()) tree pcchar_type_node = NULL_TREE;
2672
2673 static enum built_in_function DARWIN_BUILTIN_CFSTRINGMAKECONSTANTSTRING;
2674
2675 /* Store all constructed constant CFStrings in a hash table so that
2676    they get uniqued properly.  */
2677
2678 typedef struct GTY (()) cfstring_descriptor {
2679   /* The string literal.  */
2680   tree literal;
2681   /* The resulting constant CFString.  */
2682   tree constructor;
2683 } cfstring_descriptor;
2684
2685 static GTY ((param_is (struct cfstring_descriptor))) htab_t cfstring_htab;
2686
2687 static hashval_t cfstring_hash (const void *);
2688 static int cfstring_eq (const void *, const void *);
2689
2690 static tree
2691 add_builtin_field_decl (tree type, const char *name, tree **chain)
2692 {
2693   tree field = build_decl (BUILTINS_LOCATION, FIELD_DECL, 
2694                             get_identifier (name), type);
2695
2696   if (*chain != NULL)
2697     **chain = field;
2698   *chain = &DECL_CHAIN (field);
2699
2700   return field;
2701 }
2702
2703 void
2704 darwin_init_cfstring_builtins (unsigned first_avail)
2705 {
2706   tree cfsfun, fields, pccfstring_ftype_pcchar;
2707   tree *chain = NULL;
2708
2709   DARWIN_BUILTIN_CFSTRINGMAKECONSTANTSTRING = 
2710                         (enum built_in_function) first_avail;
2711   
2712   /* struct __builtin_CFString {
2713        const int *isa;          (will point at
2714        int flags;                __CFConstantStringClassReference)
2715        const char *str;
2716        long length;
2717      };  */
2718
2719   pcint_type_node = build_pointer_type 
2720                    (build_qualified_type (integer_type_node, TYPE_QUAL_CONST));
2721
2722   pcchar_type_node = build_pointer_type 
2723                    (build_qualified_type (char_type_node, TYPE_QUAL_CONST));
2724
2725   cfstring_type_node = (*lang_hooks.types.make_type) (RECORD_TYPE);
2726
2727   /* Have to build backwards for finish struct.  */
2728   fields = add_builtin_field_decl (long_integer_type_node, "length", &chain);
2729   add_builtin_field_decl (pcchar_type_node, "str", &chain);
2730   add_builtin_field_decl (integer_type_node, "flags", &chain);
2731   add_builtin_field_decl (pcint_type_node, "isa", &chain);
2732   finish_builtin_struct (cfstring_type_node, "__builtin_CFString",
2733                          fields, NULL_TREE);
2734
2735   /* const struct __builtin_CFstring *
2736      __builtin___CFStringMakeConstantString (const char *); */
2737
2738   ccfstring_type_node = build_qualified_type 
2739                         (cfstring_type_node, TYPE_QUAL_CONST);
2740   pccfstring_type_node = build_pointer_type (ccfstring_type_node);
2741   pccfstring_ftype_pcchar = build_function_type_list 
2742                         (pccfstring_type_node, pcchar_type_node, NULL_TREE);
2743
2744   cfsfun  = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, 
2745                         get_identifier ("__builtin___CFStringMakeConstantString"),
2746                         pccfstring_ftype_pcchar);
2747
2748   TREE_PUBLIC (cfsfun) = 1;
2749   DECL_EXTERNAL (cfsfun) = 1;
2750   DECL_ARTIFICIAL (cfsfun) = 1;
2751   /* Make a lang-specific section - dup_lang_specific_decl makes a new node
2752      in place of the existing, which may be NULL.  */
2753   DECL_LANG_SPECIFIC (cfsfun) = NULL;
2754   (*lang_hooks.dup_lang_specific_decl) (cfsfun);
2755   DECL_BUILT_IN_CLASS (cfsfun) = BUILT_IN_MD;
2756   DECL_FUNCTION_CODE (cfsfun) = DARWIN_BUILTIN_CFSTRINGMAKECONSTANTSTRING;
2757   lang_hooks.builtin_function (cfsfun);
2758
2759   /* extern int __CFConstantStringClassReference[];  */
2760   cfstring_class_reference = build_decl (BUILTINS_LOCATION, VAR_DECL,
2761                  get_identifier ("__CFConstantStringClassReference"),
2762                  build_array_type (integer_type_node, NULL_TREE));
2763
2764   TREE_PUBLIC (cfstring_class_reference) = 1;
2765   DECL_ARTIFICIAL (cfstring_class_reference) = 1;
2766   (*lang_hooks.decls.pushdecl) (cfstring_class_reference);
2767   DECL_EXTERNAL (cfstring_class_reference) = 1;
2768   rest_of_decl_compilation (cfstring_class_reference, 0, 0);
2769   
2770   /* Initialize the hash table used to hold the constant CFString objects.  */
2771   cfstring_htab = htab_create_ggc (31, cfstring_hash, cfstring_eq, NULL);
2772 }
2773
2774 tree
2775 darwin_fold_builtin (tree fndecl, int n_args, tree *argp, 
2776                      bool ARG_UNUSED (ignore))
2777 {
2778   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
2779   
2780   if (fcode == DARWIN_BUILTIN_CFSTRINGMAKECONSTANTSTRING)
2781     {
2782       if (!darwin_constant_cfstrings)
2783         {
2784           error ("built-in function %qD requires the" 
2785                  " %<-mconstant-cfstrings%> flag", fndecl);
2786           return error_mark_node;
2787         }
2788
2789       if (n_args != 1)
2790         {
2791           error ("built-in function %qD takes one argument only", fndecl);
2792           return error_mark_node;
2793         }
2794
2795       return darwin_build_constant_cfstring (*argp);
2796     }
2797
2798   return NULL_TREE;
2799 }
2800
2801 static hashval_t
2802 cfstring_hash (const void *ptr)
2803 {
2804   tree str = ((const struct cfstring_descriptor *)ptr)->literal;
2805   const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
2806   int i, len = TREE_STRING_LENGTH (str);
2807   hashval_t h = len;
2808
2809   for (i = 0; i < len; i++)
2810     h = ((h * 613) + p[i]);
2811
2812   return h;
2813 }
2814
2815 static int
2816 cfstring_eq (const void *ptr1, const void *ptr2)
2817 {
2818   tree str1 = ((const struct cfstring_descriptor *)ptr1)->literal;
2819   tree str2 = ((const struct cfstring_descriptor *)ptr2)->literal;
2820   int len1 = TREE_STRING_LENGTH (str1);
2821
2822   return (len1 == TREE_STRING_LENGTH (str2)
2823           && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
2824                       len1));
2825 }
2826
2827 tree
2828 darwin_build_constant_cfstring (tree str)
2829 {
2830   struct cfstring_descriptor *desc, key;
2831   void **loc;
2832   tree addr;
2833
2834   if (!str)
2835     {
2836       error ("CFString literal is missing");
2837       return error_mark_node;
2838     }
2839
2840   STRIP_NOPS (str);
2841
2842   if (TREE_CODE (str) == ADDR_EXPR)
2843     str = TREE_OPERAND (str, 0);
2844
2845   if (TREE_CODE (str) != STRING_CST)
2846     {
2847       error ("CFString literal expression is not a string constant");
2848       return error_mark_node;
2849     }
2850
2851   /* Perhaps we already constructed a constant CFString just like this one? */
2852   key.literal = str;
2853   loc = htab_find_slot (cfstring_htab, &key, INSERT);
2854   desc = (struct cfstring_descriptor *) *loc;
2855
2856   if (!desc)
2857     {
2858       tree var, constructor, field;
2859       VEC(constructor_elt,gc) *v = NULL;
2860       int length = TREE_STRING_LENGTH (str) - 1;
2861
2862       if (darwin_warn_nonportable_cfstrings)
2863         {
2864           const char *s = TREE_STRING_POINTER (str);
2865           int l = 0;
2866
2867           for (l = 0; l < length; l++)
2868             if (!s[l] || !isascii (s[l]))
2869               {
2870                 warning (darwin_warn_nonportable_cfstrings, "%s in CFString literal",
2871                          s[l] ? "non-ASCII character" : "embedded NUL");
2872                 break;
2873               }
2874         }
2875
2876       *loc = desc = ggc_alloc_cleared_cfstring_descriptor ();
2877       desc->literal = str;
2878
2879       /* isa *. */
2880       field = TYPE_FIELDS (ccfstring_type_node);
2881       CONSTRUCTOR_APPEND_ELT(v, NULL_TREE, 
2882                              build1 (ADDR_EXPR,  TREE_TYPE (field),  
2883                                      cfstring_class_reference));
2884       /* flags */
2885       field = DECL_CHAIN (field);
2886       CONSTRUCTOR_APPEND_ELT(v, NULL_TREE, 
2887                              build_int_cst (TREE_TYPE (field), 0x000007c8));
2888       /* string *. */
2889       field = DECL_CHAIN (field);
2890       CONSTRUCTOR_APPEND_ELT(v, NULL_TREE,
2891                              build1 (ADDR_EXPR, TREE_TYPE (field), str));
2892       /* length */
2893       field = DECL_CHAIN (field);
2894       CONSTRUCTOR_APPEND_ELT(v, NULL_TREE,
2895                              build_int_cst (TREE_TYPE (field), length));
2896
2897       constructor = build_constructor (ccfstring_type_node, v);
2898       TREE_READONLY (constructor) = 1;
2899       TREE_CONSTANT (constructor) = 1;
2900       TREE_STATIC (constructor) = 1;
2901
2902       /* Fromage: The C++ flavor of 'build_unary_op' expects constructor nodes
2903          to have the TREE_HAS_CONSTRUCTOR (...) bit set.  However, this file is
2904          being built without any knowledge of C++ tree accessors; hence, we shall
2905          use the generic accessor that TREE_HAS_CONSTRUCTOR actually maps to!  */
2906       if (darwin_running_cxx)
2907         TREE_LANG_FLAG_4 (constructor) = 1;  /* TREE_HAS_CONSTRUCTOR  */
2908
2909       /* Create an anonymous global variable for this CFString.  */
2910       var = build_decl (input_location, CONST_DECL, 
2911                         NULL, TREE_TYPE (constructor));
2912       DECL_ARTIFICIAL (var) = 1;
2913       TREE_STATIC (var) = 1;
2914       DECL_INITIAL (var) = constructor;
2915       /* FIXME: This should use a translation_unit_decl to indicate file scope.  */
2916       DECL_CONTEXT (var) = NULL_TREE;
2917       desc->constructor = var;
2918     }
2919
2920   addr = build1 (ADDR_EXPR, pccfstring_type_node, desc->constructor);
2921   TREE_CONSTANT (addr) = 1;
2922
2923   return addr;
2924 }
2925
2926 bool
2927 darwin_cfstring_p (tree str)
2928 {
2929   struct cfstring_descriptor key;
2930   void **loc;
2931
2932   if (!str)
2933     return false;
2934
2935   STRIP_NOPS (str);
2936
2937   if (TREE_CODE (str) == ADDR_EXPR)
2938     str = TREE_OPERAND (str, 0);
2939
2940   if (TREE_CODE (str) != STRING_CST)
2941     return false;
2942
2943   key.literal = str;
2944   loc = htab_find_slot (cfstring_htab, &key, NO_INSERT);
2945   
2946   if (loc)
2947     return true;
2948
2949   return false;
2950 }
2951
2952 void
2953 darwin_enter_string_into_cfstring_table (tree str)
2954 {
2955   struct cfstring_descriptor key;
2956   void **loc;
2957
2958   key.literal = str;
2959   loc = htab_find_slot (cfstring_htab, &key, INSERT);
2960
2961   if (!*loc)
2962     {
2963       *loc = ggc_alloc_cleared_cfstring_descriptor ();
2964       ((struct cfstring_descriptor *)*loc)->literal = str;
2965     }
2966 }
2967
2968 /* Choose named function section based on its frequency.  */
2969
2970 section *
2971 darwin_function_section (tree decl, enum node_frequency freq,
2972                           bool startup, bool exit)
2973 {
2974   /* Startup code should go to startup subsection unless it is
2975      unlikely executed (this happens especially with function splitting
2976      where we can split away unnecesary parts of static constructors.  */
2977   if (startup && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
2978     return get_named_text_section
2979              (decl, "__TEXT,__startup,regular,pure_instructions", "_startup");
2980
2981   /* Similarly for exit.  */
2982   if (exit && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
2983     return get_named_text_section (decl,
2984                                    "__TEXT,__exit,regular,pure_instructions",
2985                                    "_exit");
2986
2987   /* Group cold functions together, similarly for hot code.  */
2988   switch (freq)
2989     {
2990       case NODE_FREQUENCY_UNLIKELY_EXECUTED:
2991         return get_named_text_section
2992                  (decl,
2993                   "__TEXT,__unlikely,regular,pure_instructions", "_unlikely");
2994       case NODE_FREQUENCY_HOT:
2995         return get_named_text_section
2996                  (decl, "__TEXT,__hot,regular,pure_instructions", "_hot");
2997       default:
2998         return NULL;
2999     }
3000 }
3001
3002 #include "gt-darwin.h"