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