OSDN Git Service

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