Subversion Repositories openrisc_me

#include "aout/stab_gnu.h"

}

static INLINE bfd_boolean

mach_o_wide_p (bfd_mach_o_header *header)

{

  switch (header->version)

    {

    case 1:

      return FALSE;

    case 2:

      return TRUE;

    default:

      BFD_FAIL ();

      return FALSE;

    }

}

static INLINE bfd_boolean

bfd_mach_o_wide_p (bfd *abfd)

{

  return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);

}

/* Tables to translate well known Mach-O segment/section names to bfd

   names.  Use of canonical names (such as .text or .debug_frame) is required

   by gdb.  */

struct mach_o_section_name_xlat

{

  const char *bfd_name;

  const char *mach_o_name;

};

static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] =

  {

    { ".debug_frame", "__debug_frame" },

    { ".debug_info", "__debug_info" },

    { ".debug_abbrev", "__debug_abbrev" },

    { ".debug_aranges", "__debug_aranges" },

    { ".debug_macinfo", "__debug_macinfo" },

    { ".debug_line", "__debug_line" },

    { ".debug_loc", "__debug_loc" },

    { ".debug_pubnames", "__debug_pubnames" },

    { ".debug_pubtypes", "__debug_pubtypes" },

    { ".debug_str", "__debug_str" },

    { ".debug_ranges", "__debug_ranges" },

    { NULL, NULL}

  };

static const struct mach_o_section_name_xlat text_section_names_xlat[] =

  {

    { ".text", "__text" },

    { ".const", "__const" },

    { ".cstring", "__cstring" },

    { ".eh_frame", "__eh_frame" },

    { NULL, NULL}

  };

static const struct mach_o_section_name_xlat data_section_names_xlat[] =

  {

    { ".data", "__data" },

    { ".bss", "__bss" },

    { NULL, NULL}

  };

struct mach_o_segment_name_xlat

{

  const char *segname;

  const struct mach_o_section_name_xlat *sections;

};

static const struct mach_o_segment_name_xlat segsec_names_xlat[] =

  {

    { "__DWARF", dwarf_section_names_xlat },

    { "__TEXT", text_section_names_xlat },

    { "__DATA", data_section_names_xlat },

    { NULL, NULL }

  };

/* Mach-O to bfd names.  */

static char *

bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section)

{

  const struct mach_o_segment_name_xlat *seg;

  char *res;

  unsigned int len;

  const char *pfx = "";

  for (seg = segsec_names_xlat; seg->segname; seg++)

    {

      if (strcmp (seg->segname, section->segname) == 0)

        {

          const struct mach_o_section_name_xlat *sec;

          for (sec = seg->sections; sec->mach_o_name; sec++)

            {

              if (strcmp (sec->mach_o_name, section->sectname) == 0)

                {

                  len = strlen (sec->bfd_name);

                  res = bfd_alloc (abfd, len + 1);

                  if (res == NULL)

                    return NULL;

                  strcpy (res, sec->bfd_name);

                  return res;

                }

            }

        }

    }

  len = strlen (section->segname) + 1

    + strlen (section->sectname) + 1;

  /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start

     with an underscore.  */

  if (section->segname[0] != '_')

    {

      static const char seg_pfx[] = "LC_SEGMENT.";

      pfx = seg_pfx;

      len += sizeof (seg_pfx) - 1;

    }

  res = bfd_alloc (abfd, len);

  if (res == NULL)

    return NULL;

  snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname);

  return res;

}

/* Convert a bfd section name to a Mach-O segment + section name.  */

static void

bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,

                                           asection *sect,

                                           bfd_mach_o_section *section)

{

  const struct mach_o_segment_name_xlat *seg;

  const char *name = bfd_get_section_name (abfd, sect);

  const char *dot;

  unsigned int len;

  unsigned int seglen;

  unsigned int seclen;

  /* List of well known names.  They all start with a dot.  */

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

    for (seg = segsec_names_xlat; seg->segname; seg++)

      {

        const struct mach_o_section_name_xlat *sec;

        for (sec = seg->sections; sec->mach_o_name; sec++)

          {

            if (strcmp (sec->bfd_name, name) == 0)

              {

                strcpy (section->segname, seg->segname);

                strcpy (section->sectname, sec->mach_o_name);

                return;

              }

          }

      }

  /* Strip LC_SEGMENT. prefix.  */

  if (strncmp (name, "LC_SEGMENT.", 11) == 0)

    name += 11;

  /* Find a dot.  */

  dot = strchr (name, '.');

  len = strlen (name);

  /* Try to split name into segment and section names.  */

  if (dot && dot != name)

    {

      seglen = dot - name;

      seclen = len - (dot + 1 - name);

      if (seglen < 16 && seclen < 16)

        {

          memcpy (section->segname, name, seglen);

          section->segname[seglen] = 0;

          memcpy (section->sectname, dot + 1, seclen);

          section->sectname[seclen] = 0;

          return;

        }

    }

  if (len > 16)

    len = 16;

  memcpy (section->segname, name, len);

  section->segname[len] = 0;

  memcpy (section->sectname, name, len);

  section->sectname[len] = 0;

  if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour

      || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)

    return TRUE;

/* Count the total number of symbols.  */

  const char *name;

  bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;

        name = bfd_get_stab_name (asym->n_type);

      else

        switch (asym->n_type & BFD_MACH_O_N_TYPE)

          {

          case BFD_MACH_O_N_UNDF:

            name = "UND";

            break;

          case BFD_MACH_O_N_ABS:

            name = "ABS";

            break;

          case BFD_MACH_O_N_INDR:

            name = "INDR";

            break;

          case BFD_MACH_O_N_PBUD:

            name = "PBUD";

            break;

          case BFD_MACH_O_N_SECT:

            name = "SECT";

            break;

          default:

            name = "???";

            break;

          }

      if (name == NULL)

        name = "";

      fprintf (file, " %02x %-6s %02x %04x",

               asym->n_type, name, asym->n_sect, asym->n_desc);

      if ((asym->n_type & BFD_MACH_O_N_STAB) == 0

          && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)

        fprintf (file, " %-5s", symbol->section->name);

      fprintf (file, " %s", symbol->name);

      *type = bfd_arch_i386;

      *subtype = bfd_mach_i386_i386;

      break;

    case BFD_MACH_O_CPU_TYPE_X86_64:

      *type = bfd_arch_i386;

      *subtype = bfd_mach_x86_64;

      break;

      *type = bfd_arch_sparc;

      *subtype = bfd_mach_sparc;

      break;

      break;

  unsigned int size;

  size = mach_o_wide_p (header) ?

    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;

      || bfd_bwrite ((PTR) buf, size, abfd) != size)

    return FALSE;

  return TRUE;

      offset += cmd->flavours[i].size + 8;

    }

  return 0;

}

long

bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,

                                  asection *asect)

{

  return (asect->reloc_count + 1) * sizeof (arelent *);

}

static int

bfd_mach_o_canonicalize_one_reloc (bfd *abfd, char *buf,

                                   arelent *res, asymbol **syms)

{

  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);

  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);

  bfd_mach_o_reloc_info reloc;

  bfd_vma addr;

  bfd_vma symnum;

  asymbol **sym;

  addr = bfd_get_32 (abfd, buf + 0);

  symnum = bfd_get_32 (abfd, buf + 4);

  if (addr & BFD_MACH_O_SR_SCATTERED)

    {

      unsigned int j;

      /* Scattered relocation.

         Extract section and offset from r_value.  */

      res->sym_ptr_ptr = NULL;

      res->addend = 0;

      for (j = 0; j < mdata->nsects; j++)

        {

          bfd_mach_o_section *sect = mdata->sections[j];

          if (symnum >= sect->addr && symnum < sect->addr + sect->size)

            {

              res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;

              res->addend = symnum - sect->addr;

              break;

            }

        }

      res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);

      reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);

      reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);

      reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;

      reloc.r_scattered = 1;

    }

  else

    {

      unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);

      res->addend = 0;

      res->address = addr;

      if (symnum & BFD_MACH_O_R_EXTERN)

        sym = syms + num;

      else

        {

          BFD_ASSERT (num != 0);

          BFD_ASSERT (num <= mdata->nsects);

          sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;

        }

      res->sym_ptr_ptr = sym;

      reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);

      reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);

      reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;

      reloc.r_scattered = 0;

    }

  if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))

    return -1;

  return 0;

}