src/

2007-10-04  Roland McGrath  <roland@redhat.com>

	* readelf.c (print_archive_index): New variable.
	(options, parse_opt): Accept -c/--archive-index to set it.
	(dump_archive_index): New function.
	(process_file): Take new arg WILL_PRINT_ARCHIVE_INDEX.
	Call dump_archive_index on archives if set.
	(main): Update caller.
	(any_control_option): Give it file scope, moved out of ...
	(parse_opt): ... here.

tests/
2007-10-04  Roland McGrath  <roland@redhat.com>

	* run-readelf-test4.sh: New file.
	* Makefile.am (TESTS, EXTRA_DIST): Add it.

1 files changed, 227 insertions, 5 deletions

diff --git a/libdwfl/dwfl_module_getdwarf.c b/libdwfl/dwfl_module_getdwarf.c
index c0aeadd1..90c77c86 100644
--- a/libdwfl/dwfl_module_getdwarf.c
+++ b/libdwfl/dwfl_module_getdwarf.c
@@ -113,6 +113,15 @@ find_file (Dwfl_Module *mod)
 						    &mod->main.name,
 						    &mod->main.elf);
   mod->elferr = open_elf (mod, &mod->main);
+
+  if (mod->elferr == DWFL_E_NOERROR && !mod->main.valid)
+    {
+      /* Clear any explicitly reported build ID, just in case it was wrong.
+	 We'll fetch it from the file when asked.  */
+      if (mod->build_id_len > 0)
+	free (mod->build_id_bits);
+      mod->build_id_len = 0;
+    }
 }
 
 /* Search an ELF file for a ".gnu_debuglink" section.  */
@@ -237,6 +246,214 @@ load_symtab (struct dwfl_file *file, struct dwfl_file **symfile,
   return DWFL_E_NO_SYMTAB;
 }
 
+
+/* Translate addresses into file offsets.
+   OFFS[*] start out zero and remain zero if unresolved.  */
+static void
+find_offsets (Elf *elf, const GElf_Ehdr *ehdr, size_t n,
+	      GElf_Addr addrs[n], GElf_Off offs[n])
+{
+  size_t unsolved = n;
+  for (uint_fast16_t i = 0; i < ehdr->e_phnum; ++i)
+    {
+      GElf_Phdr phdr_mem;
+      GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
+      if (phdr != NULL && phdr->p_type == PT_LOAD && phdr->p_memsz > 0)
+	for (size_t j = 0; j < n; ++j)
+	  if (offs[j] == 0
+	      && addrs[j] >= phdr->p_vaddr
+	      && addrs[j] - phdr->p_vaddr < phdr->p_filesz)
+	    {
+	      offs[j] = addrs[j] - phdr->p_vaddr + phdr->p_offset;
+	      if (--unsolved == 0)
+		break;
+	    }
+    }
+}
+
+/* Try to find a dynamic symbol table via phdrs.  */
+static void
+find_dynsym (Dwfl_Module *mod)
+{
+  GElf_Ehdr ehdr_mem;
+  GElf_Ehdr *ehdr = gelf_getehdr (mod->main.elf, &ehdr_mem);
+
+  for (uint_fast16_t i = 0; i < ehdr->e_phnum; ++i)
+    {
+      GElf_Phdr phdr_mem;
+      GElf_Phdr *phdr = gelf_getphdr (mod->main.elf, i, &phdr_mem);
+      if (phdr == NULL)
+	break;
+
+      if (phdr->p_type == PT_DYNAMIC)
+	{
+	  /* Examine the dynamic section for the pointers we need.  */
+
+	  Elf_Data *data = elf_getdata_rawchunk (mod->main.elf,
+						 phdr->p_offset, phdr->p_filesz,
+						 ELF_T_DYN);
+	  if (data == NULL)
+	    continue;
+
+	  enum
+	    {
+	      i_symtab,
+	      i_strtab,
+	      i_hash,
+	      i_gnu_hash,
+	      i_max
+	    };
+	  GElf_Addr addrs[i_max] = { 0, };
+	  GElf_Xword strsz = 0;
+	  size_t n = data->d_size / gelf_fsize (mod->main.elf,
+						ELF_T_DYN, 1, EV_CURRENT);
+	  for (size_t j = 0; j < n; ++j)
+	    {
+	      GElf_Dyn dyn_mem;
+	      GElf_Dyn *dyn = gelf_getdyn (data, j, &dyn_mem);
+	      if (dyn != NULL)
+		switch (dyn->d_tag)
+		  {
+		  case DT_SYMTAB:
+		    addrs[i_symtab] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_HASH:
+		    addrs[i_hash] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_GNU_HASH:
+		    addrs[i_gnu_hash] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_STRTAB:
+		    addrs[i_strtab] = dyn->d_un.d_ptr;
+		    continue;
+
+		  case DT_STRSZ:
+		    strsz = dyn->d_un.d_val;
+		    continue;
+
+		  default:
+		    continue;
+
+		  case DT_NULL:
+		    break;
+		  }
+	      break;
+	    }
+
+	  /* Translate pointers into file offsets.  */
+	  GElf_Off offs[i_max] = { 0, };
+	  find_offsets (mod->main.elf, ehdr, i_max, addrs, offs);
+
+	  /* Figure out the size of the symbol table.  */
+	  if (offs[i_hash] != 0)
+	    {
+	      /* In the original format, .hash says the size of .dynsym.  */
+
+	      size_t entsz = SH_ENTSIZE_HASH (ehdr);
+	      data = elf_getdata_rawchunk (mod->main.elf,
+					   offs[i_hash] + entsz, entsz,
+					   entsz == 4 ? ELF_T_WORD
+					   : ELF_T_XWORD);
+	      if (data != NULL)
+		mod->syments = (entsz == 4
+				? *(const GElf_Word *) data->d_buf
+				: *(const GElf_Xword *) data->d_buf);
+	    }
+	  if (offs[i_gnu_hash] != 0 && mod->syments == 0)
+	    {
+	      /* In the new format, we can derive it with some work.  */
+
+	      const struct
+	      {
+		Elf32_Word nbuckets;
+		Elf32_Word symndx;
+		Elf32_Word maskwords;
+		Elf32_Word shift2;
+	      } *header;
+
+	      data = elf_getdata_rawchunk (mod->main.elf, offs[i_gnu_hash],
+					   sizeof *header, ELF_T_WORD);
+	      if (data != NULL)
+		{
+		  header = data->d_buf;
+		  Elf32_Word nbuckets = header->nbuckets;
+		  Elf32_Word symndx = header->symndx;
+		  GElf_Off buckets_at = (offs[i_gnu_hash] + sizeof *header
+					 + (gelf_getclass (mod->main.elf)
+					    * sizeof (Elf32_Word)
+					    * header->maskwords));
+
+		  data = elf_getdata_rawchunk (mod->main.elf, buckets_at,
+					       nbuckets * sizeof (Elf32_Word),
+					       ELF_T_WORD);
+		  if (data != NULL && symndx < nbuckets)
+		    {
+		      const Elf32_Word *const buckets = data->d_buf;
+		      Elf32_Word maxndx = symndx;
+		      for (Elf32_Word bucket = 0; bucket < nbuckets; ++bucket)
+			if (buckets[bucket] > maxndx)
+			  maxndx = buckets[bucket];
+
+		      GElf_Off hasharr_at = (buckets_at
+					     + nbuckets * sizeof (Elf32_Word));
+		      hasharr_at += (maxndx - symndx) * sizeof (Elf32_Word);
+		      do
+			{
+			  data = elf_getdata_rawchunk (mod->main.elf,
+						       hasharr_at,
+						       sizeof (Elf32_Word),
+						       ELF_T_WORD);
+			  if (data != NULL
+			      && (*(const Elf32_Word *) data->d_buf & 1u))
+			    {
+			      mod->syments = maxndx + 1;
+			      break;
+			    }
+			  ++maxndx;
+			  hasharr_at += sizeof (Elf32_Word);
+			} while (data != NULL);
+		    }
+		}
+	    }
+	  if (offs[i_strtab] > offs[i_symtab] && mod->syments == 0)
+	    mod->syments = ((offs[i_strtab] - offs[i_symtab])
+			    / gelf_fsize (mod->main.elf,
+					  ELF_T_SYM, 1, EV_CURRENT));
+
+	  if (mod->syments > 0)
+	    {
+	      mod->symdata = elf_getdata_rawchunk (mod->main.elf,
+						   offs[i_symtab],
+						   gelf_fsize (mod->main.elf,
+							       ELF_T_SYM,
+							       mod->syments,
+							       EV_CURRENT),
+						   ELF_T_SYM);
+	      if (mod->symdata != NULL)
+		{
+		  mod->symstrdata = elf_getdata_rawchunk (mod->main.elf,
+							  offs[i_strtab],
+							  strsz,
+							  ELF_T_BYTE);
+		  if (mod->symstrdata == NULL)
+		    mod->symdata = NULL;
+		}
+	      if (mod->symdata == NULL)
+		mod->symerr = DWFL_E (LIBELF, elf_errno ());
+	      else
+		{
+		  mod->symfile = &mod->main;
+		  mod->symerr = DWFL_E_NOERROR;
+		}
+	      return;
+	    }
+	}
+    }
+}
+
 /* Try to find a symbol table in either MOD->main.elf or MOD->debug.elf.  */
 static void
 find_symtab (Dwfl_Module *mod)
@@ -290,11 +507,16 @@ find_symtab (Dwfl_Module *mod)
 	  break;
 
 	case DWFL_E_NO_SYMTAB:
-	  if (symscn == NULL)
-	    return;
-	  /* We still have the dynamic symbol table.  */
-	  mod->symerr = DWFL_E_NOERROR;
-	  break;
+	  if (symscn != NULL)
+	    {
+	      /* We still have the dynamic symbol table.  */
+	      mod->symerr = DWFL_E_NOERROR;
+	      break;
+	    }
+
+	  /* Last ditch, look for dynamic symbols without section headers.  */
+	  find_dynsym (mod);
+	  return;
 	}
       break;
     }