gcc/config/darwin.c

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