* reloc16.c (bfd_coff_reloc16_relax_section): Count the total number

[deliverable/binutils-gdb.git] / bfd / elf.c

diff --git a/bfd/elf.c b/bfd/elf.c
index 997408ce16e5ad12bec7bf3e2f9fb18aee5d9e02..979061716967f7a575510096cde6139a0a121d29 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -1,5 +1,5 @@
 /* ELF executable support for BFD.
 /* ELF executable support for BFD.

-   Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
+   Copyright 1993, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.

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


@@ -53,6 +53,7 @@ static boolean assign_section_numbers PARAMS ((bfd *));
 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
 static boolean elf_map_symbols PARAMS ((bfd *));
 static bfd_size_type get_program_header_size PARAMS ((bfd *));
 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
 static boolean elf_map_symbols PARAMS ((bfd *));
 static bfd_size_type get_program_header_size PARAMS ((bfd *));

+static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));

 
 /* Swap version information in and out.  The version information is
    currently size independent.  If that ever changes, this code will
 
 /* Swap version information in and out.  The version information is
    currently size independent.  If that ever changes, this code will


@@ -760,6 +761,7 @@ bfd_elf_print_symbol (abfd, filep, symbol, how)
        CONST char *section_name;
        CONST char *name = NULL;
        struct elf_backend_data *bed;
        CONST char *section_name;
        CONST char *name = NULL;
        struct elf_backend_data *bed;

+       unsigned char st_other;

        
        section_name = symbol->section ? symbol->section->name : "(*none*)";
 
        
        section_name = symbol->section ? symbol->section->name : "(*none*)";
 


@@ -835,10 +837,19 @@ bfd_elf_print_symbol (abfd, filep, symbol, how)
          }
 
        /* If the st_other field is not zero, print it.  */
          }
 
        /* If the st_other field is not zero, print it.  */

-       if (((elf_symbol_type *) symbol)->internal_elf_sym.st_other != 0)
-         fprintf (file, " 0x%02x",
-                  ((unsigned int)
-                   ((elf_symbol_type *) symbol)->internal_elf_sym.st_other));
+       st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
+       
+       switch (st_other)
+         {
+         case 0: break;
+         case STV_INTERNAL:  fprintf (file, " .internal");  break;
+         case STV_HIDDEN:    fprintf (file, " .hidden");    break;
+         case STV_PROTECTED: fprintf (file, " .protected"); break;
+         default:
+           /* Some other non-defined flags are also present, so print
+              everything hex.  */
+           fprintf (file, " 0x%02x", (unsigned int) st_other);
+         }

 
        fprintf (file, " %s", name);
       }
 
        fprintf (file, " %s", name);
       }


@@ -895,6 +906,58 @@ _bfd_elf_link_hash_newfunc (entry, table, string)
   return (struct bfd_hash_entry *) ret;
 }
 
   return (struct bfd_hash_entry *) ret;
 }
 

+/* Copy data from an indirect symbol to its direct symbol, hiding the
+   old indirect symbol.  */
+
+void
+_bfd_elf_link_hash_copy_indirect (dir, ind)
+     struct elf_link_hash_entry *dir, *ind;
+{
+  /* Copy down any references that we may have already seen to the
+     symbol which just became indirect.  */
+
+  dir->elf_link_hash_flags |=
+    (ind->elf_link_hash_flags
+     & (ELF_LINK_HASH_REF_DYNAMIC
+       | ELF_LINK_HASH_REF_REGULAR
+       | ELF_LINK_HASH_REF_REGULAR_NONWEAK
+       | ELF_LINK_NON_GOT_REF));
+
+  /* Copy over the global and procedure linkage table offset entries.
+     These may have been already set up by a check_relocs routine.  */
+  if (dir->got.offset == (bfd_vma) -1)
+    {
+      dir->got.offset = ind->got.offset;
+      ind->got.offset = (bfd_vma) -1;
+    }
+  BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
+
+  if (dir->plt.offset == (bfd_vma) -1)
+    {
+      dir->plt.offset = ind->plt.offset;
+      ind->plt.offset = (bfd_vma) -1;
+    }
+  BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
+
+  if (dir->dynindx == -1)
+    {
+      dir->dynindx = ind->dynindx;
+      dir->dynstr_index = ind->dynstr_index;
+      ind->dynindx = -1;
+      ind->dynstr_index = 0;
+    }
+  BFD_ASSERT (ind->dynindx == -1);
+}
+
+void
+_bfd_elf_link_hash_hide_symbol(h)
+     struct elf_link_hash_entry *h;
+{
+  h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
+  h->dynindx = -1;
+  h->plt.offset = (bfd_vma) -1;
+}
+

 /* Initialize an ELF linker hash table.  */
 
 boolean
 /* Initialize an ELF linker hash table.  */
 
 boolean


@@ -1387,10 +1450,11 @@ _bfd_elf_new_section_hook (abfd, sec)
  */
 
 boolean
  */
 
 boolean

-bfd_section_from_phdr (abfd, hdr, index)
+_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)

      bfd *abfd;
      Elf_Internal_Phdr *hdr;
      int index;
      bfd *abfd;
      Elf_Internal_Phdr *hdr;
      int index;

+     const char *typename;

 {
   asection *newsect;
   char *name;
 {
   asection *newsect;
   char *name;


@@ -1400,7 +1464,7 @@ bfd_section_from_phdr (abfd, hdr, index)
   split = ((hdr->p_memsz > 0)
            && (hdr->p_filesz > 0)
            && (hdr->p_memsz > hdr->p_filesz));
   split = ((hdr->p_memsz > 0)
            && (hdr->p_filesz > 0)
            && (hdr->p_memsz > hdr->p_filesz));

-  sprintf (namebuf, split ? "segment%da" : "segment%d", index);
+  sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");

   name = bfd_alloc (abfd, strlen (namebuf) + 1);
   if (!name)
     return false;
   name = bfd_alloc (abfd, strlen (namebuf) + 1);
   if (!name)
     return false;


@@ -1431,7 +1495,7 @@ bfd_section_from_phdr (abfd, hdr, index)
 
   if (split)
     {
 
   if (split)
     {

-      sprintf (namebuf, "segment%db", index);
+      sprintf (namebuf, "%s%db", typename, index);

       name = bfd_alloc (abfd, strlen (namebuf) + 1);
       if (!name)
        return false;
       name = bfd_alloc (abfd, strlen (namebuf) + 1);
       if (!name)
        return false;


@@ -1455,6 +1519,52 @@ bfd_section_from_phdr (abfd, hdr, index)
   return true;
 }
 
   return true;
 }
 

+boolean
+bfd_section_from_phdr (abfd, hdr, index)
+     bfd *abfd;
+     Elf_Internal_Phdr *hdr;
+     int index;
+{
+  struct elf_backend_data *bed;
+
+  switch (hdr->p_type)
+    {
+    case PT_NULL:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
+
+    case PT_LOAD:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
+
+    case PT_DYNAMIC:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
+
+    case PT_INTERP:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
+
+    case PT_NOTE:
+      if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
+       return false;
+      if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
+       return false;
+      return true;
+
+    case PT_SHLIB:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
+
+    case PT_PHDR:
+      return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
+
+    default:
+      /* Check for any processor-specific program segment types.
+         If no handler for them, default to making "segment" sections. */
+      bed = get_elf_backend_data (abfd);
+      if (bed->elf_backend_section_from_phdr)
+       return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
+      else
+       return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
+    }
+}
+

 /* Initialize REL_HDR, the section-header for new section, containing
    relocations against ASECT.  If USE_RELA_P is true, we use RELA
    relocations; otherwise, we use REL relocations.  */
 /* Initialize REL_HDR, the section-header for new section, containing
    relocations against ASECT.  If USE_RELA_P is true, we use RELA
    relocations; otherwise, we use REL relocations.  */


@@ -3121,6 +3231,9 @@ prep_headers (abfd)
       else
        i_ehdrp->e_machine = EM_SPARC;
       break;
       else
        i_ehdrp->e_machine = EM_SPARC;
       break;

+    case bfd_arch_i370:
+      i_ehdrp->e_machine = EM_S370;
+      break;

     case bfd_arch_i386:
       i_ehdrp->e_machine = EM_386;
       break;
     case bfd_arch_i386:
       i_ehdrp->e_machine = EM_386;
       break;


@@ -3185,6 +3298,9 @@ prep_headers (abfd)
     case bfd_arch_mn10300:
       i_ehdrp->e_machine = EM_CYGNUS_MN10300;
       break;
     case bfd_arch_mn10300:
       i_ehdrp->e_machine = EM_CYGNUS_MN10300;
       break;

+    case bfd_arch_pj:
+      i_ehdrp->e_machine = EM_PJ;
+      break;

       /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
     default:
       i_ehdrp->e_machine = EM_NONE;
       /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
     default:
       i_ehdrp->e_machine = EM_NONE;


@@ -4108,7 +4224,8 @@ swap_out_syms (abfd, sttp, relocatable_p)
          type = STT_NOTYPE;
 
         /* Processor-specific types */
          type = STT_NOTYPE;
 
         /* Processor-specific types */

-        if (bed->elf_backend_get_symbol_type)
+        if (type_ptr != NULL
+           && bed->elf_backend_get_symbol_type)

           type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
 
        if (flags & BSF_SECTION_SYM)
           type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
 
        if (flags & BSF_SECTION_SYM)


@@ -4986,28 +5103,33 @@ elfcore_grok_prstatus (abfd, note)
 #endif /* defined (HAVE_PRSTATUS_T) */
 
 
 #endif /* defined (HAVE_PRSTATUS_T) */
 
 

-/* There isn't a consistent prfpregset_t across platforms,
-   but it doesn't matter, because we don't have to pick this
-   data structure apart. */
+/* Create a pseudosection containing the exact contents of NOTE.  This
+   actually creates up to two pseudosections:
+   - For the single-threaded case, a section named NAME, unless
+     such a section already exists.
+   - For the multi-threaded case, a section named "NAME/PID", where
+     PID is elfcore_make_pid (abfd).
+   Both pseudosections have identical contents: the contents of NOTE.  */

 
 static boolean
 
 static boolean

-elfcore_grok_prfpreg (abfd, note)
+elfcore_make_note_pseudosection (abfd, name, note)

      bfd* abfd;
      bfd* abfd;

+     char *name;

      Elf_Internal_Note* note;
 {
   char buf[100];
      Elf_Internal_Note* note;
 {
   char buf[100];

-  char* name;
+  char *threaded_name;

   asection* sect;
 
   asection* sect;
 

-  /* Make a ".reg2/999" section. */
+  /* Build the section name.  */

 
 

-  sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
-  name = bfd_alloc (abfd, strlen (buf) + 1);
-  if (name == NULL)
+  sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
+  threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
+  if (threaded_name == NULL)

     return false;
     return false;

-  strcpy (name, buf);
+  strcpy (threaded_name, buf);

 
 

-  sect = bfd_make_section (abfd, name);
+  sect = bfd_make_section (abfd, threaded_name);

   if (sect == NULL)
     return false;
   sect->_raw_size = note->descsz;
   if (sect == NULL)
     return false;
   sect->_raw_size = note->descsz;


@@ -5015,12 +5137,37 @@ elfcore_grok_prfpreg (abfd, note)
   sect->flags = SEC_HAS_CONTENTS;
   sect->alignment_power = 2;
 
   sect->flags = SEC_HAS_CONTENTS;
   sect->alignment_power = 2;
 

-  if (! elfcore_maybe_make_sect (abfd, ".reg2", sect))
+  if (! elfcore_maybe_make_sect (abfd, name, sect))

     return false;
 
   return true;
 }
 
     return false;
 
   return true;
 }
 

+
+/* There isn't a consistent prfpregset_t across platforms,
+   but it doesn't matter, because we don't have to pick this
+   data structure apart. */
+static boolean
+elfcore_grok_prfpreg (abfd, note)
+     bfd* abfd;
+     Elf_Internal_Note* note;
+{
+  return elfcore_make_note_pseudosection (abfd, ".reg2", note);
+}
+
+
+/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
+   type of 5 (NT_PRXFPREG).  Just include the whole note's contents
+   literally.  */
+static boolean
+elfcore_grok_prxfpreg (abfd, note)
+     bfd* abfd;
+     Elf_Internal_Note* note;
+{
+  return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
+}
+
+

 #if defined (HAVE_PRPSINFO_T)
 # define elfcore_psinfo_t prpsinfo_t
 #endif
 #if defined (HAVE_PRPSINFO_T)
 # define elfcore_psinfo_t prpsinfo_t
 #endif


@@ -5201,7 +5348,83 @@ elfcore_grok_lwpstatus (abfd, note)
 }
 #endif /* defined (HAVE_LWPSTATUS_T) */
 
 }
 #endif /* defined (HAVE_LWPSTATUS_T) */
 

+#if defined (HAVE_WIN32_PSTATUS_T)
+static boolean
+elfcore_grok_win32pstatus (abfd, note)
+     bfd * abfd;
+     Elf_Internal_Note * note;
+{
+  char buf[30];
+  char * name;
+  asection * sect;
+  win32_pstatus_t pstatus;
+
+  if (note->descsz < sizeof (pstatus))
+    return true;
+
+  memcpy (& pstatus, note->descdata, note->descsz);
+  
+  switch (pstatus.data_type) 
+    {
+    case NOTE_INFO_PROCESS:
+      /* FIXME: need to add ->core_command.  */
+      elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
+      elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
+      break ;
+
+    case NOTE_INFO_THREAD:
+      /* Make a ".reg/999" section.  */
+      sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
+      
+      name = bfd_alloc (abfd, strlen (buf) + 1);
+      if (name == NULL)
+        return false;
+      
+      strcpy (name, buf);
+
+      sect = bfd_make_section (abfd, name);
+      if (sect == NULL)
+        return false;
+      
+      sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
+      sect->filepos = note->descpos + offsetof (struct win32_pstatus,
+                                               data.thread_info.thread_context);
+      sect->flags = SEC_HAS_CONTENTS;
+      sect->alignment_power = 2;
+
+      if (pstatus.data.thread_info.is_active_thread)
+       if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
+         return false;
+      break;
+
+    case NOTE_INFO_MODULE:
+      /* Make a ".module/xxxxxxxx" section.  */
+      sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
+      
+      name = bfd_alloc (abfd, strlen (buf) + 1);
+      if (name == NULL)
+       return false;
+      
+      strcpy (name, buf);
+
+      sect = bfd_make_section (abfd, name);
+      
+      if (sect == NULL)
+       return false;
+      
+      sect->_raw_size = note->descsz;
+      sect->filepos = note->descpos;
+      sect->flags = SEC_HAS_CONTENTS;
+      sect->alignment_power = 2;
+      break;
+
+    default:
+      return true;
+    }

 
 

+  return true;
+}
+#endif /* HAVE_WIN32_PSTATUS_T */

 
 static boolean
 elfcore_grok_note (abfd, note)
 
 static boolean
 elfcore_grok_note (abfd, note)


@@ -5231,6 +5454,18 @@ elfcore_grok_note (abfd, note)
     case NT_FPREGSET:          /* FIXME: rename to NT_PRFPREG */
       return elfcore_grok_prfpreg (abfd, note);
 
     case NT_FPREGSET:          /* FIXME: rename to NT_PRFPREG */
       return elfcore_grok_prfpreg (abfd, note);
 

+#if defined (HAVE_WIN32_PSTATUS_T)
+    case NT_WIN32PSTATUS:      
+      return elfcore_grok_win32pstatus (abfd, note);
+#endif
+
+  case NT_PRXFPREG:            /* Linux SSE extension */
+      if (note->namesz == 5
+         && ! strcmp (note->namedata, "LINUX"))
+       return elfcore_grok_prxfpreg (abfd, note);
+      else
+       return true;
+

 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
     case NT_PRPSINFO:
     case NT_PSINFO:
 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
     case NT_PRPSINFO:
     case NT_PSINFO:


@@ -5293,6 +5528,8 @@ elfcore_read_notes (abfd, offset, size)
 }
 
 
 }
 
 

+/* FIXME: This function is now unnecessary.  Callers can just call
+   bfd_section_from_phdr directly.  */

 
 boolean
 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
 
 boolean
 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)


@@ -5303,10 +5540,54 @@ _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
   if (! bfd_section_from_phdr (abfd, phdr, sec_num))
     return false;
 
   if (! bfd_section_from_phdr (abfd, phdr, sec_num))
     return false;
 

-  if (phdr->p_type == PT_NOTE
-      && ! elfcore_read_notes (abfd, phdr->p_offset, phdr->p_filesz))
-    return false;
-

   return true;
 }
 
   return true;
 }
 

+
+\f
+/* Providing external access to the ELF program header table.  */
+
+/* Return an upper bound on the number of bytes required to store a
+   copy of ABFD's program header table entries.  Return -1 if an error
+   occurs; bfd_get_error will return an appropriate code.  */
+long
+bfd_get_elf_phdr_upper_bound (abfd)
+     bfd *abfd;
+{
+  if (abfd->xvec->flavour != bfd_target_elf_flavour)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return -1;
+    }
+
+  return (elf_elfheader (abfd)->e_phnum
+         * sizeof (Elf_Internal_Phdr));
+}
+
+
+/* Copy ABFD's program header table entries to *PHDRS.  The entries
+   will be stored as an array of Elf_Internal_Phdr structures, as
+   defined in include/elf/internal.h.  To find out how large the
+   buffer needs to be, call bfd_get_elf_phdr_upper_bound.
+
+   Return the number of program header table entries read, or -1 if an
+   error occurs; bfd_get_error will return an appropriate code.  */
+int
+bfd_get_elf_phdrs (abfd, phdrs)
+     bfd *abfd;
+     void *phdrs;
+{
+  int num_phdrs;
+
+  if (abfd->xvec->flavour != bfd_target_elf_flavour)
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return -1;
+    }
+
+  num_phdrs = elf_elfheader (abfd)->e_phnum;
+  memcpy (phdrs, elf_tdata (abfd)->phdr, 
+         num_phdrs * sizeof (Elf_Internal_Phdr));
+
+  return num_phdrs;
+}