contrib/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 int
1097 machopic_reloc_rw_mask (void)
1098 {
1099   return MACHOPIC_INDIRECT ? 3 : 0;
1100 }
1101
1102 section *
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1617 darwin_kextabi_p (void) {
1618   return flag_apple_kext;
1619 }
1620
1621 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"