coregrind/m_debuginfo/readelf.c

/*--------------------------------------------------------------------*/
/*--- Reading of syms & debug info from ELF .so/executable files.  ---*/
/*---                                                    readelf.c ---*/
/*--------------------------------------------------------------------*/

/*
   This file is part of Valgrind, a dynamic binary instrumentation
   framework.

   Copyright (C) 2000-2006 Julian Seward 
      jseward@acm.org

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307, USA.

   The GNU General Public License is contained in the file COPYING.
*/
/*
   Stabs reader greatly improved by Nick Nethercote, Apr 02.
   This module was also extensively hacked on by Jeremy Fitzhardinge
   and Tom Hughes.
*/

#include "pub_core_basics.h"
#include "pub_core_libcbase.h"
#include "pub_core_libcprint.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcfile.h"
#include "pub_core_aspacemgr.h"    /* for mmaping debuginfo files */
#include "pub_core_machine.h"      /* VG_ELF_CLASS */
#include "pub_core_mallocfree.h"
#include "pub_core_options.h"
#include "pub_core_oset.h"
#include "pub_core_tooliface.h"    /* VG_(needs) */
#include "priv_storage.h"
#include "priv_readelf.h"          /* self */
#include "priv_readdwarf.h"        /* 'cos ELF contains DWARF */
#include "priv_readstabs.h"        /* and stabs, if we're unlucky */

/* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
#include <elf.h>
/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */

/*------------------------------------------------------------*/
/*--- 32/64-bit parameterisation                           ---*/
/*------------------------------------------------------------*/

/* For all the ELF macros and types which specify '32' or '64',
   select the correct variant for this platform and give it
   an 'XX' name.  Then use the 'XX' variant consistently in
   the rest of this file. 
*/
#if VG_WORDSIZE == 4
#  define  ElfXX_Ehdr     Elf32_Ehdr
#  define  ElfXX_Shdr     Elf32_Shdr
#  define  ElfXX_Phdr     Elf32_Phdr
#  define  ElfXX_Sym      Elf32_Sym
#  define  ElfXX_Word     Elf32_Word
#  define  ElfXX_Addr     Elf32_Addr
#  define  ElfXX_Dyn      Elf32_Dyn
#  define  ELFXX_ST_BIND  ELF32_ST_BIND
#  define  ELFXX_ST_TYPE  ELF32_ST_TYPE

#elif VG_WORDSIZE == 8
#  define  ElfXX_Ehdr     Elf64_Ehdr
#  define  ElfXX_Shdr     Elf64_Shdr
#  define  ElfXX_Phdr     Elf64_Phdr
#  define  ElfXX_Sym      Elf64_Sym
#  define  ElfXX_Word     Elf64_Word
#  define  ElfXX_Addr     Elf64_Addr
#  define  ElfXX_Dyn      Elf64_Dyn
#  define  ELFXX_ST_BIND  ELF64_ST_BIND
#  define  ELFXX_ST_TYPE  ELF64_ST_TYPE

#else
# error "VG_WORDSIZE should be 4 or 8"
#endif


/*------------------------------------------------------------*/
/*---                                                      ---*/
/*--- Read symbol table and line info from ELF files.      ---*/
/*---                                                      ---*/
/*------------------------------------------------------------*/

/* readelf.c parses ELF files and acquires symbol table info from
   them.  It calls onwards to readdwarf.c to read DWARF2/3 line number
   and call frame info found. */


/* Identify an ELF object file by peering at the first few bytes of
   it. */

Bool ML_(is_elf_object_file)( const void* buf )
{
   ElfXX_Ehdr* ehdr = (ElfXX_Ehdr*)buf;
   Int ok = 1;

   ok &= (ehdr->e_ident[EI_MAG0] == 0x7F
          && ehdr->e_ident[EI_MAG1] == 'E'
          && ehdr->e_ident[EI_MAG2] == 'L'
          && ehdr->e_ident[EI_MAG3] == 'F');
   ok &= (ehdr->e_ident[EI_CLASS] == VG_ELF_CLASS
          && ehdr->e_ident[EI_DATA] == VG_ELF_DATA2XXX
          && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
   ok &= (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN);
   ok &= (ehdr->e_machine == VG_ELF_MACHINE);
   ok &= (ehdr->e_version == EV_CURRENT);
   ok &= (ehdr->e_shstrndx != SHN_UNDEF);
   ok &= (ehdr->e_shoff != 0 && ehdr->e_shnum != 0);
   ok &= (ehdr->e_phoff != 0 && ehdr->e_phnum != 0);

   if (ok)
      return True;
   else
      return False;
}


/* Show a raw ELF symbol, given its in-image address and name. */

static
void show_raw_elf_symbol ( Int i, 
                           ElfXX_Sym* sym, Char* sym_name, Addr sym_addr,
                           Bool ppc64_linux_format )
{
   HChar* space = ppc64_linux_format ? "                  " : "";
   VG_(printf)("raw symbol [%4d]: ", i);
   switch (ELFXX_ST_BIND(sym->st_info)) {
      case STB_LOCAL:  VG_(printf)("LOC "); break;
      case STB_GLOBAL: VG_(printf)("GLO "); break;
      case STB_WEAK:   VG_(printf)("WEA "); break;
      case STB_LOPROC: VG_(printf)("lop "); break;
      case STB_HIPROC: VG_(printf)("hip "); break;
      default:         VG_(printf)("??? "); break;
   }
   switch (ELFXX_ST_TYPE(sym->st_info)) {
      case STT_NOTYPE:  VG_(printf)("NOT "); break;
      case STT_OBJECT:  VG_(printf)("OBJ "); break;
      case STT_FUNC:    VG_(printf)("FUN "); break;
      case STT_SECTION: VG_(printf)("SEC "); break;
      case STT_FILE:    VG_(printf)("FIL "); break;
      case STT_LOPROC:  VG_(printf)("lop "); break;
      case STT_HIPROC:  VG_(printf)("hip "); break;
      default:          VG_(printf)("??? "); break;
   }
   VG_(printf)(": val %010p, %ssz %4d  %s\n",
               sym_addr, space, sym->st_size,
               ( sym->st_name ? sym_name : (Char*)"NONAME" ) ); 
}               


/* Decide whether SYM is something we should collect, and if so, copy
   relevant info to the _OUT arguments.  For {x86,amd64,ppc32}-linux
   this is straightforward - the name, address, size are copied out
   unchanged.

   For ppc64-linux it's more complex.  If the symbol is seen to be in
   the .opd section, it is taken to be a function descriptor, and so
   a dereference is attempted, in order to get hold of the real entry
   point address.  Also as part of the dereference, there is an attempt
   to calculate the TOC pointer (R2 value) associated with the symbol.

   To support the ppc64-linux pre-"dotless" ABI (prior to gcc 4.0.0),
   if the symbol is seen to be outside the .opd section and its name
   starts with a dot, an .opd deference is not attempted, and no TOC
   pointer is calculated, but the the leading dot is removed from the
   name.

   As a result, on ppc64-linux, the caller of this function may have
   to piece together the real size, address, name of the symbol from
   multiple calls to this function.  Ugly and confusing.
*/
static 
Bool get_elf_symbol_info ( 
        /* INPUTS */
        struct _SegInfo* si,  /* containing SegInfo */
        ElfXX_Sym* sym,       /* ELF symbol */
        Char*      sym_name,  /* name */
        Addr       sym_addr,  /* declared address */
        UChar*     opd_filea, /* oimage of .opd sec (ppc64-linux only) */
        OffT       opd_offset, /* base address assumed in oimage */
        /* OUTPUTS */
        Char** sym_name_out,   /* name we should record */
        Addr*  sym_addr_out,   /* addr we should record */
        Int*   sym_size_out,   /* symbol size */
        Addr*  sym_tocptr_out, /* ppc64-linux only: R2 value to be
                                  used on entry */
        Bool*  from_opd_out    /* ppc64-linux only: did we deref an
                                  .opd entry? */ 
     )
{
   Bool plausible, is_in_opd;

   /* Set defaults */
   *sym_name_out   = sym_name;
   *sym_addr_out   = sym_addr;
   *sym_size_out   = (Int)sym->st_size;
   *sym_tocptr_out = 0; /* unknown/inapplicable */
   *from_opd_out   = False;

   /* Figure out if we're interested in the symbol.  Firstly, is it of
      the right flavour?  */
   plausible 
      = (ELFXX_ST_BIND(sym->st_info) == STB_GLOBAL 
         || ELFXX_ST_BIND(sym->st_info) == STB_LOCAL 
         || ELFXX_ST_BIND(sym->st_info) == STB_WEAK
        )
        &&
        (ELFXX_ST_TYPE(sym->st_info) == STT_FUNC 
         || (VG_(needs).data_syms 
             && ELFXX_ST_TYPE(sym->st_info) == STT_OBJECT)
        );

#  if defined(VGP_ppc64_linux)
   /* Allow STT_NOTYPE in the very special case where we're running on
      ppc64-linux and the symbol is one which the .opd-chasing hack
      below will chase. */
   if (!plausible
       && ELFXX_ST_TYPE(sym->st_info) == STT_NOTYPE
       && sym->st_size > 0
       && si->opd_start_vma != 0
       && sym_addr >= si->opd_start_vma
       && sym_addr <  si->opd_start_vma + si->opd_size)
      plausible = True;
#  endif

   if (!plausible)
      return False;

   /* Ignore if nameless, or zero-sized. */
   if (sym->st_name == (ElfXX_Word)NULL
       || /* VG_(strlen)(sym_name) == 0 */
          /* equivalent but cheaper ... */
          sym_name[0] == 0
       || sym->st_size == 0) {
      TRACE_SYMTAB("    ignore -- size=0: %s\n", sym_name);
      return False;
   }

   /* This seems to significantly reduce the number of junk
      symbols, and particularly reduces the number of
      overlapping address ranges.  Don't ask me why ... */
   if ((Int)sym->st_value == 0) {
      TRACE_SYMTAB( "    ignore -- valu=0: %s\n", sym_name);
      return False;
   }

   /* If it's apparently in a GOT or PLT, it's really a reference to a
      symbol defined elsewhere, so ignore it. */
   if (si->got_start_vma != 0
       && sym_addr >= si->got_start_vma 
       && sym_addr <  si->got_start_vma + si->got_size) {
      TRACE_SYMTAB("    ignore -- in GOT: %s\n", sym_name);
      return False;
   }
   if (si->plt_start_vma != 0
       && sym_addr >= si->plt_start_vma
       && sym_addr <  si->plt_start_vma + si->plt_size) {
      TRACE_SYMTAB("    ignore -- in PLT: %s\n", sym_name);
      return False;
   }

   /* ppc64-linux nasty hack: if the symbol is in an .opd section,
      then really what we have is the address of a function
      descriptor.  So use the first word of that as the function's
      text.

      See thread starting at
      http://gcc.gnu.org/ml/gcc-patches/2004-08/msg00557.html
   */
   is_in_opd = False;

   if (si->opd_start_vma != 0
       && sym_addr >= si->opd_start_vma
       && sym_addr <  si->opd_start_vma + si->opd_size) {
#     if !defined(VGP_ppc64_linux)
      TRACE_SYMTAB("    ignore -- in OPD: %s\n", sym_name);
      return False;
#     else
      Int    offset_in_opd;
      ULong* fn_descr;

      if (0) VG_(printf)("opdXXX: opd_offset %p, sym_addr %p\n", 
                         (void*)(opd_offset), (void*)sym_addr);

      if (!VG_IS_8_ALIGNED(sym_addr)) {
         TRACE_SYMTAB("    ignore -- not 8-aligned: %s\n", sym_name);
         return False;
      }

      /* sym_addr is a vma pointing into the .opd section.  We know
         the vma of the opd section start, so we can figure out how
         far into the opd section this is. */

      offset_in_opd = (Addr)sym_addr - (Addr)(si->opd_start_vma);
      if (offset_in_opd < 0 || offset_in_opd >= si->opd_size) {
         TRACE_SYMTAB("    ignore -- invalid OPD offset: %s\n", sym_name);
         return False;
      }

      /* Now we want to know what's at that offset in the .opd
         section.  We can't look in the running image since it won't
         necessarily have been mapped.  But we can consult the oimage.
         opd_filea is the start address of the .opd in the oimage.
         Hence: */

      fn_descr = (ULong*)(opd_filea + offset_in_opd);

      if (0) VG_(printf)("opdXXY: offset %d,  fn_descr %p\n", 
                         offset_in_opd, fn_descr);
      if (0) VG_(printf)("opdXXZ: *fn_descr %p\n", (void*)(fn_descr[0]));

      /* opd_offset is the difference between si->start (where the
         library got mapped) and the address space used for addresses
         within the library file. */

      sym_addr        = fn_descr[0] + opd_offset;
      *sym_addr_out   = sym_addr;
      *sym_tocptr_out = fn_descr[1] + opd_offset;
      *from_opd_out   = True;
      is_in_opd = True;

      /* Do a final sanity check: if the symbol falls outside the
         SegInfo's mapped range, ignore it.  Since sym_addr has been
         updated, that can be achieved simply by falling through to
         the test below. */

#     endif /* ppc64-linux nasty hack */
   }

   /* Here's yet another ppc64-linux hack.  Get rid of leading dot if
      the symbol is outside .opd. */
#  if defined(VGP_ppc64_linux)
   if (si->opd_start_vma != 0
       && !is_in_opd
       && sym_name[0] == '.') {
      vg_assert(!(*from_opd_out));
      *sym_name_out = &sym_name[1];
   }
#  endif

   /* If no part of the symbol falls within the mapped range,
      ignore it. */
   if (*sym_addr_out + *sym_size_out <= si->start
       || *sym_addr_out >= si->start+si->size) {
      TRACE_SYMTAB( "ignore -- %p .. %p outside mapped range %p .. %p\n",
                    *sym_addr_out, *sym_addr_out + *sym_size_out,
                    si->start, si->start+si->size);
      return False;
   }

#  if defined(VGP_ppc64_linux)
   /* It's crucial that we never add symbol addresses in the .opd
      section.  This would completely mess up function redirection and
      intercepting.  This assert ensures that any symbols that make it
      into the symbol table on ppc64-linux don't point into .opd. */
   if (si->opd_start_vma != 0) {
      vg_assert(*sym_addr_out + *sym_size_out <= si->opd_start_vma
                || *sym_addr_out >= si->opd_start_vma + si->opd_size);
   }
#  endif

   /* Acquire! */
   return True;
}


/* Read an ELF symbol table (normal or dynamic).  This one is for the
   "normal" case ({x86,amd64,ppc32}-linux). */
static
__attribute__((unused)) /* not referred to on all targets */
void read_elf_symtab__normal( 
        struct _SegInfo* si, UChar* tab_name,
        ElfXX_Sym* o_symtab, UInt o_symtab_sz, OffT o_symtab_offset,
        UChar*     o_strtab, UInt o_strtab_sz,
        UChar*     opd_filea, OffT opd_offset /* ppc64-linux only */ 
     )
{
   Int        i;
   Addr       sym_addr, sym_addr_really;
   Char      *sym_name, *sym_name_really;
   Int        sym_size;
   Addr       sym_tocptr;
   Bool       from_opd;
   DiSym      risym;
   ElfXX_Sym *sym;

   if (o_strtab == NULL || o_symtab == NULL) {
      Char buf[80];
      vg_assert(VG_(strlen)(tab_name) < 40);
      VG_(sprintf)(buf, "   object doesn't have a %s", tab_name);
      ML_(symerr)(buf);
      return;
   }

   TRACE_SYMTAB("\nReading (ELF, standard) %s (%d entries)\n", tab_name, 
                o_symtab_sz/sizeof(ElfXX_Sym) );

   /* Perhaps should start at i = 1; ELF docs suggest that entry
      0 always denotes 'unknown symbol'. */
   for (i = 1; i < (Int)(o_symtab_sz/sizeof(ElfXX_Sym)); i++) {
      sym      = & o_symtab[i];
      sym_name = (Char*)(o_strtab + sym->st_name);
      sym_addr = o_symtab_offset + sym->st_value;

      if (VG_(clo_trace_symtab))
         show_raw_elf_symbol(i, sym, sym_name, sym_addr, False);

      if (get_elf_symbol_info(si, sym, sym_name, sym_addr,
                              opd_filea, opd_offset,
                              &sym_name_really, 
                              &sym_addr_really,
                              &sym_size,
                              &sym_tocptr,
                              &from_opd)) {

         risym.addr   = sym_addr_really;
         risym.size   = sym_size;
         risym.name   = ML_(addStr) ( si, sym_name_really, -1 );
         risym.tocptr = sym_tocptr;
         vg_assert(risym.name != NULL);
         vg_assert(risym.tocptr == 0); /* has no role except on ppc64-linux */
         ML_(addSym) ( si, &risym );

         if (VG_(clo_trace_symtab)) {
            VG_(printf)("    record [%4d]:          "
                        " val %010p, sz %4d  %s\n",
                        i, (void*)risym.addr, (Int)risym.size, 
                           (HChar*)risym.name
            );
         }

      }
   }
}


/* Read an ELF symbol table (normal or dynamic).  This one is for
   ppc64-linux, which requires special treatment. */

typedef
   struct { 
      Addr   addr; 
      UChar* name; 
   }
   TempSymKey;

typedef
   struct {
      TempSymKey key;
      Addr       tocptr;
      Int        size;
      Bool       from_opd;
   }
   TempSym;

static Word cmp_TempSymKey ( TempSymKey* key1, TempSym* elem2 ) {
   if (key1->addr < elem2->key.addr) return -1;
   if (key1->addr > elem2->key.addr) return 1;
   return (Word)VG_(strcmp)(key1->name, elem2->key.name);
}
static void* oset_malloc ( SizeT szB ) { 
   return VG_(arena_malloc)(VG_AR_SYMTAB, szB);
}
static void oset_free ( void* p ) {
   VG_(arena_free)(VG_AR_SYMTAB, p);
}

static
__attribute__((unused)) /* not referred to on all targets */
void read_elf_symtab__ppc64_linux( 
        struct _SegInfo* si, UChar* tab_name,
        ElfXX_Sym* o_symtab, UInt o_symtab_sz, OffT o_symtab_offset,
        UChar*     o_strtab, UInt o_strtab_sz,
        UChar*     opd_filea, OffT opd_offset /* ppc64-linux only */ 
     )
{
   Int         i, old_size;
   Addr        sym_addr, sym_addr_really;
   Char       *sym_name, *sym_name_really;
   Int         sym_size;
   Addr        sym_tocptr, old_tocptr;
   Bool        from_opd, modify_size, modify_tocptr;
   DiSym       risym;
   ElfXX_Sym  *sym;
   OSet       *oset;
   TempSymKey  key;
   TempSym    *elem;
   TempSym    *prev;

   if (o_strtab == NULL || o_symtab == NULL) {
      Char buf[80];
      vg_assert(VG_(strlen)(tab_name) < 40);
      VG_(sprintf)(buf, "   object doesn't have a %s", tab_name);
      ML_(symerr)(buf);
      return;
   }

   TRACE_SYMTAB("\nReading (ELF, ppc64-linux) %s (%d entries)\n", tab_name, 
                o_symtab_sz/sizeof(ElfXX_Sym) );

   oset = VG_(OSet_Create)( offsetof(TempSym,key), 
                            (OSetCmp_t)cmp_TempSymKey, 
                            oset_malloc, oset_free );
   vg_assert(oset);

   /* Perhaps should start at i = 1; ELF docs suggest that entry
      0 always denotes 'unknown symbol'. */
   for (i = 1; i < (Int)(o_symtab_sz/sizeof(ElfXX_Sym)); i++) {
      sym      = & o_symtab[i];
      sym_name = (Char*)(o_strtab + sym->st_name);
      sym_addr = o_symtab_offset + sym->st_value;

      if (VG_(clo_trace_symtab))
         show_raw_elf_symbol(i, sym, sym_name, sym_addr, True);

      if (get_elf_symbol_info(si, sym, sym_name, sym_addr,
                              opd_filea, opd_offset,
                              &sym_name_really, 
                              &sym_addr_really,
                              &sym_size,
                              &sym_tocptr,
                              &from_opd)) {

         /* Check if we've seen this (name,addr) key before. */
         key.addr = sym_addr_really;
         key.name = sym_name_really;
         prev = VG_(OSet_Lookup)( oset, &key );

         if (prev) {

            /* Seen it before.  Fold in whatever new info we can. */
            modify_size   = False;
            modify_tocptr = False;
            old_size   = 0;
	    old_tocptr = 0;

            if (prev->from_opd && !from_opd 
                && (prev->size == 24 || prev->size == 16)
                && sym_size != prev->size) {
               /* Existing one is an opd-redirect, with a bogus size,
                  so the only useful new fact we have is the real size
                  of the symbol. */
               modify_size = True;
               old_size = prev->size;
               prev->size = sym_size;
            }
            else
            if (!prev->from_opd && from_opd
                && (sym_size == 24 || sym_size == 16)) {
               /* Existing one is non-opd, new one is opd.  What we
                  can acquire from the new one is the TOC ptr to be
                  used.  Since the existing sym is non-toc, it
                  shouldn't currently have an known TOC ptr. */
               vg_assert(prev->tocptr == 0);
               modify_tocptr = True;
               old_tocptr = prev->tocptr;
               prev->tocptr = sym_tocptr;
            }
            else {
               /* ignore. can we do better here? */
            }

            /* Only one or the other is possible (I think) */
	    vg_assert(!(modify_size && modify_tocptr));

            if (modify_size && VG_(clo_trace_symtab)) {
               VG_(printf)("    modify (old sz %4d)    "
                           " val %010p, toc %010p, sz %4d  %s\n",
                           old_size,
                           (void*) prev->key.addr, 
                           (void*) prev->tocptr,
                           (Int)   prev->size, 
                           (HChar*)prev->key.name
               );
            }
            if (modify_tocptr && VG_(clo_trace_symtab)) {
               VG_(printf)("    modify (upd tocptr)     "
                           " val %010p, toc %010p, sz %4d  %s\n",
                            (void*) prev->key.addr, 
                            (void*) prev->tocptr, 
                            (Int)   prev->size, 
                            (HChar*)prev->key.name
               );
            }

         } else {

            /* A new (name,addr) key.  Add and continue. */
            elem = VG_(OSet_AllocNode)(oset, sizeof(TempSym));
            vg_assert(elem);
            elem->key      = key;
            elem->tocptr   = sym_tocptr;
            elem->size     = sym_size;
            elem->from_opd = from_opd;
            VG_(OSet_Insert)(oset, elem);
            if (VG_(clo_trace_symtab)) {
               VG_(printf)("   to-oset [%4d]:          "
                           " val %010p, toc %010p, sz %4d  %s\n",
                           i, (void*) elem->key.addr,
                              (void*) elem->tocptr,
                              (Int)   elem->size, 
                              (HChar*)elem->key.name
               );
            }

         }
      }
   }

   /* All the syms that matter are in the oset.  Now pull them out,
      build a "standard" symbol table, and nuke the oset. */

   i = 0;
   VG_(OSet_ResetIter)( oset );

   while ( (elem = VG_(OSet_Next)(oset)) ) {
      risym.addr   = elem->key.addr;
      risym.size   = elem->size;
      risym.name   = ML_(addStr) ( si, elem->key.name, -1 );
      risym.tocptr = elem->tocptr;
      vg_assert(risym.name != NULL);

      ML_(addSym) ( si, &risym );
      if (VG_(clo_trace_symtab)) {
         VG_(printf)("    record [%4d]:          "
                     " val %010p, toc %010p, sz %4d  %s\n",
                     i, (void*) risym.addr,
                        (void*) risym.tocptr,
                        (Int)   risym.size, 
                        (HChar*)risym.name
               );
      }
      i++;
   }

   VG_(OSet_Destroy)( oset, NULL );
}


/*
 * This routine for calculating the CRC for a separate debug file
 * is GPLed code borrowed from GNU binutils.
 */
static UInt
calc_gnu_debuglink_crc32(UInt crc, const UChar *buf, Int len)
{
  static const UInt crc32_table[256] =
    {
      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
      0x2d02ef8d
    };
  const UChar *end;

  crc = ~crc & 0xffffffff;
  for (end = buf + len; buf < end; ++ buf)
    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
  return ~crc & 0xffffffff;;
}

/*
 * Try and open a separate debug file, ignoring any where the CRC does
 * not match the value from the main object file.
 */
static
Addr open_debug_file( Char* name, UInt crc, UInt* size )
{
   SysRes fd, sres;
   struct vki_stat stat_buf;
   UInt calccrc;

   fd = VG_(open)(name, VKI_O_RDONLY, 0);
   if (fd.isError)
      return 0;

   if (VG_(fstat)(fd.val, &stat_buf) != 0) {
      VG_(close)(fd.val);
      return 0;
   }

   if (VG_(clo_verbosity) > 1)
      VG_(message)(Vg_DebugMsg, "Reading debug info from %s...", name);

   *size = stat_buf.st_size;
   
   sres = VG_(am_mmap_file_float_valgrind)
             ( *size, VKI_PROT_READ, fd.val, 0 );

   VG_(close)(fd.val);
   
   if (sres.isError)
      return 0;

   calccrc = calc_gnu_debuglink_crc32(0, (UChar*)sres.val, *size);
   if (calccrc != crc) {
      SysRes res = VG_(am_munmap_valgrind)(sres.val, *size);
      vg_assert(!res.isError);
      if (VG_(clo_verbosity) > 1)
	 VG_(message)(Vg_DebugMsg, "... CRC mismatch (computed %08x wanted %08x)", calccrc, crc);
      return 0;
   }
   
   return sres.val;
}

/*
 * Try to find a separate debug file for a given object file.
 */
static
Addr find_debug_file( Char* objpath, Char* debugname, UInt crc, UInt* size )
{
   Char *objdir = VG_(arena_strdup)(VG_AR_SYMTAB, objpath);
   Char *objdirptr;
   Char *debugpath;
   Addr addr = 0;
  
   if ((objdirptr = VG_(strrchr)(objdir, '/')) != NULL)
      *objdirptr = '\0';

   debugpath = VG_(arena_malloc)(VG_AR_SYMTAB, VG_(strlen)(objdir) + VG_(strlen)(debugname) + 16);
   
   VG_(sprintf)(debugpath, "%s/%s", objdir, debugname);

   if ((addr = open_debug_file(debugpath, crc, size)) == 0) {
      VG_(sprintf)(debugpath, "%s/.debug/%s", objdir, debugname);
      if ((addr = open_debug_file(debugpath, crc, size)) == 0) {
         VG_(sprintf)(debugpath, "/usr/lib/debug%s/%s", objdir, debugname);
         addr = open_debug_file(debugpath, crc, size);
      }
   }

   VG_(arena_free)(VG_AR_SYMTAB, debugpath);
   VG_(arena_free)(VG_AR_SYMTAB, objdir);
   
   return addr;
}


/* The central function for reading ELF debug info.  For the
   object/exe specified by the SegInfo, find ELF sections, then read
   the symbols, line number info, file name info, CFA (stack-unwind
   info) and anything else we want, into the tables within the
   supplied SegInfo.
*/
Bool ML_(read_elf_debug_info) ( struct _SegInfo* si )
{
   Bool          res;
   ElfXX_Ehdr*   ehdr;       /* The ELF header                   */
   ElfXX_Shdr*   shdr;       /* The section table                */
   UChar*        sh_strtab;  /* The section table's string table */
   SysRes        fd, sres;
   Int           i;
   Bool          ok;
   Addr          oimage;
   UInt          n_oimage;
   OffT          offset_oimage = 0;
   Addr          dimage = 0;
   UInt          n_dimage = 0;
   OffT          offset_dimage = 0;

   oimage = (Addr)NULL;
   if (VG_(clo_verbosity) > 1 || VG_(clo_trace_redir))
      VG_(message)(Vg_DebugMsg, "Reading syms from %s (%p)", 
                                si->filename, si->start );

   /* mmap the object image aboard, so that we can read symbols and
      line number info out of it.  It will be munmapped immediately
      thereafter; it is only aboard transiently. */

   fd = VG_(open)(si->filename, VKI_O_RDONLY, 0);
   if (fd.isError) {
      ML_(symerr)("Can't open .so/.exe to read symbols?!");
      return False;
   }

   n_oimage = VG_(fsize)(fd.val);
   if (n_oimage < 0) {
      ML_(symerr)("Can't stat .so/.exe (to determine its size)?!");
      VG_(close)(fd.val);
      return False;
   }

   sres = VG_(am_mmap_file_float_valgrind)
             ( n_oimage, VKI_PROT_READ, fd.val, 0 );

   VG_(close)(fd.val);

   if (sres.isError) {
      VG_(message)(Vg_UserMsg, "warning: mmap failed on %s", si->filename );
      VG_(message)(Vg_UserMsg, "         no symbols or debug info loaded" );
      return False;
   }

   oimage = sres.val;

   /* Ok, the object image is safely in oimage[0 .. n_oimage-1]. 
      Now verify that it is a valid ELF .so or executable image.
   */
   res = False;
   ok = (n_oimage >= sizeof(ElfXX_Ehdr));
   ehdr = (ElfXX_Ehdr*)oimage;

   if (ok)
      ok &= ML_(is_elf_object_file)(ehdr);

   if (!ok) {
      ML_(symerr)("Invalid ELF header, or missing stringtab/sectiontab.");
      goto out;
   }

   /* Walk the LOAD headers in the phdr and update the SegInfo to
      include them all, so that this segment also contains data and
      bss memory.  Also computes correct symbol offset value for this
      ELF file. */
   if (ehdr->e_phoff + ehdr->e_phnum*sizeof(ElfXX_Phdr) > n_oimage) {
      ML_(symerr)("ELF program header is beyond image end?!");
      goto out;
   }
   {
      Bool offset_set = False;
      ElfXX_Addr prev_addr = 0;
      Addr baseaddr = 0;

      vg_assert(si->soname == NULL);

      for (i = 0; i < ehdr->e_phnum; i++) {
	 ElfXX_Phdr *o_phdr;
	 ElfXX_Addr mapped, mapped_end;

	 o_phdr = &((ElfXX_Phdr *)(oimage + ehdr->e_phoff))[i];

         /* Try to get the soname.  If there isn't one, use "NONE".
            The seginfo needs to have some kind of soname in order to
            facilitate writing redirect functions, since all redirect
            specifications require a soname (pattern). */
	 if (o_phdr->p_type == PT_DYNAMIC && si->soname == NULL) {
	    const ElfXX_Dyn *dyn = (const ElfXX_Dyn *)(oimage + o_phdr->p_offset);
	    Int stroff = -1;
	    Char *strtab = NULL;
	    Int j;
	    
	    for(j = 0; dyn[j].d_tag != DT_NULL; j++) {
	       switch(dyn[j].d_tag) {
	       case DT_SONAME:
		  stroff = dyn[j].d_un.d_val;
		  break;

	       case DT_STRTAB:
		  strtab = (Char *)oimage + dyn[j].d_un.d_ptr - baseaddr;
		  break;
	       }
	    }

	    if (stroff != -1 && strtab != 0) {
	       TRACE_SYMTAB("soname=%s\n", strtab+stroff);
	       si->soname = VG_(arena_strdup)(VG_AR_SYMTAB, strtab+stroff);
	    }
	 }

	 if (o_phdr->p_type != PT_LOAD)
	    continue;

	 if (!offset_set) {
	    offset_set = True;
	    offset_oimage = si->start - o_phdr->p_vaddr;
	    baseaddr = o_phdr->p_vaddr;
	 }

         // Make sure the Phdrs are in order
	 if (o_phdr->p_vaddr < prev_addr) {
	    ML_(symerr)("ELF Phdrs are out of order!?");
            goto out;
	 }
	 prev_addr = o_phdr->p_vaddr;

         // Get the data and bss start/size if appropriate
	 mapped = o_phdr->p_vaddr + offset_oimage;
	 mapped_end = mapped + o_phdr->p_memsz;
	 if (si->data_start_vma == 0 &&
	     (o_phdr->p_flags & (PF_R|PF_W|PF_X)) == (PF_R|PF_W)) {
	    si->data_start_vma = mapped;
	    si->data_size      = o_phdr->p_filesz;
	    si->bss_start_vma  = mapped + o_phdr->p_filesz;
	    if (o_phdr->p_memsz > o_phdr->p_filesz)
	       si->bss_size = o_phdr->p_memsz - o_phdr->p_filesz;
	    else
	       si->bss_size = 0;
	 }

         mapped = mapped & ~(VKI_PAGE_SIZE-1);
	 mapped_end = (mapped_end + VKI_PAGE_SIZE - 1) & ~(VKI_PAGE_SIZE-1);

	 if (VG_(needs).data_syms &&
	     (mapped >= si->start && mapped <= (si->start+si->size)) &&
	     (mapped_end > (si->start+si->size))) {
	    UInt newsz = mapped_end - si->start;
	    if (newsz > si->size) {
	       if (0)
		  VG_(printf)("extending mapping %p..%p %d -> ..%p %d\n", 
			      si->start, si->start+si->size, si->size,
			      si->start+newsz, newsz);

	       si->size = newsz;
	    }
	 }
      }
   }

   si->offset = offset_oimage;

   /* If, after looking at all the program headers, we still didn't 
      find a soname, add a fake one. */
   if (si->soname == NULL) {
      TRACE_SYMTAB("soname(fake)=\"NONE\"\n");
      si->soname = "NONE";
   }

   TRACE_SYMTAB("shoff = %d,  shnum = %d,  size = %d,  n_vg_oimage = %d\n",
                ehdr->e_shoff, ehdr->e_shnum, sizeof(ElfXX_Shdr), n_oimage );

   if (ehdr->e_shoff + ehdr->e_shnum*sizeof(ElfXX_Shdr) > n_oimage) {
      ML_(symerr)("ELF section header is beyond image end?!");
      goto out;
   }

   shdr = (ElfXX_Shdr*)(oimage + ehdr->e_shoff);
   sh_strtab = (UChar*)(oimage + shdr[ehdr->e_shstrndx].sh_offset);

   /* Find interesting sections, read the symbol table(s), read any debug
      information */
   {
      /* Pointers to start of sections (in the oimage, not in the
	 running image) */
      UChar*     o_strtab     = NULL; /* .strtab */
      ElfXX_Sym* o_symtab     = NULL; /* .symtab */
      UChar*     o_dynstr     = NULL; /* .dynstr */
      ElfXX_Sym* o_dynsym     = NULL; /* .dynsym */
      Char*      debuglink    = NULL; /* .gnu_debuglink */
      UChar*     stab         = NULL; /* .stab         (stabs)  */
      UChar*     stabstr      = NULL; /* .stabstr      (stabs)  */
      UChar*     debug_line   = NULL; /* .debug_line   (dwarf2) */
      UChar*     debug_info   = NULL; /* .debug_info   (dwarf2) */
      UChar*     debug_abbv   = NULL; /* .debug_abbrev (dwarf2) */
      UChar*     debug_str    = NULL; /* .debug_str    (dwarf2) */
      UChar*     dwarf1d      = NULL; /* .debug        (dwarf1) */
      UChar*     dwarf1l      = NULL; /* .line         (dwarf1) */
      UChar*     ehframe      = NULL; /* .eh_frame     (dwarf2) */
      UChar*     opd_filea    = NULL; /* .opd          (dwarf2, ppc64-linux) */
      UChar*     dummy_filea  = NULL;

      OffT       o_symtab_offset = offset_oimage;
      OffT       o_dynsym_offset = offset_oimage;
      OffT       debug_offset    = offset_oimage;
      OffT       opd_offset      = offset_oimage;

      /* Section sizes, in bytes */
      UInt       o_strtab_sz     = 0;
      UInt       o_symtab_sz     = 0;
      UInt       o_dynstr_sz     = 0;
      UInt       o_dynsym_sz     = 0;
      UInt       debuglink_sz    = 0;
      UInt       stab_sz         = 0;
      UInt       stabstr_sz      = 0;
      UInt       debug_line_sz   = 0;
      UInt       debug_info_sz   = 0;
      UInt       debug_abbv_sz   = 0;
      UInt       debug_str_sz    = 0;
      UInt       dwarf1d_sz      = 0;
      UInt       dwarf1l_sz      = 0;
      UInt       ehframe_sz      = 0;

      /* Section virtual addresses */
      Addr       dummy_vma       = 0;
      Addr       ehframe_vma     = 0;

      /* Find all interesting sections */

      /* What FIND does: it finds the section called SEC_NAME.  The
	 size of it is assigned to SEC_SIZE.  The address that it will
	 appear in the running image is assigned to SEC_VMA (note,
	 this will be meaningless for sections which are not marked
	 loadable.  Even for sections which are marked loadable, the
	 client's ld.so may not have loaded them yet, so there is no
	 guarantee that we can safely prod around in any such area)
	 The address of the section in the transiently loaded oimage
	 is assigned to SEC_FILEA.  Because the entire object file is
	 transiently mapped aboard for inspection, it's always safe to
	 inspect that area. */

      for (i = 0; i < ehdr->e_shnum; i++) {

#        define FIND(sec_name, sec_size, sec_filea, sec_vma) \
         if (0 == VG_(strcmp)(sec_name, sh_strtab + shdr[i].sh_name)) { \
            Bool nobits; \
            sec_vma   = (Addr)(offset_oimage + shdr[i].sh_addr); \
            sec_filea = (void*)(oimage + shdr[i].sh_offset); \
            sec_size  = shdr[i].sh_size; \
            nobits = shdr[i].sh_type == SHT_NOBITS; \
            TRACE_SYMTAB( "%18s: filea %p .. %p, vma %p .. %p\n", \
                          sec_name, (UChar*)sec_filea, \
                                    ((UChar*)sec_filea) + sec_size - 1, \
                          sec_vma, sec_vma + sec_size - 1); \
            /* SHT_NOBITS sections have zero size in the file. */ \
            if ( shdr[i].sh_offset + (nobits ? 0 : sec_size) > n_oimage ) { \
               ML_(symerr)("   section beyond image end?!"); \
               goto out; \
            } \
         }

         /* Nb: must find where .got and .plt sections will be in the
          * executable image, not in the object image transiently loaded. */
         /*   NAME              SIZE           ADDR_IN_OIMAGE  ADDR_WHEN_MAPPED */
         FIND(".dynsym",        o_dynsym_sz,   o_dynsym,       dummy_vma)
         FIND(".dynstr",        o_dynstr_sz,   o_dynstr,       dummy_vma)
         FIND(".symtab",        o_symtab_sz,   o_symtab,       dummy_vma)
         FIND(".strtab",        o_strtab_sz,   o_strtab,       dummy_vma)

         FIND(".gnu_debuglink", debuglink_sz,  debuglink,      dummy_vma)

         FIND(".stab",          stab_sz,       stab,           dummy_vma)
         FIND(".stabstr",       stabstr_sz,    stabstr,        dummy_vma)

         FIND(".debug_line",    debug_line_sz, debug_line,     dummy_vma)
         FIND(".debug_info",    debug_info_sz, debug_info,     dummy_vma)
         FIND(".debug_abbrev",  debug_abbv_sz, debug_abbv,     dummy_vma)
         FIND(".debug_str",     debug_str_sz,  debug_str,      dummy_vma)

         FIND(".debug",         dwarf1d_sz,    dwarf1d,        dummy_vma)
         FIND(".line",          dwarf1l_sz,    dwarf1l,        dummy_vma)
         FIND(".eh_frame",      ehframe_sz,    ehframe,        ehframe_vma)

         FIND(".got",           si->got_size,  dummy_filea,    si->got_start_vma)
         FIND(".plt",           si->plt_size,  dummy_filea,    si->plt_start_vma)
         FIND(".opd",           si->opd_size,  opd_filea,      si->opd_start_vma)

#        undef FIND
      }
         
      /* Did we find a debuglink section? */
      if (debuglink != NULL) {
         UInt crc_offset = VG_ROUNDUP(VG_(strlen)(debuglink)+1, 4);
         UInt crc;

         vg_assert(crc_offset + sizeof(UInt) <= debuglink_sz);

         /* Extract the CRC from the debuglink section */
         crc = *(UInt *)(debuglink + crc_offset);

         /* See if we can find a matching debug file */
         if ((dimage = find_debug_file(si->filename, debuglink, crc, &n_dimage)) != 0) {
            ehdr = (ElfXX_Ehdr*)dimage;

            if (n_dimage >= sizeof(ElfXX_Ehdr) 
                && ML_(is_elf_object_file(ehdr))
                && ehdr->e_phoff + ehdr->e_phnum*sizeof(ElfXX_Phdr) <= n_dimage
                && ehdr->e_shoff + ehdr->e_shnum*sizeof(ElfXX_Shdr) <= n_dimage)
            {
               Bool need_symtab = (NULL == o_symtab);

               for (i = 0; i < ehdr->e_phnum; i++) {
                  ElfXX_Phdr *o_phdr = &((ElfXX_Phdr *)(dimage + ehdr->e_phoff))[i];
                  if (o_phdr->p_type == PT_LOAD) {
                     offset_dimage = si->start - o_phdr->p_vaddr;
                     break;
                  }
               }

               debug_offset = offset_dimage;
               if (need_symtab)
                  o_symtab_offset = offset_dimage;

               shdr = (ElfXX_Shdr*)(dimage + ehdr->e_shoff);
               sh_strtab = (UChar*)(dimage + shdr[ehdr->e_shstrndx].sh_offset);

               /* Same deal as previous FIND, except simpler - doesn't
                  look for vma, only oimage address. */

               /* Find all interesting sections */
               for (i = 0; i < ehdr->e_shnum; i++) {

#                 define FIND(condition, sec_name, sec_size, sec_filea)	\
                  if (condition \
                      && 0 == VG_(strcmp)(sec_name, sh_strtab + shdr[i].sh_name)) { \
                     Bool nobits; \
                     if (0 != sec_filea) \
                        VG_(core_panic)("repeated section!\n"); \
                     sec_filea = (void*)(dimage + shdr[i].sh_offset); \
                     sec_size  = shdr[i].sh_size; \
                     nobits = shdr[i].sh_type == SHT_NOBITS; \
                     TRACE_SYMTAB( "%18s: filea %p .. %p\n", \
                                   sec_name, (UChar*)sec_filea, \
                                             ((UChar*)sec_filea) + sec_size - 1); \
                     /* SHT_NOBITS sections have zero size in the file. */ \
                     if ( shdr[i].sh_offset + (nobits ? 0 : sec_size) > n_dimage ) { \
                        ML_(symerr)("   section beyond image end?!"); \
                        goto out; \
                     } \
                  }

                  FIND(need_symtab, ".symtab",       o_symtab_sz,   o_symtab)
                  FIND(need_symtab, ".strtab",       o_strtab_sz,   o_strtab)
                  FIND(1,           ".stab",         stab_sz,       stab)
                  FIND(1,           ".stabstr",      stabstr_sz,    stabstr)
                  FIND(1,           ".debug_line",   debug_line_sz, debug_line)
                  FIND(1,           ".debug_info",   debug_info_sz, debug_info)
                  FIND(1,           ".debug_abbrev", debug_abbv_sz, debug_abbv)
                  FIND(1,           ".debug_str",    debug_str_sz,  debug_str)
                  FIND(1,           ".debug",        dwarf1d_sz,    dwarf1d)
                  FIND(1,           ".line",         dwarf1l_sz,    dwarf1l)

#                 undef FIND
               }
            }
         }
      }

      /* Check some sizes */
      vg_assert((o_dynsym_sz % sizeof(ElfXX_Sym)) == 0);
      vg_assert((o_symtab_sz % sizeof(ElfXX_Sym)) == 0);

      /* Read symbols */
      {
         void (*read_elf_symtab)(struct _SegInfo*,UChar*,ElfXX_Sym*,
                                 UInt,OffT,UChar*,UInt,UChar*,OffT);
#        if defined(VGP_ppc64_linux)
         read_elf_symtab = read_elf_symtab__ppc64_linux;
#        else
         read_elf_symtab = read_elf_symtab__normal;
#        endif
         read_elf_symtab(si, "symbol table",
                         o_symtab, o_symtab_sz, o_symtab_offset,
                         o_strtab, o_strtab_sz, opd_filea, opd_offset);

         read_elf_symtab(si, "dynamic symbol table",
                         o_dynsym, o_dynsym_sz, o_dynsym_offset,
                         o_dynstr, o_dynstr_sz, opd_filea, opd_offset);
      }

      /* Read .eh_frame (call-frame-info) if any */
      if (ehframe) {
         ML_(read_callframe_info_dwarf2) ( si, ehframe, ehframe_sz, ehframe_vma );
      }

      /* Read the stabs and/or dwarf2 debug information, if any.  It
         appears reading stabs stuff on amd64-linux doesn't work, so
         we ignore it. */
#     if !defined(VGP_amd64_linux)
      if (stab && stabstr) {
         ML_(read_debuginfo_stabs) ( si, debug_offset, stab, stab_sz, 
                                         stabstr, stabstr_sz );
      }
#     endif
      /* jrs 2006-01-01: icc-8.1 has been observed to generate
         binaries without debug_str sections.  Don't preclude
         debuginfo reading for that reason, but, in
         read_unitinfo_dwarf2, do check that debugstr is non-NULL
         before using it. */
      if (debug_info && debug_abbv && debug_line /* && debug_str */) {
         ML_(read_debuginfo_dwarf2) ( si, debug_offset, 
                                      debug_info,   debug_info_sz,
                                      debug_abbv,
                                      debug_line,   debug_line_sz,
                                      debug_str );
      }
      if (dwarf1d && dwarf1l) {
         ML_(read_debuginfo_dwarf1) ( si, dwarf1d, dwarf1d_sz, 
                                          dwarf1l, dwarf1l_sz );
      }
   }
   res = True;

  out: {
   SysRes m_res;
   /* Last, but not least, heave the image(s) back overboard. */
   if (dimage) {
      m_res = VG_(am_munmap_valgrind) ( dimage, n_dimage );
      vg_assert(!m_res.isError);
   }
   m_res = VG_(am_munmap_valgrind) ( oimage, n_oimage );
   vg_assert(!m_res.isError);
   return res;
  } 
}


/*--------------------------------------------------------------------*/
/*--- end                                                          ---*/
/*--------------------------------------------------------------------*/