This is the mail archive of the binutils@sources.redhat.com mailing list for the binutils project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Fix objdump -d on ppc64 without dot syms


Hi!

This patch synthetizes the function symbols from opd.
Ok to commit?

2004-08-13  Jakub Jelinek  <jakub@redhat.com>

	* elfxx-target.h (bfd_elfNN_get_synthetic_symtab): Only define
	if not yet defined.
	* elf64-ppc.c (bfd_elf64_get_synthetic_symtab): Define.
	(synthetic_opd, synthetic_relocatable): New variables.
	(compare_symbols, compare_relocs): New helper routines.
	(ppc64_elf_get_synthetic_symtab): New function.

--- bfd/elfxx-target.h.jj	2004-08-09 10:51:28.000000000 +0200
+++ bfd/elfxx-target.h	2004-08-13 13:55:48.000000000 +0200
@@ -34,8 +34,10 @@
 
 #define bfd_elfNN_canonicalize_dynamic_symtab \
   _bfd_elf_canonicalize_dynamic_symtab
+#ifndef bfd_elfNN_get_synthetic_symtab
 #define bfd_elfNN_get_synthetic_symtab \
   _bfd_elf_get_synthetic_symtab
+#endif
 #ifndef bfd_elfNN_canonicalize_reloc
 #define bfd_elfNN_canonicalize_reloc	_bfd_elf_canonicalize_reloc
 #endif
--- bfd/elf64-ppc.c.jj	2004-08-13 14:15:37.000000000 +0200
+++ bfd/elf64-ppc.c	2004-08-13 19:26:36.657230756 +0200
@@ -76,6 +76,7 @@ static bfd_reloc_status_type ppc64_elf_u
 #define bfd_elf64_new_section_hook	      ppc64_elf_new_section_hook
 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
+#define bfd_elf64_get_synthetic_symtab	      ppc64_elf_get_synthetic_symtab
 
 #define elf_backend_object_p		      ppc64_elf_object_p
 #define elf_backend_grok_prstatus	      ppc64_elf_grok_prstatus
@@ -9501,4 +9502,370 @@ ppc64_elf_finish_dynamic_sections (bfd *
   return TRUE;
 }
 
+/* Parameters for the qsort hook.  */
+static asection *synthetic_opd;
+static bfd_boolean synthetic_relocatable;
+
+/* Helper routine for ppc64_elf_get_synthetic_symtab.  */
+
+/* Sort symbols into value order.  */
+
+static int
+compare_symbols (const void *ap, const void *bp)
+{
+  const asymbol *a = * (const asymbol **) ap;
+  const asymbol *b = * (const asymbol **) bp;
+
+  if ((a->flags & BSF_SECTION_SYM) == 0 && (b->flags & BSF_SECTION_SYM))
+    return -1;
+  if ((a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM) == 0)
+    return 1;
+
+  if (a->section == synthetic_opd && b->section != synthetic_opd)
+    return -1;
+  if (a->section != synthetic_opd && b->section == synthetic_opd)
+    return 1;
+
+  if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
+      == (SEC_CODE | SEC_ALLOC)
+      && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
+	 != (SEC_CODE | SEC_ALLOC))
+    return -1;
+
+  if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
+      != (SEC_CODE | SEC_ALLOC)
+      && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
+	 == (SEC_CODE | SEC_ALLOC))
+    return 1;
+
+  if (synthetic_relocatable)
+    {
+      if (a->section->id < b->section->id)
+	return -1;
+
+      if (a->section->id > b->section->id)
+	return 1;
+    }
+
+  if (a->value + a->section->vma < b->value + b->section->vma)
+    return -1;
+
+  if (a->value + a->section->vma > b->value + b->section->vma)
+    return 1;
+
+  return 0;
+}
+
+static int
+compare_relocs (const void *ap, const void *bp)
+{
+  const arelent *a = * (const arelent **) ap;
+  const arelent *b = * (const arelent **) bp;
+
+  if (a->address < b->address)
+    return -1;
+
+  if (a->address > b->address)
+    return 1;
+
+  return 0;
+}
+
+/* Create synthetic symbols.  */
+
+static long
+ppc64_elf_get_synthetic_symtab (bfd *abfd, asymbol **dynsyms, asymbol **ret)
+{
+  asymbol *s;
+  bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
+  arelent **relocs, **r;
+  long count, i;
+  size_t size;
+  char *names;
+  asymbol **syms = NULL;
+  long symcount = 0, opdsymcount, relcount;
+  asection *relopd, *opd;
+
+  *ret = NULL;
+
+  opd = bfd_get_section_by_name (abfd, ".opd");
+  if (opd == NULL)
+    return 0;
+
+  if ((bfd_get_file_flags (abfd) & HAS_SYMS))
+    {
+      long storage;
+      storage = bfd_get_symtab_upper_bound (abfd);
+      if (storage < 0)
+	return 0;
+
+      if (storage)
+	{
+	  syms = bfd_malloc (storage);
+	  if (syms == NULL)
+	    return 0;
+	}
+
+      symcount = bfd_canonicalize_symtab (abfd, syms);
+      if (symcount < 0)
+	{
+	  free (syms);
+	  return 0;
+	}
+
+      if (symcount == 0)
+        {
+          free (syms);
+          syms = NULL;
+        }
+    }
+
+  if (symcount == 0)
+    {
+      long storage;
+
+      storage = bfd_get_dynamic_symtab_upper_bound (abfd);
+      if (storage < 0)
+	return 0;
+
+      if (storage)
+	{
+	  syms = bfd_malloc (storage);
+	  if (syms == NULL)
+	    return 0;
+	}
+
+      symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
+      if (symcount < 0)
+	{
+	  free (syms);
+	  return 0;
+	}
+    }
+
+  synthetic_opd = opd;
+  synthetic_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
+  qsort (syms, symcount, sizeof (asymbol *), compare_symbols);
+
+  opdsymcount = symcount;
+  for (i = 0; i < symcount; ++i)
+    {
+      if (syms[i]->flags & BSF_SECTION_SYM)
+	{
+	  if (opdsymcount == symcount)
+	    opdsymcount = i;
+	  symcount = i;
+	  break;
+	}
+
+      if (syms[i]->section == opd)
+	continue;
+
+      if (opdsymcount == symcount)
+        opdsymcount = i;
+
+      if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
+	  != (SEC_CODE | SEC_ALLOC))
+	{
+	  symcount = i;
+	  break;
+	}
+    }
+
+  if (opdsymcount == 0)
+    {
+      free (syms);
+      return 0;
+    }
+
+  relopd = bfd_get_section_by_name (abfd, ".rela.opd");
+  if (relopd == NULL)
+    {
+      relopd = bfd_get_section_by_name (abfd, ".rela.dyn");
+      if (relopd == NULL)
+	{
+	  if (syms)
+	    free (syms);
+	  return 0;
+	}
+    }
+
+  relcount = relopd->size / 24;
+  slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
+  if (! (*slurp_relocs) (abfd, relopd, dynsyms, TRUE))
+    {
+      free (syms);
+      return 0;
+    }
+
+  relocs = bfd_malloc (relcount * sizeof (arelent **));
+  if (relocs == NULL)
+    {
+      free (syms);
+      return 0;
+    }
+
+  for (i = 0; i < relcount; ++i)
+    relocs[i] = &relopd->relocation[i];
+
+  qsort (relocs, relcount, sizeof (*relocs), compare_relocs);
+
+  size = 0;
+  count = 0;
+  for (i = 0, r = relocs; i < opdsymcount; ++i)
+    {
+      long lo, hi, mid;
+      asymbol *sym;
+
+      while (r < relocs + relcount
+	     && (*r)->address < syms[i]->value + opd->vma)
+	++r;
+
+      if (r == relocs + relcount)
+	continue;
+
+      if ((*r)->address != syms[i]->value + opd->vma)
+	continue;
+
+      if ((*r)->howto->type != ((abfd->flags & (EXEC_P | DYNAMIC))
+			        ? R_PPC64_RELATIVE : R_PPC64_ADDR64))
+	continue;
+
+      lo = opdsymcount;
+      hi = symcount;
+      sym = *((*r)->sym_ptr_ptr);
+      if (abfd->flags & (EXEC_P | DYNAMIC))
+	while (lo < hi)
+	  {
+	    mid = (lo + hi) >> 1;
+	    if (syms[mid]->section->id < sym->section->id)
+	      lo = mid + 1;
+	    else if (syms[mid]->section->id > sym->section->id)
+	      hi = mid;
+	    else if (syms[mid]->value < sym->value + (*r)->addend)
+	      lo = mid + 1;
+	    else if (syms[mid]->value > sym->value + (*r)->addend)
+	      hi = mid;
+	    else
+	      break;
+	  }
+      else
+	while (lo < hi)
+	  {
+	    mid = (lo + hi) >> 1;
+	    if (syms[mid]->value + syms[mid]->section->vma < (*r)->addend)
+	      lo = mid + 1;
+	    else if (syms[mid]->value + syms[mid]->section->vma > (*r)->addend)
+	      hi = mid;
+	    else
+	      break;
+	  }
+
+      if (lo >= hi)
+	{
+	  ++count;
+	  size += sizeof (asymbol);
+	  size += strlen (syms[i]->name) + 1;
+	}
+    }
+
+  s = *ret = bfd_malloc (size);
+  if (s == NULL)
+    {
+      free (syms);
+      free (relocs);
+      return 0;
+    }
+
+  names = (char *) (s + count);
+
+  for (i = 0, r = relocs; i < opdsymcount; ++i)
+    {
+      long lo, hi, mid;
+      asymbol *sym;
+
+      while (r < relocs + relcount
+	     && (*r)->address < syms[i]->value + opd->vma)
+	++r;
+
+      if (r == relocs + relcount)
+	continue;
+
+      if ((*r)->address != syms[i]->value + opd->vma)
+	continue;
+
+      if ((*r)->howto->type != ((abfd->flags & (EXEC_P | DYNAMIC))
+			        ? R_PPC64_RELATIVE : R_PPC64_ADDR64))
+	continue;
+
+      lo = opdsymcount;
+      hi = symcount;
+      sym = *((*r)->sym_ptr_ptr);
+      if (abfd->flags & (EXEC_P | DYNAMIC))
+	while (lo < hi)
+	  {
+	    mid = (lo + hi) >> 1;
+	    if (syms[mid]->section->id < sym->section->id)
+	      lo = mid + 1;
+	    else if (syms[mid]->section->id > sym->section->id)
+	      hi = mid;
+	    else if (syms[mid]->value < sym->value + (*r)->addend)
+	      lo = mid + 1;
+	    else if (syms[mid]->value > sym->value + (*r)->addend)
+	      hi = mid;
+	    else
+	      break;
+	  }
+      else
+	while (lo < hi)
+	  {
+	    mid = (lo + hi) >> 1;
+	    if (syms[mid]->value + syms[mid]->section->vma < (*r)->addend)
+	      lo = mid + 1;
+	    else if (syms[mid]->value + syms[mid]->section->vma > (*r)->addend)
+	      hi = mid;
+	    else
+	      break;
+	  }
+
+      if (lo >= hi)
+	{
+	  size_t len;
+
+	  *s = *syms[i];
+	  
+	  if (abfd->flags & (EXEC_P | DYNAMIC))
+	    {
+	      asection *sec;
+
+	      s->section = &bfd_abs_section;
+	      for (sec = abfd->sections; sec; sec = sec->next)
+		if ((sec->flags & (SEC_ALLOC | SEC_CODE))
+		    == (SEC_ALLOC | SEC_CODE)
+		    && (*r)->addend >= sec->vma
+		    && (*r)->addend < sec->vma + sec->size)
+		  {
+		    s->section = sec;
+		    break;
+		  }
+	      s->value = (*r)->addend - sec->vma;
+	    }
+	  else
+	    {
+	      s->section = sym->section;
+	      s->value = sym->value + (*r)->addend;
+	    }
+	  s->name = names;
+	  len = strlen (syms[i]->name);
+	  memcpy (names, syms[i]->name, len + 1);
+	  names += len + 1;
+	  s++;
+	}
+    }
+
+  free (syms);
+  free (relocs);
+  return count;
+}
+
 #include "elf64-target.h"

	Jakub


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]