Subversion Repositories or1k

/* Intel 80386/80486-specific support for 32-bit ELF

   Copyright 1993, 94-98, 1999 Free Software Foundation, Inc.

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 "bfdlink.h"

#include "libbfd.h"

#include "elf-bfd.h"

static reloc_howto_type *elf_i386_reloc_type_lookup

  PARAMS ((bfd *, bfd_reloc_code_real_type));

static void elf_i386_info_to_howto

  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));

static void elf_i386_info_to_howto_rel

  PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));

static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));

static struct bfd_hash_entry *elf_i386_link_hash_newfunc

  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));

static struct bfd_link_hash_table *elf_i386_link_hash_table_create

  PARAMS ((bfd *));

static boolean elf_i386_check_relocs

  PARAMS ((bfd *, struct bfd_link_info *, asection *,

           const Elf_Internal_Rela *));

static boolean elf_i386_adjust_dynamic_symbol

  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));

static boolean elf_i386_size_dynamic_sections

  PARAMS ((bfd *, struct bfd_link_info *));

static boolean elf_i386_relocate_section

  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,

           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));

static boolean elf_i386_finish_dynamic_symbol

  PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,

           Elf_Internal_Sym *));

static boolean elf_i386_finish_dynamic_sections

  PARAMS ((bfd *, struct bfd_link_info *));

#define USE_REL 1               /* 386 uses REL relocations instead of RELA */

#include "elf/i386.h"

static reloc_howto_type elf_howto_table[]=

{

  HOWTO(R_386_NONE,      0,0, 0,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_NONE",         true,0x00000000,0x00000000,false),

  HOWTO(R_386_32,        0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_32",         true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_PC32,      0,2,32,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC32",       true,0xffffffff,0xffffffff,true),

  HOWTO(R_386_GOT32,     0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOT32",    true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_PLT32,     0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PLT32",    true,0xffffffff,0xffffffff,true),

  HOWTO(R_386_COPY,      0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_COPY",       true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_GLOB_DAT,  0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GLOB_DAT", true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_JUMP_SLOT, 0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_JUMP_SLOT",true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_RELATIVE,  0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_RELATIVE", true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_GOTOFF,    0,2,32,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTOFF",   true,0xffffffff,0xffffffff,false),

  HOWTO(R_386_GOTPC,     0,2,32,true,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_GOTPC",    true,0xffffffff,0xffffffff,true),

  EMPTY_HOWTO (11),

  EMPTY_HOWTO (12),

  EMPTY_HOWTO (13),

  EMPTY_HOWTO (14),

  EMPTY_HOWTO (15),

  EMPTY_HOWTO (16),

  EMPTY_HOWTO (17),

  EMPTY_HOWTO (18),

  EMPTY_HOWTO (19),

  /* The remaining relocs are a GNU extension.  */

  HOWTO(R_386_16,        0,1,16,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_16",         true,0xffff,0xffff,false),

  HOWTO(R_386_PC16,      0,1,16,true, 0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_PC16",       true,0xffff,0xffff,true),

  HOWTO(R_386_8,         0,0,8,false,0,complain_overflow_bitfield, bfd_elf_generic_reloc,"R_386_8",            true,0xff,0xff,false),

  HOWTO(R_386_PC8,       0,0,8,true, 0,complain_overflow_signed, bfd_elf_generic_reloc,"R_386_PC8",            true,0xff,0xff,true),

};

/* GNU extension to record C++ vtable hierarchy.  */

static reloc_howto_type elf32_i386_vtinherit_howto =

  HOWTO (R_386_GNU_VTINHERIT,   /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         0,                      /* bitsize */

         false,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         NULL,                  /* special_function */

         "R_386_GNU_VTINHERIT", /* name */

         false,                 /* partial_inplace */

         0,                      /* src_mask */

         0,                      /* dst_mask */

         false);

/* GNU extension to record C++ vtable member usage.  */

static reloc_howto_type elf32_i386_vtentry_howto =

  HOWTO (R_386_GNU_VTENTRY,     /* type */

         0,                      /* rightshift */

         2,                     /* size (0 = byte, 1 = short, 2 = long) */

         0,                      /* bitsize */

         false,                 /* pc_relative */

         0,                      /* bitpos */

         complain_overflow_dont, /* complain_on_overflow */

         _bfd_elf_rel_vtable_reloc_fn, /* special_function */

         "R_386_GNU_VTENTRY",   /* name */

         false,                 /* partial_inplace */

         0,                      /* src_mask */

         0,                      /* dst_mask */

         false);

#ifdef DEBUG_GEN_RELOC

#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)

#else

#define TRACE(str)

#endif

static reloc_howto_type *

elf_i386_reloc_type_lookup (abfd, code)

     bfd *abfd ATTRIBUTE_UNUSED;

     bfd_reloc_code_real_type code;

{

  switch (code)

    {

    case BFD_RELOC_NONE:

      TRACE ("BFD_RELOC_NONE");

      return &elf_howto_table[ (int)R_386_NONE ];

    case BFD_RELOC_32:

      TRACE ("BFD_RELOC_32");

      return &elf_howto_table[ (int)R_386_32 ];

    case BFD_RELOC_CTOR:

      TRACE ("BFD_RELOC_CTOR");

      return &elf_howto_table[ (int)R_386_32 ];

    case BFD_RELOC_32_PCREL:

      TRACE ("BFD_RELOC_PC32");

      return &elf_howto_table[ (int)R_386_PC32 ];

    case BFD_RELOC_386_GOT32:

      TRACE ("BFD_RELOC_386_GOT32");

      return &elf_howto_table[ (int)R_386_GOT32 ];

    case BFD_RELOC_386_PLT32:

      TRACE ("BFD_RELOC_386_PLT32");

      return &elf_howto_table[ (int)R_386_PLT32 ];

    case BFD_RELOC_386_COPY:

      TRACE ("BFD_RELOC_386_COPY");

      return &elf_howto_table[ (int)R_386_COPY ];

    case BFD_RELOC_386_GLOB_DAT:

      TRACE ("BFD_RELOC_386_GLOB_DAT");

      return &elf_howto_table[ (int)R_386_GLOB_DAT ];

    case BFD_RELOC_386_JUMP_SLOT:

      TRACE ("BFD_RELOC_386_JUMP_SLOT");

      return &elf_howto_table[ (int)R_386_JUMP_SLOT ];

    case BFD_RELOC_386_RELATIVE:

      TRACE ("BFD_RELOC_386_RELATIVE");

      return &elf_howto_table[ (int)R_386_RELATIVE ];

    case BFD_RELOC_386_GOTOFF:

      TRACE ("BFD_RELOC_386_GOTOFF");

      return &elf_howto_table[ (int)R_386_GOTOFF ];

    case BFD_RELOC_386_GOTPC:

      TRACE ("BFD_RELOC_386_GOTPC");

      return &elf_howto_table[ (int)R_386_GOTPC ];

      /* The remaining relocs are a GNU extension.  */

    case BFD_RELOC_16:

      TRACE ("BFD_RELOC_16");

      return &elf_howto_table[(int) R_386_16];

    case BFD_RELOC_16_PCREL:

      TRACE ("BFD_RELOC_16_PCREL");

      return &elf_howto_table[(int) R_386_PC16];

    case BFD_RELOC_8:

      TRACE ("BFD_RELOC_8");

      return &elf_howto_table[(int) R_386_8];

    case BFD_RELOC_8_PCREL:

      TRACE ("BFD_RELOC_8_PCREL");

      return &elf_howto_table[(int) R_386_PC8];

    case BFD_RELOC_VTABLE_INHERIT:

      TRACE ("BFD_RELOC_VTABLE_INHERIT");

      return &elf32_i386_vtinherit_howto;

    case BFD_RELOC_VTABLE_ENTRY:

      TRACE ("BFD_RELOC_VTABLE_ENTRY");

      return &elf32_i386_vtentry_howto;

    default:

      break;

    }

  TRACE ("Unknown");

  return 0;

}

static void

elf_i386_info_to_howto (abfd, cache_ptr, dst)

     bfd                *abfd ATTRIBUTE_UNUSED;

     arelent            *cache_ptr ATTRIBUTE_UNUSED;

     Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;

{

  abort ();

}

static void

elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)

     bfd *abfd ATTRIBUTE_UNUSED;

     arelent *cache_ptr;

     Elf32_Internal_Rel *dst;

{

  enum elf_i386_reloc_type type;

  type = (enum elf_i386_reloc_type) ELF32_R_TYPE (dst->r_info);

  if (type == R_386_GNU_VTINHERIT)

    cache_ptr->howto = &elf32_i386_vtinherit_howto;

  else if (type == R_386_GNU_VTENTRY)

    cache_ptr->howto = &elf32_i386_vtentry_howto;

  else if (type < R_386_max

           && (type < FIRST_INVALID_RELOC || type > LAST_INVALID_RELOC))

    cache_ptr->howto = &elf_howto_table[(int) type];

  else

    {

      (*_bfd_error_handler) (_("%s: invalid relocation type %d"),

                             bfd_get_filename (abfd), (int) type);

      cache_ptr->howto = &elf_howto_table[(int) R_386_NONE];

    }

}

/* Return whether a symbol name implies a local label.  The UnixWare

   2.1 cc generates temporary symbols that start with .X, so we

   recognize them here.  FIXME: do other SVR4 compilers also use .X?.

   If so, we should move the .X recognition into

   _bfd_elf_is_local_label_name.  */

static boolean

elf_i386_is_local_label_name (abfd, name)

     bfd *abfd;

     const char *name;

{

  if (name[0] == '.' && name[1] == 'X')

    return true;

  return _bfd_elf_is_local_label_name (abfd, name);

}

/* Functions for the i386 ELF linker.  */

/* The name of the dynamic interpreter.  This is put in the .interp

   section.  */

#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"

/* The size in bytes of an entry in the procedure linkage table.  */

#define PLT_ENTRY_SIZE 16

/* The first entry in an absolute procedure linkage table looks like

   this.  See the SVR4 ABI i386 supplement to see how this works.  */

static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =

{

  0xff, 0x35,   /* pushl contents of address */

  0, 0, 0, 0,       /* replaced with address of .got + 4.  */

  0xff, 0x25,   /* jmp indirect */

  0, 0, 0, 0,       /* replaced with address of .got + 8.  */

  0, 0, 0, 0        /* pad out to 16 bytes.  */

};

/* Subsequent entries in an absolute procedure linkage table look like

   this.  */

static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =

{

  0xff, 0x25,   /* jmp indirect */

  0, 0, 0, 0,       /* replaced with address of this symbol in .got.  */

  0x68,         /* pushl immediate */

  0, 0, 0, 0,       /* replaced with offset into relocation table.  */

  0xe9,         /* jmp relative */

  0, 0, 0, 0        /* replaced with offset to start of .plt.  */

};

/* The first entry in a PIC procedure linkage table look like this.  */

static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =

{

  0xff, 0xb3, 4, 0, 0, 0,  /* pushl 4(%ebx) */

  0xff, 0xa3, 8, 0, 0, 0,  /* jmp *8(%ebx) */

  0, 0, 0, 0                        /* pad out to 16 bytes.  */

};

/* Subsequent entries in a PIC procedure linkage table look like this.  */

static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =

{

  0xff, 0xa3,   /* jmp *offset(%ebx) */

  0, 0, 0, 0,       /* replaced with offset of this symbol in .got.  */

  0x68,         /* pushl immediate */

  0, 0, 0, 0,       /* replaced with offset into relocation table.  */

  0xe9,         /* jmp relative */

  0, 0, 0, 0        /* replaced with offset to start of .plt.  */

};

/* The i386 linker needs to keep track of the number of relocs that it

   decides to copy in check_relocs for each symbol.  This is so that

   it can discard PC relative relocs if it doesn't need them when

   linking with -Bsymbolic.  We store the information in a field

   extending the regular ELF linker hash table.  */

/* This structure keeps track of the number of PC relative relocs we

   have copied for a given symbol.  */

struct elf_i386_pcrel_relocs_copied

{

  /* Next section.  */

  struct elf_i386_pcrel_relocs_copied *next;

  /* A section in dynobj.  */

  asection *section;

  /* Number of relocs copied in this section.  */

  bfd_size_type count;

};

/* i386 ELF linker hash entry.  */

struct elf_i386_link_hash_entry

{

  struct elf_link_hash_entry root;

  /* Number of PC relative relocs copied for this symbol.  */

  struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;

};

/* i386 ELF linker hash table.  */

struct elf_i386_link_hash_table

{

  struct elf_link_hash_table root;

};

/* Declare this now that the above structures are defined.  */

static boolean elf_i386_discard_copies

  PARAMS ((struct elf_i386_link_hash_entry *, PTR));

/* Traverse an i386 ELF linker hash table.  */

#define elf_i386_link_hash_traverse(table, func, info)                  \

  (elf_link_hash_traverse                                               \

   (&(table)->root,                                                     \

    (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \

    (info)))

/* Get the i386 ELF linker hash table from a link_info structure.  */

#define elf_i386_hash_table(p) \

  ((struct elf_i386_link_hash_table *) ((p)->hash))

/* Create an entry in an i386 ELF linker hash table.  */

static struct bfd_hash_entry *

elf_i386_link_hash_newfunc (entry, table, string)

     struct bfd_hash_entry *entry;

     struct bfd_hash_table *table;

     const char *string;

{

  struct elf_i386_link_hash_entry *ret =

    (struct elf_i386_link_hash_entry *) entry;

  /* Allocate the structure if it has not already been allocated by a

     subclass.  */

  if (ret == (struct elf_i386_link_hash_entry *) NULL)

    ret = ((struct elf_i386_link_hash_entry *)

           bfd_hash_allocate (table,

                              sizeof (struct elf_i386_link_hash_entry)));

  if (ret == (struct elf_i386_link_hash_entry *) NULL)

    return (struct bfd_hash_entry *) ret;

  /* Call the allocation method of the superclass.  */

  ret = ((struct elf_i386_link_hash_entry *)

         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,

                                     table, string));

  if (ret != (struct elf_i386_link_hash_entry *) NULL)

    {

      ret->pcrel_relocs_copied = NULL;

    }

  return (struct bfd_hash_entry *) ret;

}

/* Create an i386 ELF linker hash table.  */

static struct bfd_link_hash_table *

elf_i386_link_hash_table_create (abfd)

     bfd *abfd;

{

  struct elf_i386_link_hash_table *ret;

  ret = ((struct elf_i386_link_hash_table *)

         bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));

  if (ret == (struct elf_i386_link_hash_table *) NULL)

    return NULL;

  if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,

                                       elf_i386_link_hash_newfunc))

    {

      bfd_release (abfd, ret);

      return NULL;

    }

  return &ret->root.root;

}

/* Look through the relocs for a section during the first phase, and

   allocate space in the global offset table or procedure linkage

   table.  */

static boolean

elf_i386_check_relocs (abfd, info, sec, relocs)

     bfd *abfd;

     struct bfd_link_info *info;

     asection *sec;

     const Elf_Internal_Rela *relocs;

{

  bfd *dynobj;

  Elf_Internal_Shdr *symtab_hdr;

  struct elf_link_hash_entry **sym_hashes;

  bfd_vma *local_got_offsets;

  const Elf_Internal_Rela *rel;

  const Elf_Internal_Rela *rel_end;

  asection *sgot;

  asection *srelgot;

  asection *sreloc;

  if (info->relocateable)

    return true;

  dynobj = elf_hash_table (info)->dynobj;

  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;

  sym_hashes = elf_sym_hashes (abfd);

  local_got_offsets = elf_local_got_offsets (abfd);

  sgot = NULL;

  srelgot = NULL;

  sreloc = NULL;

  rel_end = relocs + sec->reloc_count;

  for (rel = relocs; rel < rel_end; rel++)

    {

      unsigned long r_symndx;

      struct elf_link_hash_entry *h;

      r_symndx = ELF32_R_SYM (rel->r_info);

      if (r_symndx < symtab_hdr->sh_info)

        h = NULL;

      else

        h = sym_hashes[r_symndx - symtab_hdr->sh_info];

      /* Some relocs require a global offset table.  */

      if (dynobj == NULL)

        {

          switch (ELF32_R_TYPE (rel->r_info))

            {

            case R_386_GOT32:

            case R_386_GOTOFF:

            case R_386_GOTPC:

              elf_hash_table (info)->dynobj = dynobj = abfd;

              if (! _bfd_elf_create_got_section (dynobj, info))

                return false;

              break;

            default:

              break;

            }

        }

      switch (ELF32_R_TYPE (rel->r_info))

        {

        case R_386_GOT32:

          /* This symbol requires a global offset table entry.  */

          if (sgot == NULL)

            {

              sgot = bfd_get_section_by_name (dynobj, ".got");

              BFD_ASSERT (sgot != NULL);

            }

          if (srelgot == NULL

              && (h != NULL || info->shared))

            {

              srelgot = bfd_get_section_by_name (dynobj, ".rel.got");

              if (srelgot == NULL)

                {

                  srelgot = bfd_make_section (dynobj, ".rel.got");

                  if (srelgot == NULL

                      || ! bfd_set_section_flags (dynobj, srelgot,

                                                  (SEC_ALLOC

                                                   | SEC_LOAD

                                                   | SEC_HAS_CONTENTS

                                                   | SEC_IN_MEMORY

                                                   | SEC_LINKER_CREATED

                                                   | SEC_READONLY))

                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))

                    return false;

                }

            }

          if (h != NULL)

            {

              if (h->got.offset != (bfd_vma) -1)

                {

                  /* We have already allocated space in the .got.  */

                  break;

                }

              h->got.offset = sgot->_raw_size;

              /* Make sure this symbol is output as a dynamic symbol.  */

              if (h->dynindx == -1)

                {

                  if (! bfd_elf32_link_record_dynamic_symbol (info, h))

                    return false;

                }

              srelgot->_raw_size += sizeof (Elf32_External_Rel);

            }

          else

            {

              /* This is a global offset table entry for a local

                 symbol.  */

              if (local_got_offsets == NULL)

                {

                  size_t size;

                  register unsigned int i;

                  size = symtab_hdr->sh_info * sizeof (bfd_vma);

                  local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);

                  if (local_got_offsets == NULL)

                    return false;

                  elf_local_got_offsets (abfd) = local_got_offsets;

                  for (i = 0; i < symtab_hdr->sh_info; i++)

                    local_got_offsets[i] = (bfd_vma) -1;

                }

              if (local_got_offsets[r_symndx] != (bfd_vma) -1)

                {

                  /* We have already allocated space in the .got.  */

                  break;

                }

              local_got_offsets[r_symndx] = sgot->_raw_size;

              if (info->shared)

                {

                  /* If we are generating a shared object, we need to

                     output a R_386_RELATIVE reloc so that the dynamic

                     linker can adjust this GOT entry.  */

                  srelgot->_raw_size += sizeof (Elf32_External_Rel);

                }

            }

          sgot->_raw_size += 4;

          break;

        case R_386_PLT32:

          /* This symbol requires a procedure linkage table entry.  We

             actually build the entry in adjust_dynamic_symbol,

             because this might be a case of linking PIC code which is

             never referenced by a dynamic object, in which case we

             don't need to generate a procedure linkage table entry

             after all.  */

          /* If this is a local symbol, we resolve it directly without

             creating a procedure linkage table entry.  */

          if (h == NULL)

            continue;

          h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;

          break;

        case R_386_32:

        case R_386_PC32:

          if (h != NULL)

            h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;

          /* If we are creating a shared library, and this is a reloc

             against a global symbol, or a non PC relative reloc

             against a local symbol, then we need to copy the reloc

             into the shared library.  However, if we are linking with

             -Bsymbolic, we do not need to copy a reloc against a

             global symbol which is defined in an object we are

             including in the link (i.e., DEF_REGULAR is set).  At

             this point we have not seen all the input files, so it is

             possible that DEF_REGULAR is not set now but will be set

             later (it is never cleared).  We account for that

             possibility below by storing information in the

             pcrel_relocs_copied field of the hash table entry.  */

          if (info->shared

              && (sec->flags & SEC_ALLOC) != 0

              && (ELF32_R_TYPE (rel->r_info) != R_386_PC32

                  || (h != NULL

                      && (! info->symbolic

                          || (h->elf_link_hash_flags

                              & ELF_LINK_HASH_DEF_REGULAR) == 0))))

            {

              /* When creating a shared object, we must copy these

                 reloc types into the output file.  We create a reloc

                 section in dynobj and make room for this reloc.  */

              if (sreloc == NULL)

                {

                  const char *name;

                  name = (bfd_elf_string_from_elf_section

                          (abfd,

                           elf_elfheader (abfd)->e_shstrndx,

                           elf_section_data (sec)->rel_hdr.sh_name));

                  if (name == NULL)

                    return false;

                  BFD_ASSERT (strncmp (name, ".rel", 4) == 0

                              && strcmp (bfd_get_section_name (abfd, sec),

                                         name + 4) == 0);

                  sreloc = bfd_get_section_by_name (dynobj, name);

                  if (sreloc == NULL)

                    {

                      flagword flags;

                      sreloc = bfd_make_section (dynobj, name);

                      flags = (SEC_HAS_CONTENTS | SEC_READONLY

                               | SEC_IN_MEMORY | SEC_LINKER_CREATED);

                      if ((sec->flags & SEC_ALLOC) != 0)

                        flags |= SEC_ALLOC | SEC_LOAD;