OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / config / darwin.c
1 /* Functions for generic Darwin as target machine for GNU C compiler.
2    Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Apple Computer Inc.
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
34 #include "output.h"
35 #include "insn-attr.h"
36 #include "flags.h"
37 #include "tree.h"
38 #include "expr.h"
39 #include "reload.h"
40 #include "function.h"
41 #include "ggc.h"
42 #include "langhooks.h"
43 #include "target.h"
44 #include "tm_p.h"
45 #include "toplev.h"
46 #include "hashtab.h"
47 #include "df.h"
48 #include "debug.h"
49
50 /* Darwin supports a feature called fix-and-continue, which is used
51    for rapid turn around debugging.  When code is compiled with the
52    -mfix-and-continue flag, two changes are made to the generated code
53    that allow the system to do things that it would normally not be
54    able to do easily.  These changes allow gdb to load in
55    recompilation of a translation unit that has been changed into a
56    running program and replace existing functions and methods of that
57    translation unit with versions of those functions and methods
58    from the newly compiled translation unit.  The new functions access
59    the existing static symbols from the old translation unit, if the
60    symbol existed in the unit to be replaced, and from the new
61    translation unit, otherwise.
62
63    The changes are to insert 5 nops at the beginning of all functions
64    and to use indirection to get at static symbols.  The 5 nops
65    are required by consumers of the generated code.  Currently, gdb
66    uses this to patch in a jump to the overriding function, this
67    allows all uses of the old name to forward to the replacement,
68    including existing function pointers and virtual methods.  See
69    rs6000_emit_prologue for the code that handles the nop insertions.
70
71    The added indirection allows gdb to redirect accesses to static
72    symbols from the newly loaded translation unit to the existing
73    symbol, if any.  @code{static} symbols are special and are handled by
74    setting the second word in the .non_lazy_symbol_pointer data
75    structure to symbol.  See indirect_data for the code that handles
76    the extra indirection, and machopic_output_indirection and its use
77    of MACHO_SYMBOL_STATIC for the code that handles @code{static}
78    symbol indirection.  */
79
80 /* Section names.  */
81 section * darwin_sections[NUM_DARWIN_SECTIONS];
82
83 /* True if we're setting __attribute__ ((ms_struct)).  */
84 int darwin_ms_struct = false;
85
86 /* A get_unnamed_section callback used to switch to an ObjC section.
87    DIRECTIVE is as for output_section_asm_op.  */
88
89 static void
90 output_objc_section_asm_op (const void *directive)
91 {
92   static bool been_here = false;
93
94   if (! been_here)
95     {
96       static const enum darwin_section_enum tomark[] =
97         {
98           /* written, cold -> hot */
99           objc_cat_cls_meth_section,
100           objc_cat_inst_meth_section,
101           objc_string_object_section,
102           objc_constant_string_object_section,
103           objc_selector_refs_section,
104           objc_selector_fixup_section,
105           objc_cls_refs_section,
106           objc_class_section,
107           objc_meta_class_section,
108           /* shared, hot -> cold */
109           objc_cls_meth_section,
110           objc_inst_meth_section,
111           objc_protocol_section,
112           objc_class_names_section,
113           objc_meth_var_types_section,
114           objc_meth_var_names_section,
115           objc_category_section,
116           objc_class_vars_section,
117           objc_instance_vars_section,
118           objc_module_info_section,
119           objc_symbols_section
120         };
121       size_t i;
122
123       been_here = true;
124       for (i = 0; i < ARRAY_SIZE (tomark); i++)
125         switch_to_section (darwin_sections[tomark[i]]);
126     }
127   output_section_asm_op (directive);
128 }
129
130 /* Implement TARGET_ASM_INIT_SECTIONS.  */
131
132 void
133 darwin_init_sections (void)
134 {
135 #define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC)               \
136   darwin_sections[NAME] =                                       \
137     get_unnamed_section (FLAGS, (OBJC                           \
138                                  ? output_objc_section_asm_op   \
139                                  : output_section_asm_op),      \
140                          "\t" DIRECTIVE);
141 #include "config/darwin-sections.def"
142 #undef DEF_SECTION
143
144   readonly_data_section = darwin_sections[const_section];
145   exception_section = darwin_sections[darwin_exception_section];
146   eh_frame_section = darwin_sections[darwin_eh_frame_section];
147 }
148
149 int
150 name_needs_quotes (const char *name)
151 {
152   int c;
153   while ((c = *name++) != '\0')
154     if (! ISIDNUM (c) && c != '.' && c != '$')
155       return 1;
156   return 0;
157 }
158
159 /* Return true if SYM_REF can be used without an indirection.  */
160 static int
161 machopic_symbol_defined_p (rtx sym_ref)
162 {
163   if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
164     return true;
165
166   /* If a symbol references local and is not an extern to this
167      file, then the symbol might be able to declared as defined.  */
168   if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
169     {
170       /* If the symbol references a variable and the variable is a
171          common symbol, then this symbol is not defined.  */
172       if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
173         {
174           tree decl = SYMBOL_REF_DECL (sym_ref);
175           if (!decl)
176             return true;
177           if (DECL_COMMON (decl))
178             return false;
179         }
180       return true;
181     }
182   return false;
183 }
184
185 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
186    reference, which will not be changed.  */
187
188 enum machopic_addr_class
189 machopic_classify_symbol (rtx sym_ref)
190 {
191   bool function_p;
192
193   function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
194   if (machopic_symbol_defined_p (sym_ref))
195     return (function_p
196             ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
197   else
198     return (function_p
199             ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
200 }
201
202 #ifndef TARGET_FIX_AND_CONTINUE
203 #define TARGET_FIX_AND_CONTINUE 0
204 #endif
205
206 /* Indicate when fix-and-continue style code generation is being used
207    and when a reference to data should be indirected so that it can be
208    rebound in a new translation unit to reference the original instance
209    of that data.  Symbol names that are for code generation local to
210    the translation unit are bound to the new translation unit;
211    currently this means symbols that begin with L or _OBJC_;
212    otherwise, we indicate that an indirect reference should be made to
213    permit the runtime to rebind new instances of the translation unit
214    to the original instance of the data.  */
215
216 static int
217 indirect_data (rtx sym_ref)
218 {
219   int lprefix;
220   const char *name;
221
222   /* If we aren't generating fix-and-continue code, don't do anything
223      special.  */
224   if (TARGET_FIX_AND_CONTINUE == 0)
225     return 0;
226
227   /* Otherwise, all symbol except symbols that begin with L or _OBJC_
228      are indirected.  Symbols that begin with L and _OBJC_ are always
229      bound to the current translation unit as they are used for
230      generated local data of the translation unit.  */
231
232   name = XSTR (sym_ref, 0);
233
234   lprefix = (((name[0] == '*' || name[0] == '&')
235               && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
236              || (strncmp (name, "_OBJC_", 6) == 0));
237
238   return ! lprefix;
239 }
240
241
242 static int
243 machopic_data_defined_p (rtx sym_ref)
244 {
245   if (indirect_data (sym_ref))
246     return 0;
247
248   switch (machopic_classify_symbol (sym_ref))
249     {
250     case MACHOPIC_DEFINED_DATA:
251     case MACHOPIC_DEFINED_FUNCTION:
252       return 1;
253     default:
254       return 0;
255     }
256 }
257
258 void
259 machopic_define_symbol (rtx mem)
260 {
261   rtx sym_ref;
262
263   gcc_assert (GET_CODE (mem) == MEM);
264   sym_ref = XEXP (mem, 0);
265   SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
266 }
267
268 /* Return either ORIG or:
269
270      (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))
271
272    depending on MACHO_DYNAMIC_NO_PIC_P.  */
273 rtx
274 machopic_gen_offset (rtx orig)
275 {
276   if (MACHO_DYNAMIC_NO_PIC_P)
277     return orig;
278   else
279     {
280       /* Play games to avoid marking the function as needing pic if we
281          are being called as part of the cost-estimation process.  */
282       if (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)
283         crtl->uses_pic_offset_table = 1;
284       orig = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig),
285                              UNSPEC_MACHOPIC_OFFSET);
286       return gen_rtx_CONST (Pmode, orig);
287     }
288 }
289
290 static GTY(()) const char * function_base_func_name;
291 static GTY(()) int current_pic_label_num;
292
293 void
294 machopic_output_function_base_name (FILE *file)
295 {
296   const char *current_name;
297
298   /* If dynamic-no-pic is on, we should not get here.  */
299   gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
300   current_name =
301     IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
302   if (function_base_func_name != current_name)
303     {
304       ++current_pic_label_num;
305       function_base_func_name = current_name;
306     }
307   fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
308 }
309
310 /* The suffix attached to non-lazy pointer symbols.  */
311 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
312 /* The suffix attached to stub symbols.  */
313 #define STUB_SUFFIX "$stub"
314
315 typedef struct GTY (()) machopic_indirection
316 {
317   /* The SYMBOL_REF for the entity referenced.  */
318   rtx symbol;
319   /* The name of the stub or non-lazy pointer.  */
320   const char * ptr_name;
321   /* True iff this entry is for a stub (as opposed to a non-lazy
322      pointer).  */
323   bool stub_p;
324   /* True iff this stub or pointer pointer has been referenced.  */
325   bool used;
326 } machopic_indirection;
327
328 /* A table mapping stub names and non-lazy pointer names to
329    SYMBOL_REFs for the stubbed-to and pointed-to entities.  */
330
331 static GTY ((param_is (struct machopic_indirection))) htab_t
332   machopic_indirections;
333
334 /* Return a hash value for a SLOT in the indirections hash table.  */
335
336 static hashval_t
337 machopic_indirection_hash (const void *slot)
338 {
339   const machopic_indirection *p = (const machopic_indirection *) slot;
340   return htab_hash_string (p->ptr_name);
341 }
342
343 /* Returns true if the KEY is the same as that associated with
344    SLOT.  */
345
346 static int
347 machopic_indirection_eq (const void *slot, const void *key)
348 {
349   return strcmp (((const machopic_indirection *) slot)->ptr_name,
350                  (const char *) key) == 0;
351 }
352
353 /* Return the name of the non-lazy pointer (if STUB_P is false) or
354    stub (if STUB_B is true) corresponding to the given name.  */
355
356 const char *
357 machopic_indirection_name (rtx sym_ref, bool stub_p)
358 {
359   char *buffer;
360   const char *name = XSTR (sym_ref, 0);
361   size_t namelen = strlen (name);
362   machopic_indirection *p;
363   void ** slot;
364   bool needs_quotes;
365   const char *suffix;
366   const char *prefix = user_label_prefix;
367   const char *quote = "";
368   tree id;
369
370   id = maybe_get_identifier (name);
371   if (id)
372     {
373       tree id_orig = id;
374
375       while (IDENTIFIER_TRANSPARENT_ALIAS (id))
376         id = TREE_CHAIN (id);
377       if (id != id_orig)
378         {
379           name = IDENTIFIER_POINTER (id);
380           namelen = strlen (name);
381         }
382     }
383
384   if (name[0] == '*')
385     {
386       prefix = "";
387       ++name;
388       --namelen;
389     }
390
391   needs_quotes = name_needs_quotes (name);
392   if (needs_quotes)
393     {
394       quote = "\"";
395     }
396
397   if (stub_p)
398     suffix = STUB_SUFFIX;
399   else
400     suffix = NON_LAZY_POINTER_SUFFIX;
401
402   buffer = XALLOCAVEC (char, strlen ("&L")
403                    + strlen (prefix)
404                    + namelen
405                    + strlen (suffix)
406                    + 2 * strlen (quote)
407                    + 1 /* '\0' */);
408
409   /* Construct the name of the non-lazy pointer or stub.  */
410   sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
411
412   if (!machopic_indirections)
413     machopic_indirections = htab_create_ggc (37,
414                                              machopic_indirection_hash,
415                                              machopic_indirection_eq,
416                                              /*htab_del=*/NULL);
417
418   slot = htab_find_slot_with_hash (machopic_indirections, buffer,
419                                    htab_hash_string (buffer), INSERT);
420   if (*slot)
421     {
422       p = (machopic_indirection *) *slot;
423     }
424   else
425     {
426       p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
427       p->symbol = sym_ref;
428       p->ptr_name = xstrdup (buffer);
429       p->stub_p = stub_p;
430       p->used = false;
431       *slot = p;
432     }
433
434   return p->ptr_name;
435 }
436
437 /* Return the name of the stub for the mcount function.  */
438
439 const char*
440 machopic_mcount_stub_name (void)
441 {
442   rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
443   return machopic_indirection_name (symbol, /*stub_p=*/true);
444 }
445
446 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
447    or non-lazy pointer as used -- and mark the object to which the
448    pointer/stub refers as used as well, since the pointer/stub will
449    emit a reference to it.  */
450
451 void
452 machopic_validate_stub_or_non_lazy_ptr (const char *name)
453 {
454   machopic_indirection *p;
455
456   p = ((machopic_indirection *)
457        (htab_find_with_hash (machopic_indirections, name,
458                              htab_hash_string (name))));
459   if (p && ! p->used)
460     {
461       const char *real_name;
462       tree id;
463
464       p->used = true;
465
466       /* Do what output_addr_const will do when we actually call it.  */
467       if (SYMBOL_REF_DECL (p->symbol))
468         mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
469
470       real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
471
472       id = maybe_get_identifier (real_name);
473       if (id)
474         mark_referenced (id);
475     }
476 }
477
478 /* Transform ORIG, which may be any data source, to the corresponding
479    source using indirections.  */
480
481 rtx
482 machopic_indirect_data_reference (rtx orig, rtx reg)
483 {
484   rtx ptr_ref = orig;
485
486   if (! MACHOPIC_INDIRECT)
487     return orig;
488
489   if (GET_CODE (orig) == SYMBOL_REF)
490     {
491       int defined = machopic_data_defined_p (orig);
492
493       if (defined && MACHO_DYNAMIC_NO_PIC_P)
494         {
495 #if defined (TARGET_TOC)
496           /* Create a new register for CSE opportunities.  */
497           rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));
498           emit_insn (gen_macho_high (hi_reg, orig));
499           emit_insn (gen_macho_low (reg, hi_reg, orig));
500 #else
501            /* some other cpu -- writeme!  */
502            gcc_unreachable ();
503 #endif
504            return reg;
505         }
506       else if (defined)
507         {
508 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
509           rtx offset = machopic_gen_offset (orig);
510 #endif
511
512 #if defined (TARGET_TOC) /* i.e., PowerPC */
513           rtx hi_sum_reg = (!can_create_pseudo_p ()
514                             ? reg
515                             : gen_reg_rtx (Pmode));
516
517           gcc_assert (reg);
518
519           emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
520                               gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
521                                        gen_rtx_HIGH (Pmode, offset))));
522           emit_insn (gen_rtx_SET (Pmode, reg,
523                                   gen_rtx_LO_SUM (Pmode, hi_sum_reg,
524                                                   copy_rtx (offset))));
525
526           orig = reg;
527 #else
528 #if defined (HAVE_lo_sum)
529           gcc_assert (reg);
530
531           emit_insn (gen_rtx_SET (VOIDmode, reg,
532                                   gen_rtx_HIGH (Pmode, offset)));
533           emit_insn (gen_rtx_SET (VOIDmode, reg,
534                                   gen_rtx_LO_SUM (Pmode, reg,
535                                                   copy_rtx (offset))));
536           emit_use (pic_offset_table_rtx);
537
538           orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
539 #endif
540 #endif
541           return orig;
542         }
543
544       ptr_ref = (gen_rtx_SYMBOL_REF
545                  (Pmode,
546                   machopic_indirection_name (orig, /*stub_p=*/false)));
547
548       SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
549
550       ptr_ref = gen_const_mem (Pmode, ptr_ref);
551       machopic_define_symbol (ptr_ref);
552
553       return ptr_ref;
554     }
555   else if (GET_CODE (orig) == CONST)
556     {
557       rtx base, result;
558
559       /* legitimize both operands of the PLUS */
560       if (GET_CODE (XEXP (orig, 0)) == PLUS)
561         {
562           base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
563                                                    reg);
564           orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
565                                                    (base == reg ? 0 : reg));
566         }
567       else
568         return orig;
569
570       if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
571         result = plus_constant (base, INTVAL (orig));
572       else
573         result = gen_rtx_PLUS (Pmode, base, orig);
574
575       if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
576         {
577           if (reg)
578             {
579               emit_move_insn (reg, result);
580               result = reg;
581             }
582           else
583             {
584               result = force_reg (GET_MODE (result), result);
585             }
586         }
587
588       return result;
589
590     }
591   else if (GET_CODE (orig) == MEM)
592     XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
593   /* When the target is i386, this code prevents crashes due to the
594      compiler's ignorance on how to move the PIC base register to
595      other registers.  (The reload phase sometimes introduces such
596      insns.)  */
597   else if (GET_CODE (orig) == PLUS
598            && GET_CODE (XEXP (orig, 0)) == REG
599            && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
600 #ifdef I386
601            /* Prevent the same register from being erroneously used
602               as both the base and index registers.  */
603            && GET_CODE (XEXP (orig, 1)) == CONST
604 #endif
605            && reg)
606     {
607       emit_move_insn (reg, XEXP (orig, 0));
608       XEXP (ptr_ref, 0) = reg;
609     }
610   return ptr_ref;
611 }
612
613 /* Transform TARGET (a MEM), which is a function call target, to the
614    corresponding symbol_stub if necessary.  Return a new MEM.  */
615
616 rtx
617 machopic_indirect_call_target (rtx target)
618 {
619   if (GET_CODE (target) != MEM)
620     return target;
621
622   if (MACHOPIC_INDIRECT
623       && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
624       && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
625            & MACHO_SYMBOL_FLAG_DEFINED))
626     {
627       rtx sym_ref = XEXP (target, 0);
628       const char *stub_name = machopic_indirection_name (sym_ref,
629                                                          /*stub_p=*/true);
630       enum machine_mode mode = GET_MODE (sym_ref);
631
632       XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
633       SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
634       MEM_READONLY_P (target) = 1;
635       MEM_NOTRAP_P (target) = 1;
636     }
637
638   return target;
639 }
640
641 rtx
642 machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
643 {
644   rtx pic_ref = orig;
645
646   if (! MACHOPIC_INDIRECT)
647     return orig;
648
649   /* First handle a simple SYMBOL_REF or LABEL_REF */
650   if (GET_CODE (orig) == LABEL_REF
651       || (GET_CODE (orig) == SYMBOL_REF
652           ))
653     {
654       /* addr(foo) = &func+(foo-func) */
655       orig = machopic_indirect_data_reference (orig, reg);
656
657       if (GET_CODE (orig) == PLUS
658           && GET_CODE (XEXP (orig, 0)) == REG)
659         {
660           if (reg == 0)
661             return force_reg (mode, orig);
662
663           emit_move_insn (reg, orig);
664           return reg;
665         }
666
667       if (GET_CODE (orig) == MEM)
668         {
669           if (reg == 0)
670             {
671               gcc_assert (!reload_in_progress);
672               reg = gen_reg_rtx (Pmode);
673             }
674
675 #ifdef HAVE_lo_sum
676           if (MACHO_DYNAMIC_NO_PIC_P
677               && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
678                   || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
679             {
680 #if defined (TARGET_TOC)        /* ppc  */
681               rtx temp_reg = (!can_create_pseudo_p ()
682                               ? reg :
683                               gen_reg_rtx (Pmode));
684               rtx asym = XEXP (orig, 0);
685               rtx mem;
686
687               emit_insn (gen_macho_high (temp_reg, asym));
688               mem = gen_const_mem (GET_MODE (orig),
689                                    gen_rtx_LO_SUM (Pmode, temp_reg,
690                                                    copy_rtx (asym)));
691               emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
692 #else
693               /* Some other CPU -- WriteMe! but right now there are no other
694                  platforms that can use dynamic-no-pic  */
695               gcc_unreachable ();
696 #endif
697               pic_ref = reg;
698             }
699           else
700           if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
701               || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
702             {
703               rtx offset = machopic_gen_offset (XEXP (orig, 0));
704 #if defined (TARGET_TOC) /* i.e., PowerPC */
705               /* Generating a new reg may expose opportunities for
706                  common subexpression elimination.  */
707               rtx hi_sum_reg = (!can_create_pseudo_p ()
708                                 ? reg
709                                 : gen_reg_rtx (Pmode));
710               rtx mem;
711               rtx insn;
712               rtx sum;
713
714               sum = gen_rtx_HIGH (Pmode, offset);
715               if (! MACHO_DYNAMIC_NO_PIC_P)
716                 sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
717
718               emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
719
720               mem = gen_const_mem (GET_MODE (orig),
721                                   gen_rtx_LO_SUM (Pmode,
722                                                   hi_sum_reg,
723                                                   copy_rtx (offset)));
724               insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
725               set_unique_reg_note (insn, REG_EQUAL, pic_ref);
726
727               pic_ref = reg;
728 #else
729               emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
730
731               emit_insn (gen_rtx_SET (VOIDmode, reg,
732                                       gen_rtx_HIGH (Pmode,
733                                                     gen_rtx_CONST (Pmode,
734                                                                    offset))));
735               emit_insn (gen_rtx_SET (VOIDmode, reg,
736                                   gen_rtx_LO_SUM (Pmode, reg,
737                                            gen_rtx_CONST (Pmode,
738                                                           copy_rtx (offset)))));
739               pic_ref = gen_rtx_PLUS (Pmode,
740                                       pic_offset_table_rtx, reg);
741 #endif
742             }
743           else
744 #endif  /* HAVE_lo_sum */
745             {
746               rtx pic = pic_offset_table_rtx;
747               if (GET_CODE (pic) != REG)
748                 {
749                   emit_move_insn (reg, pic);
750                   pic = reg;
751                 }
752 #if 0
753               emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
754 #endif
755
756               if (reload_in_progress)
757                 df_set_regs_ever_live (REGNO (pic), true);
758               pic_ref = gen_rtx_PLUS (Pmode, pic,
759                                       machopic_gen_offset (XEXP (orig, 0)));
760             }
761
762 #if !defined (TARGET_TOC)
763           emit_move_insn (reg, pic_ref);
764           pic_ref = gen_const_mem (GET_MODE (orig), reg);
765 #endif
766         }
767       else
768         {
769
770 #ifdef HAVE_lo_sum
771           if (GET_CODE (orig) == SYMBOL_REF
772               || GET_CODE (orig) == LABEL_REF)
773             {
774               rtx offset = machopic_gen_offset (orig);
775 #if defined (TARGET_TOC) /* i.e., PowerPC */
776               rtx hi_sum_reg;
777
778               if (reg == 0)
779                 {
780                   gcc_assert (!reload_in_progress);
781                   reg = gen_reg_rtx (Pmode);
782                 }
783
784               hi_sum_reg = reg;
785
786               emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
787                                       (MACHO_DYNAMIC_NO_PIC_P)
788                                       ? gen_rtx_HIGH (Pmode, offset)
789                                       : gen_rtx_PLUS (Pmode,
790                                                       pic_offset_table_rtx,
791                                                       gen_rtx_HIGH (Pmode,
792                                                                     offset))));
793               emit_insn (gen_rtx_SET (VOIDmode, reg,
794                                       gen_rtx_LO_SUM (Pmode,
795                                                       hi_sum_reg,
796                                                       copy_rtx (offset))));
797               pic_ref = reg;
798 #else
799               emit_insn (gen_rtx_SET (VOIDmode, reg,
800                                       gen_rtx_HIGH (Pmode, offset)));
801               emit_insn (gen_rtx_SET (VOIDmode, reg,
802                                       gen_rtx_LO_SUM (Pmode, reg,
803                                                       copy_rtx (offset))));
804               pic_ref = gen_rtx_PLUS (Pmode,
805                                       pic_offset_table_rtx, reg);
806 #endif
807             }
808           else
809 #endif  /*  HAVE_lo_sum  */
810             {
811               if (REG_P (orig)
812                   || GET_CODE (orig) == SUBREG)
813                 {
814                   return orig;
815                 }
816               else
817                 {
818                   rtx pic = pic_offset_table_rtx;
819                   if (GET_CODE (pic) != REG)
820                     {
821                       emit_move_insn (reg, pic);
822                       pic = reg;
823                     }
824 #if 0
825                   emit_use (pic_offset_table_rtx);
826 #endif
827                   if (reload_in_progress)
828                     df_set_regs_ever_live (REGNO (pic), true);
829                   pic_ref = gen_rtx_PLUS (Pmode,
830                                           pic,
831                                           machopic_gen_offset (orig));
832                 }
833             }
834         }
835
836       if (GET_CODE (pic_ref) != REG)
837         {
838           if (reg != 0)
839             {
840               emit_move_insn (reg, pic_ref);
841               return reg;
842             }
843           else
844             {
845               return force_reg (mode, pic_ref);
846             }
847         }
848       else
849         {
850           return pic_ref;
851         }
852     }
853
854   else if (GET_CODE (orig) == SYMBOL_REF)
855     return orig;
856
857   else if (GET_CODE (orig) == PLUS
858            && (GET_CODE (XEXP (orig, 0)) == MEM
859                || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
860                || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
861            && XEXP (orig, 0) != pic_offset_table_rtx
862            && GET_CODE (XEXP (orig, 1)) != REG)
863
864     {
865       rtx base;
866       int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
867
868       base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
869       orig = machopic_legitimize_pic_address (XEXP (orig, 1),
870                                               Pmode, (base == reg ? 0 : reg));
871       if (GET_CODE (orig) == CONST_INT)
872         {
873           pic_ref = plus_constant (base, INTVAL (orig));
874           is_complex = 1;
875         }
876       else
877         pic_ref = gen_rtx_PLUS (Pmode, base, orig);
878
879       if (reg && is_complex)
880         {
881           emit_move_insn (reg, pic_ref);
882           pic_ref = reg;
883         }
884       /* Likewise, should we set special REG_NOTEs here?  */
885     }
886
887   else if (GET_CODE (orig) == CONST)
888     {
889       return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
890     }
891
892   else if (GET_CODE (orig) == MEM
893            && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
894     {
895       rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
896       addr = replace_equiv_address (orig, addr);
897       emit_move_insn (reg, addr);
898       pic_ref = reg;
899     }
900
901   return pic_ref;
902 }
903
904 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
905    DATA is the FILE* for assembly output.  Called from
906    htab_traverse.  */
907
908 static int
909 machopic_output_indirection (void **slot, void *data)
910 {
911   machopic_indirection *p = *((machopic_indirection **) slot);
912   FILE *asm_out_file = (FILE *) data;
913   rtx symbol;
914   const char *sym_name;
915   const char *ptr_name;
916
917   if (!p->used)
918     return 1;
919
920   symbol = p->symbol;
921   sym_name = XSTR (symbol, 0);
922   ptr_name = p->ptr_name;
923
924   if (p->stub_p)
925     {
926       char *sym;
927       char *stub;
928       tree id;
929
930       id = maybe_get_identifier (sym_name);
931       if (id)
932         {
933           tree id_orig = id;
934
935           while (IDENTIFIER_TRANSPARENT_ALIAS (id))
936             id = TREE_CHAIN (id);
937           if (id != id_orig)
938             sym_name = IDENTIFIER_POINTER (id);
939         }
940
941       sym = XALLOCAVEC (char, strlen (sym_name) + 2);
942       if (sym_name[0] == '*' || sym_name[0] == '&')
943         strcpy (sym, sym_name + 1);
944       else if (sym_name[0] == '-' || sym_name[0] == '+')
945         strcpy (sym, sym_name);
946       else
947         sprintf (sym, "%s%s", user_label_prefix, sym_name);
948
949       stub = XALLOCAVEC (char, strlen (ptr_name) + 2);
950       if (ptr_name[0] == '*' || ptr_name[0] == '&')
951         strcpy (stub, ptr_name + 1);
952       else
953         sprintf (stub, "%s%s", user_label_prefix, ptr_name);
954
955       machopic_output_stub (asm_out_file, sym, stub);
956     }
957   else if (! indirect_data (symbol)
958            && (machopic_symbol_defined_p (symbol)
959                || SYMBOL_REF_LOCAL_P (symbol)))
960     {
961       switch_to_section (data_section);
962       assemble_align (GET_MODE_ALIGNMENT (Pmode));
963       assemble_label (ptr_name);
964       assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
965                         GET_MODE_SIZE (Pmode),
966                         GET_MODE_ALIGNMENT (Pmode), 1);
967     }
968   else
969     {
970       rtx init = const0_rtx;
971
972       switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
973
974       /* Mach-O symbols are passed around in code through indirect
975          references and the original symbol_ref hasn't passed through
976          the generic handling and reference-catching in
977          output_operand, so we need to manually mark weak references
978          as such.  */
979       if (SYMBOL_REF_WEAK (symbol))
980         {
981           tree decl = SYMBOL_REF_DECL (symbol);
982           gcc_assert (DECL_P (decl));
983
984           if (decl != NULL_TREE
985               && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
986               /* Handle only actual external-only definitions, not
987                  e.g. extern inline code or variables for which
988                  storage has been allocated.  */
989               && !TREE_STATIC (decl))
990             {
991               fputs ("\t.weak_reference ", asm_out_file);
992               assemble_name (asm_out_file, sym_name);
993               fputc ('\n', asm_out_file);
994             }
995         }
996
997       assemble_name (asm_out_file, ptr_name);
998       fprintf (asm_out_file, ":\n");
999
1000       fprintf (asm_out_file, "\t.indirect_symbol ");
1001       assemble_name (asm_out_file, sym_name);
1002       fprintf (asm_out_file, "\n");
1003
1004       /* Variables that are marked with MACHO_SYMBOL_STATIC need to
1005          have their symbol name instead of 0 in the second entry of
1006          the non-lazy symbol pointer data structure when they are
1007          defined.  This allows the runtime to rebind newer instances
1008          of the translation unit with the original instance of the
1009          symbol.  */
1010
1011       if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
1012           && machopic_symbol_defined_p (symbol))
1013         init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
1014
1015       assemble_integer (init, GET_MODE_SIZE (Pmode),
1016                         GET_MODE_ALIGNMENT (Pmode), 1);
1017     }
1018
1019   return 1;
1020 }
1021
1022 void
1023 machopic_finish (FILE *asm_out_file)
1024 {
1025   if (machopic_indirections)
1026     htab_traverse_noresize (machopic_indirections,
1027                             machopic_output_indirection,
1028                             asm_out_file);
1029 }
1030
1031 int
1032 machopic_operand_p (rtx op)
1033 {
1034   if (MACHOPIC_JUST_INDIRECT)
1035     return (GET_CODE (op) == SYMBOL_REF
1036             && machopic_symbol_defined_p (op));
1037   else
1038     return (GET_CODE (op) == CONST
1039             && GET_CODE (XEXP (op, 0)) == UNSPEC
1040             && XINT (XEXP (op, 0), 1) == UNSPEC_MACHOPIC_OFFSET);
1041 }
1042
1043 /* This function records whether a given name corresponds to a defined
1044    or undefined function or variable, for machopic_classify_ident to
1045    use later.  */
1046
1047 void
1048 darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
1049 {
1050   rtx sym_ref;
1051
1052   /* Do the standard encoding things first.  */
1053   default_encode_section_info (decl, rtl, first);
1054
1055   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
1056     return;
1057
1058   sym_ref = XEXP (rtl, 0);
1059   if (TREE_CODE (decl) == VAR_DECL)
1060     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
1061
1062   if (!DECL_EXTERNAL (decl)
1063       && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
1064       && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
1065       && ((TREE_STATIC (decl)
1066            && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
1067           || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
1068               && DECL_INITIAL (decl) != error_mark_node)))
1069     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
1070
1071   if (! TREE_PUBLIC (decl))
1072     SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
1073 }
1074
1075 void
1076 darwin_mark_decl_preserved (const char *name)
1077 {
1078   fprintf (asm_out_file, ".no_dead_strip ");
1079   assemble_name (asm_out_file, name);
1080   fputc ('\n', asm_out_file);
1081 }
1082
1083 static section *
1084 darwin_text_section (int reloc, int weak)
1085 {
1086   if (reloc)
1087     return (weak
1088             ? darwin_sections[text_unlikely_coal_section]
1089             : unlikely_text_section ());
1090   else
1091     return (weak
1092             ? darwin_sections[text_coal_section]
1093             : text_section);
1094 }
1095
1096 static section *
1097 darwin_rodata_section (int weak)
1098 {
1099   return (weak
1100           ? darwin_sections[const_coal_section]
1101           : darwin_sections[const_section]);
1102 }
1103
1104 static section *
1105 darwin_mergeable_string_section (tree exp,
1106                                  unsigned HOST_WIDE_INT align)
1107 {
1108   if (flag_merge_constants
1109       && TREE_CODE (exp) == STRING_CST
1110       && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1111       && align <= 256
1112       && (int_size_in_bytes (TREE_TYPE (exp))
1113           == TREE_STRING_LENGTH (exp))
1114       && ((size_t) TREE_STRING_LENGTH (exp)
1115           == strlen (TREE_STRING_POINTER (exp)) + 1))
1116     return darwin_sections[cstring_section];
1117
1118   return readonly_data_section;
1119 }
1120
1121 #ifndef HAVE_GAS_LITERAL16
1122 #define HAVE_GAS_LITERAL16 0
1123 #endif
1124
1125 static section *
1126 darwin_mergeable_constant_section (tree exp,
1127                                    unsigned HOST_WIDE_INT align)
1128 {
1129   enum machine_mode mode = DECL_MODE (exp);
1130   unsigned int modesize = GET_MODE_BITSIZE (mode);
1131
1132   if (flag_merge_constants
1133       && mode != VOIDmode
1134       && mode != BLKmode
1135       && modesize <= align
1136       && align >= 8
1137       && align <= 256
1138       && (align & (align -1)) == 0)
1139     {
1140       tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1141
1142       if (TREE_CODE (size) == INTEGER_CST
1143           && TREE_INT_CST_LOW (size) == 4
1144           && TREE_INT_CST_HIGH (size) == 0)
1145         return darwin_sections[literal4_section];
1146       else if (TREE_CODE (size) == INTEGER_CST
1147                && TREE_INT_CST_LOW (size) == 8
1148                && TREE_INT_CST_HIGH (size) == 0)
1149         return darwin_sections[literal8_section];
1150       else if (HAVE_GAS_LITERAL16
1151                && TARGET_64BIT
1152                && TREE_CODE (size) == INTEGER_CST
1153                && TREE_INT_CST_LOW (size) == 16
1154                && TREE_INT_CST_HIGH (size) == 0)
1155         return darwin_sections[literal16_section];
1156       else
1157         return readonly_data_section;
1158     }
1159
1160   return readonly_data_section;
1161 }
1162
1163 int
1164 machopic_reloc_rw_mask (void)
1165 {
1166   return MACHOPIC_INDIRECT ? 3 : 0;
1167 }
1168
1169 section *
1170 machopic_select_section (tree decl,
1171                          int reloc,
1172                          unsigned HOST_WIDE_INT align)
1173 {
1174   bool weak = (DECL_P (decl)
1175                && DECL_WEAK (decl)
1176                && !lookup_attribute ("weak_import",
1177                                      DECL_ATTRIBUTES (decl)));
1178   section *base_section;
1179
1180   switch (categorize_decl_for_section (decl, reloc))
1181     {
1182     case SECCAT_TEXT:
1183       base_section = darwin_text_section (reloc, weak);
1184       break;
1185
1186     case SECCAT_RODATA:
1187     case SECCAT_SRODATA:
1188       base_section = darwin_rodata_section (weak);
1189       break;
1190
1191     case SECCAT_RODATA_MERGE_STR:
1192       base_section = darwin_mergeable_string_section (decl, align);
1193       break;
1194
1195     case SECCAT_RODATA_MERGE_STR_INIT:
1196       base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1197       break;
1198
1199     case SECCAT_RODATA_MERGE_CONST:
1200       base_section =  darwin_mergeable_constant_section (decl, align);
1201       break;
1202
1203     case SECCAT_DATA:
1204     case SECCAT_DATA_REL:
1205     case SECCAT_DATA_REL_LOCAL:
1206     case SECCAT_DATA_REL_RO:
1207     case SECCAT_DATA_REL_RO_LOCAL:
1208     case SECCAT_SDATA:
1209     case SECCAT_TDATA:
1210     case SECCAT_BSS:
1211     case SECCAT_SBSS:
1212     case SECCAT_TBSS:
1213       if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1214         base_section = weak ? darwin_sections[const_data_coal_section]
1215                             : darwin_sections[const_data_section];
1216       else
1217         base_section = weak ? darwin_sections[data_coal_section] : data_section;
1218       break;
1219
1220     default:
1221       gcc_unreachable ();
1222     }
1223
1224   /* Darwin weird special cases.  */
1225   if (TREE_CODE (decl) == CONSTRUCTOR
1226       && TREE_TYPE (decl)
1227       && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1228       && TYPE_NAME (TREE_TYPE (decl)))
1229     {
1230       tree name = TYPE_NAME (TREE_TYPE (decl));
1231       if (TREE_CODE (name) == TYPE_DECL)
1232         name = DECL_NAME (name);
1233
1234       if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1235         {
1236           if (flag_next_runtime)
1237             return darwin_sections[objc_constant_string_object_section];
1238           else
1239             return darwin_sections[objc_string_object_section];
1240         }
1241       else
1242         return base_section;
1243     }
1244   else if (TREE_CODE (decl) == VAR_DECL
1245            && DECL_NAME (decl)
1246            && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1247            && IDENTIFIER_POINTER (DECL_NAME (decl))
1248            && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1249     {
1250       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1251
1252       if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1253         return darwin_sections[objc_cls_meth_section];
1254       else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1255         return darwin_sections[objc_inst_meth_section];
1256       else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1257         return darwin_sections[objc_cat_cls_meth_section];
1258       else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1259         return darwin_sections[objc_cat_inst_meth_section];
1260       else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1261         return darwin_sections[objc_class_vars_section];
1262       else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1263         return darwin_sections[objc_instance_vars_section];
1264       else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1265         return darwin_sections[objc_cat_cls_meth_section];
1266       else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1267         return darwin_sections[objc_class_names_section];
1268       else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1269         return darwin_sections[objc_meth_var_names_section];
1270       else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1271         return darwin_sections[objc_meth_var_types_section];
1272       else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1273         return darwin_sections[objc_cls_refs_section];
1274       else if (!strncmp (name, "_OBJC_CLASS_", 12))
1275         return darwin_sections[objc_class_section];
1276       else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1277         return darwin_sections[objc_meta_class_section];
1278       else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1279         return darwin_sections[objc_category_section];
1280       else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1281         return darwin_sections[objc_selector_refs_section];
1282       else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1283         return darwin_sections[objc_selector_fixup_section];
1284       else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1285         return darwin_sections[objc_symbols_section];
1286       else if (!strncmp (name, "_OBJC_MODULES", 13))
1287         return darwin_sections[objc_module_info_section];
1288       else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1289         return darwin_sections[objc_image_info_section];
1290       else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1291         return darwin_sections[objc_cat_inst_meth_section];
1292       else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1293         return darwin_sections[objc_cat_cls_meth_section];
1294       else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1295         return darwin_sections[objc_cat_cls_meth_section];
1296       else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1297         return darwin_sections[objc_protocol_section];
1298       else
1299         return base_section;
1300     }
1301
1302   return base_section;
1303 }
1304
1305 /* This can be called with address expressions as "rtx".
1306    They must go in "const".  */
1307
1308 section *
1309 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1310                              unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1311 {
1312   if (GET_MODE_SIZE (mode) == 8
1313       && (GET_CODE (x) == CONST_INT
1314           || GET_CODE (x) == CONST_DOUBLE))
1315     return darwin_sections[literal8_section];
1316   else if (GET_MODE_SIZE (mode) == 4
1317            && (GET_CODE (x) == CONST_INT
1318                || GET_CODE (x) == CONST_DOUBLE))
1319     return darwin_sections[literal4_section];
1320   else if (HAVE_GAS_LITERAL16
1321            && TARGET_64BIT
1322            && GET_MODE_SIZE (mode) == 16
1323            && (GET_CODE (x) == CONST_INT
1324                || GET_CODE (x) == CONST_DOUBLE
1325                || GET_CODE (x) == CONST_VECTOR))
1326     return darwin_sections[literal16_section];
1327   else if (MACHOPIC_INDIRECT
1328            && (GET_CODE (x) == SYMBOL_REF
1329                || GET_CODE (x) == CONST
1330                || GET_CODE (x) == LABEL_REF))
1331     return darwin_sections[const_data_section];
1332   else
1333     return darwin_sections[const_section];
1334 }
1335
1336 void
1337 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1338 {
1339   if (MACHOPIC_INDIRECT)
1340     switch_to_section (darwin_sections[mod_init_section]);
1341   else
1342     switch_to_section (darwin_sections[constructor_section]);
1343   assemble_align (POINTER_SIZE);
1344   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1345
1346   if (! MACHOPIC_INDIRECT)
1347     fprintf (asm_out_file, ".reference .constructors_used\n");
1348 }
1349
1350 void
1351 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1352 {
1353   if (MACHOPIC_INDIRECT)
1354     switch_to_section (darwin_sections[mod_term_section]);
1355   else
1356     switch_to_section (darwin_sections[destructor_section]);
1357   assemble_align (POINTER_SIZE);
1358   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1359
1360   if (! MACHOPIC_INDIRECT)
1361     fprintf (asm_out_file, ".reference .destructors_used\n");
1362 }
1363
1364 void
1365 darwin_globalize_label (FILE *stream, const char *name)
1366 {
1367   if (!!strncmp (name, "_OBJC_", 6))
1368     default_globalize_label (stream, name);
1369 }
1370
1371 /* This routine returns non-zero if 'name' starts with the special objective-c 
1372    anonymous file-scope static name.  It accommodates c++'s mangling of such 
1373    symbols (in this case the symbols will have form _ZL{d}*_OBJC_* d=digit).  */
1374    
1375 int 
1376 darwin_label_is_anonymous_local_objc_name (const char *name)
1377 {
1378   const unsigned char *p = (const unsigned char *) name;
1379   if (*p != '_')
1380     return 0;
1381   if (p[1] == 'Z' && p[2] == 'L')
1382   {
1383     p += 3;
1384     while (*p >= '0' && *p <= '9')
1385       p++;
1386   }
1387   return (!strncmp ((const char *)p, "_OBJC_", 6));
1388 }
1389
1390 void
1391 darwin_asm_named_section (const char *name,
1392                           unsigned int flags ATTRIBUTE_UNUSED,
1393                           tree decl ATTRIBUTE_UNUSED)
1394 {
1395   fprintf (asm_out_file, "\t.section %s\n", name);
1396 }
1397
1398 void
1399 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1400 {
1401   /* Darwin does not use unique sections.  */
1402 }
1403
1404 /* Handle __attribute__ ((apple_kext_compatibility)).
1405    This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1406    vtable for classes with this attribute (and their descendants) by not
1407    outputting the new 3.0 nondeleting destructor.  This means that such
1408    objects CANNOT be allocated on the stack or as globals UNLESS they have
1409    a completely empty `operator delete'.
1410    Luckily, this fits in with the Darwin kext model.
1411
1412    This attribute also disables gcc3's potential overlaying of derived
1413    class data members on the padding at the end of the base class.  */
1414
1415 tree
1416 darwin_handle_kext_attribute (tree *node, tree name,
1417                               tree args ATTRIBUTE_UNUSED,
1418                               int flags ATTRIBUTE_UNUSED,
1419                               bool *no_add_attrs)
1420 {
1421   /* APPLE KEXT stuff -- only applies with pure static C++ code.  */
1422   if (! TARGET_KEXTABI)
1423     {
1424       warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1425                "only when compiling a kext", name);
1426
1427       *no_add_attrs = true;
1428     }
1429   else if (TREE_CODE (*node) != RECORD_TYPE)
1430     {
1431       warning (0, "%qE 2.95 vtable-compatibility attribute applies "
1432                "only to C++ classes", name);
1433
1434       *no_add_attrs = true;
1435     }
1436
1437   return NULL_TREE;
1438 }
1439
1440 /* Handle a "weak_import" attribute; arguments as in
1441    struct attribute_spec.handler.  */
1442
1443 tree
1444 darwin_handle_weak_import_attribute (tree *node, tree name,
1445                                      tree ARG_UNUSED (args),
1446                                      int ARG_UNUSED (flags),
1447                                      bool * no_add_attrs)
1448 {
1449   if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1450     {
1451       warning (OPT_Wattributes, "%qE attribute ignored",
1452                name);
1453       *no_add_attrs = true;
1454     }
1455   else
1456     declare_weak (*node);
1457
1458   return NULL_TREE;
1459 }
1460
1461 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1462    The third parameter is nonzero if this is for exception handling.
1463    The fourth parameter is nonzero if this is just a placeholder for an
1464    FDE that we are omitting. */
1465
1466 void
1467 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1468 {
1469   char *lab;
1470
1471   if (! for_eh)
1472     return;
1473
1474   lab = concat (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), ".eh", NULL);
1475
1476   if (TREE_PUBLIC (decl))
1477     {
1478       targetm.asm_out.globalize_label (file, lab);
1479       if (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN)
1480         {
1481           fputs ("\t.private_extern ", file);
1482           assemble_name (file, lab);
1483           fputc ('\n', file);
1484         }
1485     }
1486
1487   if (DECL_WEAK (decl))
1488     {
1489       fputs ("\t.weak_definition ", file);
1490       assemble_name (file, lab);
1491       fputc ('\n', file);
1492     }
1493
1494   assemble_name (file, lab);
1495   if (empty)
1496     {
1497       fputs (" = 0\n", file);
1498
1499       /* Mark the absolute .eh and .eh1 style labels as needed to
1500          ensure that we don't dead code strip them and keep such
1501          labels from another instantiation point until we can fix this
1502          properly with group comdat support.  */
1503       darwin_mark_decl_preserved (lab);
1504     }
1505   else
1506     fputs (":\n", file);
1507
1508   free (lab);
1509 }
1510
1511 static GTY(()) unsigned long except_table_label_num;
1512
1513 void
1514 darwin_emit_except_table_label (FILE *file)
1515 {
1516   char section_start_label[30];
1517
1518   ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1519                                except_table_label_num++);
1520   ASM_OUTPUT_LABEL (file, section_start_label);
1521 }
1522 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
1523
1524 void
1525 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1526 {
1527   const char *nlp_name;
1528
1529   gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1530
1531   nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1532   fputs ("\t.long\t", file);
1533   ASM_OUTPUT_LABELREF (file, nlp_name);
1534   fputs ("-.", file);
1535 }
1536
1537 /* Emit an assembler directive to set visibility for a symbol.  The
1538    only supported visibilities are VISIBILITY_DEFAULT and
1539    VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1540    extern".  There is no MACH-O equivalent of ELF's
1541    VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1542
1543 void
1544 darwin_assemble_visibility (tree decl, int vis)
1545 {
1546   if (vis == VISIBILITY_DEFAULT)
1547     ;
1548   else if (vis == VISIBILITY_HIDDEN)
1549     {
1550       fputs ("\t.private_extern ", asm_out_file);
1551       assemble_name (asm_out_file,
1552                      (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1553       fputs ("\n", asm_out_file);
1554     }
1555   else
1556     warning (OPT_Wattributes, "internal and protected visibility attributes "
1557              "not supported in this configuration; ignored");
1558 }
1559
1560 /* Output a difference of two labels that will be an assembly time
1561    constant if the two labels are local.  (.long lab1-lab2 will be
1562    very different if lab1 is at the boundary between two sections; it
1563    will be relocated according to the second section, not the first,
1564    so one ends up with a difference between labels in different
1565    sections, which is bad in the dwarf2 eh context for instance.)  */
1566
1567 static int darwin_dwarf_label_counter;
1568
1569 void
1570 darwin_asm_output_dwarf_delta (FILE *file, int size,
1571                                const char *lab1, const char *lab2)
1572 {
1573   int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1574                      && lab2[0] == '*' && lab2[1] == 'L');
1575   const char *directive = (size == 8 ? ".quad" : ".long");
1576
1577   if (islocaldiff)
1578     fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1579   else
1580     fprintf (file, "\t%s\t", directive);
1581   assemble_name_raw (file, lab1);
1582   fprintf (file, "-");
1583   assemble_name_raw (file, lab2);
1584   if (islocaldiff)
1585     fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1586 }
1587
1588 /* Output labels for the start of the DWARF sections if necessary.  */
1589 void
1590 darwin_file_start (void)
1591 {
1592   if (write_symbols == DWARF2_DEBUG)
1593     {
1594       static const char * const debugnames[] =
1595         {
1596           DEBUG_FRAME_SECTION,
1597           DEBUG_INFO_SECTION,
1598           DEBUG_ABBREV_SECTION,
1599           DEBUG_ARANGES_SECTION,
1600           DEBUG_MACINFO_SECTION,
1601           DEBUG_LINE_SECTION,
1602           DEBUG_LOC_SECTION,
1603           DEBUG_PUBNAMES_SECTION,
1604           DEBUG_PUBTYPES_SECTION,
1605           DEBUG_STR_SECTION,
1606           DEBUG_RANGES_SECTION
1607         };
1608       size_t i;
1609
1610       for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1611         {
1612           int namelen;
1613
1614           switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1615
1616           gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1617           gcc_assert (strchr (debugnames[i] + 8, ','));
1618
1619           namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1620           fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1621         }
1622     }
1623 }
1624
1625 /* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
1626    offsets are not represented using relocs in .o files; either the
1627    section never leaves the .o file, or the linker or other tool is
1628    responsible for parsing the DWARF and updating the offsets.  */
1629
1630 void
1631 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1632                                 section *base)
1633 {
1634   char sname[64];
1635   int namelen;
1636
1637   gcc_assert (base->common.flags & SECTION_NAMED);
1638   gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1639   gcc_assert (strchr (base->named.name + 8, ','));
1640
1641   namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1642   sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1643   darwin_asm_output_dwarf_delta (file, size, lab, sname);
1644 }
1645
1646 void
1647 darwin_file_end (void)
1648 {
1649   machopic_finish (asm_out_file);
1650   if (strcmp (lang_hooks.name, "GNU C++") == 0)
1651     {
1652       switch_to_section (darwin_sections[constructor_section]);
1653       switch_to_section (darwin_sections[destructor_section]);
1654       ASM_OUTPUT_ALIGN (asm_out_file, 1);
1655     }
1656   fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1657 }
1658
1659 /* TODO: Add a language hook for identifying if a decl is a vtable.  */
1660 #define DARWIN_VTABLE_P(DECL) 0
1661
1662 /* Cross-module name binding.  Darwin does not support overriding
1663    functions at dynamic-link time, except for vtables in kexts.  */
1664
1665 bool
1666 darwin_binds_local_p (const_tree decl)
1667 {
1668   return default_binds_local_p_1 (decl,
1669                                   TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
1670 }
1671
1672 #if 0
1673 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet.  */
1674 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
1675    anchor relative to ".", the current section position.  We cannot use
1676    the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
1677
1678 void
1679 darwin_asm_output_anchor (rtx symbol)
1680 {
1681   fprintf (asm_out_file, "\t.set\t");
1682   assemble_name (asm_out_file, XSTR (symbol, 0));
1683   fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1684            SYMBOL_REF_BLOCK_OFFSET (symbol));
1685 }
1686 #endif
1687
1688 /* Set the darwin specific attributes on TYPE.  */
1689 void
1690 darwin_set_default_type_attributes (tree type)
1691 {
1692   if (darwin_ms_struct
1693       && TREE_CODE (type) == RECORD_TYPE)
1694     TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1695                                         NULL_TREE,
1696                                         TYPE_ATTRIBUTES (type));
1697 }
1698
1699 /* True, iff we're generating code for loadable kernel extensions.  */
1700
1701 bool
1702 darwin_kextabi_p (void) {
1703   return flag_apple_kext;
1704 }
1705
1706 void
1707 darwin_override_options (void)
1708 {
1709   /* Don't emit DWARF3/4 unless specifically selected.  This is a 
1710      workaround for tool bugs.  */
1711   if (dwarf_strict < 0) 
1712     dwarf_strict = 1;
1713
1714   /* Disable -freorder-blocks-and-partition for darwin_emit_unwind_label.  */
1715   if (flag_reorder_blocks_and_partition 
1716       && (targetm.asm_out.unwind_label == darwin_emit_unwind_label))
1717     {
1718       inform (input_location,
1719               "-freorder-blocks-and-partition does not work with exceptions "
1720               "on this architecture");
1721       flag_reorder_blocks_and_partition = 0;
1722       flag_reorder_blocks = 1;
1723     }
1724
1725   if (flag_mkernel || flag_apple_kext)
1726     {
1727       /* -mkernel implies -fapple-kext for C++ */
1728       if (strcmp (lang_hooks.name, "GNU C++") == 0)
1729         flag_apple_kext = 1;
1730
1731       flag_no_common = 1;
1732
1733       /* No EH in kexts.  */
1734       flag_exceptions = 0;
1735       /* No -fnon-call-exceptions data in kexts.  */
1736       flag_non_call_exceptions = 0;
1737     }
1738   if (flag_var_tracking
1739       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1740       && debug_info_level >= DINFO_LEVEL_NORMAL
1741       && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
1742     flag_var_tracking_uninit = 1;
1743 }
1744
1745 /* Add $LDBL128 suffix to long double builtins.  */
1746
1747 static void
1748 darwin_patch_builtin (int fncode)
1749 {
1750   tree fn = built_in_decls[fncode];
1751   tree sym;
1752   char *newname;
1753
1754   if (!fn)
1755     return;
1756
1757   sym = DECL_ASSEMBLER_NAME (fn);
1758   newname = ACONCAT (("_", IDENTIFIER_POINTER (sym), "$LDBL128", NULL));
1759
1760   set_user_assembler_name (fn, newname);
1761
1762   fn = implicit_built_in_decls[fncode];
1763   if (fn)
1764     set_user_assembler_name (fn, newname);
1765 }
1766
1767 void
1768 darwin_patch_builtins (void)
1769 {
1770   if (LONG_DOUBLE_TYPE_SIZE != 128)
1771     return;
1772
1773 #define PATCH_BUILTIN(fncode) darwin_patch_builtin (fncode);
1774 #define PATCH_BUILTIN_NO64(fncode)              \
1775   if (!TARGET_64BIT)                            \
1776     darwin_patch_builtin (fncode);
1777 #define PATCH_BUILTIN_VARIADIC(fncode)                            \
1778   if (!TARGET_64BIT                                               \
1779       && (strverscmp (darwin_macosx_version_min, "10.3.9") >= 0)) \
1780     darwin_patch_builtin (fncode);
1781 #include "darwin-ppc-ldouble-patch.def"
1782 #undef PATCH_BUILTIN
1783 #undef PATCH_BUILTIN_NO64
1784 #undef PATCH_BUILTIN_VARIADIC
1785 }
1786
1787
1788 #include "gt-darwin.h"