Subversion Repositories openrisc

/* Functions for generic Darwin as target machine for GNU C compiler.

   Copyright (C) 1989, 1990, 1991, 1992, 1993, 2000, 2001, 2002, 2003, 2004,

   2005, 2006, 2007, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

   Contributed by Apple Computer Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3, or (at your option)

any later version.

GCC is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "insn-config.h"

#include "conditions.h"

#include "insn-flags.h"

#include "output.h"

#include "insn-attr.h"

#include "flags.h"

#include "tree.h"

#include "expr.h"

#include "reload.h"

#include "function.h"

#include "ggc.h"

#include "langhooks.h"

#include "target.h"

#include "tm_p.h"

#include "diagnostic-core.h"

#include "toplev.h"

#include "hashtab.h"

#include "df.h"

#include "debug.h"

#include "obstack.h"

#include "lto-streamer.h"

/* Darwin supports a feature called fix-and-continue, which is used

   for rapid turn around debugging.  When code is compiled with the

   -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

   able to do easily.  These changes allow gdb to load in

   recompilation of a translation unit that has been changed into a

   running program and replace existing functions and methods of that

   translation unit with versions of those functions and methods

   from the newly compiled translation unit.  The new functions access

   the existing static symbols from the old translation unit, if the

   symbol existed in the unit to be replaced, and from the new

   translation unit, otherwise.

   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

   are required by consumers of the generated code.  Currently, gdb

   uses this to patch in a jump to the overriding function, this

   allows all uses of the old name to forward to the replacement,

   including existing function pointers and virtual methods.  See

   rs6000_emit_prologue for the code that handles the nop insertions.

   The added indirection allows gdb to redirect accesses to static

   symbols from the newly loaded translation unit to the existing

   symbol, if any.  @code{static} symbols are special and are handled by

   setting the second word in the .non_lazy_symbol_pointer data

   structure to symbol.  See indirect_data for the code that handles

   the extra indirection, and machopic_output_indirection and its use

   of MACHO_SYMBOL_STATIC for the code that handles @code{static}

   symbol indirection.  */

/* For darwin >= 9  (OSX 10.5) the linker is capable of making the necessary

   branch islands and we no longer need to emit darwin stubs.

   However, if we are generating code for earlier systems (or for use in the

   kernel) the stubs might still be required, and this will be set true.  */

int darwin_emit_branch_islands = false;

/* A flag to determine whether we are running c++ or obj-c++.  This has to be

   settable from non-c-family contexts too (i.e. we can't use the c_dialect_

   functions).  */

int darwin_running_cxx;

/* Some code-gen now depends on OS major version numbers (at least).  */

int generating_for_darwin_version ;

/* Section names.  */

section * darwin_sections[NUM_DARWIN_SECTIONS];

/* While we transition to using in-tests instead of ifdef'd code.  */

#ifndef HAVE_lo_sum

#define HAVE_lo_sum 0

#define gen_macho_high(a,b) (a)

#define gen_macho_low(a,b,c) (a)

#endif

/* True if we're setting __attribute__ ((ms_struct)).  */

int darwin_ms_struct = false;

/* Earlier versions of Darwin as do not recognize an alignment field in

   .comm directives, this should be set for versions that allow it.  */

int emit_aligned_common = false;

/* A get_unnamed_section callback used to switch to an ObjC section.

   DIRECTIVE is as for output_section_asm_op.  */

static void

output_objc_section_asm_op (const void *directive)

{

  static bool been_here = false;

  /* The NeXT ObjC Runtime requires these sections to be present and in

     order in the object.  The code below implements this by emitting

     a section header for each ObjC section the first time that an ObjC

     section is requested.  */

  if (! been_here)

    {

      section *saved_in_section = in_section;

      static const enum darwin_section_enum tomark[] =

        {

          /* written, cold -> hot */

          objc_cat_cls_meth_section,

          objc_cat_inst_meth_section,

          objc_string_object_section,

          objc_constant_string_object_section,

          objc_selector_refs_section,

          objc_selector_fixup_section,

          objc_cls_refs_section,

          objc_class_section,

          objc_meta_class_section,

          /* shared, hot -> cold */

          objc_cls_meth_section,

          objc_inst_meth_section,

          objc_protocol_section,

          objc_class_names_section,

          objc_meth_var_types_section,

          objc_meth_var_names_section,

          objc_category_section,

          objc_class_vars_section,

          objc_instance_vars_section,

          objc_module_info_section,

          objc_symbols_section,

        };

      /* ABI=1 */

      static const enum darwin_section_enum tomarkv1[] =

        {

          objc1_protocol_ext_section,

          objc1_class_ext_section,

          objc1_prop_list_section

        } ;

      /* ABI=2 */

      static const enum darwin_section_enum tomarkv2[] =

        {

          objc2_message_refs_section,

          objc2_classdefs_section,

          objc2_metadata_section,

          objc2_classrefs_section,

          objc2_classlist_section,

          objc2_categorylist_section,

          objc2_selector_refs_section,

          objc2_nonlazy_class_section,

          objc2_nonlazy_category_section,

          objc2_protocollist_section,

          objc2_protocolrefs_section,

          objc2_super_classrefs_section,

          objc2_image_info_section,

          objc2_constant_string_object_section

        } ;

      size_t i;

      been_here = true;

      if (flag_objc_abi < 2)

        {

          for (i = 0; i < ARRAY_SIZE (tomark); i++)

            switch_to_section (darwin_sections[tomark[i]]);

          if (flag_objc_abi == 1)

            for (i = 0; i < ARRAY_SIZE (tomarkv1); i++)

              switch_to_section (darwin_sections[tomarkv1[i]]);

        }

      else

        for (i = 0; i < ARRAY_SIZE (tomarkv2); i++)

          switch_to_section (darwin_sections[tomarkv2[i]]);

      /* Make sure we don't get varasm.c out of sync with us.  */

      switch_to_section (saved_in_section);

    }

  output_section_asm_op (directive);

}

/* Private flag applied to disable section-anchors in a particular section.  */

#define SECTION_NO_ANCHOR SECTION_MACH_DEP

/* Implement TARGET_ASM_INIT_SECTIONS.  */

void

darwin_init_sections (void)

{

#define DEF_SECTION(NAME, FLAGS, DIRECTIVE, OBJC)               \

  darwin_sections[NAME] =                                       \

    get_unnamed_section (FLAGS, (OBJC                           \

                                 ? output_objc_section_asm_op   \

                                 : output_section_asm_op),      \

                         "\t" DIRECTIVE);

#include "config/darwin-sections.def"

#undef DEF_SECTION

  readonly_data_section = darwin_sections[const_section];

  exception_section = darwin_sections[darwin_exception_section];

  eh_frame_section = darwin_sections[darwin_eh_frame_section];

}

int

name_needs_quotes (const char *name)

{

  int c;

  while ((c = *name++) != '\0')

    if (! ISIDNUM (c)

          && c != '.' && c != '$' && c != '_' )

      return 1;

  return 0;

}

/* Return true if SYM_REF can be used without an indirection.  */

int

machopic_symbol_defined_p (rtx sym_ref)

{

  if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_DEFINED)

    return true;

  /* If a symbol references local and is not an extern to this

     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 the symbol references a variable and the variable is a

         common symbol, then this symbol is not defined.  */

      if (SYMBOL_REF_FLAGS (sym_ref) & MACHO_SYMBOL_FLAG_VARIABLE)

        {

          tree decl = SYMBOL_REF_DECL (sym_ref);

          if (!decl)

            return true;

          if (DECL_COMMON (decl))

            return false;

        }

      return true;

    }

  return false;

}

/* This module assumes that (const (symbol_ref "foo")) is a legal pic

   reference, which will not be changed.  */

enum machopic_addr_class

machopic_classify_symbol (rtx sym_ref)

{

  bool function_p;

  function_p = SYMBOL_REF_FUNCTION_P (sym_ref);

  if (machopic_symbol_defined_p (sym_ref))

    return (function_p

            ? MACHOPIC_DEFINED_FUNCTION : MACHOPIC_DEFINED_DATA);

  else

    return (function_p

            ? MACHOPIC_UNDEFINED_FUNCTION : MACHOPIC_UNDEFINED_DATA);

}

#ifndef TARGET_FIX_AND_CONTINUE

#define TARGET_FIX_AND_CONTINUE 0

#endif

/* 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

   rebound in a new translation unit to reference the original instance

   of that data.  Symbol names that are for code generation local to

   the translation unit are bound to the new translation unit;

   currently this means symbols that begin with L or _OBJC_;

   otherwise, we indicate that an indirect reference should be made to

   permit the runtime to rebind new instances of the translation unit

   to the original instance of the data.  */

static int

indirect_data (rtx sym_ref)

{

  int lprefix;

  const char *name;

  /* If we aren't generating fix-and-continue code, don't do anything

     special.  */

  if (TARGET_FIX_AND_CONTINUE == 0)

    return 0;

  /* Otherwise, all symbol except symbols that begin with L or _OBJC_

     are indirected.  Symbols that begin with L and _OBJC_ are always

     bound to the current translation unit as they are used for

     generated local data of the translation unit.  */

  name = XSTR (sym_ref, 0);

  lprefix = (((name[0] == '*' || name[0] == '&')

              && (name[1] == 'L' || (name[1] == '"' && name[2] == 'L')))

             || (strncmp (name, "_OBJC_", 6) == 0));

  return ! lprefix;

}

static int

machopic_data_defined_p (rtx sym_ref)

{

  if (indirect_data (sym_ref))

    return 0;

  switch (machopic_classify_symbol (sym_ref))

    {

    case MACHOPIC_DEFINED_DATA:

    case MACHOPIC_DEFINED_FUNCTION:

      return 1;

    default:

      return 0;

    }

}

void

machopic_define_symbol (rtx mem)

{

  rtx sym_ref;

  gcc_assert (GET_CODE (mem) == MEM);

  sym_ref = XEXP (mem, 0);

  SYMBOL_REF_FLAGS (sym_ref) |= MACHO_SYMBOL_FLAG_DEFINED;

}

/* Return either ORIG or:

     (const:P (unspec:P [ORIG] UNSPEC_MACHOPIC_OFFSET))

   depending on MACHO_DYNAMIC_NO_PIC_P.  */

rtx

machopic_gen_offset (rtx orig)

{

  if (MACHO_DYNAMIC_NO_PIC_P)

    return orig;

  else

    {

      /* Play games to avoid marking the function as needing pic if we

         are being called as part of the cost-estimation process.  */

      if (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl)

        crtl->uses_pic_offset_table = 1;

      orig = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig),

                             UNSPEC_MACHOPIC_OFFSET);

      return gen_rtx_CONST (Pmode, orig);

    }

}

static GTY(()) const char * function_base_func_name;

static GTY(()) int current_pic_label_num;

void

machopic_output_function_base_name (FILE *file)

{

  const char *current_name;

  /* If dynamic-no-pic is on, we should not get here.  */

  gcc_assert (!MACHO_DYNAMIC_NO_PIC_P);

  /* When we are generating _get_pc thunks within stubs, there is no current

     function.  */

  if (current_function_decl)

    {

      current_name =

        IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));

      if (function_base_func_name != current_name)

        {

          ++current_pic_label_num;

          function_base_func_name = current_name;

        }

    }

  else

    {

      ++current_pic_label_num;

      function_base_func_name = "L_machopic_stub_dummy";

    }

  fprintf (file, "L%011d$pb", current_pic_label_num);

}

/* The suffix attached to non-lazy pointer symbols.  */

#define NON_LAZY_POINTER_SUFFIX "$non_lazy_ptr"

/* The suffix attached to stub symbols.  */

#define STUB_SUFFIX "$stub"

typedef struct GTY (()) machopic_indirection

{

  /* The SYMBOL_REF for the entity referenced.  */

  rtx symbol;

  /* The name of the stub or non-lazy pointer.  */

  const char * ptr_name;

  /* True iff this entry is for a stub (as opposed to a non-lazy

     pointer).  */

  bool stub_p;

  /* True iff this stub or pointer pointer has been referenced.  */

  bool used;

} machopic_indirection;

/* A table mapping stub names and non-lazy pointer names to

   SYMBOL_REFs for the stubbed-to and pointed-to entities.  */

static GTY ((param_is (struct machopic_indirection))) htab_t

  machopic_indirections;

/* Return a hash value for a SLOT in the indirections hash table.  */

static hashval_t

machopic_indirection_hash (const void *slot)

{

  const machopic_indirection *p = (const machopic_indirection *) slot;

  return htab_hash_string (p->ptr_name);

}

/* Returns true if the KEY is the same as that associated with

   SLOT.  */

static int

machopic_indirection_eq (const void *slot, const void *key)

{

  return strcmp (((const machopic_indirection *) slot)->ptr_name,

                 (const char *) key) == 0;

}

/* 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.  */

const char *

machopic_indirection_name (rtx sym_ref, bool stub_p)

{

  char *buffer;

  const char *name = XSTR (sym_ref, 0);

  size_t namelen = strlen (name);

  machopic_indirection *p;

  void ** slot;

  bool needs_quotes;

  const char *suffix;

  const char *prefix = user_label_prefix;

  const char *quote = "";

  tree id;

  id = maybe_get_identifier (name);

  if (id)

    {

      tree id_orig = id;

      while (IDENTIFIER_TRANSPARENT_ALIAS (id))

        id = TREE_CHAIN (id);

      if (id != id_orig)

        {

          name = IDENTIFIER_POINTER (id);

          namelen = strlen (name);

        }

    }

  if (name[0] == '*')

    {

      prefix = "";

      ++name;

      --namelen;

    }

  needs_quotes = name_needs_quotes (name);

  if (needs_quotes)

    {

      quote = "\"";

    }

  if (stub_p)

    suffix = STUB_SUFFIX;

  else

    suffix = NON_LAZY_POINTER_SUFFIX;

  buffer = XALLOCAVEC (char, strlen ("&L")

                   + strlen (prefix)

                   + namelen

                   + strlen (suffix)

                   + 2 * strlen (quote)

                   + 1 /* '\0' */);

  /* Construct the name of the non-lazy pointer or stub.  */

  sprintf (buffer, "&%sL%s%s%s%s", quote, prefix, name, suffix, quote);

  if (!machopic_indirections)

    machopic_indirections = htab_create_ggc (37,

                                             machopic_indirection_hash,

                                             machopic_indirection_eq,

                                             /*htab_del=*/NULL);

  slot = htab_find_slot_with_hash (machopic_indirections, buffer,

                                   htab_hash_string (buffer), INSERT);

  if (*slot)

    {

      p = (machopic_indirection *) *slot;

    }

  else

    {

      p = ggc_alloc_machopic_indirection ();

      p->symbol = sym_ref;

      p->ptr_name = xstrdup (buffer);

      p->stub_p = stub_p;

      p->used = false;

      *slot = p;

    }

  return p->ptr_name;

}

/* Return the name of the stub for the mcount function.  */

const char*

machopic_mcount_stub_name (void)

{

  rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "*mcount");

  return machopic_indirection_name (symbol, /*stub_p=*/true);

}

/* 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

   pointer/stub refers as used as well, since the pointer/stub will

   emit a reference to it.  */

void

machopic_validate_stub_or_non_lazy_ptr (const char *name)

{

  machopic_indirection *p;

  p = ((machopic_indirection *)

       (htab_find_with_hash (machopic_indirections, name,

                             htab_hash_string (name))));

  if (p && ! p->used)

    {

      const char *real_name;

      tree id;

      p->used = true;

      /* Do what output_addr_const will do when we actually call it.  */

      if (SYMBOL_REF_DECL (p->symbol))

        mark_decl_referenced (SYMBOL_REF_DECL (p->symbol));

      real_name = targetm.strip_name_encoding (XSTR (p->symbol, 0));

      id = maybe_get_identifier (real_name);

      if (id)

        mark_referenced (id);

    }

}

/* Transform ORIG, which may be any data source, to the corresponding

   source using indirections.  */

rtx

machopic_indirect_data_reference (rtx orig, rtx reg)

{

  rtx ptr_ref = orig;

  if (! MACHOPIC_INDIRECT)

    return orig;

  if (GET_CODE (orig) == SYMBOL_REF)

    {

      int defined = machopic_data_defined_p (orig);

      if (defined && MACHO_DYNAMIC_NO_PIC_P)

        {

          if (DARWIN_PPC)

            {

          /* Create a new register for CSE opportunities.  */

          rtx hi_reg = (!can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode));

          emit_insn (gen_macho_high (hi_reg, orig));

          emit_insn (gen_macho_low (reg, hi_reg, orig));

              return reg;

            }

          else if (DARWIN_X86)

            return orig;

          else

           /* some other cpu -- writeme!  */

           gcc_unreachable ();

        }

      else if (defined)

        {

          rtx offset = NULL;

          if (DARWIN_PPC || HAVE_lo_sum)

            offset = machopic_gen_offset (orig);

          if (DARWIN_PPC)

            {

          rtx hi_sum_reg = (!can_create_pseudo_p ()

                            ? reg

                            : gen_reg_rtx (Pmode));

          gcc_assert (reg);

          emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,

                              gen_rtx_PLUS (Pmode, pic_offset_table_rtx,

                                       gen_rtx_HIGH (Pmode, offset))));

          emit_insn (gen_rtx_SET (Pmode, reg,

                                  gen_rtx_LO_SUM (Pmode, hi_sum_reg,

                                                  copy_rtx (offset))));

          orig = reg;

            }

          else if (HAVE_lo_sum)

            {

          gcc_assert (reg);

          emit_insn (gen_rtx_SET (VOIDmode, reg,

                                  gen_rtx_HIGH (Pmode, offset)));

          emit_insn (gen_rtx_SET (VOIDmode, reg,

                                  gen_rtx_LO_SUM (Pmode, reg,

                                                  copy_rtx (offset))));

          emit_use (pic_offset_table_rtx);

          orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);

            }

          return orig;

        }

      ptr_ref = (gen_rtx_SYMBOL_REF

                 (Pmode,

                  machopic_indirection_name (orig, /*stub_p=*/false)));

      SYMBOL_REF_DATA (ptr_ref) = SYMBOL_REF_DATA (orig);

      ptr_ref = gen_const_mem (Pmode, ptr_ref);

      machopic_define_symbol (ptr_ref);

      if (DARWIN_X86

          && reg

          && MACHO_DYNAMIC_NO_PIC_P)

        {

            emit_insn (gen_rtx_SET (Pmode, reg, ptr_ref));

            ptr_ref = reg;

        }

      return ptr_ref;

    }

  else if (GET_CODE (orig) == CONST)

    {

      /* If "(const (plus ...", walk the PLUS and return that result.

         PLUS processing (below) will restore the "(const ..." if

         appropriate.  */

      if (GET_CODE (XEXP (orig, 0)) == PLUS)

        return machopic_indirect_data_reference (XEXP (orig, 0), reg);

      else

        return orig;

    }

  else if (GET_CODE (orig) == MEM)

    {

      XEXP (ptr_ref, 0) =

                machopic_indirect_data_reference (XEXP (orig, 0), reg);

      return ptr_ref;

    }

  else if (GET_CODE (orig) == PLUS)

    {

      rtx base, result;

      /* When the target is i386, this code prevents crashes due to the

        compiler's ignorance on how to move the PIC base register to

        other registers.  (The reload phase sometimes introduces such

        insns.)  */

      if (GET_CODE (XEXP (orig, 0)) == REG

           && REGNO (XEXP (orig, 0)) == PIC_OFFSET_TABLE_REGNUM

           /* Prevent the same register from being erroneously used

              as both the base and index registers.  */

           && (DARWIN_X86 && (GET_CODE (XEXP (orig, 1)) == CONST))

           && reg)

        {

          emit_move_insn (reg, XEXP (orig, 0));

          XEXP (ptr_ref, 0) = reg;

          return ptr_ref;

        }

      /* Legitimize both operands of the PLUS.  */

      base = machopic_indirect_data_reference (XEXP (orig, 0), reg);

      orig = machopic_indirect_data_reference (XEXP (orig, 1),

                                               (base == reg ? 0 : reg));

      if (MACHOPIC_INDIRECT && (GET_CODE (orig) == CONST_INT))

        result = plus_constant (base, INTVAL (orig));

      else

        result = gen_rtx_PLUS (Pmode, base, orig);

      if (MACHOPIC_JUST_INDIRECT && GET_CODE (base) == MEM)

        {

          if (reg)

            {

              emit_move_insn (reg, result);

              result = reg;

            }

          else

            {

              result = force_reg (GET_MODE (result), result);

            }

        }

      return result;

    }

  return ptr_ref;

}

/* Transform TARGET (a MEM), which is a function call target, to the

   corresponding symbol_stub if necessary.  Return a new MEM.  */

rtx

machopic_indirect_call_target (rtx target)

{

  if (! darwin_emit_branch_islands)

    return target;

  if (GET_CODE (target) != MEM)

    return target;

  if (MACHOPIC_INDIRECT