Back to index

cell-binutils  2.17cvs20070401
Defines | Functions | Variables
elf32-i370.c File Reference
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/i370.h"
#include "elf32-target.h"

Go to the source code of this file.

Defines

#define ELF_DYNAMIC_INTERPRETER   "/lib/ld.so"
#define add_dynamic_entry(TAG, VAL)   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
#define TARGET_BIG_SYM   bfd_elf32_i370_vec
#define TARGET_BIG_NAME   "elf32-i370"
#define ELF_ARCH   bfd_arch_i370
#define ELF_MACHINE_CODE   EM_S370
#define ELF_MAXPAGESIZE   0x1000
#define ELF_OSABI   ELFOSABI_LINUX
#define elf_info_to_howto   i370_elf_info_to_howto
#define elf_backend_plt_not_loaded   1
#define elf_backend_rela_normal   1
#define bfd_elf32_bfd_reloc_type_lookup   i370_elf_reloc_type_lookup
#define bfd_elf32_bfd_reloc_name_lookup   i370_elf_reloc_name_lookup
#define bfd_elf32_bfd_set_private_flags   i370_elf_set_private_flags
#define bfd_elf32_bfd_merge_private_bfd_data   i370_elf_merge_private_bfd_data
#define elf_backend_relocate_section   i370_elf_relocate_section
#define elf_backend_create_dynamic_sections   i370_elf_create_dynamic_sections
#define elf_backend_size_dynamic_sections   i370_elf_size_dynamic_sections
#define elf_backend_init_index_section   _bfd_elf_init_1_index_section
#define elf_backend_finish_dynamic_sections   i370_elf_finish_dynamic_sections
#define elf_backend_fake_sections   i370_elf_fake_sections
#define elf_backend_section_from_shdr   i370_elf_section_from_shdr
#define elf_backend_adjust_dynamic_symbol   i370_elf_adjust_dynamic_symbol
#define elf_backend_check_relocs   i370_elf_check_relocs
#define elf_backend_post_process_headers   _bfd_elf_set_osabi
#define elf_backend_finish_dynamic_symbol

Functions

static void i370_elf_howto_init (void)
static reloc_howto_type * i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
static reloc_howto_type * i370_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
static void i370_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, Elf_Internal_Rela *dst)
static bfd_boolean i370_elf_set_private_flags (bfd *abfd, flagword flags)
static bfd_boolean i370_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
static bfd_boolean i370_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name, int shindex)
static bfd_boolean i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *shdr, asection *asect)
static bfd_boolean i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
static bfd_boolean i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
static bfd_boolean i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void *cparg)
static bfd_boolean i370_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
static bfd_boolean i370_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, const Elf_Internal_Rela *relocs)
static bfd_boolean i370_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
static bfd_boolean i370_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd, asection *input_section, bfd_byte *contents, Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms, asection **local_sections)
static int i370_noop (void)

Variables

static reloc_howto_type * i370_elf_howto_table [(int) R_I370_max]
static reloc_howto_type i370_elf_howto_raw []

Define Documentation

#define add_dynamic_entry (   TAG,
  VAL 
)    _bfd_elf_add_dynamic_entry (info, TAG, VAL)

Definition at line 1455 of file elf32-i370.c.

Definition at line 1453 of file elf32-i370.c.

Definition at line 1452 of file elf32-i370.c.

Definition at line 1454 of file elf32-i370.c.

#define ELF_ARCH   bfd_arch_i370

Definition at line 1439 of file elf32-i370.c.

Definition at line 1466 of file elf32-i370.c.

Definition at line 1467 of file elf32-i370.c.

Definition at line 1460 of file elf32-i370.c.

Definition at line 1464 of file elf32-i370.c.

Definition at line 1463 of file elf32-i370.c.

Value:
(bfd_boolean (*) \
     (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
      Elf_Internal_Sym *)) i370_noop

Definition at line 1476 of file elf32-i370.c.

Definition at line 1462 of file elf32-i370.c.

Definition at line 1449 of file elf32-i370.c.

Definition at line 1468 of file elf32-i370.c.

#define elf_backend_rela_normal   1

Definition at line 1450 of file elf32-i370.c.

Definition at line 1456 of file elf32-i370.c.

Definition at line 1465 of file elf32-i370.c.

Definition at line 1461 of file elf32-i370.c.

#define ELF_DYNAMIC_INTERPRETER   "/lib/ld.so"

Definition at line 289 of file elf32-i370.c.

Definition at line 1447 of file elf32-i370.c.

#define ELF_MACHINE_CODE   EM_S370

Definition at line 1440 of file elf32-i370.c.

#define ELF_MAXPAGESIZE   0x1000

Definition at line 1444 of file elf32-i370.c.

#define ELF_OSABI   ELFOSABI_LINUX

Definition at line 1445 of file elf32-i370.c.

#define TARGET_BIG_NAME   "elf32-i370"

Definition at line 1438 of file elf32-i370.c.

Definition at line 1437 of file elf32-i370.c.


Function Documentation

Definition at line 459 of file elf32-i370.c.

{
  bfd *dynobj = elf_hash_table (info)->dynobj;
  asection *s;
  unsigned int power_of_two;

#ifdef DEBUG
  fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
          h->root.root.string);
#endif

  /* Make sure we know what is going on here.  */
  BFD_ASSERT (dynobj != NULL
             && (h->needs_plt
                || h->u.weakdef != NULL
                || (h->def_dynamic
                    && h->ref_regular
                    && !h->def_regular)));

  s = bfd_get_section_by_name (dynobj, ".rela.text");
  BFD_ASSERT (s != NULL);
  s->size += sizeof (Elf32_External_Rela);

  /* If this is a weak symbol, and there is a real definition, the
     processor independent code will have arranged for us to see the
     real definition first, and we can just use the same value.  */
  if (h->u.weakdef != NULL)
    {
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
                || h->u.weakdef->root.type == bfd_link_hash_defweak);
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
      return TRUE;
    }

  /* This is a reference to a symbol defined by a dynamic object which
     is not a function.  */

  /* If we are creating a shared library, we must presume that the
     only references to the symbol are via the global offset table.
     For such cases we need not do anything here; the relocations will
     be handled correctly by relocate_section.  */
  if (info->shared)
    return TRUE;

  if (h->size == 0)
    {
      (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
                          h->root.root.string);
      return TRUE;
    }

  /* We must allocate the symbol in our .dynbss section, which will
     become part of the .bss section of the executable.  There will be
     an entry for this symbol in the .dynsym section.  The dynamic
     object will contain position independent code, so all references
     from the dynamic object to this symbol will go through the global
     offset table.  The dynamic linker will use the .dynsym entry to
     determine the address it must put in the global offset table, so
     both the dynamic object and the regular object will refer to the
     same memory location for the variable.

     Of course, if the symbol is sufficiently small, we must instead
     allocate it in .sbss.  FIXME: It would be better to do this if and
     only if there were actually SDAREL relocs for that symbol.  */

  if (h->size <= elf_gp_size (dynobj))
    s = bfd_get_section_by_name (dynobj, ".dynsbss");
  else
    s = bfd_get_section_by_name (dynobj, ".dynbss");
  BFD_ASSERT (s != NULL);

  /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
     copy the initial value out of the dynamic object and into the
     runtime process image.  We need to remember the offset into the
     .rela.bss section we are going to use.  */
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
    {
      asection *srel;

      if (h->size <= elf_gp_size (dynobj))
       srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
      else
       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
      BFD_ASSERT (srel != NULL);
      srel->size += sizeof (Elf32_External_Rela);
      h->needs_copy = 1;
    }

  /* We need to figure out the alignment required for this symbol.  I
     have no idea how ELF linkers handle this.  */
  power_of_two = bfd_log2 (h->size);
  if (power_of_two > 4)
    power_of_two = 4;

  /* Apply the required alignment.  */
  s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
  if (power_of_two > bfd_get_section_alignment (dynobj, s))
    {
      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
       return FALSE;
    }

  /* Define the symbol as being at this point in the section.  */
  h->root.u.def.section = s;
  h->root.u.def.value = s->size;

  /* Increment the section size to make room for the symbol.  */
  s->size += h->size;

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean i370_elf_adjust_dynindx ( struct elf_link_hash_entry h,
void *  cparg 
) [static]

Definition at line 580 of file elf32-i370.c.

{
  int *cp = (int *) cparg;

#ifdef DEBUG
  fprintf (stderr,
          "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
          h->dynindx, *cp);
#endif

  if (h->root.type == bfd_link_hash_warning)
    h = (struct elf_link_hash_entry *) h->root.u.i.link;

  if (h->dynindx != -1)
    h->dynindx += *cp;

  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean i370_elf_check_relocs ( bfd abfd,
struct bfd_link_info info,
asection sec,
const Elf_Internal_Rela relocs 
) [static]

Definition at line 822 of file elf32-i370.c.

{
  bfd *dynobj;
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes;
  const Elf_Internal_Rela *rel;
  const Elf_Internal_Rela *rel_end;
  bfd_vma *local_got_offsets;
  asection *sreloc;

  if (info->relocatable)
    return TRUE;

#ifdef DEBUG
  _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
                    sec, abfd);
#endif

  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);

  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];
         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;
       }

      if (info->shared)
       {
#ifdef DEBUG
         fprintf (stderr,
                 "i370_elf_check_relocs needs to create relocation for %s\n",
                 (h && h->root.root.string)
                 ? h->root.root.string : "<unknown>");
#endif
         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 (CONST_STRNEQ (name, ".rela")
                       && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);

             sreloc = bfd_get_section_by_name (dynobj, name);
             if (sreloc == NULL)
              {
                flagword flags;

                flags = (SEC_HAS_CONTENTS | SEC_READONLY
                        | SEC_IN_MEMORY | SEC_LINKER_CREATED);
                if ((sec->flags & SEC_ALLOC) != 0)
                  flags |= SEC_ALLOC | SEC_LOAD;
                sreloc = bfd_make_section_with_flags (dynobj, name,
                                                 flags);
                if (sreloc == NULL
                    || ! bfd_set_section_alignment (dynobj, sreloc, 2))
                  return FALSE;
              }
           }

         sreloc->size += sizeof (Elf32_External_Rela);

         /* FIXME: We should here do what the m68k and i386
            backends do: if the reloc is pc-relative, record it
            in case it turns out that the reloc is unnecessary
            because the symbol is forced local by versioning or
            we are linking with -Bdynamic.  Fortunately this
            case is not frequent.  */
       }
    }

  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean i370_elf_create_dynamic_sections ( bfd abfd,
struct bfd_link_info info 
) [static]

Definition at line 415 of file elf32-i370.c.

{
  asection *s;
  flagword flags;

  if (!_bfd_elf_create_dynamic_sections(abfd, info))
    return FALSE;

  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
          | SEC_LINKER_CREATED);

  s = bfd_make_section_with_flags (abfd, ".dynsbss",
                               SEC_ALLOC | SEC_LINKER_CREATED);
  if (s == NULL)
    return FALSE;

  if (! info->shared)
    {
      s = bfd_make_section_with_flags (abfd, ".rela.sbss",
                                   flags | SEC_READONLY);
      if (s == NULL
         || ! bfd_set_section_alignment (abfd, s, 2))
       return FALSE;
    }

   /* XXX beats me, seem to need a rela.text ...  */
   s = bfd_make_section_with_flags (abfd, ".rela.text",
                                flags | SEC_READONLY);
   if (s == NULL
      || ! bfd_set_section_alignment (abfd, s, 2))
    return FALSE;
  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean i370_elf_fake_sections ( bfd *abfd  ATTRIBUTE_UNUSED,
Elf_Internal_Shdr shdr,
asection asect 
) [static]

Definition at line 394 of file elf32-i370.c.

{
  if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
    shdr->sh_flags |= SHF_EXCLUDE;

  if ((asect->flags & SEC_SORT_ENTRIES) != 0)
    shdr->sh_type = SHT_ORDERED;

  return TRUE;
}
static bfd_boolean i370_elf_finish_dynamic_sections ( bfd output_bfd,
struct bfd_link_info info 
) [static]

Definition at line 926 of file elf32-i370.c.

{
  asection *sdyn;
  bfd *dynobj = elf_hash_table (info)->dynobj;
  asection *sgot = bfd_get_section_by_name (dynobj, ".got");

#ifdef DEBUG
  fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
#endif

  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");

  if (elf_hash_table (info)->dynamic_sections_created)
    {
      asection *splt;
      Elf32_External_Dyn *dyncon, *dynconend;

      splt = bfd_get_section_by_name (dynobj, ".plt");
      BFD_ASSERT (splt != NULL && sdyn != NULL);

      dyncon = (Elf32_External_Dyn *) sdyn->contents;
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
      for (; dyncon < dynconend; dyncon++)
       {
         Elf_Internal_Dyn dyn;
         const char *name;
         bfd_boolean size;

         bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);

         switch (dyn.d_tag)
           {
           case DT_PLTGOT:   name = ".plt";        size = FALSE; break;
           case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE;  break;
           case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
           default:        name = NULL;     size = FALSE; break;
           }

         if (name != NULL)
           {
             asection *s;

             s = bfd_get_section_by_name (output_bfd, name);
             if (s == NULL)
              dyn.d_un.d_val = 0;
             else
              {
                if (! size)
                  dyn.d_un.d_ptr = s->vma;
                else
                  dyn.d_un.d_val = s->size;
              }
             bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
           }
       }
    }

  if (sgot && sgot->size != 0)
    {
      unsigned char *contents = sgot->contents;

      if (sdyn == NULL)
       bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
      else
       bfd_put_32 (output_bfd,
                  sdyn->output_section->vma + sdyn->output_offset,
                  contents);

      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
    }

  if (info->shared)
    {
      asection *sdynsym;
      asection *s;
      Elf_Internal_Sym sym;
      int maxdindx = 0;

      /* Set up the section symbols for the output sections.  */

      sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
      BFD_ASSERT (sdynsym != NULL);

      sym.st_size = 0;
      sym.st_name = 0;
      sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
      sym.st_other = 0;

      for (s = output_bfd->sections; s != NULL; s = s->next)
       {
         int indx, dindx;
         Elf32_External_Sym *esym;

         sym.st_value = s->vma;

         indx = elf_section_data (s)->this_idx;
         dindx = elf_section_data (s)->dynindx;
         if (dindx != -1)
           {
             BFD_ASSERT(indx > 0);
             BFD_ASSERT(dindx > 0);

             if (dindx > maxdindx)
              maxdindx = dindx;

             sym.st_shndx = indx;

             esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
             bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
           }
       }

      /* Set the sh_info field of the output .dynsym section to the
        index of the first global symbol.  */
      elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
       maxdindx + 1;
    }

  return TRUE;
}

Here is the call graph for this function:

static void i370_elf_howto_init ( void  ) [static]

Definition at line 232 of file elf32-i370.c.

{
  unsigned int i, type;

  for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
    {
      type = i370_elf_howto_raw[i].type;
      BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
      i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
    }
}

Here is the caller graph for this function:

static void i370_elf_info_to_howto ( bfd *abfd  ATTRIBUTE_UNUSED,
arelent cache_ptr,
Elf_Internal_Rela dst 
) [static]

Definition at line 294 of file elf32-i370.c.

{
  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
    /* Initialize howto table.  */
    i370_elf_howto_init ();

  BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
  cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
}

Here is the call graph for this function:

static bfd_boolean i370_elf_merge_private_bfd_data ( bfd ibfd,
bfd obfd 
) [static]

Definition at line 325 of file elf32-i370.c.

{
  flagword old_flags;
  flagword new_flags;

  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
    return TRUE;

  new_flags = elf_elfheader (ibfd)->e_flags;
  old_flags = elf_elfheader (obfd)->e_flags;
  if (!elf_flags_init (obfd))      /* First call, no flags set.  */
    {
      elf_flags_init (obfd) = TRUE;
      elf_elfheader (obfd)->e_flags = new_flags;
    }

  else if (new_flags == old_flags) /* Compatible flags are ok.  */
    ;

  else                             /* Incompatible flags.  */
    {
      (*_bfd_error_handler)
       ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
        ibfd, (long) new_flags, (long) old_flags);

      bfd_set_error (bfd_error_bad_value);
      return FALSE;
    }

  return TRUE;
}

Here is the call graph for this function:

static reloc_howto_type* i370_elf_reloc_name_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
const char *  r_name 
) [static]

Definition at line 271 of file elf32-i370.c.

{
  unsigned int i;

  for (i = 0;
       i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]);
       i++)
    if (i370_elf_howto_raw[i].name != NULL
       && strcasecmp (i370_elf_howto_raw[i].name, r_name) == 0)
      return &i370_elf_howto_raw[i];

  return NULL;
}

Here is the call graph for this function:

static reloc_howto_type* i370_elf_reloc_type_lookup ( bfd *abfd  ATTRIBUTE_UNUSED,
bfd_reloc_code_real_type  code 
) [static]

Definition at line 245 of file elf32-i370.c.

{
  enum i370_reloc_type i370_reloc = R_I370_NONE;

  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
    /* Initialize howto table if needed.  */
    i370_elf_howto_init ();

  switch ((int) code)
    {
    default:
      return NULL;

    case BFD_RELOC_NONE:    i370_reloc = R_I370_NONE;   break;
    case BFD_RELOC_32:             i370_reloc = R_I370_ADDR31; break;
    case BFD_RELOC_16:             i370_reloc = R_I370_ADDR16; break;
    case BFD_RELOC_32_PCREL:       i370_reloc = R_I370_REL31;  break;
    case BFD_RELOC_CTOR:    i370_reloc = R_I370_ADDR31; break;
    case BFD_RELOC_I370_D12:       i370_reloc = R_I370_ADDR12; break;
    }

  return i370_elf_howto_table[ (int)i370_reloc ];
};

Here is the call graph for this function:

static bfd_boolean i370_elf_relocate_section ( bfd output_bfd,
struct bfd_link_info info,
bfd input_bfd,
asection input_section,
bfd_byte contents,
Elf_Internal_Rela relocs,
Elf_Internal_Sym *  local_syms,
asection **  local_sections 
) [static]

Definition at line 1078 of file elf32-i370.c.

{
  Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
  bfd *dynobj = elf_hash_table (info)->dynobj;
  Elf_Internal_Rela *rel = relocs;
  Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
  asection *sreloc = NULL;
  bfd_vma *local_got_offsets;
  bfd_boolean ret = TRUE;

#ifdef DEBUG
  _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
                    input_bfd, input_section,
                    (long) input_section->reloc_count,
                    (info->relocatable) ? " (relocatable)" : "");
#endif

  if (!i370_elf_howto_table[ R_I370_ADDR31 ])
    /* Initialize howto table if needed.  */
    i370_elf_howto_init ();

  local_got_offsets = elf_local_got_offsets (input_bfd);

  for (; rel < relend; rel++)
    {
      enum i370_reloc_type r_type    = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
      bfd_vma offset             = rel->r_offset;
      bfd_vma addend             = rel->r_addend;
      bfd_reloc_status_type r           = bfd_reloc_other;
      Elf_Internal_Sym *sym      = NULL;
      asection *sec              = NULL;
      struct elf_link_hash_entry * h = NULL;
      const char *sym_name       = NULL;
      reloc_howto_type *howto;
      unsigned long r_symndx;
      bfd_vma relocation;

      /* Unknown relocation handling.  */
      if ((unsigned) r_type >= (unsigned) R_I370_max
         || !i370_elf_howto_table[(int)r_type])
       {
         (*_bfd_error_handler) ("%B: unknown relocation type %d",
                             input_bfd,
                             (int) r_type);

         bfd_set_error (bfd_error_bad_value);
         ret = FALSE;
         continue;
       }

      howto = i370_elf_howto_table[(int) r_type];
      r_symndx = ELF32_R_SYM (rel->r_info);
      relocation = 0;

      if (r_symndx < symtab_hdr->sh_info)
       {
         sym = local_syms + r_symndx;
         sec = local_sections[r_symndx];
         sym_name = "<local symbol>";

         relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
         addend = rel->r_addend;
       }
      else
       {
         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
         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;
         sym_name = h->root.root.string;
         if (h->root.type == bfd_link_hash_defined
             || h->root.type == bfd_link_hash_defweak)
           {
             sec = h->root.u.def.section;
             if (info->shared
                && ((! info->symbolic && h->dynindx != -1)
                    || !h->def_regular)
                && (input_section->flags & SEC_ALLOC) != 0
                && (r_type == R_I370_ADDR31
                    || r_type == R_I370_COPY
                    || r_type == R_I370_ADDR16
                    || r_type == R_I370_RELATIVE))
              /* In these cases, we don't need the relocation
                 value.  We check specially because in some
                 obscure cases sec->output_section will be NULL.  */
              ;
             else
              relocation = (h->root.u.def.value
                           + sec->output_section->vma
                           + sec->output_offset);
           }
         else if (h->root.type == bfd_link_hash_undefweak)
           ;
         else if (info->unresolved_syms_in_objects == RM_IGNORE
                 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
           ;
         else if (!info->relocatable)
           {
             if ((*info->callbacks->undefined_symbol)
                (info, h->root.root.string, input_bfd,
                 input_section, rel->r_offset,
                 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
                  || ELF_ST_VISIBILITY (h->other))))
              {
                ret = FALSE;
                continue;
              }
           }
       }

      if (sec != NULL && elf_discarded_section (sec))
       {
         /* For relocs against symbols from removed linkonce sections,
            or sections discarded by a linker script, we just want the
            section contents zeroed.  Avoid any special processing.  */
         _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
         rel->r_info = 0;
         rel->r_addend = 0;
         continue;
       }

      if (info->relocatable)
       continue;

      switch ((int) r_type)
       {
       default:
         (*_bfd_error_handler)
           ("%B: unknown relocation type %d for symbol %s",
            input_bfd, (int) r_type, sym_name);

         bfd_set_error (bfd_error_bad_value);
         ret = FALSE;
         continue;

       case (int) R_I370_NONE:
         continue;

       /* Relocations that may need to be propagated if this is a shared
          object.  */
       case (int) R_I370_REL31:
         /* If these relocations are not to a named symbol, they can be
            handled right here, no need to bother the dynamic linker.  */
         if (h == NULL
             || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
           break;
       /* Fall through.  */

       /* Relocations that always need to be propagated if this is a shared
          object.  */
       case (int) R_I370_ADDR31:
       case (int) R_I370_ADDR16:
         if (info->shared
             && r_symndx != 0)
           {
             Elf_Internal_Rela outrel;
             bfd_byte *loc;
             int skip;

#ifdef DEBUG
             fprintf (stderr,
                     "i370_elf_relocate_section needs to create relocation for %s\n",
                     (h && h->root.root.string) ? h->root.root.string : "<unknown>");
#endif

             /* When generating a shared object, these relocations
               are copied into the output file to be resolved at run
               time.  */

             if (sreloc == NULL)
              {
                const char *name;

                name = (bfd_elf_string_from_elf_section
                       (input_bfd,
                        elf_elfheader (input_bfd)->e_shstrndx,
                        elf_section_data (input_section)->rel_hdr.sh_name));
                if (name == NULL)
                  return FALSE;

                BFD_ASSERT (CONST_STRNEQ (name, ".rela")
                           && strcmp (bfd_get_section_name (input_bfd,
                                                        input_section),
                                    name + 5) == 0);

                sreloc = bfd_get_section_by_name (dynobj, name);
                BFD_ASSERT (sreloc != NULL);
              }

             skip = 0;

             outrel.r_offset =
              _bfd_elf_section_offset (output_bfd, info, input_section,
                                    rel->r_offset);
             if (outrel.r_offset == (bfd_vma) -1
                || outrel.r_offset == (bfd_vma) -2)
              skip = (int) outrel.r_offset;
             outrel.r_offset += (input_section->output_section->vma
                              + input_section->output_offset);

             if (skip)
              memset (&outrel, 0, sizeof outrel);
             /* h->dynindx may be -1 if this symbol was marked to
               become local.  */
             else if (h != NULL
                     && ((! info->symbolic && h->dynindx != -1)
                        || !h->def_regular))
              {
                BFD_ASSERT (h->dynindx != -1);
                outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
                outrel.r_addend = rel->r_addend;
              }
             else
              {
                if (r_type == R_I370_ADDR31)
                  {
                    outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
                    outrel.r_addend = relocation + rel->r_addend;
                  }
                else
                  {
                    long indx;

                    if (bfd_is_abs_section (sec))
                     indx = 0;
                    else if (sec == NULL || sec->owner == NULL)
                     {
                       bfd_set_error (bfd_error_bad_value);
                       return FALSE;
                     }
                    else
                     {
                       asection *osec;

                       /* We are turning this relocation into one
                          against a section symbol.  It would be
                          proper to subtract the symbol's value,
                          osec->vma, from the emitted reloc addend,
                          but ld.so expects buggy relocs.  */
                       osec = sec->output_section;
                       indx = elf_section_data (osec)->dynindx;
                       if (indx == 0)
                         {
                           struct elf_link_hash_table *htab;
                           htab = elf_hash_table (info);
                           osec = htab->text_index_section;
                           indx = elf_section_data (osec)->dynindx;
                         }
                       BFD_ASSERT (indx != 0);
#ifdef DEBUG
                       if (indx <= 0)
                         {
                           printf ("indx=%ld section=%s flags=%08x name=%s\n",
                                  indx, osec->name, osec->flags,
                                  h->root.root.string);
                         }
#endif
                     }

                    outrel.r_info = ELF32_R_INFO (indx, r_type);
                    outrel.r_addend = relocation + rel->r_addend;
                  }
              }

             loc = sreloc->contents;
             loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
             bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);

             /* This reloc will be computed at runtime, so there's no
               need to do anything now, unless this is a RELATIVE
               reloc in an unallocated section.  */
             if (skip == -1
                || (input_section->flags & SEC_ALLOC) != 0
                || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
              continue;
           }
         break;

       case (int) R_I370_COPY:
       case (int) R_I370_RELATIVE:
         (*_bfd_error_handler)
           ("%B: Relocation %s is not yet supported for symbol %s.",
            input_bfd,
            i370_elf_howto_table[(int) r_type]->name,
            sym_name);

         bfd_set_error (bfd_error_invalid_operation);
         ret = FALSE;
         continue;
       }

#ifdef DEBUG
      fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
              howto->name,
              (int)r_type,
              sym_name,
              r_symndx,
              (long) offset,
              (long) addend);
#endif

      r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
                                offset, relocation, addend);

      if (r != bfd_reloc_ok)
       {
         ret = FALSE;
         switch (r)
           {
           default:
             break;

           case bfd_reloc_overflow:
             {
              const char *name;

              if (h != NULL)
                name = NULL;
              else
                {
                  name = bfd_elf_string_from_elf_section (input_bfd,
                                                     symtab_hdr->sh_link,
                                                     sym->st_name);
                  if (name == NULL)
                    break;

                  if (*name == '\0')
                    name = bfd_section_name (input_bfd, sec);
                }

              (*info->callbacks->reloc_overflow) (info,
                                              (h ? &h->root : NULL),
                                              name,
                                              howto->name,
                                              (bfd_vma) 0,
                                              input_bfd,
                                              input_section,
                                              offset);
             }
             break;
           }
       }
    }

#ifdef DEBUG
  fprintf (stderr, "\n");
#endif

  return ret;
}

Here is the call graph for this function:

static bfd_boolean i370_elf_section_from_shdr ( bfd abfd,
Elf_Internal_Shdr hdr,
const char *  name,
int  shindex 
) [static]

Definition at line 365 of file elf32-i370.c.

{
  asection *newsect;
  flagword flags;

  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
    return FALSE;

  newsect = hdr->bfd_section;
  flags = bfd_get_section_flags (abfd, newsect);
  if (hdr->sh_flags & SHF_EXCLUDE)
    flags |= SEC_EXCLUDE;

  if (hdr->sh_type == SHT_ORDERED)
    flags |= SEC_SORT_ENTRIES;

  bfd_set_section_flags (abfd, newsect, flags);
  return TRUE;
}

Here is the call graph for this function:

static bfd_boolean i370_elf_set_private_flags ( bfd abfd,
flagword  flags 
) [static]

Definition at line 311 of file elf32-i370.c.

{
  BFD_ASSERT (!elf_flags_init (abfd)
             || elf_elfheader (abfd)->e_flags == flags);

  elf_elfheader (abfd)->e_flags = flags;
  elf_flags_init (abfd) = TRUE;
  return TRUE;
}
static bfd_boolean i370_elf_size_dynamic_sections ( bfd output_bfd,
struct bfd_link_info info 
) [static]

Definition at line 605 of file elf32-i370.c.

{
  bfd *dynobj;
  asection *s;
  bfd_boolean plt;
  bfd_boolean relocs;
  bfd_boolean reltext;

#ifdef DEBUG
  fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
#endif

  dynobj = elf_hash_table (info)->dynobj;
  BFD_ASSERT (dynobj != NULL);

  if (elf_hash_table (info)->dynamic_sections_created)
    {
      /* Set the contents of the .interp section to the interpreter.  */
      if (info->executable)
       {
         s = bfd_get_section_by_name (dynobj, ".interp");
         BFD_ASSERT (s != NULL);
         s->size = sizeof ELF_DYNAMIC_INTERPRETER;
         s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
       }
    }
  else
    {
      /* We may have created entries in the .rela.got, .rela.sdata, and
        .rela.sdata2 sections.  However, if we are not creating the
        dynamic sections, we will not actually use these entries.  Reset
        the size of .rela.got, et al, which will cause it to get
        stripped from the output file below.  */
      static char *rela_sections[] = { ".rela.got", ".rela.sdata",
                                   ".rela.sdata2", ".rela.sbss",
                                   NULL };
      char **p;

      for (p = rela_sections; *p != NULL; p++)
       {
         s = bfd_get_section_by_name (dynobj, *p);
         if (s != NULL)
           s->size = 0;
       }
    }

  /* The check_relocs and adjust_dynamic_symbol entry points have
     determined the sizes of the various dynamic sections.  Allocate
     memory for them.  */
  plt = FALSE;
  relocs = FALSE;
  reltext = FALSE;
  for (s = dynobj->sections; s != NULL; s = s->next)
    {
      const char *name;

      if ((s->flags & SEC_LINKER_CREATED) == 0)
       continue;

      /* It's OK to base decisions on the section name, because none
        of the dynobj section names depend upon the input files.  */
      name = bfd_get_section_name (dynobj, s);

      if (strcmp (name, ".plt") == 0)
       {
         /* Remember whether there is a PLT.  */
         plt = s->size != 0;
       }
      else if (CONST_STRNEQ (name, ".rela"))
       {
         if (s->size != 0)
           {
             asection *target;
             const char *outname;

             /* Remember whether there are any relocation sections.  */
             relocs = TRUE;

             /* If this relocation section applies to a read only
               section, then we probably need a DT_TEXTREL entry.  */
             outname = bfd_get_section_name (output_bfd,
                                         s->output_section);
             target = bfd_get_section_by_name (output_bfd, outname + 5);
             if (target != NULL
                && (target->flags & SEC_READONLY) != 0
                && (target->flags & SEC_ALLOC) != 0)
              reltext = TRUE;

             /* We use the reloc_count field as a counter if we need
               to copy relocs into the output file.  */
             s->reloc_count = 0;
           }
       }
      else if (strcmp (name, ".got") != 0
              && strcmp (name, ".sdata") != 0
              && strcmp (name, ".sdata2") != 0
              && strcmp (name, ".dynbss") != 0
              && strcmp (name, ".dynsbss") != 0)
       {
         /* It's not one of our sections, so don't allocate space.  */
         continue;
       }

      if (s->size == 0)
       {
         /* If we don't need this section, strip it from the
            output file.  This is mostly to handle .rela.bss and
            .rela.plt.  We must create both sections in
            create_dynamic_sections, because they must be created
            before the linker maps input sections to output
            sections.  The linker does that before
            adjust_dynamic_symbol is called, and it is that
            function which decides whether anything needs to go
            into these sections.  */
         s->flags |= SEC_EXCLUDE;
         continue;
       }

      if ((s->flags & SEC_HAS_CONTENTS) == 0)
       continue;

      /* Allocate memory for the section contents.  */
      s->contents = bfd_zalloc (dynobj, s->size);
      if (s->contents == NULL)
       return FALSE;
    }

  if (elf_hash_table (info)->dynamic_sections_created)
    {
      /* Add some entries to the .dynamic section.  We fill in the
        values later, in i370_elf_finish_dynamic_sections, but we
        must add the entries now so that we get the correct size for
        the .dynamic section.  The DT_DEBUG entry is filled in by the
        dynamic linker and used by the debugger.  */
#define add_dynamic_entry(TAG, VAL) \
  _bfd_elf_add_dynamic_entry (info, TAG, VAL)

      if (!info->shared)
       {
         if (!add_dynamic_entry (DT_DEBUG, 0))
           return FALSE;
       }

      if (plt)
       {
         if (!add_dynamic_entry (DT_PLTGOT, 0)
             || !add_dynamic_entry (DT_PLTRELSZ, 0)
             || !add_dynamic_entry (DT_PLTREL, DT_RELA)
             || !add_dynamic_entry (DT_JMPREL, 0))
           return FALSE;
       }

      if (relocs)
       {
         if (!add_dynamic_entry (DT_RELA, 0)
             || !add_dynamic_entry (DT_RELASZ, 0)
             || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
           return FALSE;
       }

      if (reltext)
       {
         if (!add_dynamic_entry (DT_TEXTREL, 0))
           return FALSE;
         info->flags |= DF_TEXTREL;
       }
    }
#undef add_dynamic_entry

  /* If we are generating a shared library, we generate a section
     symbol for each output section.  These are local symbols, which
     means that they must come first in the dynamic symbol table.
     That means we must increment the dynamic symbol index of every
     other dynamic symbol.

     FIXME: We assume that there will never be relocations to
     locations in linker-created sections that do not have
     externally-visible names. Instead, we should work out precisely
     which sections relocations are targeted at.  */
  if (info->shared)
    {
      int c;

      for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
       {
         if ((s->flags & SEC_LINKER_CREATED) != 0
             || (s->flags & SEC_ALLOC) == 0)
           {
             elf_section_data (s)->dynindx = -1;
             continue;
           }

         /* These symbols will have no names, so we don't need to
            fiddle with dynstr_index.  */

         elf_section_data (s)->dynindx = c + 1;

         c++;
       }

      elf_link_hash_traverse (elf_hash_table (info),
                           i370_elf_adjust_dynindx, & c);
      elf_hash_table (info)->dynsymcount += c;
    }

  return TRUE;
}

Here is the call graph for this function:

static int i370_noop ( void  ) [static]

Definition at line 1471 of file elf32-i370.c.

{
  return 1;
}

Variable Documentation

reloc_howto_type i370_elf_howto_raw[] [static]

Definition at line 39 of file elf32-i370.c.

reloc_howto_type* i370_elf_howto_table[(int) R_I370_max] [static]

Definition at line 37 of file elf32-i370.c.