OSDN Git Service

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