OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [config/] [darwin.c] - Diff between revs 38 and 154

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 38 Rev 154
/* Functions for generic Darwin as target machine for GNU C compiler.
/* Functions for generic Darwin as target machine for GNU C compiler.
   Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
   Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,
   2005, 2007
   2005, 2007
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   Contributed by Apple Computer Inc.
   Contributed by Apple Computer Inc.
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
the Free Software Foundation; either version 3, or (at your option)
any later version.
any later version.
 
 
GCC is distributed in the hope that it will be useful,
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "tm.h"
#include "tm.h"
#include "rtl.h"
#include "rtl.h"
#include "regs.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "hard-reg-set.h"
#include "real.h"
#include "real.h"
#include "insn-config.h"
#include "insn-config.h"
#include "conditions.h"
#include "conditions.h"
#include "insn-flags.h"
#include "insn-flags.h"
#include "output.h"
#include "output.h"
#include "insn-attr.h"
#include "insn-attr.h"
#include "flags.h"
#include "flags.h"
#include "tree.h"
#include "tree.h"
#include "expr.h"
#include "expr.h"
#include "reload.h"
#include "reload.h"
#include "function.h"
#include "function.h"
#include "ggc.h"
#include "ggc.h"
#include "langhooks.h"
#include "langhooks.h"
#include "target.h"
#include "target.h"
#include "tm_p.h"
#include "tm_p.h"
#include "toplev.h"
#include "toplev.h"
#include "hashtab.h"
#include "hashtab.h"
 
 
/* Darwin supports a feature called fix-and-continue, which is used
/* Darwin supports a feature called fix-and-continue, which is used
   for rapid turn around debugging.  When code is compiled with the
   for rapid turn around debugging.  When code is compiled with the
   -mfix-and-continue flag, two changes are made to the generated code
   -mfix-and-continue flag, two changes are made to the generated code
   that allow the system to do things that it would normally not be
   that allow the system to do things that it would normally not be
   able to do easily.  These changes allow gdb to load in
   able to do easily.  These changes allow gdb to load in
   recompilation of a translation unit that has been changed into a
   recompilation of a translation unit that has been changed into a
   running program and replace existing functions and methods of that
   running program and replace existing functions and methods of that
   translation unit with versions of those functions and methods
   translation unit with versions of those functions and methods
   from the newly compiled translation unit.  The new functions access
   from the newly compiled translation unit.  The new functions access
   the existing static symbols from the old translation unit, if the
   the existing static symbols from the old translation unit, if the
   symbol existed in the unit to be replaced, and from the new
   symbol existed in the unit to be replaced, and from the new
   translation unit, otherwise.
   translation unit, otherwise.
 
 
   The changes are to insert 5 nops at the beginning of all functions
   The changes are to insert 5 nops at the beginning of all functions
   and to use indirection to get at static symbols.  The 5 nops
   and to use indirection to get at static symbols.  The 5 nops
   are required by consumers of the generated code.  Currently, gdb
   are required by consumers of the generated code.  Currently, gdb
   uses this to patch in a jump to the overriding function, this
   uses this to patch in a jump to the overriding function, this
   allows all uses of the old name to forward to the replacement,
   allows all uses of the old name to forward to the replacement,
   including existing function pointers and virtual methods.  See
   including existing function pointers and virtual methods.  See
   rs6000_emit_prologue for the code that handles the nop insertions.
   rs6000_emit_prologue for the code that handles the nop insertions.
 
 
   The added indirection allows gdb to redirect accesses to static
   The added indirection allows gdb to redirect accesses to static
   symbols from the newly loaded translation unit to the existing
   symbols from the newly loaded translation unit to the existing
   symbol, if any.  @code{static} symbols are special and are handled by
   symbol, if any.  @code{static} symbols are special and are handled by
   setting the second word in the .non_lazy_symbol_pointer data
   setting the second word in the .non_lazy_symbol_pointer data
   structure to symbol.  See indirect_data for the code that handles
   structure to symbol.  See indirect_data for the code that handles
   the extra indirection, and machopic_output_indirection and its use
   the extra indirection, and machopic_output_indirection and its use
   of MACHO_SYMBOL_STATIC for the code that handles @code{static}
   of MACHO_SYMBOL_STATIC for the code that handles @code{static}
   symbol indirection.  */
   symbol indirection.  */
 
 
/* Section names.  */
/* Section names.  */
section * darwin_sections[NUM_DARWIN_SECTIONS];
section * darwin_sections[NUM_DARWIN_SECTIONS];
 
 
/* True if we're setting __attribute__ ((ms_struct)).  */
/* True if we're setting __attribute__ ((ms_struct)).  */
int darwin_ms_struct = false;
int darwin_ms_struct = false;
 
 
/* A get_unnamed_section callback used to switch to an ObjC section.
/* A get_unnamed_section callback used to switch to an ObjC section.
   DIRECTIVE is as for output_section_asm_op.  */
   DIRECTIVE is as for output_section_asm_op.  */
 
 
static void
static void
output_objc_section_asm_op (const void *directive)
output_objc_section_asm_op (const void *directive)
{
{
  static bool been_here = false;
  static bool been_here = false;
 
 
  if (! been_here)
  if (! been_here)
    {
    {
      static const enum darwin_section_enum tomark[] =
      static const enum darwin_section_enum tomark[] =
        {
        {
          /* written, cold -> hot */
          /* written, cold -> hot */
          objc_cat_cls_meth_section,
          objc_cat_cls_meth_section,
          objc_cat_inst_meth_section,
          objc_cat_inst_meth_section,
          objc_string_object_section,
          objc_string_object_section,
          objc_constant_string_object_section,
          objc_constant_string_object_section,
          objc_selector_refs_section,
          objc_selector_refs_section,
          objc_selector_fixup_section,
          objc_selector_fixup_section,
          objc_cls_refs_section,
          objc_cls_refs_section,
          objc_class_section,
          objc_class_section,
          objc_meta_class_section,
          objc_meta_class_section,
          /* shared, hot -> cold */
          /* shared, hot -> cold */
          objc_cls_meth_section,
          objc_cls_meth_section,
          objc_inst_meth_section,
          objc_inst_meth_section,
          objc_protocol_section,
          objc_protocol_section,
          objc_class_names_section,
          objc_class_names_section,
          objc_meth_var_types_section,
          objc_meth_var_types_section,
          objc_meth_var_names_section,
          objc_meth_var_names_section,
          objc_category_section,
          objc_category_section,
          objc_class_vars_section,
          objc_class_vars_section,
          objc_instance_vars_section,
          objc_instance_vars_section,
          objc_module_info_section,
          objc_module_info_section,
          objc_symbols_section
          objc_symbols_section
        };
        };
      size_t i;
      size_t i;
 
 
      been_here = true;
      been_here = true;
      for (i = 0; i < ARRAY_SIZE (tomark); i++)
      for (i = 0; i < ARRAY_SIZE (tomark); i++)
        switch_to_section (darwin_sections[tomark[i]]);
        switch_to_section (darwin_sections[tomark[i]]);
    }
    }
  output_section_asm_op (directive);
  output_section_asm_op (directive);
}
}
 
 
/* Implement TARGET_ASM_INIT_SECTIONS.  */
/* Implement TARGET_ASM_INIT_SECTIONS.  */
 
 
void
void
darwin_init_sections (void)
darwin_init_sections (void)
{
{
#define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC)               \
#define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC)               \
  darwin_sections[NAME] =                                       \
  darwin_sections[NAME] =                                       \
    get_unnamed_section (FLAGS, (OBJC                           \
    get_unnamed_section (FLAGS, (OBJC                           \
                                 ? output_objc_section_asm_op   \
                                 ? output_objc_section_asm_op   \
                                 : output_section_asm_op),      \
                                 : output_section_asm_op),      \
                         "\t" DIRECTIVE);
                         "\t" DIRECTIVE);
#include "config/darwin-sections.def"
#include "config/darwin-sections.def"
#undef DEF_SECTION
#undef DEF_SECTION
 
 
  readonly_data_section = darwin_sections[const_section];
  readonly_data_section = darwin_sections[const_section];
  exception_section = darwin_sections[darwin_exception_section];
  exception_section = darwin_sections[darwin_exception_section];
  eh_frame_section = darwin_sections[darwin_eh_frame_section];
  eh_frame_section = darwin_sections[darwin_eh_frame_section];
}
}
 
 
int
int
name_needs_quotes (const char *name)
name_needs_quotes (const char *name)
{
{
  int c;
  int c;
  while ((c = *name++) != '\0')
  while ((c = *name++) != '\0')
    if (! ISIDNUM (c) && c != '.' && c != '$')
    if (! ISIDNUM (c) && c != '.' && c != '$')
      return 1;
      return 1;
  return 0;
  return 0;
}
}
 
 
/* Return true if SYM_REF can be used without an indirection.  */
/* Return true if SYM_REF can be used without an indirection.  */
static int
static int
machopic_symbol_defined_p (rtx sym_ref)
machopic_symbol_defined_p (rtx sym_ref)
{
{
  if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
  if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)
    return true;
    return true;
 
 
  /* If a symbol references local and is not an extern to this
  /* If a symbol references local and is not an extern to this
     file, then the symbol might be able to declared as defined.  */
     file, then the symbol might be able to declared as defined.  */
  if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
  if (SYMBOL_REF_LOCAL_P (sym_ref) && ! SYMBOL_REF_EXTERNAL_P (sym_ref))
    {
    {
      /* If the symbol references a variable and the variable is a
      /* If the symbol references a variable and the variable is a
         common symbol, then this symbol is not defined.  */
         common symbol, then this symbol is not defined.  */
      if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
      if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)
        {
        {
          tree decl = SYMBOL_REF_DECL (sym_ref);
          tree decl = SYMBOL_REF_DECL (sym_ref);
          if (!decl)
          if (!decl)
            return true;
            return true;
          if (DECL_COMMON (decl))
          if (DECL_COMMON (decl))
            return false;
            return false;
        }
        }
      return true;
      return true;
    }
    }
  return false;
  return false;
}
}
 
 
/* This module assumes that (const (symbol_ref "foo")) is a legal pic
/* This module assumes that (const (symbol_ref "foo")) is a legal pic
   reference, which will not be changed.  */
   reference, which will not be changed.  */
 
 
enum machopic_addr_class
enum machopic_addr_class
machopic_classify_symbol (rtx sym_ref)
machopic_classify_symbol (rtx sym_ref)
{
{
  int flags;
  int flags;
  bool function_p;
  bool function_p;
 
 
  flags = SYMBOL_REF_FLAGS (sym_ref);
  flags = SYMBOL_REF_FLAGS (sym_ref);
  function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
  function_p = SYMBOL_REF_FUNCTION_P (sym_ref);
  if (machopic_symbol_defined_p (sym_ref))
  if (machopic_symbol_defined_p (sym_ref))
    return (function_p
    return (function_p
            ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
            ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);
  else
  else
    return (function_p
    return (function_p
            ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
            ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);
}
}
 
 
#ifndef TARGET_FIX_AND_CONTINUE
#ifndef TARGET_FIX_AND_CONTINUE
#define TARGET_FIX_AND_CONTINUE 0
#define TARGET_FIX_AND_CONTINUE 0
#endif
#endif
 
 
/* Indicate when fix-and-continue style code generation is being used
/* Indicate when fix-and-continue style code generation is being used
   and when a reference to data should be indirected so that it can be
   and when a reference to data should be indirected so that it can be
   rebound in a new translation unit to reference the original instance
   rebound in a new translation unit to reference the original instance
   of that data.  Symbol names that are for code generation local to
   of that data.  Symbol names that are for code generation local to
   the translation unit are bound to the new translation unit;
   the translation unit are bound to the new translation unit;
   currently this means symbols that begin with L or _OBJC_;
   currently this means symbols that begin with L or _OBJC_;
   otherwise, we indicate that an indirect reference should be made to
   otherwise, we indicate that an indirect reference should be made to
   permit the runtime to rebind new instances of the translation unit
   permit the runtime to rebind new instances of the translation unit
   to the original instance of the data.  */
   to the original instance of the data.  */
 
 
static int
static int
indirect_data (rtx sym_ref)
indirect_data (rtx sym_ref)
{
{
  int lprefix;
  int lprefix;
  const char *name;
  const char *name;
 
 
  /* If we aren't generating fix-and-continue code, don't do anything special.  */
  /* If we aren't generating fix-and-continue code, don't do anything special.  */
  if (TARGET_FIX_AND_CONTINUE == 0)
  if (TARGET_FIX_AND_CONTINUE == 0)
    return 0;
    return 0;
 
 
  /* Otherwise, all symbol except symbols that begin with L or _OBJC_
  /* Otherwise, all symbol except symbols that begin with L or _OBJC_
     are indirected.  Symbols that begin with L and _OBJC_ are always
     are indirected.  Symbols that begin with L and _OBJC_ are always
     bound to the current translation unit as they are used for
     bound to the current translation unit as they are used for
     generated local data of the translation unit.  */
     generated local data of the translation unit.  */
 
 
  name = XSTR (sym_ref, 0);
  name = XSTR (sym_ref, 0);
 
 
  lprefix = (((name[0] == '*' || name[0] == '&')
  lprefix = (((name[0] == '*' || name[0] == '&')
              && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
              && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))
             || (strncmp (name, "_OBJC_", 6) == 0));
             || (strncmp (name, "_OBJC_", 6) == 0));
 
 
  return ! lprefix;
  return ! lprefix;
}
}
 
 
 
 
static int
static int
machopic_data_defined_p (rtx sym_ref)
machopic_data_defined_p (rtx sym_ref)
{
{
  if (indirect_data (sym_ref))
  if (indirect_data (sym_ref))
    return 0;
    return 0;
 
 
  switch (machopic_classify_symbol (sym_ref))
  switch (machopic_classify_symbol (sym_ref))
    {
    {
    case MACHOPIC_DEFINED_DATA:
    case MACHOPIC_DEFINED_DATA:
    case MACHOPIC_DEFINED_FUNCTION:
    case MACHOPIC_DEFINED_FUNCTION:
      return 1;
      return 1;
    default:
    default:
      return 0;
      return 0;
    }
    }
}
}
 
 
void
void
machopic_define_symbol (rtx mem)
machopic_define_symbol (rtx mem)
{
{
  rtx sym_ref;
  rtx sym_ref;
 
 
  gcc_assert (GET_CODE (mem) == MEM);
  gcc_assert (GET_CODE (mem) == MEM);
  sym_ref = XEXP (mem, 0);
  sym_ref = XEXP (mem, 0);
  SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
  SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
}
}
 
 
static GTY(()) char * function_base;
static GTY(()) char * function_base;
 
 
const char *
const char *
machopic_function_base_name (void)
machopic_function_base_name (void)
{
{
  /* if dynamic-no-pic is on, we should not get here */
  /* if dynamic-no-pic is on, we should not get here */
  gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
  gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
 
 
  if (function_base == NULL)
  if (function_base == NULL)
    function_base =
    function_base =
      (char *) ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
      (char *) ggc_alloc_string ("<pic base>", sizeof ("<pic base>"));
 
 
  current_function_uses_pic_offset_table = 1;
  current_function_uses_pic_offset_table = 1;
 
 
  return function_base;
  return function_base;
}
}
 
 
/* Return a SYMBOL_REF for the PIC function base.  */
/* Return a SYMBOL_REF for the PIC function base.  */
 
 
rtx
rtx
machopic_function_base_sym (void)
machopic_function_base_sym (void)
{
{
  rtx sym_ref;
  rtx sym_ref;
 
 
  sym_ref = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
  sym_ref = gen_rtx_SYMBOL_REF (Pmode, machopic_function_base_name ());
  SYMBOL_REF_FLAGS (sym_ref)
  SYMBOL_REF_FLAGS (sym_ref)
    |= (MACHO_SYMBOL_FLAG_VARIABLE | MACHO_SYMBOL_FLAG_DEFINED);
    |= (MACHO_SYMBOL_FLAG_VARIABLE | MACHO_SYMBOL_FLAG_DEFINED);
  return sym_ref;
  return sym_ref;
}
}
 
 
/* Return either ORIG or (const:P (minus:P ORIG PIC_BASE)), depending
/* Return either ORIG or (const:P (minus:P ORIG PIC_BASE)), depending
   on whether pic_base is NULL or not.  */
   on whether pic_base is NULL or not.  */
static inline rtx
static inline rtx
gen_pic_offset (rtx orig, rtx pic_base)
gen_pic_offset (rtx orig, rtx pic_base)
{
{
  if (!pic_base)
  if (!pic_base)
    return orig;
    return orig;
  else
  else
    return gen_rtx_CONST (Pmode, gen_rtx_MINUS (Pmode, orig, pic_base));
    return gen_rtx_CONST (Pmode, gen_rtx_MINUS (Pmode, orig, pic_base));
}
}
 
 
static GTY(()) const char * function_base_func_name;
static GTY(()) const char * function_base_func_name;
static GTY(()) int current_pic_label_num;
static GTY(()) int current_pic_label_num;
 
 
void
void
machopic_output_function_base_name (FILE *file)
machopic_output_function_base_name (FILE *file)
{
{
  const char *current_name;
  const char *current_name;
 
 
  /* If dynamic-no-pic is on, we should not get here.  */
  /* If dynamic-no-pic is on, we should not get here.  */
  gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
  gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);
  current_name =
  current_name =
    IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
    IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
  if (function_base_func_name != current_name)
  if (function_base_func_name != current_name)
    {
    {
      ++current_pic_label_num;
      ++current_pic_label_num;
      function_base_func_name = current_name;
      function_base_func_name = current_name;
    }
    }
  fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
  fprintf (file, "\"L%011d$pb\"", current_pic_label_num);
}
}
 
 
/* The suffix attached to non-lazy pointer symbols.  */
/* The suffix attached to non-lazy pointer symbols.  */
#define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
#define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"
/* The suffix attached to stub symbols.  */
/* The suffix attached to stub symbols.  */
#define STUB_SUFFIX "$stub"
#define STUB_SUFFIX "$stub"
 
 
typedef struct machopic_indirection GTY (())
typedef struct machopic_indirection GTY (())
{
{
  /* The SYMBOL_REF for the entity referenced.  */
  /* The SYMBOL_REF for the entity referenced.  */
  rtx symbol;
  rtx symbol;
  /* The name of the stub or non-lazy pointer.  */
  /* The name of the stub or non-lazy pointer.  */
  const char * ptr_name;
  const char * ptr_name;
  /* True iff this entry is for a stub (as opposed to a non-lazy
  /* True iff this entry is for a stub (as opposed to a non-lazy
     pointer).  */
     pointer).  */
  bool stub_p;
  bool stub_p;
  /* True iff this stub or pointer pointer has been referenced.  */
  /* True iff this stub or pointer pointer has been referenced.  */
  bool used;
  bool used;
} machopic_indirection;
} machopic_indirection;
 
 
/* A table mapping stub names and non-lazy pointer names to
/* A table mapping stub names and non-lazy pointer names to
   SYMBOL_REFs for the stubbed-to and pointed-to entities.  */
   SYMBOL_REFs for the stubbed-to and pointed-to entities.  */
 
 
static GTY ((param_is (struct machopic_indirection))) htab_t
static GTY ((param_is (struct machopic_indirection))) htab_t
  machopic_indirections;
  machopic_indirections;
 
 
/* Return a hash value for a SLOT in the indirections hash table.  */
/* Return a hash value for a SLOT in the indirections hash table.  */
 
 
static hashval_t
static hashval_t
machopic_indirection_hash (const void *slot)
machopic_indirection_hash (const void *slot)
{
{
  const machopic_indirection *p = (const machopic_indirection *) slot;
  const machopic_indirection *p = (const machopic_indirection *) slot;
  return htab_hash_string (p->ptr_name);
  return htab_hash_string (p->ptr_name);
}
}
 
 
/* Returns true if the KEY is the same as that associated with
/* Returns true if the KEY is the same as that associated with
   SLOT.  */
   SLOT.  */
 
 
static int
static int
machopic_indirection_eq (const void *slot, const void *key)
machopic_indirection_eq (const void *slot, const void *key)
{
{
  return strcmp (((const machopic_indirection *) slot)->ptr_name, key) == 0;
  return strcmp (((const machopic_indirection *) slot)->ptr_name, key) == 0;
}
}
 
 
/* Return the name of the non-lazy pointer (if STUB_P is false) or
/* Return the name of the non-lazy pointer (if STUB_P is false) or
   stub (if STUB_B is true) corresponding to the given name.  */
   stub (if STUB_B is true) corresponding to the given name.  */
 
 
const char *
const char *
machopic_indirection_name (rtx sym_ref, bool stub_p)
machopic_indirection_name (rtx sym_ref, bool stub_p)
{
{
  char *buffer;
  char *buffer;
  const char *name = XSTR (sym_ref, 0);
  const char *name = XSTR (sym_ref, 0);
  size_t namelen = strlen (name);
  size_t namelen = strlen (name);
  machopic_indirection *p;
  machopic_indirection *p;
  void ** slot;
  void ** slot;
  bool saw_star = false;
  bool saw_star = false;
  bool needs_quotes;
  bool needs_quotes;
  const char *suffix;
  const char *suffix;
  const char *prefix = user_label_prefix;
  const char *prefix = user_label_prefix;
  const char *quote = "";
  const char *quote = "";
  tree id;
  tree id;
 
 
  id = maybe_get_identifier (name);
  id = maybe_get_identifier (name);
  if (id)
  if (id)
    {
    {
      tree id_orig = id;
      tree id_orig = id;
 
 
      while (IDENTIFIER_TRANSPARENT_ALIAS (id))
      while (IDENTIFIER_TRANSPARENT_ALIAS (id))
        id = TREE_CHAIN (id);
        id = TREE_CHAIN (id);
      if (id != id_orig)
      if (id != id_orig)
        {
        {
          name = IDENTIFIER_POINTER (id);
          name = IDENTIFIER_POINTER (id);
          namelen = strlen (name);
          namelen = strlen (name);
        }
        }
    }
    }
 
 
  if (name[0] == '*')
  if (name[0] == '*')
    {
    {
      saw_star = true;
      saw_star = true;
      prefix = "";
      prefix = "";
      ++name;
      ++name;
      --namelen;
      --namelen;
    }
    }
 
 
  needs_quotes = name_needs_quotes (name);
  needs_quotes = name_needs_quotes (name);
  if (needs_quotes)
  if (needs_quotes)
    {
    {
      quote = "\"";
      quote = "\"";
    }
    }
 
 
  if (stub_p)
  if (stub_p)
    suffix = STUB_SUFFIX;
    suffix = STUB_SUFFIX;
  else
  else
    suffix = NON_LAZY_POINTER_SUFFIX;
    suffix = NON_LAZY_POINTER_SUFFIX;
 
 
  buffer = alloca (strlen ("&L")
  buffer = alloca (strlen ("&L")
                   + strlen (prefix)
                   + strlen (prefix)
                   + namelen
                   + namelen
                   + strlen (suffix)
                   + strlen (suffix)
                   + 2 * strlen (quote)
                   + 2 * strlen (quote)
                   + 1 /* '\0' */);
                   + 1 /* '\0' */);
 
 
  /* Construct the name of the non-lazy pointer or stub.  */
  /* Construct the name of the non-lazy pointer or stub.  */
  sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
  sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);
 
 
  if (!machopic_indirections)
  if (!machopic_indirections)
    machopic_indirections = htab_create_ggc (37,
    machopic_indirections = htab_create_ggc (37,
                                             machopic_indirection_hash,
                                             machopic_indirection_hash,
                                             machopic_indirection_eq,
                                             machopic_indirection_eq,
                                             /*htab_del=*/NULL);
                                             /*htab_del=*/NULL);
 
 
  slot = htab_find_slot_with_hash (machopic_indirections, buffer,
  slot = htab_find_slot_with_hash (machopic_indirections, buffer,
                                   htab_hash_string (buffer), INSERT);
                                   htab_hash_string (buffer), INSERT);
  if (*slot)
  if (*slot)
    {
    {
      p = (machopic_indirection *) *slot;
      p = (machopic_indirection *) *slot;
    }
    }
  else
  else
    {
    {
      p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
      p = (machopic_indirection *) ggc_alloc (sizeof (machopic_indirection));
      p->symbol = sym_ref;
      p->symbol = sym_ref;
      p->ptr_name = xstrdup (buffer);
      p->ptr_name = xstrdup (buffer);
      p->stub_p = stub_p;
      p->stub_p = stub_p;
      p->used = false;
      p->used = false;
      *slot = p;
      *slot = p;
    }
    }
 
 
  return p->ptr_name;
  return p->ptr_name;
}
}
 
 
/* Return the name of the stub for the mcount function.  */
/* Return the name of the stub for the mcount function.  */
 
 
const char*
const char*
machopic_mcount_stub_name (void)
machopic_mcount_stub_name (void)
{
{
  rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
  rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");
  return machopic_indirection_name (symbol, /*stub_p=*/true);
  return machopic_indirection_name (symbol, /*stub_p=*/true);
}
}
 
 
/* If NAME is the name of a stub or a non-lazy pointer , mark the stub
/* If NAME is the name of a stub or a non-lazy pointer , mark the stub
   or non-lazy pointer as used -- and mark the object to which the
   or non-lazy pointer as used -- and mark the object to which the
   pointer/stub refers as used as well, since the pointer/stub will
   pointer/stub refers as used as well, since the pointer/stub will
   emit a reference to it.  */
   emit a reference to it.  */
 
 
void
void
machopic_validate_stub_or_non_lazy_ptr (const char *name)
machopic_validate_stub_or_non_lazy_ptr (const char *name)
{
{
  machopic_indirection *p;
  machopic_indirection *p;
 
 
  p = ((machopic_indirection *)
  p = ((machopic_indirection *)
       (htab_find_with_hash (machopic_indirections, name,
       (htab_find_with_hash (machopic_indirections, name,
                             htab_hash_string (name))));
                             htab_hash_string (name))));
  if (p && ! p->used)
  if (p && ! p->used)
    {
    {
      const char *real_name;
      const char *real_name;
      tree id;
      tree id;
 
 
      p->used = true;
      p->used = true;
 
 
      /* Do what output_addr_const will do when we actually call it.  */
      /* Do what output_addr_const will do when we actually call it.  */
      if (SYMBOL_REF_DECL (p->symbol))
      if (SYMBOL_REF_DECL (p->symbol))
        mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
        mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));
 
 
      real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
      real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));
 
 
      id = maybe_get_identifier (real_name);
      id = maybe_get_identifier (real_name);
      if (id)
      if (id)
        mark_referenced (id);
        mark_referenced (id);
    }
    }
}
}
 
 
/* Transform ORIG, which may be any data source, to the corresponding
/* Transform ORIG, which may be any data source, to the corresponding
   source using indirections.  */
   source using indirections.  */
 
 
rtx
rtx
machopic_indirect_data_reference (rtx orig, rtx reg)
machopic_indirect_data_reference (rtx orig, rtx reg)
{
{
  rtx ptr_ref = orig;
  rtx ptr_ref = orig;
 
 
  if (! MACHOPIC_INDIRECT)
  if (! MACHOPIC_INDIRECT)
    return orig;
    return orig;
 
 
  if (GET_CODE (orig) == SYMBOL_REF)
  if (GET_CODE (orig) == SYMBOL_REF)
    {
    {
      int defined = machopic_data_defined_p (orig);
      int defined = machopic_data_defined_p (orig);
 
 
      if (defined && MACHO_DYNAMIC_NO_PIC_P)
      if (defined && MACHO_DYNAMIC_NO_PIC_P)
        {
        {
#if defined (TARGET_TOC)
#if defined (TARGET_TOC)
          /* Create a new register for CSE opportunities.  */
          /* Create a new register for CSE opportunities.  */
          rtx hi_reg = (no_new_pseudos ? reg : gen_reg_rtx (Pmode));
          rtx hi_reg = (no_new_pseudos ? reg : gen_reg_rtx (Pmode));
          emit_insn (gen_macho_high (hi_reg, orig));
          emit_insn (gen_macho_high (hi_reg, orig));
          emit_insn (gen_macho_low (reg, hi_reg, orig));
          emit_insn (gen_macho_low (reg, hi_reg, orig));
#else
#else
           /* some other cpu -- writeme!  */
           /* some other cpu -- writeme!  */
           gcc_unreachable ();
           gcc_unreachable ();
#endif
#endif
           return reg;
           return reg;
        }
        }
      else if (defined)
      else if (defined)
        {
        {
#if defined (TARGET_TOC) || defined (HAVE_lo_sum)
#if defined (TARGET_TOC) || defined (HAVE_lo_sum)
          rtx pic_base = machopic_function_base_sym ();
          rtx pic_base = machopic_function_base_sym ();
          rtx offset = gen_pic_offset (orig, pic_base);
          rtx offset = gen_pic_offset (orig, pic_base);
#endif
#endif
 
 
#if defined (TARGET_TOC) /* i.e., PowerPC */
#if defined (TARGET_TOC) /* i.e., PowerPC */
          rtx hi_sum_reg = (no_new_pseudos ? reg : gen_reg_rtx (Pmode));
          rtx hi_sum_reg = (no_new_pseudos ? reg : gen_reg_rtx (Pmode));
 
 
          gcc_assert (reg);
          gcc_assert (reg);
 
 
          emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
          emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
                              gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
                              gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
                                       gen_rtx_HIGH (Pmode, offset))));
                                       gen_rtx_HIGH (Pmode, offset))));
          emit_insn (gen_rtx_SET (Pmode, reg,
          emit_insn (gen_rtx_SET (Pmode, reg,
                                  gen_rtx_LO_SUM (Pmode, hi_sum_reg, offset)));
                                  gen_rtx_LO_SUM (Pmode, hi_sum_reg, offset)));
 
 
          orig = reg;
          orig = reg;
#else
#else
#if defined (HAVE_lo_sum)
#if defined (HAVE_lo_sum)
          gcc_assert (reg);
          gcc_assert (reg);
 
 
          emit_insn (gen_rtx_SET (VOIDmode, reg,
          emit_insn (gen_rtx_SET (VOIDmode, reg,
                                  gen_rtx_HIGH (Pmode, offset)));
                                  gen_rtx_HIGH (Pmode, offset)));
          emit_insn (gen_rtx_SET (VOIDmode, reg,
          emit_insn (gen_rtx_SET (VOIDmode, reg,
                                  gen_rtx_LO_SUM (Pmode, reg, offset)));
                                  gen_rtx_LO_SUM (Pmode, reg, offset)));
          emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
          emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
 
 
          orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
          orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
#endif
#endif
#endif
#endif
          return orig;
          return orig;
        }
        }
 
 
      ptr_ref = (gen_rtx_SYMBOL_REF
      ptr_ref = (gen_rtx_SYMBOL_REF
                 (Pmode,
                 (Pmode,
                  machopic_indirection_name (orig, /*stub_p=*/false)));
                  machopic_indirection_name (orig, /*stub_p=*/false)));
 
 
      SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
      SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);
 
 
      ptr_ref = gen_const_mem (Pmode, ptr_ref);
      ptr_ref = gen_const_mem (Pmode, ptr_ref);
      machopic_define_symbol (ptr_ref);
      machopic_define_symbol (ptr_ref);
 
 
      return ptr_ref;
      return ptr_ref;
    }
    }
  else if (GET_CODE (orig) == CONST)
  else if (GET_CODE (orig) == CONST)
    {
    {
      rtx base, result;
      rtx base, result;
 
 
      /* legitimize both operands of the PLUS */
      /* legitimize both operands of the PLUS */
      if (GET_CODE (XEXP (orig, 0)) == PLUS)
      if (GET_CODE (XEXP (orig, 0)) == PLUS)
        {
        {
          base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
          base = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 0),
                                                   reg);
                                                   reg);
          orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
          orig = machopic_indirect_data_reference (XEXP (XEXP (orig, 0), 1),
                                                   (base == reg ? 0 : reg));
                                                   (base == reg ? 0 : reg));
        }
        }
      else
      else
        return orig;
        return orig;
 
 
      if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
      if (MACHOPIC_PURE && GET_CODE (orig) == CONST_INT)
        result = plus_constant (base, INTVAL (orig));
        result = plus_constant (base, INTVAL (orig));
      else
      else
        result = gen_rtx_PLUS (Pmode, base, orig);
        result = gen_rtx_PLUS (Pmode, base, orig);
 
 
      if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
      if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)
        {
        {
          if (reg)
          if (reg)
            {
            {
              emit_move_insn (reg, result);
              emit_move_insn (reg, result);
              result = reg;
              result = reg;
            }
            }
          else
          else
            {
            {
              result = force_reg (GET_MODE (result), result);
              result = force_reg (GET_MODE (result), result);
            }
            }
        }
        }
 
 
      return result;
      return result;
 
 
    }
    }
  else if (GET_CODE (orig) == MEM)
  else if (GET_CODE (orig) == MEM)
    XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
    XEXP (ptr_ref, 0) = machopic_indirect_data_reference (XEXP (orig, 0), reg);
  /* When the target is i386, this code prevents crashes due to the
  /* When the target is i386, this code prevents crashes due to the
     compiler's ignorance on how to move the PIC base register to
     compiler's ignorance on how to move the PIC base register to
     other registers.  (The reload phase sometimes introduces such
     other registers.  (The reload phase sometimes introduces such
     insns.)  */
     insns.)  */
  else if (GET_CODE (orig) == PLUS
  else if (GET_CODE (orig) == PLUS
           && GET_CODE (XEXP (orig, 0)) == REG
           && GET_CODE (XEXP (orig, 0)) == REG
           && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
           && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM
#ifdef I386
#ifdef I386
           /* Prevent the same register from being erroneously used
           /* Prevent the same register from being erroneously used
              as both the base and index registers.  */
              as both the base and index registers.  */
           && GET_CODE (XEXP (orig, 1)) == CONST
           && GET_CODE (XEXP (orig, 1)) == CONST
#endif
#endif
           && reg)
           && reg)
    {
    {
      emit_move_insn (reg, XEXP (orig, 0));
      emit_move_insn (reg, XEXP (orig, 0));
      XEXP (ptr_ref, 0) = reg;
      XEXP (ptr_ref, 0) = reg;
    }
    }
  return ptr_ref;
  return ptr_ref;
}
}
 
 
/* Transform TARGET (a MEM), which is a function call target, to the
/* Transform TARGET (a MEM), which is a function call target, to the
   corresponding symbol_stub if necessary.  Return a new MEM.  */
   corresponding symbol_stub if necessary.  Return a new MEM.  */
 
 
rtx
rtx
machopic_indirect_call_target (rtx target)
machopic_indirect_call_target (rtx target)
{
{
  if (GET_CODE (target) != MEM)
  if (GET_CODE (target) != MEM)
    return target;
    return target;
 
 
  if (MACHOPIC_INDIRECT
  if (MACHOPIC_INDIRECT
      && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
      && GET_CODE (XEXP (target, 0)) == SYMBOL_REF
      && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
      && !(SYMBOL_REF_FLAGS (XEXP (target, 0))
           & MACHO_SYMBOL_FLAG_DEFINED))
           & MACHO_SYMBOL_FLAG_DEFINED))
    {
    {
      rtx sym_ref = XEXP (target, 0);
      rtx sym_ref = XEXP (target, 0);
      const char *stub_name = machopic_indirection_name (sym_ref,
      const char *stub_name = machopic_indirection_name (sym_ref,
                                                         /*stub_p=*/true);
                                                         /*stub_p=*/true);
      enum machine_mode mode = GET_MODE (sym_ref);
      enum machine_mode mode = GET_MODE (sym_ref);
 
 
      XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
      XEXP (target, 0) = gen_rtx_SYMBOL_REF (mode, stub_name);
      SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
      SYMBOL_REF_DATA (XEXP (target, 0)) = SYMBOL_REF_DATA (sym_ref);
      MEM_READONLY_P (target) = 1;
      MEM_READONLY_P (target) = 1;
      MEM_NOTRAP_P (target) = 1;
      MEM_NOTRAP_P (target) = 1;
    }
    }
 
 
  return target;
  return target;
}
}
 
 
rtx
rtx
machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
machopic_legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
{
{
  rtx pic_ref = orig;
  rtx pic_ref = orig;
 
 
  if (! MACHOPIC_INDIRECT)
  if (! MACHOPIC_INDIRECT)
    return orig;
    return orig;
 
 
  /* First handle a simple SYMBOL_REF or LABEL_REF */
  /* First handle a simple SYMBOL_REF or LABEL_REF */
  if (GET_CODE (orig) == LABEL_REF
  if (GET_CODE (orig) == LABEL_REF
      || (GET_CODE (orig) == SYMBOL_REF
      || (GET_CODE (orig) == SYMBOL_REF
          ))
          ))
    {
    {
      /* addr(foo) = &func+(foo-func) */
      /* addr(foo) = &func+(foo-func) */
      rtx pic_base;
      rtx pic_base;
 
 
      orig = machopic_indirect_data_reference (orig, reg);
      orig = machopic_indirect_data_reference (orig, reg);
 
 
      if (GET_CODE (orig) == PLUS
      if (GET_CODE (orig) == PLUS
          && GET_CODE (XEXP (orig, 0)) == REG)
          && GET_CODE (XEXP (orig, 0)) == REG)
        {
        {
          if (reg == 0)
          if (reg == 0)
            return force_reg (mode, orig);
            return force_reg (mode, orig);
 
 
          emit_move_insn (reg, orig);
          emit_move_insn (reg, orig);
          return reg;
          return reg;
        }
        }
 
 
      /* if dynamic-no-pic we don't have a pic base  */
      /* if dynamic-no-pic we don't have a pic base  */
      if (MACHO_DYNAMIC_NO_PIC_P)
      if (MACHO_DYNAMIC_NO_PIC_P)
        pic_base = NULL;
        pic_base = NULL;
      else
      else
        pic_base = machopic_function_base_sym ();
        pic_base = machopic_function_base_sym ();
 
 
      if (GET_CODE (orig) == MEM)
      if (GET_CODE (orig) == MEM)
        {
        {
          if (reg == 0)
          if (reg == 0)
            {
            {
              gcc_assert (!reload_in_progress);
              gcc_assert (!reload_in_progress);
              reg = gen_reg_rtx (Pmode);
              reg = gen_reg_rtx (Pmode);
            }
            }
 
 
#ifdef HAVE_lo_sum
#ifdef HAVE_lo_sum
          if (MACHO_DYNAMIC_NO_PIC_P
          if (MACHO_DYNAMIC_NO_PIC_P
              && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
              && (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
                  || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
                  || GET_CODE (XEXP (orig, 0)) == LABEL_REF))
            {
            {
#if defined (TARGET_TOC)        /* ppc  */
#if defined (TARGET_TOC)        /* ppc  */
              rtx temp_reg = (no_new_pseudos) ? reg : gen_reg_rtx (Pmode);
              rtx temp_reg = (no_new_pseudos) ? reg : gen_reg_rtx (Pmode);
              rtx asym = XEXP (orig, 0);
              rtx asym = XEXP (orig, 0);
              rtx mem;
              rtx mem;
 
 
              emit_insn (gen_macho_high (temp_reg, asym));
              emit_insn (gen_macho_high (temp_reg, asym));
              mem = gen_const_mem (GET_MODE (orig),
              mem = gen_const_mem (GET_MODE (orig),
                                   gen_rtx_LO_SUM (Pmode, temp_reg, asym));
                                   gen_rtx_LO_SUM (Pmode, temp_reg, asym));
              emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
              emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
#else
#else
              /* Some other CPU -- WriteMe! but right now there are no other platform that can use dynamic-no-pic  */
              /* Some other CPU -- WriteMe! but right now there are no other platform that can use dynamic-no-pic  */
              gcc_unreachable ();
              gcc_unreachable ();
#endif
#endif
              pic_ref = reg;
              pic_ref = reg;
            }
            }
          else
          else
          if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
          if (GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
              || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
              || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
            {
            {
              rtx offset = gen_pic_offset (XEXP (orig, 0), pic_base);
              rtx offset = gen_pic_offset (XEXP (orig, 0), pic_base);
#if defined (TARGET_TOC) /* i.e., PowerPC */
#if defined (TARGET_TOC) /* i.e., PowerPC */
              /* Generating a new reg may expose opportunities for
              /* Generating a new reg may expose opportunities for
                 common subexpression elimination.  */
                 common subexpression elimination.  */
              rtx hi_sum_reg = no_new_pseudos ? reg : gen_reg_rtx (Pmode);
              rtx hi_sum_reg = no_new_pseudos ? reg : gen_reg_rtx (Pmode);
              rtx mem;
              rtx mem;
              rtx insn;
              rtx insn;
              rtx sum;
              rtx sum;
 
 
              sum = gen_rtx_HIGH (Pmode, offset);
              sum = gen_rtx_HIGH (Pmode, offset);
              if (! MACHO_DYNAMIC_NO_PIC_P)
              if (! MACHO_DYNAMIC_NO_PIC_P)
                sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
                sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
 
 
              emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
              emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
 
 
              mem = gen_const_mem (GET_MODE (orig),
              mem = gen_const_mem (GET_MODE (orig),
                                  gen_rtx_LO_SUM (Pmode,
                                  gen_rtx_LO_SUM (Pmode,
                                                  hi_sum_reg, offset));
                                                  hi_sum_reg, offset));
              insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
              insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
              REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, pic_ref,
              REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, pic_ref,
                                                    REG_NOTES (insn));
                                                    REG_NOTES (insn));
 
 
              pic_ref = reg;
              pic_ref = reg;
#else
#else
              emit_insn (gen_rtx_USE (VOIDmode,
              emit_insn (gen_rtx_USE (VOIDmode,
                                      gen_rtx_REG (Pmode,
                                      gen_rtx_REG (Pmode,
                                                   PIC_OFFSET_TABLE_REGNUM)));
                                                   PIC_OFFSET_TABLE_REGNUM)));
 
 
              emit_insn (gen_rtx_SET (VOIDmode, reg,
              emit_insn (gen_rtx_SET (VOIDmode, reg,
                                      gen_rtx_HIGH (Pmode,
                                      gen_rtx_HIGH (Pmode,
                                                    gen_rtx_CONST (Pmode,
                                                    gen_rtx_CONST (Pmode,
                                                                   offset))));
                                                                   offset))));
              emit_insn (gen_rtx_SET (VOIDmode, reg,
              emit_insn (gen_rtx_SET (VOIDmode, reg,
                                  gen_rtx_LO_SUM (Pmode, reg,
                                  gen_rtx_LO_SUM (Pmode, reg,
                                           gen_rtx_CONST (Pmode, offset))));
                                           gen_rtx_CONST (Pmode, offset))));
              pic_ref = gen_rtx_PLUS (Pmode,
              pic_ref = gen_rtx_PLUS (Pmode,
                                      pic_offset_table_rtx, reg);
                                      pic_offset_table_rtx, reg);
#endif
#endif
            }
            }
          else
          else
#endif  /* HAVE_lo_sum */
#endif  /* HAVE_lo_sum */
            {
            {
              rtx pic = pic_offset_table_rtx;
              rtx pic = pic_offset_table_rtx;
              if (GET_CODE (pic) != REG)
              if (GET_CODE (pic) != REG)
                {
                {
                  emit_move_insn (reg, pic);
                  emit_move_insn (reg, pic);
                  pic = reg;
                  pic = reg;
                }
                }
#if 0
#if 0
              emit_insn (gen_rtx_USE (VOIDmode,
              emit_insn (gen_rtx_USE (VOIDmode,
                                      gen_rtx_REG (Pmode,
                                      gen_rtx_REG (Pmode,
                                                   PIC_OFFSET_TABLE_REGNUM)));
                                                   PIC_OFFSET_TABLE_REGNUM)));
#endif
#endif
 
 
              if (reload_in_progress)
              if (reload_in_progress)
                regs_ever_live[REGNO (pic)] = 1;
                regs_ever_live[REGNO (pic)] = 1;
              pic_ref = gen_rtx_PLUS (Pmode, pic,
              pic_ref = gen_rtx_PLUS (Pmode, pic,
                                      gen_pic_offset (XEXP (orig, 0),
                                      gen_pic_offset (XEXP (orig, 0),
                                                      pic_base));
                                                      pic_base));
            }
            }
 
 
#if !defined (TARGET_TOC)
#if !defined (TARGET_TOC)
          emit_move_insn (reg, pic_ref);
          emit_move_insn (reg, pic_ref);
          pic_ref = gen_const_mem (GET_MODE (orig), reg);
          pic_ref = gen_const_mem (GET_MODE (orig), reg);
#endif
#endif
        }
        }
      else
      else
        {
        {
 
 
#ifdef HAVE_lo_sum
#ifdef HAVE_lo_sum
          if (GET_CODE (orig) == SYMBOL_REF
          if (GET_CODE (orig) == SYMBOL_REF
              || GET_CODE (orig) == LABEL_REF)
              || GET_CODE (orig) == LABEL_REF)
            {
            {
              rtx offset = gen_pic_offset (orig, pic_base);
              rtx offset = gen_pic_offset (orig, pic_base);
#if defined (TARGET_TOC) /* i.e., PowerPC */
#if defined (TARGET_TOC) /* i.e., PowerPC */
              rtx hi_sum_reg;
              rtx hi_sum_reg;
 
 
              if (reg == 0)
              if (reg == 0)
                {
                {
                  gcc_assert (!reload_in_progress);
                  gcc_assert (!reload_in_progress);
                  reg = gen_reg_rtx (Pmode);
                  reg = gen_reg_rtx (Pmode);
                }
                }
 
 
              hi_sum_reg = reg;
              hi_sum_reg = reg;
 
 
              emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
              emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
                                      (MACHO_DYNAMIC_NO_PIC_P)
                                      (MACHO_DYNAMIC_NO_PIC_P)
                                      ? gen_rtx_HIGH (Pmode, offset)
                                      ? gen_rtx_HIGH (Pmode, offset)
                                      : gen_rtx_PLUS (Pmode,
                                      : gen_rtx_PLUS (Pmode,
                                                      pic_offset_table_rtx,
                                                      pic_offset_table_rtx,
                                                      gen_rtx_HIGH (Pmode,
                                                      gen_rtx_HIGH (Pmode,
                                                                    offset))));
                                                                    offset))));
              emit_insn (gen_rtx_SET (VOIDmode, reg,
              emit_insn (gen_rtx_SET (VOIDmode, reg,
                                      gen_rtx_LO_SUM (Pmode,
                                      gen_rtx_LO_SUM (Pmode,
                                                      hi_sum_reg, offset)));
                                                      hi_sum_reg, offset)));
              pic_ref = reg;
              pic_ref = reg;
#else
#else
              emit_insn (gen_rtx_SET (VOIDmode, reg,
              emit_insn (gen_rtx_SET (VOIDmode, reg,
                                      gen_rtx_HIGH (Pmode, offset)));
                                      gen_rtx_HIGH (Pmode, offset)));
              emit_insn (gen_rtx_SET (VOIDmode, reg,
              emit_insn (gen_rtx_SET (VOIDmode, reg,
                                      gen_rtx_LO_SUM (Pmode, reg, offset)));
                                      gen_rtx_LO_SUM (Pmode, reg, offset)));
              pic_ref = gen_rtx_PLUS (Pmode,
              pic_ref = gen_rtx_PLUS (Pmode,
                                      pic_offset_table_rtx, reg);
                                      pic_offset_table_rtx, reg);
#endif
#endif
            }
            }
          else
          else
#endif  /*  HAVE_lo_sum  */
#endif  /*  HAVE_lo_sum  */
            {
            {
              if (REG_P (orig)
              if (REG_P (orig)
                  || GET_CODE (orig) == SUBREG)
                  || GET_CODE (orig) == SUBREG)
                {
                {
                  return orig;
                  return orig;
                }
                }
              else
              else
                {
                {
                  rtx pic = pic_offset_table_rtx;
                  rtx pic = pic_offset_table_rtx;
                  if (GET_CODE (pic) != REG)
                  if (GET_CODE (pic) != REG)
                    {
                    {
                      emit_move_insn (reg, pic);
                      emit_move_insn (reg, pic);
                      pic = reg;
                      pic = reg;
                    }
                    }
#if 0
#if 0
                  emit_insn (gen_rtx_USE (VOIDmode,
                  emit_insn (gen_rtx_USE (VOIDmode,
                                          pic_offset_table_rtx));
                                          pic_offset_table_rtx));
#endif
#endif
                  if (reload_in_progress)
                  if (reload_in_progress)
                    regs_ever_live[REGNO (pic)] = 1;
                    regs_ever_live[REGNO (pic)] = 1;
                  pic_ref = gen_rtx_PLUS (Pmode,
                  pic_ref = gen_rtx_PLUS (Pmode,
                                          pic,
                                          pic,
                                          gen_pic_offset (orig, pic_base));
                                          gen_pic_offset (orig, pic_base));
                }
                }
            }
            }
        }
        }
 
 
      if (GET_CODE (pic_ref) != REG)
      if (GET_CODE (pic_ref) != REG)
        {
        {
          if (reg != 0)
          if (reg != 0)
            {
            {
              emit_move_insn (reg, pic_ref);
              emit_move_insn (reg, pic_ref);
              return reg;
              return reg;
            }
            }
          else
          else
            {
            {
              return force_reg (mode, pic_ref);
              return force_reg (mode, pic_ref);
            }
            }
        }
        }
      else
      else
        {
        {
          return pic_ref;
          return pic_ref;
        }
        }
    }
    }
 
 
  else if (GET_CODE (orig) == SYMBOL_REF)
  else if (GET_CODE (orig) == SYMBOL_REF)
    return orig;
    return orig;
 
 
  else if (GET_CODE (orig) == PLUS
  else if (GET_CODE (orig) == PLUS
           && (GET_CODE (XEXP (orig, 0)) == MEM
           && (GET_CODE (XEXP (orig, 0)) == MEM
               || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
               || GET_CODE (XEXP (orig, 0)) == SYMBOL_REF
               || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
               || GET_CODE (XEXP (orig, 0)) == LABEL_REF)
           && XEXP (orig, 0) != pic_offset_table_rtx
           && XEXP (orig, 0) != pic_offset_table_rtx
           && GET_CODE (XEXP (orig, 1)) != REG)
           && GET_CODE (XEXP (orig, 1)) != REG)
 
 
    {
    {
      rtx base;
      rtx base;
      int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
      int is_complex = (GET_CODE (XEXP (orig, 0)) == MEM);
 
 
      base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
      base = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
      orig = machopic_legitimize_pic_address (XEXP (orig, 1),
      orig = machopic_legitimize_pic_address (XEXP (orig, 1),
                                              Pmode, (base == reg ? 0 : reg));
                                              Pmode, (base == reg ? 0 : reg));
      if (GET_CODE (orig) == CONST_INT)
      if (GET_CODE (orig) == CONST_INT)
        {
        {
          pic_ref = plus_constant (base, INTVAL (orig));
          pic_ref = plus_constant (base, INTVAL (orig));
          is_complex = 1;
          is_complex = 1;
        }
        }
      else
      else
        pic_ref = gen_rtx_PLUS (Pmode, base, orig);
        pic_ref = gen_rtx_PLUS (Pmode, base, orig);
 
 
      if (reg && is_complex)
      if (reg && is_complex)
        {
        {
          emit_move_insn (reg, pic_ref);
          emit_move_insn (reg, pic_ref);
          pic_ref = reg;
          pic_ref = reg;
        }
        }
      /* Likewise, should we set special REG_NOTEs here?  */
      /* Likewise, should we set special REG_NOTEs here?  */
    }
    }
 
 
  else if (GET_CODE (orig) == CONST)
  else if (GET_CODE (orig) == CONST)
    {
    {
      return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
      return machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
    }
    }
 
 
  else if (GET_CODE (orig) == MEM
  else if (GET_CODE (orig) == MEM
           && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
           && GET_CODE (XEXP (orig, 0)) == SYMBOL_REF)
    {
    {
      rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
      rtx addr = machopic_legitimize_pic_address (XEXP (orig, 0), Pmode, reg);
      addr = replace_equiv_address (orig, addr);
      addr = replace_equiv_address (orig, addr);
      emit_move_insn (reg, addr);
      emit_move_insn (reg, addr);
      pic_ref = reg;
      pic_ref = reg;
    }
    }
 
 
  return pic_ref;
  return pic_ref;
}
}
 
 
/* Output the stub or non-lazy pointer in *SLOT, if it has been used.
/* Output the stub or non-lazy pointer in *SLOT, if it has been used.
   DATA is the FILE* for assembly output.  Called from
   DATA is the FILE* for assembly output.  Called from
   htab_traverse.  */
   htab_traverse.  */
 
 
static int
static int
machopic_output_indirection (void **slot, void *data)
machopic_output_indirection (void **slot, void *data)
{
{
  machopic_indirection *p = *((machopic_indirection **) slot);
  machopic_indirection *p = *((machopic_indirection **) slot);
  FILE *asm_out_file = (FILE *) data;
  FILE *asm_out_file = (FILE *) data;
  rtx symbol;
  rtx symbol;
  const char *sym_name;
  const char *sym_name;
  const char *ptr_name;
  const char *ptr_name;
 
 
  if (!p->used)
  if (!p->used)
    return 1;
    return 1;
 
 
  symbol = p->symbol;
  symbol = p->symbol;
  sym_name = XSTR (symbol, 0);
  sym_name = XSTR (symbol, 0);
  ptr_name = p->ptr_name;
  ptr_name = p->ptr_name;
 
 
  if (p->stub_p)
  if (p->stub_p)
    {
    {
      char *sym;
      char *sym;
      char *stub;
      char *stub;
      tree id;
      tree id;
 
 
      id = maybe_get_identifier (sym_name);
      id = maybe_get_identifier (sym_name);
      if (id)
      if (id)
        {
        {
          tree id_orig = id;
          tree id_orig = id;
 
 
          while (IDENTIFIER_TRANSPARENT_ALIAS (id))
          while (IDENTIFIER_TRANSPARENT_ALIAS (id))
            id = TREE_CHAIN (id);
            id = TREE_CHAIN (id);
          if (id != id_orig)
          if (id != id_orig)
            sym_name = IDENTIFIER_POINTER (id);
            sym_name = IDENTIFIER_POINTER (id);
        }
        }
 
 
      sym = alloca (strlen (sym_name) + 2);
      sym = alloca (strlen (sym_name) + 2);
      if (sym_name[0] == '*' || sym_name[0] == '&')
      if (sym_name[0] == '*' || sym_name[0] == '&')
        strcpy (sym, sym_name + 1);
        strcpy (sym, sym_name + 1);
      else if (sym_name[0] == '-' || sym_name[0] == '+')
      else if (sym_name[0] == '-' || sym_name[0] == '+')
        strcpy (sym, sym_name);
        strcpy (sym, sym_name);
      else
      else
        sprintf (sym, "%s%s", user_label_prefix, sym_name);
        sprintf (sym, "%s%s", user_label_prefix, sym_name);
 
 
      stub = alloca (strlen (ptr_name) + 2);
      stub = alloca (strlen (ptr_name) + 2);
      if (ptr_name[0] == '*' || ptr_name[0] == '&')
      if (ptr_name[0] == '*' || ptr_name[0] == '&')
        strcpy (stub, ptr_name + 1);
        strcpy (stub, ptr_name + 1);
      else
      else
        sprintf (stub, "%s%s", user_label_prefix, ptr_name);
        sprintf (stub, "%s%s", user_label_prefix, ptr_name);
 
 
      machopic_output_stub (asm_out_file, sym, stub);
      machopic_output_stub (asm_out_file, sym, stub);
    }
    }
  else if (! indirect_data (symbol)
  else if (! indirect_data (symbol)
           && (machopic_symbol_defined_p (symbol)
           && (machopic_symbol_defined_p (symbol)
               || SYMBOL_REF_LOCAL_P (symbol)))
               || SYMBOL_REF_LOCAL_P (symbol)))
    {
    {
      switch_to_section (data_section);
      switch_to_section (data_section);
      assemble_align (GET_MODE_ALIGNMENT (Pmode));
      assemble_align (GET_MODE_ALIGNMENT (Pmode));
      assemble_label (ptr_name);
      assemble_label (ptr_name);
      assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
      assemble_integer (gen_rtx_SYMBOL_REF (Pmode, sym_name),
                        GET_MODE_SIZE (Pmode),
                        GET_MODE_SIZE (Pmode),
                        GET_MODE_ALIGNMENT (Pmode), 1);
                        GET_MODE_ALIGNMENT (Pmode), 1);
    }
    }
  else
  else
    {
    {
      rtx init = const0_rtx;
      rtx init = const0_rtx;
 
 
      switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
      switch_to_section (darwin_sections[machopic_nl_symbol_ptr_section]);
      assemble_name (asm_out_file, ptr_name);
      assemble_name (asm_out_file, ptr_name);
      fprintf (asm_out_file, ":\n");
      fprintf (asm_out_file, ":\n");
 
 
      fprintf (asm_out_file, "\t.indirect_symbol ");
      fprintf (asm_out_file, "\t.indirect_symbol ");
      assemble_name (asm_out_file, sym_name);
      assemble_name (asm_out_file, sym_name);
      fprintf (asm_out_file, "\n");
      fprintf (asm_out_file, "\n");
 
 
      /* Variables that are marked with MACHO_SYMBOL_STATIC need to
      /* Variables that are marked with MACHO_SYMBOL_STATIC need to
         have their symbol name instead of 0 in the second entry of
         have their symbol name instead of 0 in the second entry of
         the non-lazy symbol pointer data structure when they are
         the non-lazy symbol pointer data structure when they are
         defined.  This allows the runtime to rebind newer instances
         defined.  This allows the runtime to rebind newer instances
         of the translation unit with the original instance of the
         of the translation unit with the original instance of the
         symbol.  */
         symbol.  */
 
 
      if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
      if ((SYMBOL_REF_FLAGS (symbol) & MACHO_SYMBOL_STATIC)
          && machopic_symbol_defined_p (symbol))
          && machopic_symbol_defined_p (symbol))
        init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
        init = gen_rtx_SYMBOL_REF (Pmode, sym_name);
 
 
      assemble_integer (init, GET_MODE_SIZE (Pmode),
      assemble_integer (init, GET_MODE_SIZE (Pmode),
                        GET_MODE_ALIGNMENT (Pmode), 1);
                        GET_MODE_ALIGNMENT (Pmode), 1);
    }
    }
 
 
  return 1;
  return 1;
}
}
 
 
void
void
machopic_finish (FILE *asm_out_file)
machopic_finish (FILE *asm_out_file)
{
{
  if (machopic_indirections)
  if (machopic_indirections)
    htab_traverse_noresize (machopic_indirections,
    htab_traverse_noresize (machopic_indirections,
                            machopic_output_indirection,
                            machopic_output_indirection,
                            asm_out_file);
                            asm_out_file);
}
}
 
 
int
int
machopic_operand_p (rtx op)
machopic_operand_p (rtx op)
{
{
  if (MACHOPIC_JUST_INDIRECT)
  if (MACHOPIC_JUST_INDIRECT)
    {
    {
      while (GET_CODE (op) == CONST)
      while (GET_CODE (op) == CONST)
        op = XEXP (op, 0);
        op = XEXP (op, 0);
 
 
      if (GET_CODE (op) == SYMBOL_REF)
      if (GET_CODE (op) == SYMBOL_REF)
        return machopic_symbol_defined_p (op);
        return machopic_symbol_defined_p (op);
      else
      else
        return 0;
        return 0;
    }
    }
 
 
  while (GET_CODE (op) == CONST)
  while (GET_CODE (op) == CONST)
    op = XEXP (op, 0);
    op = XEXP (op, 0);
 
 
  if (GET_CODE (op) == MINUS
  if (GET_CODE (op) == MINUS
      && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
      && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
      && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
      && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
      && machopic_symbol_defined_p (XEXP (op, 0))
      && machopic_symbol_defined_p (XEXP (op, 0))
      && machopic_symbol_defined_p (XEXP (op, 1)))
      && machopic_symbol_defined_p (XEXP (op, 1)))
      return 1;
      return 1;
 
 
  return 0;
  return 0;
}
}
 
 
/* This function records whether a given name corresponds to a defined
/* This function records whether a given name corresponds to a defined
   or undefined function or variable, for machopic_classify_ident to
   or undefined function or variable, for machopic_classify_ident to
   use later.  */
   use later.  */
 
 
void
void
darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
darwin_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
{
{
  rtx sym_ref;
  rtx sym_ref;
 
 
  /* Do the standard encoding things first.  */
  /* Do the standard encoding things first.  */
  default_encode_section_info (decl, rtl, first);
  default_encode_section_info (decl, rtl, first);
 
 
  if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
  if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
    return;
    return;
 
 
  sym_ref = XEXP (rtl, 0);
  sym_ref = XEXP (rtl, 0);
  if (TREE_CODE (decl) == VAR_DECL)
  if (TREE_CODE (decl) == VAR_DECL)
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_VARIABLE;
 
 
  if (!DECL_EXTERNAL (decl)
  if (!DECL_EXTERNAL (decl)
      && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
      && (!TREE_PUBLIC (decl) || !DECL_WEAK (decl))
      && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
      && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
      && ((TREE_STATIC (decl)
      && ((TREE_STATIC (decl)
           && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
           && (!DECL_COMMON (decl) || !TREE_PUBLIC (decl)))
          || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
          || (!DECL_COMMON (decl) && DECL_INITIAL (decl)
              && DECL_INITIAL (decl) != error_mark_node)))
              && DECL_INITIAL (decl) != error_mark_node)))
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;
 
 
  if (! TREE_PUBLIC (decl))
  if (! TREE_PUBLIC (decl))
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
    SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_STATIC;
}
}
 
 
void
void
darwin_mark_decl_preserved (const char *name)
darwin_mark_decl_preserved (const char *name)
{
{
  fprintf (asm_out_file, ".no_dead_strip ");
  fprintf (asm_out_file, ".no_dead_strip ");
  assemble_name (asm_out_file, name);
  assemble_name (asm_out_file, name);
  fputc ('\n', asm_out_file);
  fputc ('\n', asm_out_file);
}
}
 
 
int
int
machopic_reloc_rw_mask (void)
machopic_reloc_rw_mask (void)
{
{
  return MACHOPIC_INDIRECT ? 3 : 0;
  return MACHOPIC_INDIRECT ? 3 : 0;
}
}
 
 
section *
section *
machopic_select_section (tree exp, int reloc,
machopic_select_section (tree exp, int reloc,
                         unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
                         unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
{
{
  section *base_section;
  section *base_section;
  bool weak_p = (DECL_P (exp) && DECL_WEAK (exp)
  bool weak_p = (DECL_P (exp) && DECL_WEAK (exp)
                 && (lookup_attribute ("weak", DECL_ATTRIBUTES (exp))
                 && (lookup_attribute ("weak", DECL_ATTRIBUTES (exp))
                     || ! lookup_attribute ("weak_import",
                     || ! lookup_attribute ("weak_import",
                                            DECL_ATTRIBUTES (exp))));
                                            DECL_ATTRIBUTES (exp))));
 
 
  if (TREE_CODE (exp) == FUNCTION_DECL)
  if (TREE_CODE (exp) == FUNCTION_DECL)
    {
    {
      if (reloc == 1)
      if (reloc == 1)
        base_section = (weak_p
        base_section = (weak_p
                        ? darwin_sections[text_unlikely_coal_section]
                        ? darwin_sections[text_unlikely_coal_section]
                        : unlikely_text_section ());
                        : unlikely_text_section ());
      else
      else
        base_section = weak_p ? darwin_sections[text_coal_section] : text_section;
        base_section = weak_p ? darwin_sections[text_coal_section] : text_section;
    }
    }
  else if (decl_readonly_section (exp, reloc))
  else if (decl_readonly_section (exp, reloc))
    base_section = weak_p ? darwin_sections[const_coal_section] : darwin_sections[const_section];
    base_section = weak_p ? darwin_sections[const_coal_section] : darwin_sections[const_section];
  else if (TREE_READONLY (exp) || TREE_CONSTANT (exp))
  else if (TREE_READONLY (exp) || TREE_CONSTANT (exp))
    base_section = weak_p ? darwin_sections[const_data_coal_section] : darwin_sections[const_data_section];
    base_section = weak_p ? darwin_sections[const_data_coal_section] : darwin_sections[const_data_section];
  else
  else
    base_section = weak_p ? darwin_sections[data_coal_section] : data_section;
    base_section = weak_p ? darwin_sections[data_coal_section] : data_section;
 
 
  if (TREE_CODE (exp) == STRING_CST
  if (TREE_CODE (exp) == STRING_CST
      && ((size_t) TREE_STRING_LENGTH (exp)
      && ((size_t) TREE_STRING_LENGTH (exp)
          == strlen (TREE_STRING_POINTER (exp)) + 1))
          == strlen (TREE_STRING_POINTER (exp)) + 1))
    return darwin_sections[cstring_section];
    return darwin_sections[cstring_section];
  else if ((TREE_CODE (exp) == INTEGER_CST || TREE_CODE (exp) == REAL_CST)
  else if ((TREE_CODE (exp) == INTEGER_CST || TREE_CODE (exp) == REAL_CST)
           && flag_merge_constants)
           && flag_merge_constants)
    {
    {
      tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
      tree size = TYPE_SIZE_UNIT (TREE_TYPE (exp));
 
 
      if (TREE_CODE (size) == INTEGER_CST &&
      if (TREE_CODE (size) == INTEGER_CST &&
          TREE_INT_CST_LOW (size) == 4 &&
          TREE_INT_CST_LOW (size) == 4 &&
          TREE_INT_CST_HIGH (size) == 0)
          TREE_INT_CST_HIGH (size) == 0)
        return darwin_sections[literal4_section];
        return darwin_sections[literal4_section];
      else if (TREE_CODE (size) == INTEGER_CST &&
      else if (TREE_CODE (size) == INTEGER_CST &&
               TREE_INT_CST_LOW (size) == 8 &&
               TREE_INT_CST_LOW (size) == 8 &&
               TREE_INT_CST_HIGH (size) == 0)
               TREE_INT_CST_HIGH (size) == 0)
        return darwin_sections[literal8_section];
        return darwin_sections[literal8_section];
      else if (TARGET_64BIT
      else if (TARGET_64BIT
               && TREE_CODE (size) == INTEGER_CST
               && TREE_CODE (size) == INTEGER_CST
               && TREE_INT_CST_LOW (size) == 16
               && TREE_INT_CST_LOW (size) == 16
               && TREE_INT_CST_HIGH (size) == 0)
               && TREE_INT_CST_HIGH (size) == 0)
        return darwin_sections[literal16_section];
        return darwin_sections[literal16_section];
      else
      else
        return base_section;
        return base_section;
    }
    }
  else if (TREE_CODE (exp) == CONSTRUCTOR
  else if (TREE_CODE (exp) == CONSTRUCTOR
           && TREE_TYPE (exp)
           && TREE_TYPE (exp)
           && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
           && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
           && TYPE_NAME (TREE_TYPE (exp)))
           && TYPE_NAME (TREE_TYPE (exp)))
    {
    {
      tree name = TYPE_NAME (TREE_TYPE (exp));
      tree name = TYPE_NAME (TREE_TYPE (exp));
      if (TREE_CODE (name) == TYPE_DECL)
      if (TREE_CODE (name) == TYPE_DECL)
        name = DECL_NAME (name);
        name = DECL_NAME (name);
 
 
      if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
      if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString"))
        {
        {
          if (flag_next_runtime)
          if (flag_next_runtime)
            return darwin_sections[objc_constant_string_object_section];
            return darwin_sections[objc_constant_string_object_section];
          else
          else
            return darwin_sections[objc_string_object_section];
            return darwin_sections[objc_string_object_section];
        }
        }
      else
      else
        return base_section;
        return base_section;
    }
    }
  else if (TREE_CODE (exp) == VAR_DECL &&
  else if (TREE_CODE (exp) == VAR_DECL &&
           DECL_NAME (exp) &&
           DECL_NAME (exp) &&
           TREE_CODE (DECL_NAME (exp)) == IDENTIFIER_NODE &&
           TREE_CODE (DECL_NAME (exp)) == IDENTIFIER_NODE &&
           IDENTIFIER_POINTER (DECL_NAME (exp)) &&
           IDENTIFIER_POINTER (DECL_NAME (exp)) &&
           !strncmp (IDENTIFIER_POINTER (DECL_NAME (exp)), "_OBJC_", 6))
           !strncmp (IDENTIFIER_POINTER (DECL_NAME (exp)), "_OBJC_", 6))
    {
    {
      const char *name = IDENTIFIER_POINTER (DECL_NAME (exp));
      const char *name = IDENTIFIER_POINTER (DECL_NAME (exp));
 
 
      if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
      if (!strncmp (name, "_OBJC_CLASS_METHODS_", 20))
        return darwin_sections[objc_cls_meth_section];
        return darwin_sections[objc_cls_meth_section];
      else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
      else if (!strncmp (name, "_OBJC_INSTANCE_METHODS_", 23))
        return darwin_sections[objc_inst_meth_section];
        return darwin_sections[objc_inst_meth_section];
      else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
      else if (!strncmp (name, "_OBJC_CATEGORY_CLASS_METHODS_", 20))
        return darwin_sections[objc_cat_cls_meth_section];
        return darwin_sections[objc_cat_cls_meth_section];
      else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
      else if (!strncmp (name, "_OBJC_CATEGORY_INSTANCE_METHODS_", 23))
        return darwin_sections[objc_cat_inst_meth_section];
        return darwin_sections[objc_cat_inst_meth_section];
      else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
      else if (!strncmp (name, "_OBJC_CLASS_VARIABLES_", 22))
        return darwin_sections[objc_class_vars_section];
        return darwin_sections[objc_class_vars_section];
      else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
      else if (!strncmp (name, "_OBJC_INSTANCE_VARIABLES_", 25))
        return darwin_sections[objc_instance_vars_section];
        return darwin_sections[objc_instance_vars_section];
      else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
      else if (!strncmp (name, "_OBJC_CLASS_PROTOCOLS_", 22))
        return darwin_sections[objc_cat_cls_meth_section];
        return darwin_sections[objc_cat_cls_meth_section];
      else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
      else if (!strncmp (name, "_OBJC_CLASS_NAME_", 17))
        return darwin_sections[objc_class_names_section];
        return darwin_sections[objc_class_names_section];
      else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
      else if (!strncmp (name, "_OBJC_METH_VAR_NAME_", 20))
        return darwin_sections[objc_meth_var_names_section];
        return darwin_sections[objc_meth_var_names_section];
      else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
      else if (!strncmp (name, "_OBJC_METH_VAR_TYPE_", 20))
        return darwin_sections[objc_meth_var_types_section];
        return darwin_sections[objc_meth_var_types_section];
      else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
      else if (!strncmp (name, "_OBJC_CLASS_REFERENCES", 22))
        return darwin_sections[objc_cls_refs_section];
        return darwin_sections[objc_cls_refs_section];
      else if (!strncmp (name, "_OBJC_CLASS_", 12))
      else if (!strncmp (name, "_OBJC_CLASS_", 12))
        return darwin_sections[objc_class_section];
        return darwin_sections[objc_class_section];
      else if (!strncmp (name, "_OBJC_METACLASS_", 16))
      else if (!strncmp (name, "_OBJC_METACLASS_", 16))
        return darwin_sections[objc_meta_class_section];
        return darwin_sections[objc_meta_class_section];
      else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
      else if (!strncmp (name, "_OBJC_CATEGORY_", 15))
        return darwin_sections[objc_category_section];
        return darwin_sections[objc_category_section];
      else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
      else if (!strncmp (name, "_OBJC_SELECTOR_REFERENCES", 25))
        return darwin_sections[objc_selector_refs_section];
        return darwin_sections[objc_selector_refs_section];
      else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
      else if (!strncmp (name, "_OBJC_SELECTOR_FIXUP", 20))
        return darwin_sections[objc_selector_fixup_section];
        return darwin_sections[objc_selector_fixup_section];
      else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
      else if (!strncmp (name, "_OBJC_SYMBOLS", 13))
        return darwin_sections[objc_symbols_section];
        return darwin_sections[objc_symbols_section];
      else if (!strncmp (name, "_OBJC_MODULES", 13))
      else if (!strncmp (name, "_OBJC_MODULES", 13))
        return darwin_sections[objc_module_info_section];
        return darwin_sections[objc_module_info_section];
      else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
      else if (!strncmp (name, "_OBJC_IMAGE_INFO", 16))
        return darwin_sections[objc_image_info_section];
        return darwin_sections[objc_image_info_section];
      else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
      else if (!strncmp (name, "_OBJC_PROTOCOL_INSTANCE_METHODS_", 32))
        return darwin_sections[objc_cat_inst_meth_section];
        return darwin_sections[objc_cat_inst_meth_section];
      else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
      else if (!strncmp (name, "_OBJC_PROTOCOL_CLASS_METHODS_", 29))
        return darwin_sections[objc_cat_cls_meth_section];
        return darwin_sections[objc_cat_cls_meth_section];
      else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
      else if (!strncmp (name, "_OBJC_PROTOCOL_REFS_", 20))
        return darwin_sections[objc_cat_cls_meth_section];
        return darwin_sections[objc_cat_cls_meth_section];
      else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
      else if (!strncmp (name, "_OBJC_PROTOCOL_", 15))
        return darwin_sections[objc_protocol_section];
        return darwin_sections[objc_protocol_section];
      else
      else
        return base_section;
        return base_section;
    }
    }
  else
  else
    return base_section;
    return base_section;
}
}
 
 
/* This can be called with address expressions as "rtx".
/* This can be called with address expressions as "rtx".
   They must go in "const".  */
   They must go in "const".  */
 
 
section *
section *
machopic_select_rtx_section (enum machine_mode mode, rtx x,
machopic_select_rtx_section (enum machine_mode mode, rtx x,
                             unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
                             unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
{
{
  if (GET_MODE_SIZE (mode) == 8
  if (GET_MODE_SIZE (mode) == 8
      && (GET_CODE (x) == CONST_INT
      && (GET_CODE (x) == CONST_INT
          || GET_CODE (x) == CONST_DOUBLE))
          || GET_CODE (x) == CONST_DOUBLE))
    return darwin_sections[literal8_section];
    return darwin_sections[literal8_section];
  else if (GET_MODE_SIZE (mode) == 4
  else if (GET_MODE_SIZE (mode) == 4
           && (GET_CODE (x) == CONST_INT
           && (GET_CODE (x) == CONST_INT
               || GET_CODE (x) == CONST_DOUBLE))
               || GET_CODE (x) == CONST_DOUBLE))
    return darwin_sections[literal4_section];
    return darwin_sections[literal4_section];
  else if (TARGET_64BIT
  else if (TARGET_64BIT
           && GET_MODE_SIZE (mode) == 16
           && GET_MODE_SIZE (mode) == 16
           && (GET_CODE (x) == CONST_INT
           && (GET_CODE (x) == CONST_INT
               || GET_CODE (x) == CONST_DOUBLE
               || GET_CODE (x) == CONST_DOUBLE
               || GET_CODE (x) == CONST_VECTOR))
               || GET_CODE (x) == CONST_VECTOR))
    return darwin_sections[literal16_section];
    return darwin_sections[literal16_section];
  else if (MACHOPIC_INDIRECT
  else if (MACHOPIC_INDIRECT
           && (GET_CODE (x) == SYMBOL_REF
           && (GET_CODE (x) == SYMBOL_REF
               || GET_CODE (x) == CONST
               || GET_CODE (x) == CONST
               || GET_CODE (x) == LABEL_REF))
               || GET_CODE (x) == LABEL_REF))
    return darwin_sections[const_data_section];
    return darwin_sections[const_data_section];
  else
  else
    return darwin_sections[const_section];
    return darwin_sections[const_section];
}
}
 
 
void
void
machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
machopic_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
{
{
  if (MACHOPIC_INDIRECT)
  if (MACHOPIC_INDIRECT)
    switch_to_section (darwin_sections[mod_init_section]);
    switch_to_section (darwin_sections[mod_init_section]);
  else
  else
    switch_to_section (darwin_sections[constructor_section]);
    switch_to_section (darwin_sections[constructor_section]);
  assemble_align (POINTER_SIZE);
  assemble_align (POINTER_SIZE);
  assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
  assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
 
 
  if (! MACHOPIC_INDIRECT)
  if (! MACHOPIC_INDIRECT)
    fprintf (asm_out_file, ".reference .constructors_used\n");
    fprintf (asm_out_file, ".reference .constructors_used\n");
}
}
 
 
void
void
machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
machopic_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
{
{
  if (MACHOPIC_INDIRECT)
  if (MACHOPIC_INDIRECT)
    switch_to_section (darwin_sections[mod_term_section]);
    switch_to_section (darwin_sections[mod_term_section]);
  else
  else
    switch_to_section (darwin_sections[destructor_section]);
    switch_to_section (darwin_sections[destructor_section]);
  assemble_align (POINTER_SIZE);
  assemble_align (POINTER_SIZE);
  assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
  assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
 
 
  if (! MACHOPIC_INDIRECT)
  if (! MACHOPIC_INDIRECT)
    fprintf (asm_out_file, ".reference .destructors_used\n");
    fprintf (asm_out_file, ".reference .destructors_used\n");
}
}
 
 
void
void
darwin_globalize_label (FILE *stream, const char *name)
darwin_globalize_label (FILE *stream, const char *name)
{
{
  if (!!strncmp (name, "_OBJC_", 6))
  if (!!strncmp (name, "_OBJC_", 6))
    default_globalize_label (stream, name);
    default_globalize_label (stream, name);
}
}
 
 
void
void
darwin_asm_named_section (const char *name,
darwin_asm_named_section (const char *name,
                          unsigned int flags ATTRIBUTE_UNUSED,
                          unsigned int flags ATTRIBUTE_UNUSED,
                          tree decl ATTRIBUTE_UNUSED)
                          tree decl ATTRIBUTE_UNUSED)
{
{
  fprintf (asm_out_file, "\t.section %s\n", name);
  fprintf (asm_out_file, "\t.section %s\n", name);
}
}
 
 
void
void
darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
darwin_unique_section (tree decl ATTRIBUTE_UNUSED, int reloc ATTRIBUTE_UNUSED)
{
{
  /* Darwin does not use unique sections.  */
  /* Darwin does not use unique sections.  */
}
}
 
 
/* Handle __attribute__ ((apple_kext_compatibility)).
/* Handle __attribute__ ((apple_kext_compatibility)).
   This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
   This only applies to darwin kexts for 2.95 compatibility -- it shrinks the
   vtable for classes with this attribute (and their descendants) by not
   vtable for classes with this attribute (and their descendants) by not
   outputting the new 3.0 nondeleting destructor.  This means that such
   outputting the new 3.0 nondeleting destructor.  This means that such
   objects CANNOT be allocated on the stack or as globals UNLESS they have
   objects CANNOT be allocated on the stack or as globals UNLESS they have
   a completely empty `operator delete'.
   a completely empty `operator delete'.
   Luckily, this fits in with the Darwin kext model.
   Luckily, this fits in with the Darwin kext model.
 
 
   This attribute also disables gcc3's potential overlaying of derived
   This attribute also disables gcc3's potential overlaying of derived
   class data members on the padding at the end of the base class.  */
   class data members on the padding at the end of the base class.  */
 
 
tree
tree
darwin_handle_kext_attribute (tree *node, tree name,
darwin_handle_kext_attribute (tree *node, tree name,
                              tree args ATTRIBUTE_UNUSED,
                              tree args ATTRIBUTE_UNUSED,
                              int flags ATTRIBUTE_UNUSED,
                              int flags ATTRIBUTE_UNUSED,
                              bool *no_add_attrs)
                              bool *no_add_attrs)
{
{
  /* APPLE KEXT stuff -- only applies with pure static C++ code.  */
  /* APPLE KEXT stuff -- only applies with pure static C++ code.  */
  if (! TARGET_KEXTABI)
  if (! TARGET_KEXTABI)
    {
    {
      warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
      warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
               "only when compiling a kext", IDENTIFIER_POINTER (name));
               "only when compiling a kext", IDENTIFIER_POINTER (name));
 
 
      *no_add_attrs = true;
      *no_add_attrs = true;
    }
    }
  else if (TREE_CODE (*node) != RECORD_TYPE)
  else if (TREE_CODE (*node) != RECORD_TYPE)
    {
    {
      warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
      warning (0, "%<%s%> 2.95 vtable-compatability attribute applies "
               "only to C++ classes", IDENTIFIER_POINTER (name));
               "only to C++ classes", IDENTIFIER_POINTER (name));
 
 
      *no_add_attrs = true;
      *no_add_attrs = true;
    }
    }
 
 
  return NULL_TREE;
  return NULL_TREE;
}
}
 
 
/* Handle a "weak_import" attribute; arguments as in
/* Handle a "weak_import" attribute; arguments as in
   struct attribute_spec.handler.  */
   struct attribute_spec.handler.  */
 
 
tree
tree
darwin_handle_weak_import_attribute (tree *node, tree name,
darwin_handle_weak_import_attribute (tree *node, tree name,
                                     tree ARG_UNUSED (args),
                                     tree ARG_UNUSED (args),
                                     int ARG_UNUSED (flags),
                                     int ARG_UNUSED (flags),
                                     bool * no_add_attrs)
                                     bool * no_add_attrs)
{
{
  if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
  if (TREE_CODE (*node) != FUNCTION_DECL && TREE_CODE (*node) != VAR_DECL)
    {
    {
      warning (OPT_Wattributes, "%qs attribute ignored",
      warning (OPT_Wattributes, "%qs attribute ignored",
               IDENTIFIER_POINTER (name));
               IDENTIFIER_POINTER (name));
      *no_add_attrs = true;
      *no_add_attrs = true;
    }
    }
  else
  else
    declare_weak (*node);
    declare_weak (*node);
 
 
  return NULL_TREE;
  return NULL_TREE;
}
}
 
 
static void
static void
no_dead_strip (FILE *file, const char *lab)
no_dead_strip (FILE *file, const char *lab)
{
{
  fprintf (file, ".no_dead_strip %s\n", lab);
  fprintf (file, ".no_dead_strip %s\n", lab);
}
}
 
 
/* Emit a label for an FDE, making it global and/or weak if appropriate.
/* Emit a label for an FDE, making it global and/or weak if appropriate.
   The third parameter is nonzero if this is for exception handling.
   The third parameter is nonzero if this is for exception handling.
   The fourth parameter is nonzero if this is just a placeholder for an
   The fourth parameter is nonzero if this is just a placeholder for an
   FDE that we are omitting. */
   FDE that we are omitting. */
 
 
void
void
darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
darwin_emit_unwind_label (FILE *file, tree decl, int for_eh, int empty)
{
{
  const char *base;
  const char *base;
  char *lab;
  char *lab;
  bool need_quotes;
  bool need_quotes;
 
 
  if (DECL_ASSEMBLER_NAME_SET_P (decl))
  if (DECL_ASSEMBLER_NAME_SET_P (decl))
    base = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
    base = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
  else
  else
    base = IDENTIFIER_POINTER (DECL_NAME (decl));
    base = IDENTIFIER_POINTER (DECL_NAME (decl));
 
 
  base = targetm.strip_name_encoding (base);
  base = targetm.strip_name_encoding (base);
  need_quotes = name_needs_quotes (base);
  need_quotes = name_needs_quotes (base);
 
 
  if (! for_eh)
  if (! for_eh)
    return;
    return;
 
 
  lab = concat (need_quotes ? "\"" : "", user_label_prefix, base, ".eh",
  lab = concat (need_quotes ? "\"" : "", user_label_prefix, base, ".eh",
                need_quotes ? "\"" : "", NULL);
                need_quotes ? "\"" : "", NULL);
 
 
  if (TREE_PUBLIC (decl))
  if (TREE_PUBLIC (decl))
    fprintf (file, "\t%s %s\n",
    fprintf (file, "\t%s %s\n",
             (DECL_VISIBILITY (decl) != VISIBILITY_HIDDEN
             (DECL_VISIBILITY (decl) != VISIBILITY_HIDDEN
              ? ".globl"
              ? ".globl"
              : ".private_extern"),
              : ".private_extern"),
             lab);
             lab);
 
 
  if (DECL_WEAK (decl))
  if (DECL_WEAK (decl))
    fprintf (file, "\t.weak_definition %s\n", lab);
    fprintf (file, "\t.weak_definition %s\n", lab);
 
 
  if (empty)
  if (empty)
    {
    {
      fprintf (file, "%s = 0\n", lab);
      fprintf (file, "%s = 0\n", lab);
 
 
      /* Mark the absolute .eh and .eh1 style labels as needed to
      /* Mark the absolute .eh and .eh1 style labels as needed to
         ensure that we don't dead code strip them and keep such
         ensure that we don't dead code strip them and keep such
         labels from another instantiation point until we can fix this
         labels from another instantiation point until we can fix this
         properly with group comdat support.  */
         properly with group comdat support.  */
      no_dead_strip (file, lab);
      no_dead_strip (file, lab);
    }
    }
  else
  else
    fprintf (file, "%s:\n", lab);
    fprintf (file, "%s:\n", lab);
 
 
  free (lab);
  free (lab);
}
}
 
 
static GTY(()) unsigned long except_table_label_num;
static GTY(()) unsigned long except_table_label_num;
 
 
void
void
darwin_emit_except_table_label (FILE *file)
darwin_emit_except_table_label (FILE *file)
{
{
  char section_start_label[30];
  char section_start_label[30];
 
 
  ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
  ASM_GENERATE_INTERNAL_LABEL (section_start_label, "GCC_except_table",
                               except_table_label_num++);
                               except_table_label_num++);
  ASM_OUTPUT_LABEL (file, section_start_label);
  ASM_OUTPUT_LABEL (file, section_start_label);
}
}
/* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
/* Generate a PC-relative reference to a Mach-O non-lazy-symbol.  */
 
 
void
void
darwin_non_lazy_pcrel (FILE *file, rtx addr)
darwin_non_lazy_pcrel (FILE *file, rtx addr)
{
{
  const char *nlp_name;
  const char *nlp_name;
 
 
  gcc_assert (GET_CODE (addr) == SYMBOL_REF);
  gcc_assert (GET_CODE (addr) == SYMBOL_REF);
 
 
  nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
  nlp_name = machopic_indirection_name (addr, /*stub_p=*/false);
  fputs ("\t.long\t", file);
  fputs ("\t.long\t", file);
  ASM_OUTPUT_LABELREF (file, nlp_name);
  ASM_OUTPUT_LABELREF (file, nlp_name);
  fputs ("-.", file);
  fputs ("-.", file);
}
}
 
 
/* Emit an assembler directive to set visibility for a symbol.  The
/* Emit an assembler directive to set visibility for a symbol.  The
   only supported visibilities are VISIBILITY_DEFAULT and
   only supported visibilities are VISIBILITY_DEFAULT and
   VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
   VISIBILITY_HIDDEN; the latter corresponds to Darwin's "private
   extern".  There is no MACH-O equivalent of ELF's
   extern".  There is no MACH-O equivalent of ELF's
   VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
   VISIBILITY_INTERNAL or VISIBILITY_PROTECTED. */
 
 
void
void
darwin_assemble_visibility (tree decl, int vis)
darwin_assemble_visibility (tree decl, int vis)
{
{
  if (vis == VISIBILITY_DEFAULT)
  if (vis == VISIBILITY_DEFAULT)
    ;
    ;
  else if (vis == VISIBILITY_HIDDEN)
  else if (vis == VISIBILITY_HIDDEN)
    {
    {
      fputs ("\t.private_extern ", asm_out_file);
      fputs ("\t.private_extern ", asm_out_file);
      assemble_name (asm_out_file,
      assemble_name (asm_out_file,
                     (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
                     (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
      fputs ("\n", asm_out_file);
      fputs ("\n", asm_out_file);
    }
    }
  else
  else
    warning (OPT_Wattributes, "internal and protected visibility attributes "
    warning (OPT_Wattributes, "internal and protected visibility attributes "
             "not supported in this configuration; ignored");
             "not supported in this configuration; ignored");
}
}
 
 
/* Output a difference of two labels that will be an assembly time
/* Output a difference of two labels that will be an assembly time
   constant if the two labels are local.  (.long lab1-lab2 will be
   constant if the two labels are local.  (.long lab1-lab2 will be
   very different if lab1 is at the boundary between two sections; it
   very different if lab1 is at the boundary between two sections; it
   will be relocated according to the second section, not the first,
   will be relocated according to the second section, not the first,
   so one ends up with a difference between labels in different
   so one ends up with a difference between labels in different
   sections, which is bad in the dwarf2 eh context for instance.)  */
   sections, which is bad in the dwarf2 eh context for instance.)  */
 
 
static int darwin_dwarf_label_counter;
static int darwin_dwarf_label_counter;
 
 
void
void
darwin_asm_output_dwarf_delta (FILE *file, int size,
darwin_asm_output_dwarf_delta (FILE *file, int size,
                               const char *lab1, const char *lab2)
                               const char *lab1, const char *lab2)
{
{
  int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
  int islocaldiff = (lab1[0] == '*' && lab1[1] == 'L'
                     && lab2[0] == '*' && lab2[1] == 'L');
                     && lab2[0] == '*' && lab2[1] == 'L');
  const char *directive = (size == 8 ? ".quad" : ".long");
  const char *directive = (size == 8 ? ".quad" : ".long");
 
 
  if (islocaldiff)
  if (islocaldiff)
    fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
    fprintf (file, "\t.set L$set$%d,", darwin_dwarf_label_counter);
  else
  else
    fprintf (file, "\t%s\t", directive);
    fprintf (file, "\t%s\t", directive);
  assemble_name_raw (file, lab1);
  assemble_name_raw (file, lab1);
  fprintf (file, "-");
  fprintf (file, "-");
  assemble_name_raw (file, lab2);
  assemble_name_raw (file, lab2);
  if (islocaldiff)
  if (islocaldiff)
    fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
    fprintf (file, "\n\t%s L$set$%d", directive, darwin_dwarf_label_counter++);
}
}
 
 
/* Output labels for the start of the DWARF sections if necessary.  */
/* Output labels for the start of the DWARF sections if necessary.  */
void
void
darwin_file_start (void)
darwin_file_start (void)
{
{
  if (write_symbols == DWARF2_DEBUG)
  if (write_symbols == DWARF2_DEBUG)
    {
    {
      static const char * const debugnames[] =
      static const char * const debugnames[] =
        {
        {
          DEBUG_FRAME_SECTION,
          DEBUG_FRAME_SECTION,
          DEBUG_INFO_SECTION,
          DEBUG_INFO_SECTION,
          DEBUG_ABBREV_SECTION,
          DEBUG_ABBREV_SECTION,
          DEBUG_ARANGES_SECTION,
          DEBUG_ARANGES_SECTION,
          DEBUG_MACINFO_SECTION,
          DEBUG_MACINFO_SECTION,
          DEBUG_LINE_SECTION,
          DEBUG_LINE_SECTION,
          DEBUG_LOC_SECTION,
          DEBUG_LOC_SECTION,
          DEBUG_PUBNAMES_SECTION,
          DEBUG_PUBNAMES_SECTION,
          DEBUG_STR_SECTION,
          DEBUG_STR_SECTION,
          DEBUG_RANGES_SECTION
          DEBUG_RANGES_SECTION
        };
        };
      size_t i;
      size_t i;
 
 
      for (i = 0; i < ARRAY_SIZE (debugnames); i++)
      for (i = 0; i < ARRAY_SIZE (debugnames); i++)
        {
        {
          int namelen;
          int namelen;
 
 
          switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
          switch_to_section (get_section (debugnames[i], SECTION_DEBUG, NULL));
 
 
          gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
          gcc_assert (strncmp (debugnames[i], "__DWARF,", 8) == 0);
          gcc_assert (strchr (debugnames[i] + 8, ','));
          gcc_assert (strchr (debugnames[i] + 8, ','));
 
 
          namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
          namelen = strchr (debugnames[i] + 8, ',') - (debugnames[i] + 8);
          fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
          fprintf (asm_out_file, "Lsection%.*s:\n", namelen, debugnames[i] + 8);
        }
        }
    }
    }
}
}
 
 
/* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
/* Output an offset in a DWARF section on Darwin.  On Darwin, DWARF section
   offsets are not represented using relocs in .o files; either the
   offsets are not represented using relocs in .o files; either the
   section never leaves the .o file, or the linker or other tool is
   section never leaves the .o file, or the linker or other tool is
   responsible for parsing the DWARF and updating the offsets.  */
   responsible for parsing the DWARF and updating the offsets.  */
 
 
void
void
darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
darwin_asm_output_dwarf_offset (FILE *file, int size, const char * lab,
                                section *base)
                                section *base)
{
{
  char sname[64];
  char sname[64];
  int namelen;
  int namelen;
 
 
  gcc_assert (base->common.flags & SECTION_NAMED);
  gcc_assert (base->common.flags & SECTION_NAMED);
  gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
  gcc_assert (strncmp (base->named.name, "__DWARF,", 8) == 0);
  gcc_assert (strchr (base->named.name + 8, ','));
  gcc_assert (strchr (base->named.name + 8, ','));
 
 
  namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
  namelen = strchr (base->named.name + 8, ',') - (base->named.name + 8);
  sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
  sprintf (sname, "*Lsection%.*s", namelen, base->named.name + 8);
  darwin_asm_output_dwarf_delta (file, size, lab, sname);
  darwin_asm_output_dwarf_delta (file, size, lab, sname);
}
}
 
 
void
void
darwin_file_end (void)
darwin_file_end (void)
{
{
  machopic_finish (asm_out_file);
  machopic_finish (asm_out_file);
  if (strcmp (lang_hooks.name, "GNU C++") == 0)
  if (strcmp (lang_hooks.name, "GNU C++") == 0)
    {
    {
      switch_to_section (darwin_sections[constructor_section]);
      switch_to_section (darwin_sections[constructor_section]);
      switch_to_section (darwin_sections[destructor_section]);
      switch_to_section (darwin_sections[destructor_section]);
      ASM_OUTPUT_ALIGN (asm_out_file, 1);
      ASM_OUTPUT_ALIGN (asm_out_file, 1);
    }
    }
  fprintf (asm_out_file, "\t.subsections_via_symbols\n");
  fprintf (asm_out_file, "\t.subsections_via_symbols\n");
}
}
 
 
/* TODO: Add a language hook for identifying if a decl is a vtable.  */
/* TODO: Add a language hook for identifying if a decl is a vtable.  */
#define DARWIN_VTABLE_P(DECL) 0
#define DARWIN_VTABLE_P(DECL) 0
 
 
/* Cross-module name binding.  Darwin does not support overriding
/* Cross-module name binding.  Darwin does not support overriding
   functions at dynamic-link time, except for vtables in kexts.  */
   functions at dynamic-link time, except for vtables in kexts.  */
 
 
bool
bool
darwin_binds_local_p (tree decl)
darwin_binds_local_p (tree decl)
{
{
  return default_binds_local_p_1 (decl,
  return default_binds_local_p_1 (decl,
                                  TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
                                  TARGET_KEXTABI && DARWIN_VTABLE_P (decl));
}
}
 
 
#if 0
#if 0
/* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet.  */
/* See TARGET_ASM_OUTPUT_ANCHOR for why we can't do this yet.  */
/* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
/* The Darwin's implementation of TARGET_ASM_OUTPUT_ANCHOR.  Define the
   anchor relative to ".", the current section position.  We cannot use
   anchor relative to ".", the current section position.  We cannot use
   the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
   the default one because ASM_OUTPUT_DEF is wrong for Darwin.  */
 
 
void
void
darwin_asm_output_anchor (rtx symbol)
darwin_asm_output_anchor (rtx symbol)
{
{
  fprintf (asm_out_file, "\t.set\t");
  fprintf (asm_out_file, "\t.set\t");
  assemble_name (asm_out_file, XSTR (symbol, 0));
  assemble_name (asm_out_file, XSTR (symbol, 0));
  fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
  fprintf (asm_out_file, ", . + " HOST_WIDE_INT_PRINT_DEC "\n",
           SYMBOL_REF_BLOCK_OFFSET (symbol));
           SYMBOL_REF_BLOCK_OFFSET (symbol));
}
}
#endif
#endif
 
 
/* Set the darwin specific attributes on TYPE.  */
/* Set the darwin specific attributes on TYPE.  */
void
void
darwin_set_default_type_attributes (tree type)
darwin_set_default_type_attributes (tree type)
{
{
  if (darwin_ms_struct
  if (darwin_ms_struct
      && TREE_CODE (type) == RECORD_TYPE)
      && TREE_CODE (type) == RECORD_TYPE)
    TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
    TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("ms_struct"),
                                        NULL_TREE,
                                        NULL_TREE,
                                        TYPE_ATTRIBUTES (type));
                                        TYPE_ATTRIBUTES (type));
}
}
 
 
/* True, iff we're generating code for loadable kernel extentions.  */
/* True, iff we're generating code for loadable kernel extentions.  */
 
 
bool
bool
darwin_kextabi_p (void) {
darwin_kextabi_p (void) {
  return flag_apple_kext;
  return flag_apple_kext;
}
}
 
 
void
void
darwin_override_options (void)
darwin_override_options (void)
{
{
  if (flag_apple_kext && strcmp (lang_hooks.name, "GNU C++") != 0)
  if (flag_apple_kext && strcmp (lang_hooks.name, "GNU C++") != 0)
    {
    {
      warning (0, "command line option %<-fapple-kext%> is only valid for C++");
      warning (0, "command line option %<-fapple-kext%> is only valid for C++");
      flag_apple_kext = 0;
      flag_apple_kext = 0;
    }
    }
  if (flag_mkernel || flag_apple_kext)
  if (flag_mkernel || flag_apple_kext)
    {
    {
      /* -mkernel implies -fapple-kext for C++ */
      /* -mkernel implies -fapple-kext for C++ */
      if (strcmp (lang_hooks.name, "GNU C++") == 0)
      if (strcmp (lang_hooks.name, "GNU C++") == 0)
        flag_apple_kext = 1;
        flag_apple_kext = 1;
 
 
      flag_no_common = 1;
      flag_no_common = 1;
 
 
      /* No EH in kexts.  */
      /* No EH in kexts.  */
      flag_exceptions = 0;
      flag_exceptions = 0;
      /* No -fnon-call-exceptions data in kexts.  */
      /* No -fnon-call-exceptions data in kexts.  */
      flag_non_call_exceptions = 0;
      flag_non_call_exceptions = 0;
    }
    }
}
}
 
 
#include "gt-darwin.h"
#include "gt-darwin.h"
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.