Subversion Repositories or1k

/* .eh_frame section optimization.

   Copyright 2001, 2002 Free Software Foundation, Inc.

   Written by Jakub Jelinek <jakub@redhat.com>.

This file is part of BFD, the Binary File Descriptor library.

This program 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 2 of the License, or

(at your option) any later version.

This program 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 this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"

#include "sysdep.h"

#include "libbfd.h"

#include "elf-bfd.h"

#include "elf/dwarf2.h"

#define EH_FRAME_HDR_SIZE 8

struct cie_header

{

  unsigned int length;

  unsigned int id;

};

struct cie

{

  struct cie_header hdr;

  unsigned char version;

  unsigned char augmentation[20];

  unsigned int code_align;

  int data_align;

  unsigned int ra_column;

  unsigned int augmentation_size;

  struct elf_link_hash_entry *personality;

  unsigned char per_encoding;

  unsigned char lsda_encoding;

  unsigned char fde_encoding;

  unsigned char initial_insn_length;

  unsigned char make_relative;

  unsigned char make_lsda_relative;

  unsigned char initial_instructions[50];

};

struct eh_cie_fde

{

  unsigned int offset;

  unsigned int size;

  asection *sec;

  unsigned int new_offset;

  unsigned char fde_encoding;

  unsigned char lsda_encoding;

  unsigned char lsda_offset;

  unsigned char cie : 1;

  unsigned char removed : 1;

  unsigned char make_relative : 1;

  unsigned char make_lsda_relative : 1;

  unsigned char per_encoding_relative : 1;

};

struct eh_frame_sec_info

{

  unsigned int count;

  unsigned int alloced;

  struct eh_cie_fde entry[1];

};

struct eh_frame_array_ent

{

  bfd_vma initial_loc;

  bfd_vma fde;

};

struct eh_frame_hdr_info

{

  struct cie last_cie;

  asection *last_cie_sec;

  unsigned int last_cie_offset;

  unsigned int fde_count, array_count;

  struct eh_frame_array_ent *array;

  /* TRUE if .eh_frame_hdr should contain the sorted search table.

     We build it if we successfully read all .eh_frame input sections

     and recognize them.  */

  boolean table;

  boolean strip;

};

static bfd_vma read_unsigned_leb128

  PARAMS ((bfd *, char *, unsigned int *));

static bfd_signed_vma read_signed_leb128

  PARAMS ((bfd *, char *, unsigned int *));

static int get_DW_EH_PE_width

  PARAMS ((int, int));

static bfd_vma read_value

  PARAMS ((bfd *, bfd_byte *, int));

static void write_value

  PARAMS ((bfd *, bfd_byte *, bfd_vma, int));

static int cie_compare

  PARAMS ((struct cie *, struct cie *));

static int vma_compare

  PARAMS ((const PTR a, const PTR b));

/* Helper function for reading uleb128 encoded data.  */

static bfd_vma

read_unsigned_leb128 (abfd, buf, bytes_read_ptr)

     bfd *abfd ATTRIBUTE_UNUSED;

     char *buf;

     unsigned int *bytes_read_ptr;

{

  bfd_vma  result;

  unsigned int  num_read;

  int           shift;

  unsigned char byte;

  result   = 0;

  shift    = 0;

  num_read = 0;

  do

    {

      byte = bfd_get_8 (abfd, (bfd_byte *) buf);

      buf ++;

      num_read ++;

      result |= (((bfd_vma) byte & 0x7f) << shift);

      shift += 7;

    }

  while (byte & 0x80);

  * bytes_read_ptr = num_read;

  return result;

}

/* Helper function for reading sleb128 encoded data.  */

static bfd_signed_vma

read_signed_leb128 (abfd, buf, bytes_read_ptr)

     bfd *abfd ATTRIBUTE_UNUSED;

     char *buf;

     unsigned int * bytes_read_ptr;

{

  bfd_vma       result;

  int           shift;

  int           num_read;

  unsigned char byte;

  result = 0;

  shift = 0;

  num_read = 0;

  do

    {

      byte = bfd_get_8 (abfd, (bfd_byte *) buf);

      buf ++;

      num_read ++;

      result |= (((bfd_vma) byte & 0x7f) << shift);

      shift += 7;

    }

  while (byte & 0x80);

  if (byte & 0x40)

    result |= (((bfd_vma) -1) << (shift - 7)) << 7;

  * bytes_read_ptr = num_read;

  return result;

}

#define read_uleb128(VAR, BUF)                                  \

do                                                              \

  {                                                             \

    (VAR) = read_unsigned_leb128 (abfd, buf, &leb128_tmp);      \

    (BUF) += leb128_tmp;                                        \

  }                                                             \

while (0)

#define read_sleb128(VAR, BUF)                                  \

do                                                              \

  {                                                             \

    (VAR) = read_signed_leb128 (abfd, buf, &leb128_tmp);        \

    (BUF) += leb128_tmp;                                        \

  }                                                             \

while (0)

/* Return 0 if either encoding is variable width, or not yet known to bfd.  */

static

int get_DW_EH_PE_width (encoding, ptr_size)

     int encoding, ptr_size;

{

  /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame

     was added to bfd.  */

  if ((encoding & 0x60) == 0x60)

    return 0;

  switch (encoding & 7)

    {

    case DW_EH_PE_udata2: return 2;

    case DW_EH_PE_udata4: return 4;

    case DW_EH_PE_udata8: return 8;

    case DW_EH_PE_absptr: return ptr_size;

    default:

      break;

    }

  return 0;

}

/* Read a width sized value from memory.  */

static bfd_vma

read_value (abfd, buf, width)

     bfd *abfd;

     bfd_byte *buf;

     int width;

{

  bfd_vma value;

  switch (width)

    {

    case 2: value = bfd_get_16 (abfd, buf); break;

    case 4: value = bfd_get_32 (abfd, buf); break;

    case 8: value = bfd_get_64 (abfd, buf); break;

    default: BFD_FAIL (); return 0;

    }

  return value;

}

/* Store a width sized value to memory.  */

static void

write_value (abfd, buf, value, width)

     bfd *abfd;

     bfd_byte *buf;

     bfd_vma value;

     int width;

{

  switch (width)

    {

    case 2: bfd_put_16 (abfd, value, buf); break;

    case 4: bfd_put_32 (abfd, value, buf); break;

    case 8: bfd_put_64 (abfd, value, buf); break;

    default: BFD_FAIL ();

    }

}

/* Return zero if C1 and C2 CIEs can be merged.  */

static

int cie_compare (c1, c2)

     struct cie *c1, *c2;

{

  if (c1->hdr.length == c2->hdr.length

      && c1->version == c2->version

      && strcmp (c1->augmentation, c2->augmentation) == 0

      && strcmp (c1->augmentation, "eh") != 0

      && c1->code_align == c2->code_align

      && c1->data_align == c2->data_align

      && c1->ra_column == c2->ra_column

      && c1->augmentation_size == c2->augmentation_size

      && c1->personality == c2->personality

      && c1->per_encoding == c2->per_encoding

      && c1->lsda_encoding == c2->lsda_encoding

      && c1->fde_encoding == c2->fde_encoding

      && (c1->initial_insn_length

          == c2->initial_insn_length)

      && memcmp (c1->initial_instructions,

                 c2->initial_instructions,

                 c1->initial_insn_length) == 0)

    return 0;

  return 1;

}

/* This function is called for each input file before the .eh_frame

   section is relocated.  It discards duplicate CIEs and FDEs for discarded

   functions.  The function returns true iff any entries have been

   deleted.  */

boolean

_bfd_elf_discard_section_eh_frame (abfd, info, sec, ehdrsec,

                                   reloc_symbol_deleted_p, cookie)

     bfd *abfd;

     struct bfd_link_info *info;

     asection *sec, *ehdrsec;

     boolean (*reloc_symbol_deleted_p) PARAMS ((bfd_vma, PTR));

     struct elf_reloc_cookie *cookie;

{

  bfd_byte *ehbuf = NULL, *buf;

  bfd_byte *last_cie, *last_fde;

  struct cie_header hdr;

  struct cie cie;

  struct eh_frame_hdr_info *hdr_info;

  struct eh_frame_sec_info *sec_info = NULL;

  unsigned int leb128_tmp;

  unsigned int cie_usage_count, last_cie_ndx, i, offset;

  unsigned int make_relative, make_lsda_relative;

  Elf_Internal_Rela *rel;

  bfd_size_type new_size;

  unsigned int ptr_size;

  if (sec->_raw_size == 0)

    {

      /* This file does not contain .eh_frame information.  */

      return false;

    }

  if ((sec->output_section != NULL

       && bfd_is_abs_section (sec->output_section)))

    {

      /* At least one of the sections is being discarded from the

         link, so we should just ignore them.  */

      return false;

    }

  BFD_ASSERT (elf_section_data (ehdrsec)->sec_info_type

              == ELF_INFO_TYPE_EH_FRAME_HDR);

  hdr_info = (struct eh_frame_hdr_info *)

             elf_section_data (ehdrsec)->sec_info;

  /* Read the frame unwind information from abfd.  */

  ehbuf = (bfd_byte *) bfd_malloc (sec->_raw_size);

  if (ehbuf == NULL)

    goto free_no_table;

  if (! bfd_get_section_contents (abfd, sec, ehbuf, (bfd_vma) 0,

                                  sec->_raw_size))

    goto free_no_table;

  if (sec->_raw_size >= 4

      && bfd_get_32 (abfd, ehbuf) == 0

      && cookie->rel == cookie->relend)

    {

      /* Empty .eh_frame section.  */

      free (ehbuf);

      return false;

    }

  /* If .eh_frame section size doesn't fit into int, we cannot handle

     it (it would need to use 64-bit .eh_frame format anyway).  */

  if (sec->_raw_size != (unsigned int) sec->_raw_size)

    goto free_no_table;

  ptr_size = (elf_elfheader (abfd)->e_ident[EI_CLASS]

              == ELFCLASS64) ? 8 : 4;

  buf = ehbuf;

  last_cie = NULL;

  last_cie_ndx = 0;

  memset (&cie, 0, sizeof (cie));

  cie_usage_count = 0;

  new_size = sec->_raw_size;

  make_relative = hdr_info->last_cie.make_relative;

  make_lsda_relative = hdr_info->last_cie.make_lsda_relative;

  sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)

                          + 99 * sizeof (struct eh_cie_fde));

  if (sec_info == NULL)

    goto free_no_table;

  sec_info->alloced = 100;

#define ENSURE_NO_RELOCS(buf)                           \

  if (cookie->rel < cookie->relend                      \

      && (cookie->rel->r_offset                         \

          < (bfd_size_type) ((buf) - ehbuf)))           \

    goto free_no_table

#define SKIP_RELOCS(buf)                                \

  while (cookie->rel < cookie->relend                   \

         && (cookie->rel->r_offset                      \

             < (bfd_size_type) ((buf) - ehbuf)))        \

    cookie->rel++

#define GET_RELOC(buf)                                  \

  ((cookie->rel < cookie->relend                        \

    && (cookie->rel->r_offset                           \

        == (bfd_size_type) ((buf) - ehbuf)))            \

   ? cookie->rel : NULL)

  for (;;)

    {

      unsigned char *aug;

      if (sec_info->count == sec_info->alloced)

        {

          sec_info = bfd_realloc (sec_info,

                                  sizeof (struct eh_frame_sec_info)

                                  + (sec_info->alloced + 99)

                                     * sizeof (struct eh_cie_fde));

          if (sec_info == NULL)

            goto free_no_table;

          memset (&sec_info->entry[sec_info->alloced], 0,

                  100 * sizeof (struct eh_cie_fde));

          sec_info->alloced += 100;

        }

      last_fde = buf;

      /* If we are at the end of the section, we still need to decide

         on whether to output or discard last encountered CIE (if any).  */

      if ((bfd_size_type) (buf - ehbuf) == sec->_raw_size)

        hdr.id = (unsigned int) -1;

      else

        {

          if ((bfd_size_type) (buf + 4 - ehbuf) > sec->_raw_size)

            /* No space for CIE/FDE header length.  */

            goto free_no_table;

          hdr.length = bfd_get_32 (abfd, buf);

          if (hdr.length == 0xffffffff)

            /* 64-bit .eh_frame is not supported.  */

            goto free_no_table;

          buf += 4;

          if ((buf - ehbuf) + hdr.length > sec->_raw_size)

            /* CIE/FDE not contained fully in this .eh_frame input section.  */

            goto free_no_table;

          sec_info->entry[sec_info->count].offset = last_fde - ehbuf;

          sec_info->entry[sec_info->count].size = 4 + hdr.length;

          if (hdr.length == 0)

            {

              /* CIE with length 0 must be only the last in the section.  */

              if ((bfd_size_type) (buf - ehbuf) < sec->_raw_size)

                goto free_no_table;

              ENSURE_NO_RELOCS (buf);

              sec_info->count++;

              /* Now just finish last encountered CIE processing and break

                 the loop.  */

              hdr.id = (unsigned int) -1;

            }

          else

            {

              hdr.id = bfd_get_32 (abfd, buf);

              buf += 4;

              if (hdr.id == (unsigned int) -1)

                goto free_no_table;

            }

        }

      if (hdr.id == 0 || hdr.id == (unsigned int) -1)

        {

          unsigned int initial_insn_length;

          /* CIE  */

          if (last_cie != NULL)

            {

              /* Now check if this CIE is identical to last CIE, in which case

                 we can remove it, provided we adjust all FDEs.

                 Also, it can be removed if we have removed all FDEs using

                 that. */

              if (cie_compare (&cie, &hdr_info->last_cie) == 0

                  || cie_usage_count == 0)

                {

                  new_size -= cie.hdr.length + 4;

                  sec_info->entry[last_cie_ndx].removed = 1;

                  sec_info->entry[last_cie_ndx].sec = hdr_info->last_cie_sec;

                  sec_info->entry[last_cie_ndx].new_offset

                    = hdr_info->last_cie_offset;

                }

              else

                {

                  hdr_info->last_cie = cie;

                  hdr_info->last_cie_sec = sec;

                  hdr_info->last_cie_offset = last_cie - ehbuf;

                  sec_info->entry[last_cie_ndx].make_relative

                    = cie.make_relative;

                  sec_info->entry[last_cie_ndx].make_lsda_relative

                    = cie.make_lsda_relative;

                  sec_info->entry[last_cie_ndx].per_encoding_relative

                    = (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;

                }

            }

          if (hdr.id == (unsigned int) -1)

            break;

          last_cie_ndx = sec_info->count;

          sec_info->entry[sec_info->count].cie = 1;

          cie_usage_count = 0;

          memset (&cie, 0, sizeof (cie));

          cie.hdr = hdr;

          cie.version = *buf++;

          /* Cannot handle unknown versions.  */

          if (cie.version != 1)

            goto free_no_table;

          if (strlen (buf) > sizeof (cie.augmentation) - 1)

            goto free_no_table;

          strcpy (cie.augmentation, buf);

          buf = strchr (buf, '\0') + 1;

          ENSURE_NO_RELOCS (buf);

          if (buf[0] == 'e' && buf[1] == 'h')

            {

              /* GCC < 3.0 .eh_frame CIE */

              /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__

                 is private to each CIE, so we don't need it for anything.

                 Just skip it.  */

              buf += ptr_size;

              SKIP_RELOCS (buf);

            }

          read_uleb128 (cie.code_align, buf);

          read_sleb128 (cie.data_align, buf);

          /* Note - in DWARF2 the return address column is an unsigned byte.

             In DWARF3 it is a ULEB128.  We are following DWARF3.  For most

             ports this will not matter as the value will be less than 128.

             For the others (eg FRV, SH, MMIX, IA64) they need a fixed GCC

             which conforms to the DWARF3 standard.  */

          read_uleb128 (cie.ra_column, buf);

          ENSURE_NO_RELOCS (buf);

          cie.lsda_encoding = DW_EH_PE_omit;

          cie.fde_encoding = DW_EH_PE_omit;

          cie.per_encoding = DW_EH_PE_omit;

          aug = cie.augmentation;

          if (aug[0] != 'e' || aug[1] != 'h')

            {

              if (*aug == 'z')

                {

                  aug++;

                  read_uleb128 (cie.augmentation_size, buf);

                  ENSURE_NO_RELOCS (buf);

                }

              while (*aug != '\0')

                switch (*aug++)

                  {

                  case 'L':

                    cie.lsda_encoding = *buf++;

                    ENSURE_NO_RELOCS (buf);

                    if (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size) == 0)

                      goto free_no_table;

                    break;

                  case 'R':

                    cie.fde_encoding = *buf++;

                    ENSURE_NO_RELOCS (buf);

                    if (get_DW_EH_PE_width (cie.fde_encoding, ptr_size) == 0)

                      goto free_no_table;

                    break;

                  case 'P':

                    {

                      int per_width;

                      cie.per_encoding = *buf++;

                      per_width = get_DW_EH_PE_width (cie.per_encoding,

                                                      ptr_size);

                      if (per_width == 0)

                        goto free_no_table;

                      if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)

                        buf = (ehbuf

                               + ((buf - ehbuf + per_width - 1)

                                  & ~((bfd_size_type) per_width - 1)));

                      ENSURE_NO_RELOCS (buf);

                      rel = GET_RELOC (buf);

                      /* Ensure we have a reloc here, against

                         a global symbol.  */

                      if (rel != NULL)

                        {

                          unsigned long r_symndx;

#ifdef BFD64

                          if (ptr_size == 8)

                            r_symndx = ELF64_R_SYM (cookie->rel->r_info);

                          else

#endif

                            r_symndx = ELF32_R_SYM (cookie->rel->r_info);

                          if (r_symndx >= cookie->locsymcount)

                            {

                              struct elf_link_hash_entry *h;

                              r_symndx -= cookie->extsymoff;

                              h = cookie->sym_hashes[r_symndx];

                              while (h->root.type == bfd_link_hash_indirect

                                     || h->root.type == bfd_link_hash_warning)

                                h = (struct elf_link_hash_entry *)

                                    h->root.u.i.link;

                              cie.personality = h;

                            }

                          cookie->rel++;

                        }

                      buf += per_width;

                    }

                    break;

                  default:

                    /* Unrecognized augmentation. Better bail out.  */

                    goto free_no_table;

                  }

            }

          /* For shared libraries, try to get rid of as many RELATIVE relocs

             as possible.  */

          if (info->shared

              && (cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)

            cie.make_relative = 1;

          if (info->shared

              && (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)

            cie.make_lsda_relative = 1;

          /* If FDE encoding was not specified, it defaults to

             DW_EH_absptr.  */

          if (cie.fde_encoding == DW_EH_PE_omit)

            cie.fde_encoding = DW_EH_PE_absptr;

          initial_insn_length = cie.hdr.length - (buf - last_fde - 4);

          if (initial_insn_length <= 50)

            {

              cie.initial_insn_length = initial_insn_length;

              memcpy (cie.initial_instructions, buf, initial_insn_length);

            }

          buf += initial_insn_length;

          ENSURE_NO_RELOCS (buf);

          last_cie = last_fde;

        }

      else

        {

          /* Ensure this FDE uses the last CIE encountered.  */

          if (last_cie == NULL

              || hdr.id != (unsigned int) (buf - 4 - last_cie))

            goto free_no_table;

          ENSURE_NO_RELOCS (buf);

          rel = GET_RELOC (buf);

          if (rel == NULL)

            /* This should not happen.  */

            goto free_no_table;

          if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))

            {

              cookie->rel = rel;

              /* This is a FDE against discarded section, it should

                 be deleted.  */

              new_size -= hdr.length + 4;

              sec_info->entry[sec_info->count].removed = 1;

            }

          else

            {

              if (info->shared

                  && (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr

                       && cie.make_relative == 0)

                      || (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))

                {

                  /* If shared library uses absolute pointers

                     which we cannot turn into PC relative,

                     don't create the binary search table,

                     since it is affected by runtime relocations.  */

                  hdr_info->table = false;

                }

              cie_usage_count++;

              hdr_info->fde_count++;

            }

          cookie->rel = rel;

          if (cie.lsda_encoding != DW_EH_PE_omit)

            {

              unsigned int dummy;

              aug = buf;

              buf += 2 * get_DW_EH_PE_width (cie.fde_encoding, ptr_size);