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 Free Software Foundation, Inc.
4 Contributed by Apple Computer Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
35 #include "insn-attr.h"
42 #include "langhooks.h"
47 /* Darwin supports a feature called fix-and-continue, which is used
48 for rapid turn around debugging. When code is compiled with the
49 -mfix-and-continue flag, two changes are made to the generated code
50 that allow the system to do things that it would normally not be
51 able to do easily. These changes allow gdb to load in
52 recompilation of a translation unit that has been changed into a
53 running program and replace existing functions and methods of that
54 translation unit with with versions of those functions and methods
55 from the newly compiled translation unit. The new functions access
56 the existing static data from the old translation unit, if the data
57 existed in the unit to be replaced, and from the new translation
60 The changes are to insert 4 nops at the beginning of all functions
61 and to use indirection to get at static duration data. The 4 nops
62 are required by consumers of the generated code. Currently, gdb
63 uses this to patch in a jump to the overriding function, this
64 allows all uses of the old name to forward to the replacement,
65 including existing function poiinters and virtual methods. See
66 rs6000_emit_prologue for the code that handles the nop insertions.
68 The added indirection allows gdb to redirect accesses to static
69 duration data from the newly loaded translation unit to the
70 existing data, if any. @code{static} data is special and is
71 handled by setting the second word in the .non_lazy_symbol_pointer
72 data structure to the address of the data. See indirect_data for
73 the code that handles the extra indirection, and
74 machopic_output_indirection and its use of MACHO_SYMBOL_STATIC for
75 the code that handles @code{static} data indirection. */
78 /* Nonzero if the user passes the -mone-byte-bool switch, which forces
79 sizeof(bool) to be 1. */
80 const char *darwin_one_byte_bool
= 0;
83 name_needs_quotes (const char *name
)
86 while ((c
= *name
++) != '\0')
87 if (! ISIDNUM (c
) && c
!= '.' && c
!= '$')
93 * flag_pic = 1 ... generate only indirections
94 * flag_pic = 2 ... generate indirections and pure code
98 machopic_symbol_defined_p (rtx sym_ref
)
100 return (SYMBOL_REF_FLAGS (sym_ref
) & MACHO_SYMBOL_FLAG_DEFINED
)
101 || (SYMBOL_REF_LOCAL_P (sym_ref
) && ! SYMBOL_REF_EXTERNAL_P (sym_ref
));
104 /* This module assumes that (const (symbol_ref "foo")) is a legal pic
105 reference, which will not be changed. */
107 enum machopic_addr_class
108 machopic_classify_symbol (rtx sym_ref
)
113 flags
= SYMBOL_REF_FLAGS (sym_ref
);
114 function_p
= SYMBOL_REF_FUNCTION_P (sym_ref
);
115 if (machopic_symbol_defined_p (sym_ref
))
117 ? MACHOPIC_DEFINED_FUNCTION
: MACHOPIC_DEFINED_DATA
);
120 ? MACHOPIC_UNDEFINED_FUNCTION
: MACHOPIC_UNDEFINED_DATA
);
123 #ifndef TARGET_FIX_AND_CONTINUE
124 #define TARGET_FIX_AND_CONTINUE 0
127 /* Indicate when fix-and-continue style code generation is being used
128 and when a reference to data should be indirected so that it can be
129 rebound in a new translation unit to refernce the original instance
130 of that data. Symbol names that are for code generation local to
131 the translation unit are bound to the new translation unit;
132 currently this means symbols that begin with L or _OBJC_;
133 otherwise, we indicate that an indirect reference should be made to
134 permit the runtime to rebind new instances of the translation unit
135 to the original instance of the data. */
138 indirect_data (rtx sym_ref
)
143 /* If we aren't generating fix-and-continue code, don't do anything special. */
144 if (TARGET_FIX_AND_CONTINUE
== 0)
147 /* Otherwise, all symbol except symbols that begin with L or _OBJC_
148 are indirected. Symbols that begin with L and _OBJC_ are always
149 bound to the current translation unit as they are used for
150 generated local data of the translation unit. */
152 name
= XSTR (sym_ref
, 0);
154 lprefix
= (((name
[0] == '*' || name
[0] == '&')
155 && (name
[1] == 'L' || (name
[1] == '"' && name
[2] == 'L')))
156 || (strncmp (name
, "_OBJC_", 6)));
163 machopic_data_defined_p (rtx sym_ref
)
165 if (indirect_data (sym_ref
))
168 switch (machopic_classify_symbol (sym_ref
))
170 case MACHOPIC_DEFINED_DATA
:
178 machopic_define_symbol (rtx mem
)
181 if (GET_CODE (mem
) != MEM
)
183 sym_ref
= XEXP (mem
, 0);
184 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
187 static GTY(()) char * function_base
;
190 machopic_function_base_name (void)
192 /* if dynamic-no-pic is on, we should not get here */
193 if (MACHO_DYNAMIC_NO_PIC_P
)
196 if (function_base
== NULL
)
198 (char *) ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
200 current_function_uses_pic_offset_table
= 1;
202 return function_base
;
205 /* Return a SYMBOL_REF for the PIC function base. */
208 machopic_function_base_sym (void)
212 sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, machopic_function_base_name ());
213 SYMBOL_REF_FLAGS (sym_ref
)
214 |= (MACHO_SYMBOL_FLAG_VARIABLE
| MACHO_SYMBOL_FLAG_DEFINED
);
218 static GTY(()) const char * function_base_func_name
;
219 static GTY(()) int current_pic_label_num
;
222 machopic_output_function_base_name (FILE *file
)
224 const char *current_name
;
226 /* If dynamic-no-pic is on, we should not get here. */
227 if (MACHO_DYNAMIC_NO_PIC_P
)
230 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
231 if (function_base_func_name
!= current_name
)
233 ++current_pic_label_num
;
234 function_base_func_name
= current_name
;
236 fprintf (file
, "\"L%011d$pb\"", current_pic_label_num
);
239 /* The suffix attached to non-lazy pointer symbols. */
240 #define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
241 /* The suffix attached to stub symbols. */
242 #define STUB_SUFFIX "$stub"
244 typedef struct machopic_indirection
GTY (())
246 /* The SYMBOL_REF for the entity referenced. */
248 /* The IDENTIFIER_NODE giving the name of the stub or non-lazy
251 /* True iff this entry is for a stub (as opposed to a non-lazy
254 /* True iff this stub or pointer pointer has been referenced. */
256 } machopic_indirection
;
258 /* A table mapping stub names and non-lazy pointer names to
259 SYMBOL_REFs for the stubbed-to and pointed-to entities. */
261 static GTY ((param_is (struct machopic_indirection
))) htab_t
262 machopic_indirections
;
264 /* Return a hash value for a SLOT in the indirections hash table. */
267 machopic_indirection_hash (const void *slot
)
269 const machopic_indirection
*p
= (const machopic_indirection
*) slot
;
270 return IDENTIFIER_HASH_VALUE (p
->ptr_name
);
273 /* Returns true if the KEY is the same as that associated with
277 machopic_indirection_eq (const void *slot
, const void *key
)
279 return ((const machopic_indirection
*) slot
)->ptr_name
== (tree
) key
;
282 /* Return the name of the non-lazy pointer (if STUB_P is false) or
283 stub (if STUB_B is true) corresponding to the given name. */
286 machopic_indirection_name (rtx sym_ref
, bool stub_p
)
289 const char *name
= XSTR (sym_ref
, 0);
290 int namelen
= strlen (name
);
292 machopic_indirection
*p
;
294 /* Construct the name of the non-lazy pointer or stub. */
297 int needs_quotes
= name_needs_quotes (name
);
298 buffer
= alloca (strlen ("&L")
300 + strlen (STUB_SUFFIX
)
301 + 2 /* possible quotes */
307 sprintf (buffer
, "&\"L%s" STUB_SUFFIX
"\"", name
+ 1);
309 sprintf (buffer
, "&\"L%s%s" STUB_SUFFIX
"\"", user_label_prefix
,
312 else if (name
[0] == '*')
313 sprintf (buffer
, "&L%s" STUB_SUFFIX
, name
+ 1);
315 sprintf (buffer
, "&L%s%s" STUB_SUFFIX
, user_label_prefix
, name
);
319 buffer
= alloca (strlen ("&L")
320 + strlen (user_label_prefix
)
322 + strlen (NON_LAZY_POINTER_SUFFIX
)
325 sprintf (buffer
, "&L%s" NON_LAZY_POINTER_SUFFIX
, name
+ 1);
327 sprintf (buffer
, "&L%s%s" NON_LAZY_POINTER_SUFFIX
,
328 user_label_prefix
, name
);
331 /* See if we already have it. */
332 ptr_name
= maybe_get_identifier (buffer
);
333 /* If not, create a mapping from the non-lazy pointer to the
338 ptr_name
= get_identifier (buffer
);
339 p
= (machopic_indirection
*) ggc_alloc (sizeof (machopic_indirection
));
341 p
->ptr_name
= ptr_name
;
344 if (!machopic_indirections
)
345 machopic_indirections
346 = htab_create_ggc (37,
347 machopic_indirection_hash
,
348 machopic_indirection_eq
,
350 slot
= htab_find_slot_with_hash (machopic_indirections
, ptr_name
,
351 IDENTIFIER_HASH_VALUE (ptr_name
),
353 *((machopic_indirection
**) slot
) = p
;
356 return IDENTIFIER_POINTER (ptr_name
);
359 /* Return the name of the stub for the mcount function. */
362 machopic_mcount_stub_name (void)
364 return "&L*mcount$stub";
367 /* If NAME is the name of a stub or a non-lazy pointer , mark the stub
368 or non-lazy pointer as used -- and mark the object to which the
369 pointer/stub refers as used as well, since the pointer/stub will
370 emit a reference to it. */
373 machopic_validate_stub_or_non_lazy_ptr (const char *name
)
375 tree ident
= get_identifier (name
);
377 machopic_indirection
*p
;
379 p
= ((machopic_indirection
*)
380 (htab_find_with_hash (machopic_indirections
, ident
,
381 IDENTIFIER_HASH_VALUE (ident
))));
385 mark_referenced (ident
);
386 mark_referenced (get_identifier (XSTR (p
->symbol
, 0)));
390 /* Transform ORIG, which may be any data source, to the corresponding
391 source using indirections. */
394 machopic_indirect_data_reference (rtx orig
, rtx reg
)
398 if (! MACHOPIC_INDIRECT
)
401 if (GET_CODE (orig
) == SYMBOL_REF
)
403 int defined
= machopic_data_defined_p (orig
);
405 if (defined
&& MACHO_DYNAMIC_NO_PIC_P
)
407 #if defined (TARGET_TOC)
408 emit_insn (GET_MODE (orig
) == DImode
409 ? gen_macho_high_di (reg
, orig
)
410 : gen_macho_high (reg
, orig
));
411 emit_insn (GET_MODE (orig
) == DImode
412 ? gen_macho_low_di (reg
, reg
, orig
)
413 : gen_macho_low (reg
, reg
, orig
));
415 /* some other cpu -- writeme! */
422 #if defined (TARGET_TOC) || defined (HAVE_lo_sum)
423 rtx pic_base
= machopic_function_base_sym ();
424 rtx offset
= gen_rtx_CONST (Pmode
,
425 gen_rtx_MINUS (Pmode
, orig
, pic_base
));
428 #if defined (TARGET_TOC) /* i.e., PowerPC */
429 rtx hi_sum_reg
= (no_new_pseudos
? reg
: gen_reg_rtx (Pmode
));
434 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
435 gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
,
436 gen_rtx_HIGH (Pmode
, offset
))));
437 emit_insn (gen_rtx_SET (Pmode
, reg
,
438 gen_rtx_LO_SUM (Pmode
, hi_sum_reg
, offset
)));
442 #if defined (HAVE_lo_sum)
443 if (reg
== 0) abort ();
445 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
446 gen_rtx_HIGH (Pmode
, offset
)));
447 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
448 gen_rtx_LO_SUM (Pmode
, reg
, offset
)));
449 emit_insn (gen_rtx_USE (VOIDmode
, pic_offset_table_rtx
));
451 orig
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, reg
);
457 ptr_ref
= (gen_rtx_SYMBOL_REF
459 machopic_indirection_name (orig
, /*stub_p=*/false)));
461 SYMBOL_REF_DECL (ptr_ref
) = SYMBOL_REF_DECL (orig
);
463 ptr_ref
= gen_const_mem (Pmode
, ptr_ref
);
464 machopic_define_symbol (ptr_ref
);
468 else if (GET_CODE (orig
) == CONST
)
472 /* legitimize both operands of the PLUS */
473 if (GET_CODE (XEXP (orig
, 0)) == PLUS
)
475 base
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 0),
477 orig
= machopic_indirect_data_reference (XEXP (XEXP (orig
, 0), 1),
478 (base
== reg
? 0 : reg
));
483 if (MACHOPIC_PURE
&& GET_CODE (orig
) == CONST_INT
)
484 result
= plus_constant (base
, INTVAL (orig
));
486 result
= gen_rtx_PLUS (Pmode
, base
, orig
);
488 if (MACHOPIC_JUST_INDIRECT
&& GET_CODE (base
) == MEM
)
492 emit_move_insn (reg
, result
);
497 result
= force_reg (GET_MODE (result
), result
);
504 else if (GET_CODE (orig
) == MEM
)
505 XEXP (ptr_ref
, 0) = machopic_indirect_data_reference (XEXP (orig
, 0), reg
);
506 /* When the target is i386, this code prevents crashes due to the
507 compiler's ignorance on how to move the PIC base register to
508 other registers. (The reload phase sometimes introduces such
510 else if (GET_CODE (orig
) == PLUS
511 && GET_CODE (XEXP (orig
, 0)) == REG
512 && REGNO (XEXP (orig
, 0)) == PIC_OFFSET_TABLE_REGNUM
514 /* Prevent the same register from being erroneously used
515 as both the base and index registers. */
516 && GET_CODE (XEXP (orig
, 1)) == CONST
520 emit_move_insn (reg
, XEXP (orig
, 0));
521 XEXP (ptr_ref
, 0) = reg
;
526 /* Transform TARGET (a MEM), which is a function call target, to the
527 corresponding symbol_stub if necessary. Return a new MEM. */
530 machopic_indirect_call_target (rtx target
)
532 if (GET_CODE (target
) != MEM
)
535 if (MACHOPIC_INDIRECT
536 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
537 && !(SYMBOL_REF_FLAGS (XEXP (target
, 0))
538 & MACHO_SYMBOL_FLAG_DEFINED
))
540 rtx sym_ref
= XEXP (target
, 0);
541 const char *stub_name
= machopic_indirection_name (sym_ref
,
543 enum machine_mode mode
= GET_MODE (sym_ref
);
544 tree decl
= SYMBOL_REF_DECL (sym_ref
);
546 XEXP (target
, 0) = gen_rtx_SYMBOL_REF (mode
, stub_name
);
547 SYMBOL_REF_DECL (XEXP (target
, 0)) = decl
;
548 MEM_READONLY_P (target
) = 1;
549 MEM_NOTRAP_P (target
) = 1;
556 machopic_legitimize_pic_address (rtx orig
, enum machine_mode mode
, rtx reg
)
560 if (! MACHOPIC_INDIRECT
)
563 /* First handle a simple SYMBOL_REF or LABEL_REF */
564 if (GET_CODE (orig
) == LABEL_REF
565 || (GET_CODE (orig
) == SYMBOL_REF
568 /* addr(foo) = &func+(foo-func) */
571 orig
= machopic_indirect_data_reference (orig
, reg
);
573 if (GET_CODE (orig
) == PLUS
574 && GET_CODE (XEXP (orig
, 0)) == REG
)
577 return force_reg (mode
, orig
);
579 emit_move_insn (reg
, orig
);
583 /* if dynamic-no-pic then use 0 as the pic base */
584 if (MACHO_DYNAMIC_NO_PIC_P
)
585 pic_base
= CONST0_RTX (Pmode
);
587 pic_base
= machopic_function_base_sym ();
589 if (GET_CODE (orig
) == MEM
)
593 if (reload_in_progress
)
596 reg
= gen_reg_rtx (Pmode
);
600 if (MACHO_DYNAMIC_NO_PIC_P
601 && (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
602 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
))
604 #if defined (TARGET_TOC) /* ppc */
605 rtx temp_reg
= (no_new_pseudos
) ? reg
: gen_reg_rtx (Pmode
);
606 rtx asym
= XEXP (orig
, 0);
609 emit_insn (mode
== DImode
610 ? gen_macho_high_di (temp_reg
, asym
)
611 : gen_macho_high (temp_reg
, asym
));
612 mem
= gen_const_mem (GET_MODE (orig
),
613 gen_rtx_LO_SUM (Pmode
, temp_reg
, asym
));
614 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
616 /* Some other CPU -- WriteMe! but right now there are no other platform that can use dynamic-no-pic */
622 if (GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
623 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
625 rtx offset
= gen_rtx_CONST (Pmode
,
626 gen_rtx_MINUS (Pmode
,
629 #if defined (TARGET_TOC) /* i.e., PowerPC */
630 /* Generating a new reg may expose opportunities for
631 common subexpression elimination. */
632 rtx hi_sum_reg
= no_new_pseudos
? reg
: gen_reg_rtx (Pmode
);
637 sum
= gen_rtx_HIGH (Pmode
, offset
);
638 if (! MACHO_DYNAMIC_NO_PIC_P
)
639 sum
= gen_rtx_PLUS (Pmode
, pic_offset_table_rtx
, sum
);
641 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
, sum
));
643 mem
= gen_const_mem (GET_MODE (orig
),
644 gen_rtx_LO_SUM (Pmode
,
645 hi_sum_reg
, offset
));
646 insn
= emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
647 REG_NOTES (insn
) = gen_rtx_EXPR_LIST (REG_EQUAL
, pic_ref
,
652 emit_insn (gen_rtx_USE (VOIDmode
,
654 PIC_OFFSET_TABLE_REGNUM
)));
656 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
658 gen_rtx_CONST (Pmode
,
660 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
661 gen_rtx_LO_SUM (Pmode
, reg
,
662 gen_rtx_CONST (Pmode
, offset
))));
663 pic_ref
= gen_rtx_PLUS (Pmode
,
664 pic_offset_table_rtx
, reg
);
668 #endif /* HAVE_lo_sum */
670 rtx pic
= pic_offset_table_rtx
;
671 if (GET_CODE (pic
) != REG
)
673 emit_move_insn (reg
, pic
);
677 emit_insn (gen_rtx_USE (VOIDmode
,
679 PIC_OFFSET_TABLE_REGNUM
)));
682 pic_ref
= gen_rtx_PLUS (Pmode
,
684 gen_rtx_CONST (Pmode
,
685 gen_rtx_MINUS (Pmode
,
690 #if !defined (TARGET_TOC)
691 emit_move_insn (reg
, pic_ref
);
692 pic_ref
= gen_const_mem (GET_MODE (orig
), reg
);
699 if (GET_CODE (orig
) == SYMBOL_REF
700 || GET_CODE (orig
) == LABEL_REF
)
702 rtx offset
= gen_rtx_CONST (Pmode
,
703 gen_rtx_MINUS (Pmode
,
705 #if defined (TARGET_TOC) /* i.e., PowerPC */
710 if (reload_in_progress
)
713 reg
= gen_reg_rtx (Pmode
);
718 emit_insn (gen_rtx_SET (Pmode
, hi_sum_reg
,
719 (MACHO_DYNAMIC_NO_PIC_P
)
720 ? gen_rtx_HIGH (Pmode
, offset
)
721 : gen_rtx_PLUS (Pmode
,
722 pic_offset_table_rtx
,
725 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
726 gen_rtx_LO_SUM (Pmode
,
727 hi_sum_reg
, offset
)));
730 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
731 gen_rtx_HIGH (Pmode
, offset
)));
732 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
733 gen_rtx_LO_SUM (Pmode
, reg
, offset
)));
734 pic_ref
= gen_rtx_PLUS (Pmode
,
735 pic_offset_table_rtx
, reg
);
739 #endif /* HAVE_lo_sum */
741 if (GET_CODE (orig
) == REG
)
747 rtx pic
= pic_offset_table_rtx
;
748 if (GET_CODE (pic
) != REG
)
750 emit_move_insn (reg
, pic
);
754 emit_insn (gen_rtx_USE (VOIDmode
,
755 pic_offset_table_rtx
));
757 pic_ref
= gen_rtx_PLUS (Pmode
,
759 gen_rtx_CONST (Pmode
,
760 gen_rtx_MINUS (Pmode
,
766 if (GET_CODE (pic_ref
) != REG
)
770 emit_move_insn (reg
, pic_ref
);
775 return force_reg (mode
, pic_ref
);
784 else if (GET_CODE (orig
) == SYMBOL_REF
)
787 else if (GET_CODE (orig
) == PLUS
788 && (GET_CODE (XEXP (orig
, 0)) == MEM
789 || GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
790 || GET_CODE (XEXP (orig
, 0)) == LABEL_REF
)
791 && XEXP (orig
, 0) != pic_offset_table_rtx
792 && GET_CODE (XEXP (orig
, 1)) != REG
)
796 int is_complex
= (GET_CODE (XEXP (orig
, 0)) == MEM
);
798 base
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
799 orig
= machopic_legitimize_pic_address (XEXP (orig
, 1),
800 Pmode
, (base
== reg
? 0 : reg
));
801 if (GET_CODE (orig
) == CONST_INT
)
803 pic_ref
= plus_constant (base
, INTVAL (orig
));
807 pic_ref
= gen_rtx_PLUS (Pmode
, base
, orig
);
809 if (reg
&& is_complex
)
811 emit_move_insn (reg
, pic_ref
);
814 /* Likewise, should we set special REG_NOTEs here? */
817 else if (GET_CODE (orig
) == CONST
)
819 return machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
822 else if (GET_CODE (orig
) == MEM
823 && GET_CODE (XEXP (orig
, 0)) == SYMBOL_REF
)
825 rtx addr
= machopic_legitimize_pic_address (XEXP (orig
, 0), Pmode
, reg
);
826 addr
= replace_equiv_address (orig
, addr
);
827 emit_move_insn (reg
, addr
);
834 /* Output the stub or non-lazy pointer in *SLOT, if it has been used.
835 DATA is the FILE* for assembly output. Called from
839 machopic_output_indirection (void **slot
, void *data
)
841 machopic_indirection
*p
= *((machopic_indirection
**) slot
);
842 FILE *asm_out_file
= (FILE *) data
;
844 const char *sym_name
;
845 const char *ptr_name
;
851 sym_name
= XSTR (symbol
, 0);
852 ptr_name
= IDENTIFIER_POINTER (p
->ptr_name
);
859 sym
= alloca (strlen (sym_name
) + 2);
860 if (sym_name
[0] == '*' || sym_name
[0] == '&')
861 strcpy (sym
, sym_name
+ 1);
862 else if (sym_name
[0] == '-' || sym_name
[0] == '+')
863 strcpy (sym
, sym_name
);
865 sprintf (sym
, "%s%s", user_label_prefix
, sym_name
);
867 stub
= alloca (strlen (ptr_name
) + 2);
868 if (ptr_name
[0] == '*' || ptr_name
[0] == '&')
869 strcpy (stub
, ptr_name
+ 1);
871 sprintf (stub
, "%s%s", user_label_prefix
, ptr_name
);
873 machopic_output_stub (asm_out_file
, sym
, stub
);
875 else if (! indirect_data (symbol
)
876 && (machopic_symbol_defined_p (symbol
)
877 || SYMBOL_REF_LOCAL_P (symbol
)))
880 assemble_align (GET_MODE_ALIGNMENT (Pmode
));
881 assemble_label (ptr_name
);
882 assemble_integer (gen_rtx_SYMBOL_REF (Pmode
, sym_name
),
883 GET_MODE_SIZE (Pmode
),
884 GET_MODE_ALIGNMENT (Pmode
), 1);
888 rtx init
= const0_rtx
;
890 machopic_nl_symbol_ptr_section ();
891 assemble_name (asm_out_file
, ptr_name
);
892 fprintf (asm_out_file
, ":\n");
894 fprintf (asm_out_file
, "\t.indirect_symbol ");
895 assemble_name (asm_out_file
, sym_name
);
896 fprintf (asm_out_file
, "\n");
898 /* Variables that are marked with MACHO_SYMBOL_STATIC need to
899 have their symbol name instead of 0 in the second entry of
900 the non-lazy symbol pointer data structure when they are
901 defined. This allows the runtime to rebind newer instances
902 of the translation unit with the original instance of the
905 if ((SYMBOL_REF_FLAGS (symbol
) & MACHO_SYMBOL_STATIC
)
906 && machopic_symbol_defined_p (symbol
))
907 init
= gen_rtx_SYMBOL_REF (Pmode
, sym_name
);
909 assemble_integer (init
, GET_MODE_SIZE (Pmode
),
910 GET_MODE_ALIGNMENT (Pmode
), 1);
917 machopic_finish (FILE *asm_out_file
)
919 if (machopic_indirections
)
920 htab_traverse_noresize (machopic_indirections
,
921 machopic_output_indirection
,
926 machopic_operand_p (rtx op
)
928 if (MACHOPIC_JUST_INDIRECT
)
930 while (GET_CODE (op
) == CONST
)
933 if (GET_CODE (op
) == SYMBOL_REF
)
934 return machopic_symbol_defined_p (op
);
939 while (GET_CODE (op
) == CONST
)
942 if (GET_CODE (op
) == MINUS
943 && GET_CODE (XEXP (op
, 0)) == SYMBOL_REF
944 && GET_CODE (XEXP (op
, 1)) == SYMBOL_REF
945 && machopic_symbol_defined_p (XEXP (op
, 0))
946 && machopic_symbol_defined_p (XEXP (op
, 1)))
952 /* This function records whether a given name corresponds to a defined
953 or undefined function or variable, for machopic_classify_ident to
957 darwin_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
961 /* Do the standard encoding things first. */
962 default_encode_section_info (decl
, rtl
, first
);
964 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
967 sym_ref
= XEXP (rtl
, 0);
968 if (TREE_CODE (decl
) == VAR_DECL
)
969 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_VARIABLE
;
971 if (!DECL_EXTERNAL (decl
)
972 && (!TREE_PUBLIC (decl
) || (!DECL_ONE_ONLY (decl
) && !DECL_WEAK (decl
)))
973 && ((TREE_STATIC (decl
)
974 && (!DECL_COMMON (decl
) || !TREE_PUBLIC (decl
)))
975 || (!DECL_COMMON (decl
) && DECL_INITIAL (decl
)
976 && DECL_INITIAL (decl
) != error_mark_node
)))
977 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_FLAG_DEFINED
;
979 if (TREE_CODE (decl
) == VAR_DECL
980 && indirect_data (sym_ref
)
981 && ! TREE_PUBLIC (decl
))
982 SYMBOL_REF_FLAGS (sym_ref
) |= MACHO_SYMBOL_STATIC
;
985 static GTY(()) tree textcoal_section
= 0;
986 static GTY(()) tree datacoal_section
= 0;
989 darwin_make_decl_one_only (tree decl
)
992 if (textcoal_section
== 0)
994 static const char *ts
= "__TEXT,__textcoal_nt,coalesced,no_toc";
995 static const char *ds
= "__DATA,__datacoal_nt,coalesced,no_toc";
996 textcoal_section
= build_string (strlen (ts
), ts
);
997 datacoal_section
= build_string (strlen (ds
), ds
);
1000 sec
= TREE_CODE (decl
) == FUNCTION_DECL
1003 TREE_PUBLIC (decl
) = 1;
1004 DECL_ONE_ONLY (decl
) = 1;
1005 DECL_SECTION_NAME (decl
) = sec
;
1009 darwin_mark_decl_preserved (const char *name
)
1011 fprintf (asm_out_file
, ".no_dead_strip ");
1012 assemble_name (asm_out_file
, name
);
1013 fputc ('\n', asm_out_file
);
1017 machopic_select_section (tree exp
, int reloc
,
1018 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1020 void (*base_function
)(void);
1022 if (decl_readonly_section_1 (exp
, reloc
, MACHOPIC_INDIRECT
))
1023 base_function
= readonly_data_section
;
1024 else if (TREE_READONLY (exp
) || TREE_CONSTANT (exp
))
1025 base_function
= const_data_section
;
1027 base_function
= data_section
;
1029 if (TREE_CODE (exp
) == STRING_CST
1030 && ((size_t) TREE_STRING_LENGTH (exp
)
1031 == strlen (TREE_STRING_POINTER (exp
)) + 1))
1033 else if ((TREE_CODE (exp
) == INTEGER_CST
|| TREE_CODE (exp
) == REAL_CST
)
1034 && flag_merge_constants
)
1036 tree size
= TYPE_SIZE (TREE_TYPE (exp
));
1038 if (TREE_CODE (size
) == INTEGER_CST
&&
1039 TREE_INT_CST_LOW (size
) == 4 &&
1040 TREE_INT_CST_HIGH (size
) == 0)
1041 literal4_section ();
1042 else if (TREE_CODE (size
) == INTEGER_CST
&&
1043 TREE_INT_CST_LOW (size
) == 8 &&
1044 TREE_INT_CST_HIGH (size
) == 0)
1045 literal8_section ();
1049 else if (TREE_CODE (exp
) == CONSTRUCTOR
1051 && TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
1052 && TYPE_NAME (TREE_TYPE (exp
)))
1054 tree name
= TYPE_NAME (TREE_TYPE (exp
));
1055 if (TREE_CODE (name
) == TYPE_DECL
)
1056 name
= DECL_NAME (name
);
1057 if (!strcmp (IDENTIFIER_POINTER (name
), "NSConstantString"))
1058 objc_constant_string_object_section ();
1059 else if (!strcmp (IDENTIFIER_POINTER (name
), "NXConstantString"))
1060 objc_string_object_section ();
1064 else if (TREE_CODE (exp
) == VAR_DECL
&&
1066 TREE_CODE (DECL_NAME (exp
)) == IDENTIFIER_NODE
&&
1067 IDENTIFIER_POINTER (DECL_NAME (exp
)) &&
1068 !strncmp (IDENTIFIER_POINTER (DECL_NAME (exp
)), "_OBJC_", 6))
1070 const char *name
= IDENTIFIER_POINTER (DECL_NAME (exp
));
1072 if (!strncmp (name
, "_OBJC_CLASS_METHODS_", 20))
1073 objc_cls_meth_section ();
1074 else if (!strncmp (name
, "_OBJC_INSTANCE_METHODS_", 23))
1075 objc_inst_meth_section ();
1076 else if (!strncmp (name
, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1077 objc_cat_cls_meth_section ();
1078 else if (!strncmp (name
, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1079 objc_cat_inst_meth_section ();
1080 else if (!strncmp (name
, "_OBJC_CLASS_VARIABLES_", 22))
1081 objc_class_vars_section ();
1082 else if (!strncmp (name
, "_OBJC_INSTANCE_VARIABLES_", 25))
1083 objc_instance_vars_section ();
1084 else if (!strncmp (name
, "_OBJC_CLASS_PROTOCOLS_", 22))
1085 objc_cat_cls_meth_section ();
1086 else if (!strncmp (name
, "_OBJC_CLASS_NAME_", 17))
1087 objc_class_names_section ();
1088 else if (!strncmp (name
, "_OBJC_METH_VAR_NAME_", 20))
1089 objc_meth_var_names_section ();
1090 else if (!strncmp (name
, "_OBJC_METH_VAR_TYPE_", 20))
1091 objc_meth_var_types_section ();
1092 else if (!strncmp (name
, "_OBJC_CLASS_REFERENCES", 22))
1093 objc_cls_refs_section ();
1094 else if (!strncmp (name
, "_OBJC_CLASS_", 12))
1095 objc_class_section ();
1096 else if (!strncmp (name
, "_OBJC_METACLASS_", 16))
1097 objc_meta_class_section ();
1098 else if (!strncmp (name
, "_OBJC_CATEGORY_", 15))
1099 objc_category_section ();
1100 else if (!strncmp (name
, "_OBJC_SELECTOR_REFERENCES", 25))
1101 objc_selector_refs_section ();
1102 else if (!strncmp (name
, "_OBJC_SELECTOR_FIXUP", 20))
1103 objc_selector_fixup_section ();
1104 else if (!strncmp (name
, "_OBJC_SYMBOLS", 13))
1105 objc_symbols_section ();
1106 else if (!strncmp (name
, "_OBJC_MODULES", 13))
1107 objc_module_info_section ();
1108 else if (!strncmp (name
, "_OBJC_IMAGE_INFO", 16))
1109 objc_image_info_section ();
1110 else if (!strncmp (name
, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1111 objc_cat_inst_meth_section ();
1112 else if (!strncmp (name
, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1113 objc_cat_cls_meth_section ();
1114 else if (!strncmp (name
, "_OBJC_PROTOCOL_REFS_", 20))
1115 objc_cat_cls_meth_section ();
1116 else if (!strncmp (name
, "_OBJC_PROTOCOL_", 15))
1117 objc_protocol_section ();
1125 /* This can be called with address expressions as "rtx".
1126 They must go in "const". */
1129 machopic_select_rtx_section (enum machine_mode mode
, rtx x
,
1130 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
1132 if (GET_MODE_SIZE (mode
) == 8)
1133 literal8_section ();
1134 else if (GET_MODE_SIZE (mode
) == 4
1135 && (GET_CODE (x
) == CONST_INT
1136 || GET_CODE (x
) == CONST_DOUBLE
))
1137 literal4_section ();
1138 else if (MACHOPIC_INDIRECT
1139 && (GET_CODE (x
) == SYMBOL_REF
1140 || GET_CODE (x
) == CONST
1141 || GET_CODE (x
) == LABEL_REF
))
1142 const_data_section ();
1148 machopic_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1150 if (MACHOPIC_INDIRECT
)
1151 mod_init_section ();
1153 constructor_section ();
1154 assemble_align (POINTER_SIZE
);
1155 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1157 if (! MACHOPIC_INDIRECT
)
1158 fprintf (asm_out_file
, ".reference .constructors_used\n");
1162 machopic_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
1164 if (MACHOPIC_INDIRECT
)
1165 mod_term_section ();
1167 destructor_section ();
1168 assemble_align (POINTER_SIZE
);
1169 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1171 if (! MACHOPIC_INDIRECT
)
1172 fprintf (asm_out_file
, ".reference .destructors_used\n");
1176 darwin_globalize_label (FILE *stream
, const char *name
)
1178 if (!!strncmp (name
, "_OBJC_", 6))
1179 default_globalize_label (stream
, name
);
1183 darwin_asm_named_section (const char *name
, unsigned int flags ATTRIBUTE_UNUSED
)
1185 fprintf (asm_out_file
, ".section %s\n", name
);
1189 darwin_section_type_flags (tree decl
, const char *name
, int reloc
)
1191 unsigned int flags
= default_section_type_flags (decl
, name
, reloc
);
1193 /* Weak or linkonce variables live in a writable section. */
1194 if (decl
!= 0 && TREE_CODE (decl
) != FUNCTION_DECL
1195 && (DECL_WEAK (decl
) || DECL_ONE_ONLY (decl
)))
1196 flags
|= SECTION_WRITE
;
1202 darwin_unique_section (tree decl
, int reloc ATTRIBUTE_UNUSED
)
1204 /* Darwin does not use unique sections. However, the target's
1205 unique_section hook is called for linkonce symbols. We need
1206 to set an appropriate section for such symbols. */
1207 if (DECL_ONE_ONLY (decl
) && !DECL_SECTION_NAME (decl
))
1208 darwin_make_decl_one_only (decl
);
1211 #define HAVE_DEAD_STRIP 0
1214 no_dead_strip (FILE *file
, const char *lab
)
1216 if (HAVE_DEAD_STRIP
)
1217 fprintf (file
, ".no_dead_strip %s\n", lab
);
1220 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1221 The third parameter is nonzero if this is for exception handling.
1222 The fourth parameter is nonzero if this is just a placeholder for an
1223 FDE that we are omitting. */
1226 darwin_emit_unwind_label (FILE *file
, tree decl
, int for_eh
, int empty
)
1228 tree id
= DECL_ASSEMBLER_NAME (decl
)
1229 ? DECL_ASSEMBLER_NAME (decl
)
1232 const char *prefix
= "_";
1233 const int prefix_len
= 1;
1235 const char *base
= IDENTIFIER_POINTER (id
);
1236 unsigned int base_len
= IDENTIFIER_LENGTH (id
);
1238 const char *suffix
= ".eh";
1240 int need_quotes
= name_needs_quotes (base
);
1241 int quotes_len
= need_quotes
? 2 : 0;
1247 lab
= xmalloc (prefix_len
+ base_len
+ strlen (suffix
) + quotes_len
+ 1);
1252 strcat(lab
, prefix
);
1254 strcat(lab
, suffix
);
1258 if (TREE_PUBLIC (decl
))
1259 fprintf (file
, "%s %s\n",
1260 (DECL_VISIBILITY (decl
) != VISIBILITY_HIDDEN
1262 : ".private_extern"),
1265 if (DECL_ONE_ONLY (decl
) && TREE_PUBLIC (decl
))
1266 fprintf (file
, ".weak_definition %s\n", lab
);
1270 fprintf (file
, "%s = 0\n", lab
);
1272 /* Mark the absolute .eh and .eh1 style labels as needed to
1273 ensure that we don't dead code strip them and keep such
1274 labels from another instantiation point until we can fix this
1275 properly with group comdat support. */
1276 no_dead_strip (file
, lab
);
1279 fprintf (file
, "%s:\n", lab
);
1284 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol. */
1287 darwin_non_lazy_pcrel (FILE *file
, rtx addr
)
1289 const char *nlp_name
;
1291 if (GET_CODE (addr
) != SYMBOL_REF
)
1294 nlp_name
= machopic_indirection_name (addr
, /*stub_p=*/false);
1295 fputs ("\t.long\t", file
);
1296 ASM_OUTPUT_LABELREF (file
, nlp_name
);
1300 /* Emit an assembler directive to set visibility for a symbol. The
1301 only supported visibilities are VISIBILITY_DEFAULT and
1302 VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1303 extern". There is no MACH-O equivalent of ELF's
1304 VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1307 darwin_assemble_visibility (tree decl
, int vis
)
1309 if (vis
== VISIBILITY_DEFAULT
)
1311 else if (vis
== VISIBILITY_HIDDEN
)
1313 fputs ("\t.private_extern ", asm_out_file
);
1314 assemble_name (asm_out_file
,
1315 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
1316 fputs ("\n", asm_out_file
);
1319 warning ("internal and protected visibility attributes not supported"
1320 "in this configuration; ignored");
1323 /* Output a difference of two labels that will be an assembly time
1324 constant if the two labels are local. (.long lab1-lab2 will be
1325 very different if lab1 is at the boundary between two sections; it
1326 will be relocated according to the second section, not the first,
1327 so one ends up with a difference between labels in different
1328 sections, which is bad in the dwarf2 eh context for instance.) */
1330 static int darwin_dwarf_label_counter
;
1333 darwin_asm_output_dwarf_delta (FILE *file
, int size ATTRIBUTE_UNUSED
,
1334 const char *lab1
, const char *lab2
)
1336 int islocaldiff
= (lab1
[0] == '*' && lab1
[1] == 'L'
1337 && lab2
[0] == '*' && lab2
[1] == 'L');
1340 fprintf (file
, "\t.set L$set$%d,", darwin_dwarf_label_counter
);
1342 fprintf (file
, "\t%s\t", ".long");
1343 assemble_name (file
, lab1
);
1344 fprintf (file
, "-");
1345 assemble_name (file
, lab2
);
1347 fprintf (file
, "\n\t.long L$set$%d", darwin_dwarf_label_counter
++);
1351 darwin_file_end (void)
1353 machopic_finish (asm_out_file
);
1354 if (strcmp (lang_hooks
.name
, "GNU C++") == 0)
1356 constructor_section ();
1357 destructor_section ();
1358 ASM_OUTPUT_ALIGN (asm_out_file
, 1);
1360 fprintf (asm_out_file
, "\t.subsections_via_symbols\n");
1363 /* True, iff we're generating fast turn around debugging code. When
1364 true, we arrange for function prologues to start with 4 nops so
1365 that gdb may insert code to redirect them, and for data to accessed
1366 indirectly. The runtime uses this indirection to forward
1367 references for data to the original instance of that data. */
1369 int darwin_fix_and_continue
;
1370 const char *darwin_fix_and_continue_switch
;
1372 #include "gt-darwin.h"