]> Git Repo - binutils.git/blobdiff - bfd/elf.c
Make ld -N more reasonable for ELF:
[binutils.git] / bfd / elf.c
index eab15b009b3bd3aac06471c239ca7ef0cac05557..6a27ba56dd743bf63c322c8542ae0c48514e884d 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -583,6 +583,8 @@ _bfd_elf_link_hash_table_init (table, abfd, newfunc)
   table->dynstr = NULL;
   table->bucketcount = 0;
   table->needed = NULL;
+  table->hgot = NULL;
+  table->stab_info = NULL;
   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
 }
 
@@ -799,7 +801,6 @@ bfd_section_from_shdr (abfd, shindex)
       {
        asection *target_sect;
        Elf_Internal_Shdr *hdr2;
-       int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
 
        /* For some incomprehensible reason Oracle distributes
           libraries for Solaris in which some of the objects have
@@ -844,30 +845,24 @@ bfd_section_from_shdr (abfd, shindex)
        if (hdr->sh_link != elf_onesymtab (abfd))
          return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 
-       /* Don't allow REL relocations on a machine that uses RELA and
-          vice versa.  */
-       /* @@ Actually, the generic ABI does suggest that both might be
-          used in one file.  But the four ABI Processor Supplements I
-          have access to right now all specify that only one is used on
-          each of those architectures.  It's conceivable that, e.g., a
-          bunch of absolute 32-bit relocs might be more compact in REL
-          form even on a RELA machine...  */
-       BFD_ASSERT (use_rela_p
-                   ? (hdr->sh_type == SHT_RELA
-                      && hdr->sh_entsize == bed->s->sizeof_rela)
-                   : (hdr->sh_type == SHT_REL
-                      && hdr->sh_entsize == bed->s->sizeof_rel));
-
        if (! bfd_section_from_shdr (abfd, hdr->sh_info))
          return false;
        target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
        if (target_sect == NULL)
          return false;
 
-       hdr2 = &elf_section_data (target_sect)->rel_hdr;
+       if ((target_sect->flags & SEC_RELOC) == 0
+           || target_sect->reloc_count == 0)
+         hdr2 = &elf_section_data (target_sect)->rel_hdr;
+       else
+         {
+           BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
+           hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
+           elf_section_data (target_sect)->rel_hdr2 = hdr2;
+         }
        *hdr2 = *hdr;
        elf_elfsections (abfd)[shindex] = hdr2;
-       target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
+       target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
        target_sect->flags |= SEC_RELOC;
        target_sect->relocation = NULL;
        target_sect->rel_filepos = hdr->sh_offset;
@@ -1044,7 +1039,8 @@ elf_fake_sections (abfd, asect, failedptrarg)
 
   this_hdr->sh_flags = 0;
 
-  if ((asect->flags & SEC_ALLOC) != 0)
+  if ((asect->flags & SEC_ALLOC) != 0
+      || asect->user_set_vma)
     this_hdr->sh_addr = asect->vma;
   else
     this_hdr->sh_addr = 0;
@@ -1739,12 +1735,21 @@ map_sections_to_segments (abfd)
       && (dynsec->flags & SEC_LOAD) == 0)
     dynsec = NULL;
 
-  /* Deal with -Ttext or something similar such that the
-     first section is not adjacent to the program headers.  */
-  if (count
-      && ((sections[0]->lma % maxpagesize) <
-         (elf_tdata (abfd)->program_header_size % maxpagesize)))
-    phdr_in_section = false;
+  /* Deal with -Ttext or something similar such that the first section
+     is not adjacent to the program headers.  This is an
+     approximation, since at this point we don't know exactly how many
+     program headers we will need.  */
+  if (count > 0)
+    {
+      bfd_size_type phdr_size;
+
+      phdr_size = elf_tdata (abfd)->program_header_size;
+      if (phdr_size == 0)
+       phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
+      if ((abfd->flags & D_PAGED) == 0
+         || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
+       phdr_in_section = false;
+    }
 
   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
     {
@@ -1755,19 +1760,26 @@ map_sections_to_segments (abfd)
       /* See if this section and the last one will fit in the same
          segment.  Don't put a loadable section after a non-loadable
          section.  If we are building a dynamic executable, don't put
-         a writable section in a read only segment (we don't do this
-         for a non-dynamic executable because some people prefer to
-         have only one program segment; anybody can use PHDRS in their
-         linker script to control what happens anyhow).  */
+         a writable section in a read only segment, unless they're on
+         the same page anyhow (we don't do this for a non-dynamic
+         executable because some people prefer to have only one
+         program segment; anybody can use PHDRS in their linker script
+         to control what happens anyhow).  */
       if (last_hdr == NULL
+         || (abfd->flags & D_PAGED) == 0
          || ((BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
               >= hdr->lma)
              && ((last_hdr->flags & SEC_LOAD) != 0
                  || (hdr->flags & SEC_LOAD) == 0)
              && (dynsec == NULL
                  || writable
-                 || (hdr->flags & SEC_READONLY) != 0)))
+                 || (hdr->flags & SEC_READONLY) != 0
+                 || (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size,
+                                maxpagesize)
+                     > hdr->lma))))
        {
+         if ((hdr->flags & SEC_READONLY) == 0)
+           writable = true;
          last_hdr = hdr;
          continue;
        }
@@ -1785,6 +1797,8 @@ map_sections_to_segments (abfd)
 
       if ((hdr->flags & SEC_READONLY) == 0)
        writable = true;
+      else
+       writable = false;
 
       last_hdr = hdr;
       phdr_index = i;
@@ -1845,6 +1859,13 @@ elf_sort_sections (arg1, arg2)
   else if (sec1->vma > sec2->vma)
     return 1;
 
+  /* Sort by LMA.  Normally the LMA and the VMA will be the same, and
+     this will do nothing.  */
+  if (sec1->lma < sec2->lma)
+    return -1;
+  else if (sec1->lma > sec2->lma)
+    return 1;
+
   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
 
 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
@@ -1884,7 +1905,7 @@ assign_file_positions_for_segments (abfd)
   struct elf_segment_map *m;
   unsigned int alloc;
   Elf_Internal_Phdr *phdrs;
-  file_ptr off;
+  file_ptr off, voff;
   bfd_vma filehdr_vaddr, filehdr_paddr;
   bfd_vma phdrs_vaddr, phdrs_paddr;
   Elf_Internal_Phdr *p;
@@ -1963,7 +1984,13 @@ assign_file_positions_for_segments (abfd)
       if (p->p_type == PT_LOAD
          && m->count > 0
          && (m->sections[0]->flags & SEC_LOAD) != 0)
-       off += (m->sections[0]->vma - off) % bed->maxpagesize;
+       {
+         if ((abfd->flags & D_PAGED) != 0)
+           off += (m->sections[0]->vma - off) % bed->maxpagesize;
+         else
+           off += ((m->sections[0]->vma - off)
+                   % (1 << bfd_get_section_alignment (abfd, m->sections[0])));
+       }
 
       if (m->count == 0)
        p->p_vaddr = 0;
@@ -1977,7 +2004,8 @@ assign_file_positions_for_segments (abfd)
       else
        p->p_paddr = m->sections[0]->lma;
 
-      if (p->p_type == PT_LOAD)
+      if (p->p_type == PT_LOAD
+         && (abfd->flags & D_PAGED) != 0)
        p->p_align = bed->maxpagesize;
       else if (m->count == 0)
        p->p_align = bed->s->file_align;
@@ -2055,6 +2083,7 @@ assign_file_positions_for_segments (abfd)
            }
        }
 
+      voff = off;
       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
        {
          asection *sec;
@@ -2063,6 +2092,7 @@ assign_file_positions_for_segments (abfd)
 
          sec = *secpp;
          flags = sec->flags;
+         align = 1 << bfd_get_section_alignment (abfd, sec);
 
          if (p->p_type == PT_LOAD)
            {
@@ -2070,17 +2100,21 @@ assign_file_positions_for_segments (abfd)
 
              /* The section VMA must equal the file position modulo
                  the page size.  */
-             if ((flags & SEC_LOAD) != 0)
+             if ((flags & SEC_ALLOC) != 0)
                {
-                 adjust = (sec->vma - off) % bed->maxpagesize;
+                 if ((abfd->flags & D_PAGED) != 0)
+                   adjust = (sec->vma - voff) % bed->maxpagesize;
+                 else
+                   adjust = (sec->vma - voff) % align;
                  if (adjust != 0)
                    {
                      if (i == 0)
                        abort ();
                      p->p_memsz += adjust;
+                     off += adjust;
+                     voff += adjust;
                      if ((flags & SEC_LOAD) != 0)
                        p->p_filesz += adjust;
-                     off += adjust;
                    }
                }
 
@@ -2088,6 +2122,8 @@ assign_file_positions_for_segments (abfd)
 
              if ((flags & SEC_LOAD) != 0)
                off += sec->_raw_size;
+             if ((flags & SEC_ALLOC) != 0)
+               voff += sec->_raw_size;
            }
 
          p->p_memsz += sec->_raw_size;
@@ -2095,7 +2131,6 @@ assign_file_positions_for_segments (abfd)
          if ((flags & SEC_LOAD) != 0)
            p->p_filesz += sec->_raw_size;
 
-         align = 1 << bfd_get_section_alignment (abfd, sec);
          if (align > p->p_align)
            p->p_align = align;
 
@@ -2307,7 +2342,10 @@ assign_file_positions_except_relocs (abfd)
                (hdr->bfd_section == NULL
                 ? "*unknown*"
                 : hdr->bfd_section->name)));
-             off += (hdr->sh_addr - off) % bed->maxpagesize;
+             if ((abfd->flags & D_PAGED) != 0)
+               off += (hdr->sh_addr - off) % bed->maxpagesize;
+             else
+               off += (hdr->sh_addr - off) % hdr->sh_addralign;
              off = _bfd_elf_assign_file_position_for_section (hdr, off,
                                                               false);
            }
@@ -2403,6 +2441,14 @@ prep_headers (abfd)
     case bfd_arch_powerpc:
       i_ehdrp->e_machine = EM_PPC;
       break;
+    case bfd_arch_alpha:
+      i_ehdrp->e_machine = EM_ALPHA;
+      break;
+/* start-sanitize-d10v */
+    case bfd_arch_d10v:
+      i_ehdrp->e_machine = EM_CYGNUS_D10V;
+      break;
+/* end-sanitize-d10v */
 /* start-sanitize-arc */
     case bfd_arch_arc:
       i_ehdrp->e_machine = EM_CYGNUS_ARC;
@@ -2581,13 +2627,15 @@ _bfd_elf_section_from_bfd_section (abfd, asect)
   return -1;
 }
 
-/* given a symbol, return the bfd index for that symbol.  */
- int
+/* Given a BFD symbol, return the index in the ELF symbol table, or -1
+   on error.  */
+
+int
 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
      bfd *abfd;
-     struct symbol_cache_entry **asym_ptr_ptr;
+     asymbol **asym_ptr_ptr;
 {
-  struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
+  asymbol *asym_ptr = *asym_ptr_ptr;
   int idx;
   flagword flags = asym_ptr->flags;
 
@@ -2611,13 +2659,24 @@ _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
     }
 
   idx = asym_ptr->udata.i;
-  BFD_ASSERT (idx != 0);
+
+  if (idx == 0)
+    {
+      /* This case can occur when using --strip-symbol on a symbol
+         which is used in a relocation entry.  */
+      (*_bfd_error_handler)
+       ("%s: symbol `%s' required but not present",
+        bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
+      bfd_set_error (bfd_error_no_symbols);
+      return -1;
+    }
 
 #if DEBUG & 4
   {
     fprintf (stderr,
             "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
-     (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
+            (long) asym_ptr, asym_ptr->name, idx, flags,
+            elf_symbol_flags (flags));
     fflush (stderr);
   }
 #endif
@@ -3308,3 +3367,101 @@ _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
   abort ();
 }
 #endif
+
+/* Try to convert a non-ELF reloc into an ELF one.  */
+
+boolean
+_bfd_elf_validate_reloc (abfd, areloc)
+     bfd *abfd;
+     arelent *areloc;
+{
+  /* Check whether we really have an ELF howto. */
+
+  if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 
+    {
+      bfd_reloc_code_real_type code;
+      reloc_howto_type *howto;
+      
+      /* Alien reloc: Try to determine its type to replace it with an
+        equivalent ELF reloc. */
+
+      if (areloc->howto->pc_relative)
+       {
+         switch (areloc->howto->bitsize)
+           {
+           case 8:
+             code = BFD_RELOC_8_PCREL; 
+             break;
+           case 12:
+             code = BFD_RELOC_12_PCREL; 
+             break;
+           case 16:
+             code = BFD_RELOC_16_PCREL; 
+             break;
+           case 24:
+             code = BFD_RELOC_24_PCREL; 
+             break;
+           case 32:
+             code = BFD_RELOC_32_PCREL; 
+             break;
+           case 64:
+             code = BFD_RELOC_64_PCREL; 
+             break;
+           default:
+             goto fail;
+           }
+
+         howto = bfd_reloc_type_lookup (abfd, code);
+
+         if (areloc->howto->pcrel_offset != howto->pcrel_offset)
+           {
+             if (howto->pcrel_offset)
+               areloc->addend += areloc->address;
+             else
+               areloc->addend -= areloc->address; /* addend is unsigned!! */
+           }
+       }
+      else
+       {
+         switch (areloc->howto->bitsize)
+           {
+           case 8:
+             code = BFD_RELOC_8; 
+             break;
+           case 14:
+             code = BFD_RELOC_14; 
+             break;
+           case 16:
+             code = BFD_RELOC_16; 
+             break;
+           case 26:
+             code = BFD_RELOC_26; 
+             break;
+           case 32:
+             code = BFD_RELOC_32; 
+             break;
+           case 64:
+             code = BFD_RELOC_64; 
+             break;
+           default:
+             goto fail;
+           }
+
+         howto = bfd_reloc_type_lookup (abfd, code);
+       }
+
+      if (howto)
+       areloc->howto = howto;
+      else
+       goto fail;
+    }
+
+  return true;
+
+ fail:
+  (*_bfd_error_handler)
+    ("%s: unsupported relocation type %s",
+     bfd_get_filename (abfd), areloc->howto->name);
+  bfd_set_error (bfd_error_bad_value);
+  return false;
+}
This page took 0.033663 seconds and 4 git commands to generate.