OSDN Git Service

2007-09-06 Jan Hubicka <jh@suse.cz>
[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
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       && ((size_t) TREE_STRING_LENGTH (exp)
1140           == strlen (TREE_STRING_POINTER (exp)) + 1))
1141     return darwin_sections[cstring_section];
1142
1143   return readonly_data_section;
1144 }
1145
1146 #ifndef HAVE_GAS_LITERAL16
1147 #define HAVE_GAS_LITERAL16 0
1148 #endif
1149
1150 static section *
1151 darwin_mergeable_constant_section (tree exp,
1152                                    unsigned HOST_WIDE_INT align)
1153 {
1154   enum machine_mode mode = DECL_MODE (exp);
1155   unsigned int modesize = GET_MODE_BITSIZE (mode);
1156
1157   if (flag_merge_constants
1158       && mode != VOIDmode
1159       && mode != BLKmode
1160       && modesize <= align
1161       && align >= 8
1162       && align <= 256
1163       && (align & (align -1)) == 0)
1164     {
1165       tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1166
1167       if (TREE_CODE (size) == INTEGER_CST
1168           && TREE_INT_CST_LOW (size) == 4
1169           && TREE_INT_CST_HIGH (size) == 0)
1170         return darwin_sections[literal4_section];
1171       else if (TREE_CODE (size) == INTEGER_CST
1172                && TREE_INT_CST_LOW (size) == 8
1173                && TREE_INT_CST_HIGH (size) == 0)
1174         return darwin_sections[literal8_section];
1175       else if (HAVE_GAS_LITERAL16
1176                && TARGET_64BIT
1177                && TREE_CODE (size) == INTEGER_CST
1178                && TREE_INT_CST_LOW (size) == 16
1179                && TREE_INT_CST_HIGH (size) == 0)
1180         return darwin_sections[literal16_section];
1181       else
1182         return readonly_data_section;
1183     }
1184
1185   return readonly_data_section;
1186 }
1187
1188 int
1189 machopic_reloc_rw_mask (void)
1190 {
1191   return MACHOPIC_INDIRECT ? 3 : 0;
1192 }
1193
1194 section *
1195 machopic_select_section (tree decl,
1196                          int reloc,
1197                          unsigned HOST_WIDE_INT align)
1198 {
1199   bool weak = (DECL_P (decl)
1200                && DECL_WEAK (decl)
1201                && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
1202                    || ! lookup_attribute ("weak_import",
1203                                           DECL_ATTRIBUTES (decl))));
1204   section *base_section;
1205
1206   switch (categorize_decl_for_section (decl, reloc))
1207     {
1208     case SECCAT_TEXT:
1209       base_section = darwin_text_section (reloc, weak);
1210       break;
1211
1212     case SECCAT_RODATA:
1213     case SECCAT_SRODATA:
1214       base_section = darwin_rodata_section (weak);
1215       break;
1216
1217     case SECCAT_RODATA_MERGE_STR:
1218       base_section = darwin_mergeable_string_section (decl, align);
1219       break;
1220
1221     case SECCAT_RODATA_MERGE_STR_INIT:
1222       base_section = darwin_mergeable_string_section (DECL_INITIAL (decl), align);
1223       break;
1224
1225     case SECCAT_RODATA_MERGE_CONST:
1226       base_section =  darwin_mergeable_constant_section (decl, align);
1227       break;
1228
1229     case SECCAT_DATA:
1230     case SECCAT_DATA_REL:
1231     case SECCAT_DATA_REL_LOCAL:
1232     case SECCAT_DATA_REL_RO:
1233     case SECCAT_DATA_REL_RO_LOCAL:
1234     case SECCAT_SDATA:
1235     case SECCAT_TDATA:
1236     case SECCAT_BSS:
1237     case SECCAT_SBSS:
1238     case SECCAT_TBSS:
1239       if (TREE_READONLY (decl) || TREE_CONSTANT (decl))
1240         base_section = weak ? darwin_sections[const_data_coal_section]
1241                             : darwin_sections[const_data_section];
1242       else
1243         base_section = weak ? darwin_sections[data_coal_section] : data_section;
1244       break;
1245
1246     default:
1247       gcc_unreachable ();
1248     }
1249
1250   /* Darwin weird special cases.  */
1251   if (TREE_CODE (decl) == CONSTRUCTOR
1252       && TREE_TYPE (decl)
1253       && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1254       && TYPE_NAME (TREE_TYPE (decl)))
1255     {
1256       tree name = TYPE_NAME (TREE_TYPE (decl));
1257       if (TREE_CODE (name) == TYPE_DECL)
1258         name = DECL_NAME (name);
1259
1260       if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1261         {
1262           if (flag_next_runtime)
1263             return darwin_sections[objc_constant_string_object_section];
1264           else
1265             return darwin_sections[objc_string_object_section];
1266         }
1267       else
1268         return base_section;
1269     }
1270   else if (TREE_CODE (decl) == VAR_DECL
1271            && DECL_NAME (decl)
1272            && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE
1273            && IDENTIFIER_POINTER (DECL_NAME (decl))
1274            && !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "_OBJC_", 6))
1275     {
1276       const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1277
1278       if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1279         return darwin_sections[objc_cls_meth_section];
1280       else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1281         return darwin_sections[objc_inst_meth_section];
1282       else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1283         return darwin_sections[objc_cat_cls_meth_section];
1284       else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1285         return darwin_sections[objc_cat_inst_meth_section];
1286       else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1287         return darwin_sections[objc_class_vars_section];
1288       else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1289         return darwin_sections[objc_instance_vars_section];
1290       else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1291         return darwin_sections[objc_cat_cls_meth_section];
1292       else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1293         return darwin_sections[objc_class_names_section];
1294       else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1295         return darwin_sections[objc_meth_var_names_section];
1296       else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1297         return darwin_sections[objc_meth_var_types_section];
1298       else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1299         return darwin_sections[objc_cls_refs_section];
1300       else if (!strncmp (name, "_OBJC_CLASS_", 12))
1301         return darwin_sections[objc_class_section];
1302       else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1303         return darwin_sections[objc_meta_class_section];
1304       else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1305         return darwin_sections[objc_category_section];
1306       else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1307         return darwin_sections[objc_selector_refs_section];
1308       else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1309         return darwin_sections[objc_selector_fixup_section];
1310       else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1311         return darwin_sections[objc_symbols_section];
1312       else if (!strncmp (name, "_OBJC_MODULES", 13))
1313         return darwin_sections[objc_module_info_section];
1314       else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1315         return darwin_sections[objc_image_info_section];
1316       else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1317         return darwin_sections[objc_cat_inst_meth_section];
1318       else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1319         return darwin_sections[objc_cat_cls_meth_section];
1320       else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1321         return darwin_sections[objc_cat_cls_meth_section];
1322       else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1323         return darwin_sections[objc_protocol_section];
1324       else
1325         return base_section;
1326     }
1327
1328   return base_section;
1329 }
1330
1331 /* This can be called with address expressions as "rtx".
1332    They must go in "const".  */
1333
1334 section *
1335 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1336                              unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1337 {
1338   if (GET_MODE_SIZE (mode) == 8
1339       && (GET_CODE (x) == CONST_INT
1340           || GET_CODE (x) == CONST_DOUBLE))
1341     return darwin_sections[literal8_section];
1342   else if (GET_MODE_SIZE (mode) == 4
1343            && (GET_CODE (x) == CONST_INT
1344                || GET_CODE (x) == CONST_DOUBLE))
1345     return darwin_sections[literal4_section];
1346   else if (HAVE_GAS_LITERAL16
1347            && TARGET_64BIT
1348            && GET_MODE_SIZE (mode) == 16
1349            && (GET_CODE (x) == CONST_INT
1350                || GET_CODE (x) == CONST_DOUBLE
1351                || GET_CODE (x) == CONST_VECTOR))
1352     return darwin_sections[literal16_section];
1353   else if (MACHOPIC_INDIRECT
1354            && (GET_CODE (x) == SYMBOL_REF
1355                || GET_CODE (x) == CONST
1356                || GET_CODE (x) == LABEL_REF))
1357     return darwin_sections[const_data_section];
1358   else
1359     return darwin_sections[const_section];
1360 }
1361
1362 void
1363 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1364 {
1365   if (MACHOPIC_INDIRECT)
1366     switch_to_section (darwin_sections[mod_init_section]);
1367   else
1368     switch_to_section (darwin_sections[constructor_section]);
1369   assemble_align (POINTER_SIZE);
1370   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1371
1372   if (! MACHOPIC_INDIRECT)
1373     fprintf (asm_out_file, ".reference .constructors_used\n");
1374 }
1375
1376 void
1377 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1378 {
1379   if (MACHOPIC_INDIRECT)
1380     switch_to_section (darwin_sections[mod_term_section]);
1381   else
1382     switch_to_section (darwin_sections[destructor_section]);
1383   assemble_align (POINTER_SIZE);
1384   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1385
1386   if (! MACHOPIC_INDIRECT)
1387     fprintf (asm_out_file, ".reference .destructors_used\n");
1388 }
1389
1390 void
1391 darwin_globalize_label (FILE *stream, const char *name)
1392 {
1393   if (!!strncmp (name, "_OBJC_", 6))
1394     default_globalize_label (stream, name);
1395 }
1396
1397 void
1398 darwin_asm_named_section (const char *name,
1399                           unsigned int flags ATTRIBUTE_UNUSED,
1400                           tree decl ATTRIBUTE_UNUSED)
1401 {
1402   fprintf (asm_out_file, "\t.section %s\n", name);
1403 }
1404
1405 void
1406 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1407 {
1408   /* Darwin does not use unique sections.  */
1409 }
1410
1411 /* Handle __attribute__ ((apple_kext_compatibility)).
1412    This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
1413    vtable for classes with this attribute (and their descendants) by not
1414    outputting the new 3.0 nondeleting destructor.  This means that such
1415    objects CANNOT be allocated on the stack or as globals UNLESS they have
1416    a completely empty `operator delete'.
1417    Luckily, this fits in with the Darwin kext model.
1418
1419    This attribute also disables gcc3's potential overlaying of derived
1420    class data members on the padding at the end of the base class.  */
1421
1422 tree
1423 darwin_handle_kext_attribute (tree *node, tree name,
1424                               tree args ATTRIBUTE_UNUSED,
1425                               int flags ATTRIBUTE_UNUSED,
1426                               bool *no_add_attrs)
1427 {
1428   /* APPLE KEXT stuff -- only applies with pure static C++ code.  */
1429   if (! TARGET_KEXTABI)
1430     {
1431       warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1432                "only when compiling a kext", IDENTIFIER_POINTER (name));
1433
1434       *no_add_attrs = true;
1435     }
1436   else if (TREE_CODE (*node) != RECORD_TYPE)
1437     {
1438       warning (0, "%<%s%> 2.95 vtable-compatibility attribute applies "
1439                "only to C++ classes", IDENTIFIER_POINTER (name));
1440
1441       *no_add_attrs = true;
1442     }
1443
1444   return NULL_TREE;
1445 }
1446
1447 /* Handle a "weak_import" attribute; arguments as in
1448    struct attribute_spec.handler.  */
1449
1450 tree
1451 darwin_handle_weak_import_attribute (tree *node, tree name,
1452                                      tree ARG_UNUSED (args),
1453                                      int ARG_UNUSED (flags),
1454                                      bool * no_add_attrs)
1455 {
1456   if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1457     {
1458       warning (OPT_Wattributes, "%qs attribute ignored",
1459                IDENTIFIER_POINTER (name));
1460       *no_add_attrs = true;
1461     }
1462   else
1463     declare_weak (*node);
1464
1465   return NULL_TREE;
1466 }
1467
1468 static void
1469 no_dead_strip (FILE *file, const char *lab)
1470 {
1471   fprintf (file, ".no_dead_strip %s\n", lab);
1472 }
1473
1474 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1475    The third parameter is nonzero if this is for exception handling.
1476    The fourth parameter is nonzero if this is just a placeholder for an
1477    FDE that we are omitting. */
1478
1479 void
1480 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1481 {
1482   const char *base;
1483   char *lab;
1484   bool need_quotes;
1485
1486   if (DECL_ASSEMBLER_NAME_SET_P (decl))
1487     base = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1488   else
1489     base = IDENTIFIER_POINTER (DECL_NAME (decl));
1490
1491   base = targetm.strip_name_encoding (base);
1492   need_quotes = name_needs_quotes (base);
1493
1494   if (! for_eh)
1495     return;
1496
1497   lab = concat (need_quotes ? "\"" : "", user_label_prefix, base, ".eh",
1498                 need_quotes ? "\"" : "", NULL);
1499
1500   if (TREE_PUBLIC (decl))
1501     fprintf (file, "\t%s %s\n",
1502              (DECL_VISIBILITY (decl) != VISIBILITY_HIDDEN
1503               ? ".globl"
1504               : ".private_extern"),
1505              lab);
1506
1507   if (DECL_WEAK (decl))
1508     fprintf (file, "\t.weak_definition %s\n", lab);
1509
1510   if (empty)
1511     {
1512       fprintf (file, "%s = 0\n", lab);
1513
1514       /* Mark the absolute .eh and .eh1 style labels as needed to
1515          ensure that we don't dead code strip them and keep such
1516          labels from another instantiation point until we can fix this
1517          properly with group comdat support.  */
1518       no_dead_strip (file, lab);
1519     }
1520   else
1521     fprintf (file, "%s:\n", lab);
1522
1523   free (lab);
1524 }
1525
1526 static GTY(()) unsigned long except_table_label_num;
1527
1528 void
1529 darwin_emit_except_table_label (FILE *file)
1530 {
1531   char section_start_label[30];
1532
1533   ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1534                                except_table_label_num++);
1535   ASM_OUTPUT_LABEL (file, section_start_label);
1536 }
1537 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
1538
1539 void
1540 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1541 {
1542   const char *nlp_name;
1543
1544   gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1545
1546   nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1547   fputs ("\t.long\t", file);
1548   ASM_OUTPUT_LABELREF (file, nlp_name);
1549   fputs ("-.", file);
1550 }
1551
1552 /* Emit an assembler directive to set visibility for a symbol.  The
1553    only supported visibilities are VISIBILITY_DEFAULT and
1554    VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1555    extern".  There is no MACH-O equivalent of ELF's
1556    VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1557
1558 void
1559 darwin_assemble_visibility (tree decl, int vis)
1560 {
1561   if (vis == VISIBILITY_DEFAULT)
1562     ;
1563   else if (vis == VISIBILITY_HIDDEN)
1564     {
1565       fputs ("\t.private_extern ", asm_out_file);
1566       assemble_name (asm_out_file,
1567                      (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1568       fputs ("\n", asm_out_file);
1569     }
1570   else
1571     warning (OPT_Wattributes, "internal and protected visibility attributes "
1572              "not supported in this configuration; ignored");
1573 }
1574
1575 /* Output a difference of two labels that will be an assembly time
1576    constant if the two labels are local.  (.long lab1-lab2 will be
1577    very different if lab1 is at the boundary between two sections; it
1578    will be relocated according to the second section, not the first,
1579    so one ends up with a difference between labels in different
1580    sections, which is bad in the dwarf2 eh context for instance.)  */
1581
1582 static int darwin_dwarf_label_counter;
1583
1584 void
1585 darwin_asm_output_dwarf_delta (FILE *file, int size,
1586                                const char *lab1, const char *lab2)
1587 {
1588   int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1589                      && lab2[0] == '*' && lab2[1] == 'L');
1590   const char *directive = (size == 8 ? ".quad" : ".long");
1591
1592   if (islocaldiff)
1593     fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1594   else
1595     fprintf (file, "\t%s\t", directive);
1596   assemble_name_raw (file, lab1);
1597   fprintf (file, "-");
1598   assemble_name_raw (file, lab2);
1599   if (islocaldiff)
1600     fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1601 }
1602
1603 /* Output labels for the start of the DWARF sections if necessary.  */
1604 void
1605 darwin_file_start (void)
1606 {
1607   if (write_symbols == DWARF2_DEBUG)
1608     {
1609       static const char * const debugnames[] =
1610         {
1611           DEBUG_FRAME_SECTION,
1612           DEBUG_INFO_SECTION,
1613           DEBUG_ABBREV_SECTION,
1614           DEBUG_ARANGES_SECTION,
1615           DEBUG_MACINFO_SECTION,
1616           DEBUG_LINE_SECTION,
1617           DEBUG_LOC_SECTION,
1618           DEBUG_PUBNAMES_SECTION,
1619           DEBUG_PUBTYPES_SECTION,
1620           DEBUG_STR_SECTION,
1621           DEBUG_RANGES_SECTION
1622         };
1623       size_t i;
1624
1625       for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1626         {
1627           int namelen;
1628
1629           switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1630
1631           gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1632           gcc_assert (strchr (debugnames[i] + 8, ','));
1633
1634           namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1635           fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1636         }
1637     }
1638 }
1639
1640 /* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
1641    offsets are not represented using relocs in .o files; either the
1642    section never leaves the .o file, or the linker or other tool is
1643    responsible for parsing the DWARF and updating the offsets.  */
1644
1645 void
1646 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1647                                 section *base)
1648 {
1649   char sname[64];
1650   int namelen;
1651
1652   gcc_assert (base->common.flags & SECTION_NAMED);
1653   gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1654   gcc_assert (strchr (base->named.name + 8, ','));
1655
1656   namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1657   sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1658   darwin_asm_output_dwarf_delta (file, size, lab, sname);
1659 }
1660
1661 void
1662 darwin_file_end (void)
1663 {
1664   machopic_finish (asm_out_file);
1665   if (strcmp (lang_hooks.name, "GNU C++") == 0)
1666     {
1667       switch_to_section (darwin_sections[constructor_section]);
1668       switch_to_section (darwin_sections[destructor_section]);
1669       ASM_OUTPUT_ALIGN (asm_out_file, 1);
1670     }
1671   fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1672 }
1673
1674 /* TODO: Add a language hook for identifying if a decl is a vtable.  */
1675 #define DARWIN_VTABLE_P(DECL) 0
1676
1677 /* Cross-module name binding.  Darwin does not support overriding
1678    functions at dynamic-link time, except for vtables in kexts.  */
1679
1680 bool
1681 darwin_binds_local_p (const_tree decl)
1682 {
1683   return default_binds_local_p_1 (decl,
1684                                   TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
1685 }
1686
1687 #if 0
1688 /* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet.  */
1689 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
1690    anchor relative to ".", the current section position.  We cannot use
1691    the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
1692
1693 void
1694 darwin_asm_output_anchor (rtx symbol)
1695 {
1696   fprintf (asm_out_file, "\t.set\t");
1697   assemble_name (asm_out_file, XSTR (symbol, 0));
1698   fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1699            SYMBOL_REF_BLOCK_OFFSET (symbol));
1700 }
1701 #endif
1702
1703 /* Set the darwin specific attributes on TYPE.  */
1704 void
1705 darwin_set_default_type_attributes (tree type)
1706 {
1707   if (darwin_ms_struct
1708       && TREE_CODE (type) == RECORD_TYPE)
1709     TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1710                                         NULL_TREE,
1711                                         TYPE_ATTRIBUTES (type));
1712 }
1713
1714 /* True, iff we're generating code for loadable kernel extensions.  */
1715
1716 bool
1717 darwin_kextabi_p (void) {
1718   return flag_apple_kext;
1719 }
1720
1721 void
1722 darwin_override_options (void)
1723 {
1724   if (flag_mkernel || flag_apple_kext)
1725     {
1726       /* -mkernel implies -fapple-kext for C++ */
1727       if (strcmp (lang_hooks.name, "GNU C++") == 0)
1728         flag_apple_kext = 1;
1729
1730       flag_no_common = 1;
1731
1732       /* No EH in kexts.  */
1733       flag_exceptions = 0;
1734       /* No -fnon-call-exceptions data in kexts.  */
1735       flag_non_call_exceptions = 0;
1736     }
1737   if (flag_var_tracking
1738       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1739       && debug_info_level >= DINFO_LEVEL_NORMAL
1740       && debug_hooks->var_location != do_nothing_debug_hooks.var_location)
1741     flag_var_tracking_uninit = 1;
1742 }
1743
1744 #include "gt-darwin.h"