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
   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
  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
 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
 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
 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
 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
 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
 243 machopic_data_defined_p (rtx sym_ref)
 244 {
 245   if (indirect_data (sym_ref))
 246     return 0;
 247
 248   switch (machopic_classify_symbol (sym_ref))
 249     {
 250     case MACHOPIC_DEFINED_DATA:
 251     case MACHOPIC_DEFINED_FUNCTION:
 252       return 1;
 253     default:
 254       return 0;
 255     }
 256 }
 257
 258 void
 259 machopic_define_symbol (rtx mem)
 260 {
 261   rtx sym_ref;
 262
 263   gcc_assert (GET_CODE (mem) == MEM);
 264   sym_ref = XEXP (mem, 0);
 265   SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
 266 }
 267
 268 static GTY(()) char * function_base;
 269
 270 const char *
 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
 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
 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
 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
 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
 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 *
 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*
 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
 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
 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
 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
 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
 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
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
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
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
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 section *
1097 machopic_select_section (tree exp, int reloc,
1098                          unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1099 {
1100   section *base_section;
1101   bool weak_p = (DECL_P (exp) && DECL_WEAK (exp)
1102                  && (lookup_attribute ("weak", DECL_ATTRIBUTES (exp))
1103                      || ! lookup_attribute ("weak_import",
1104                                             DECL_ATTRIBUTES (exp))));
1105
1106   if (TREE_CODE (exp) == FUNCTION_DECL)
1107     {
1108       if (reloc == 1)
1109         base_section = (weak_p
1110                         ? darwin_sections[text_unlikely_coal_section]
1111                         : unlikely_text_section ());
1112       else
1113         base_section = weak_p ? darwin_sections[text_coal_section] : text_section;
1114     }
1115   else if (decl_readonly_section_1 (exp, reloc, MACHOPIC_INDIRECT))
1116     base_section = weak_p ? darwin_sections[const_coal_section] : darwin_sections[const_section];
1117   else if (TREE_READONLY (exp) || TREE_CONSTANT (exp))
1118     base_section = weak_p ? darwin_sections[const_data_coal_section] : darwin_sections[const_data_section];
1119   else
1120     base_section = weak_p ? darwin_sections[data_coal_section] : data_section;
1121
1122   if (TREE_CODE (exp) == STRING_CST
1123       && ((size_t) TREE_STRING_LENGTH (exp)
1124           == strlen (TREE_STRING_POINTER (exp)) + 1))
1125     return darwin_sections[cstring_section];
1126   else if ((TREE_CODE (exp) == INTEGER_CST || TREE_CODE (exp) == REAL_CST)
1127            && flag_merge_constants)
1128     {
1129       tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
1130
1131       if (TREE_CODE (size) == INTEGER_CST &&
1132           TREE_INT_CST_LOW (size) == 4 &&
1133           TREE_INT_CST_HIGH (size) == 0)
1134         return darwin_sections[literal4_section];
1135       else if (TREE_CODE (size) == INTEGER_CST &&
1136                TREE_INT_CST_LOW (size) == 8 &&
1137                TREE_INT_CST_HIGH (size) == 0)
1138         return darwin_sections[literal8_section];
1139       else
1140         return base_section;
1141     }
1142   else if (TREE_CODE (exp) == CONSTRUCTOR
1143            && TREE_TYPE (exp)
1144            && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
1145            && TYPE_NAME (TREE_TYPE (exp)))
1146     {
1147       tree name = TYPE_NAME (TREE_TYPE (exp));
1148       if (TREE_CODE (name) == TYPE_DECL)
1149         name = DECL_NAME (name);
1150
1151       if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
1152         {
1153           if (flag_next_runtime)
1154             return darwin_sections[objc_constant_string_object_section];
1155           else
1156             return darwin_sections[objc_string_object_section];
1157         }
1158       else
1159         return base_section;
1160     }
1161   else if (TREE_CODE (exp) == VAR_DECL &&
1162            DECL_NAME (exp) &&
1163            TREE_CODE (DECL_NAME (exp)) == IDENTIFIER_NODE &&
1164            IDENTIFIER_POINTER (DECL_NAME (exp)) &&
1165            !strncmp (IDENTIFIER_POINTER (DECL_NAME (exp)), "_OBJC_", 6))
1166     {
1167       const char *name = IDENTIFIER_POINTER (DECL_NAME (exp));
1168
1169       if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
1170         return darwin_sections[objc_cls_meth_section];
1171       else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
1172         return darwin_sections[objc_inst_meth_section];
1173       else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
1174         return darwin_sections[objc_cat_cls_meth_section];
1175       else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
1176         return darwin_sections[objc_cat_inst_meth_section];
1177       else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
1178         return darwin_sections[objc_class_vars_section];
1179       else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
1180         return darwin_sections[objc_instance_vars_section];
1181       else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
1182         return darwin_sections[objc_cat_cls_meth_section];
1183       else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
1184         return darwin_sections[objc_class_names_section];
1185       else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
1186         return darwin_sections[objc_meth_var_names_section];
1187       else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
1188         return darwin_sections[objc_meth_var_types_section];
1189       else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
1190         return darwin_sections[objc_cls_refs_section];
1191       else if (!strncmp (name, "_OBJC_CLASS_", 12))
1192         return darwin_sections[objc_class_section];
1193       else if (!strncmp (name, "_OBJC_METACLASS_", 16))
1194         return darwin_sections[objc_meta_class_section];
1195       else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
1196         return darwin_sections[objc_category_section];
1197       else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
1198         return darwin_sections[objc_selector_refs_section];
1199       else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
1200         return darwin_sections[objc_selector_fixup_section];
1201       else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
1202         return darwin_sections[objc_symbols_section];
1203       else if (!strncmp (name, "_OBJC_MODULES", 13))
1204         return darwin_sections[objc_module_info_section];
1205       else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
1206         return darwin_sections[objc_image_info_section];
1207       else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
1208         return darwin_sections[objc_cat_inst_meth_section];
1209       else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
1210         return darwin_sections[objc_cat_cls_meth_section];
1211       else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
1212         return darwin_sections[objc_cat_cls_meth_section];
1213       else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
1214         return darwin_sections[objc_protocol_section];
1215       else
1216         return base_section;
1217     }
1218   else
1219     return base_section;
1220 }
1221
1222 /* This can be called with address expressions as "rtx".
1223    They must go in "const".  */
1224
1225 section *
1226 machopic_select_rtx_section (enum machine_mode mode, rtx x,
1227                              unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
1228 {
1229   if (GET_MODE_SIZE (mode) == 8
1230       && (GET_CODE (x) == CONST_INT
1231           || GET_CODE (x) == CONST_DOUBLE))
1232     return darwin_sections[literal8_section];
1233   else if (GET_MODE_SIZE (mode) == 4
1234            && (GET_CODE (x) == CONST_INT
1235                || GET_CODE (x) == CONST_DOUBLE))
1236     return darwin_sections[literal4_section];
1237   else if (MACHOPIC_INDIRECT
1238            && (GET_CODE (x) == SYMBOL_REF
1239                || GET_CODE (x) == CONST
1240                || GET_CODE (x) == LABEL_REF))
1241     return darwin_sections[const_data_section];
1242   else
1243     return darwin_sections[const_section];
1244 }
1245
1246 void
1247 machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1248 {
1249   if (MACHOPIC_INDIRECT)
1250     switch_to_section (darwin_sections[mod_init_section]);
1251   else
1252     switch_to_section (darwin_sections[constructor_section]);
1253   assemble_align (POINTER_SIZE);
1254   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1255
1256   if (! MACHOPIC_INDIRECT)
1257     fprintf (asm_out_file, ".reference .constructors_used\n");
1258 }
1259
1260 void
1261 machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1262 {
1263   if (MACHOPIC_INDIRECT)
1264     switch_to_section (darwin_sections[mod_term_section]);
1265   else
1266     switch_to_section (darwin_sections[destructor_section]);
1267   assemble_align (POINTER_SIZE);
1268   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1269
1270   if (! MACHOPIC_INDIRECT)
1271     fprintf (asm_out_file, ".reference .destructors_used\n");
1272 }
1273
1274 void
1275 darwin_globalize_label (FILE *stream, const char *name)
1276 {
1277   if (!!strncmp (name, "_OBJC_", 6))
1278     default_globalize_label (stream, name);
1279 }
1280
1281 void
1282 darwin_asm_named_section (const char *name,
1283                           unsigned int flags ATTRIBUTE_UNUSED,
1284                           tree decl ATTRIBUTE_UNUSED)
1285 {
1286   fprintf (asm_out_file, "\t.section %s\n", name);
1287 }
1288
1289 void
1290 darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
1291 {
1292   /* Darwin does not use unique sections.  */
1293 }
1294
1295 /* Handle a "weak_import" attribute; arguments as in
1296    struct attribute_spec.handler.  */
1297
1298 tree
1299 darwin_handle_weak_import_attribute (tree *node, tree name,
1300                                      tree ARG_UNUSED (args),
1301                                      int ARG_UNUSED (flags),
1302                                      bool * no_add_attrs)
1303 {
1304   if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
1305     {
1306       warning (OPT_Wattributes, "%qs attribute ignored",
1307                IDENTIFIER_POINTER (name));
1308       *no_add_attrs = true;
1309     }
1310   else
1311     declare_weak (*node);
1312
1313   return NULL_TREE;
1314 }
1315
1316 static void
1317 no_dead_strip (FILE *file, const char *lab)
1318 {
1319   fprintf (file, ".no_dead_strip %s\n", lab);
1320 }
1321
1322 /* Emit a label for an FDE, making it global and/or weak if appropriate.
1323    The third parameter is nonzero if this is for exception handling.
1324    The fourth parameter is nonzero if this is just a placeholder for an
1325    FDE that we are omitting. */
1326
1327 void
1328 darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
1329 {
1330   tree id = DECL_ASSEMBLER_NAME (decl)
1331     ? DECL_ASSEMBLER_NAME (decl)
1332     : DECL_NAME (decl);
1333
1334   const char *base = IDENTIFIER_POINTER (id);
1335
1336   bool need_quotes = name_needs_quotes (base);
1337   char *lab;
1338
1339   if (! for_eh)
1340     return;
1341
1342   lab = concat (need_quotes ? "\"" : "", user_label_prefix, base, ".eh",
1343                 need_quotes ? "\"" : "", NULL);
1344
1345   if (TREE_PUBLIC (decl))
1346     fprintf (file, "\t%s %s\n",
1347              (DECL_VISIBILITY (decl) != VISIBILITY_HIDDEN
1348               ? ".globl"
1349               : ".private_extern"),
1350              lab);
1351
1352   if (DECL_WEAK (decl))
1353     fprintf (file, "\t.weak_definition %s\n", lab);
1354
1355   if (empty)
1356     {
1357       fprintf (file, "%s = 0\n", lab);
1358
1359       /* Mark the absolute .eh and .eh1 style labels as needed to
1360          ensure that we don't dead code strip them and keep such
1361          labels from another instantiation point until we can fix this
1362          properly with group comdat support.  */
1363       no_dead_strip (file, lab);
1364     }
1365   else
1366     fprintf (file, "%s:\n", lab);
1367
1368   free (lab);
1369 }
1370
1371 static GTY(()) unsigned long except_table_label_num;
1372
1373 void
1374 darwin_emit_except_table_label (FILE *file)
1375 {
1376   char section_start_label[30];
1377
1378   ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
1379                                except_table_label_num++);
1380   ASM_OUTPUT_LABEL (file, section_start_label);
1381 }
1382 /* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
1383
1384 void
1385 darwin_non_lazy_pcrel (FILE *file, rtx addr)
1386 {
1387   const char *nlp_name;
1388
1389   gcc_assert (GET_CODE (addr) == SYMBOL_REF);
1390
1391   nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
1392   fputs ("\t.long\t", file);
1393   ASM_OUTPUT_LABELREF (file, nlp_name);
1394   fputs ("-.", file);
1395 }
1396
1397 /* Emit an assembler directive to set visibility for a symbol.  The
1398    only supported visibilities are VISIBILITY_DEFAULT and
1399    VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
1400    extern".  There is no MACH-O equivalent of ELF's
1401    VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
1402
1403 void
1404 darwin_assemble_visibility (tree decl, int vis)
1405 {
1406   if (vis == VISIBILITY_DEFAULT)
1407     ;
1408   else if (vis == VISIBILITY_HIDDEN)
1409     {
1410       fputs ("\t.private_extern ", asm_out_file);
1411       assemble_name (asm_out_file,
1412                      (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
1413       fputs ("\n", asm_out_file);
1414     }
1415   else
1416     warning (OPT_Wattributes, "internal and protected visibility attributes "
1417              "not supported in this configuration; ignored");
1418 }
1419
1420 /* Output a difference of two labels that will be an assembly time
1421    constant if the two labels are local.  (.long lab1-lab2 will be
1422    very different if lab1 is at the boundary between two sections; it
1423    will be relocated according to the second section, not the first,
1424    so one ends up with a difference between labels in different
1425    sections, which is bad in the dwarf2 eh context for instance.)  */
1426
1427 static int darwin_dwarf_label_counter;
1428
1429 void
1430 darwin_asm_output_dwarf_delta (FILE *file, int size,
1431                                const char *lab1, const char *lab2)
1432 {
1433   int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
1434                      && lab2[0] == '*' && lab2[1] == 'L');
1435   const char *directive = (size == 8 ? ".quad" : ".long");
1436
1437   if (islocaldiff)
1438     fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
1439   else
1440     fprintf (file, "\t%s\t", directive);
1441   assemble_name_raw (file, lab1);
1442   fprintf (file, "-");
1443   assemble_name_raw (file, lab2);
1444   if (islocaldiff)
1445     fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
1446 }
1447
1448 /* Output labels for the start of the DWARF sections if necessary.  */
1449 void
1450 darwin_file_start (void)
1451 {
1452   if (write_symbols == DWARF2_DEBUG)
1453     {
1454       static const char * const debugnames[] =
1455         {
1456           DEBUG_FRAME_SECTION,
1457           DEBUG_INFO_SECTION,
1458           DEBUG_ABBREV_SECTION,
1459           DEBUG_ARANGES_SECTION,
1460           DEBUG_MACINFO_SECTION,
1461           DEBUG_LINE_SECTION,
1462           DEBUG_LOC_SECTION,
1463           DEBUG_PUBNAMES_SECTION,
1464           DEBUG_STR_SECTION,
1465           DEBUG_RANGES_SECTION
1466         };
1467       size_t i;
1468
1469       for (i = 0; i < ARRAY_SIZE (debugnames); i++)
1470         {
1471           int namelen;
1472
1473           switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
1474
1475           gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
1476           gcc_assert (strchr (debugnames[i] + 8, ','));
1477
1478           namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
1479           fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
1480         }
1481     }
1482 }
1483
1484 /* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
1485    offsets are not represented using relocs in .o files; either the
1486    section never leaves the .o file, or the linker or other tool is
1487    responsible for parsing the DWARF and updating the offsets.  */
1488
1489 void
1490 darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
1491                                 section *base)
1492 {
1493   char sname[64];
1494   int namelen;
1495
1496   gcc_assert (base->common.flags & SECTION_NAMED);
1497   gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
1498   gcc_assert (strchr (base->named.name + 8, ','));
1499
1500   namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
1501   sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
1502   darwin_asm_output_dwarf_delta (file, size, lab, sname);
1503 }
1504
1505 void
1506 darwin_file_end (void)
1507 {
1508   machopic_finish (asm_out_file);
1509   if (strcmp (lang_hooks.name, "GNU C++") == 0)
1510     {
1511       switch_to_section (darwin_sections[constructor_section]);
1512       switch_to_section (darwin_sections[destructor_section]);
1513       ASM_OUTPUT_ALIGN (asm_out_file, 1);
1514     }
1515   fprintf (asm_out_file, "\t.subsections_via_symbols\n");
1516 }
1517
1518 /* Cross-module name binding.  Darwin does not support overriding
1519    functions at dynamic-link time.  */
1520
1521 bool
1522 darwin_binds_local_p (tree decl)
1523 {
1524   return default_binds_local_p_1 (decl, 0);
1525 }
1526
1527 /* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
1528    anchor relative to ".", the current section position.  We cannot use
1529    the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
1530
1531 void
1532 darwin_asm_output_anchor (rtx symbol)
1533 {
1534   fprintf (asm_out_file, "\t.set\t");
1535   assemble_name (asm_out_file, XSTR (symbol, 0));
1536   fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
1537            SYMBOL_REF_BLOCK_OFFSET (symbol));
1538 }
1539
1540 /* Set the darwin specific attributes on TYPE.  */
1541 void
1542 darwin_set_default_type_attributes (tree type)
1543 {
1544   if (darwin_ms_struct
1545       && TREE_CODE (type) == RECORD_TYPE)
1546     TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
1547                                         NULL_TREE,
1548                                         TYPE_ATTRIBUTES (type));
1549 }
1550
1551 #include "gt-darwin.h"