← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to coregrind/m_debuginfo/readelf.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrés Roldán
  • Date: 2008-06-13 02:31:40 UTC
  • mto: (1.4.1 upstream) (2.2.1 squeeze)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20080613023140-iwk33rz9rhvfkr96
Import upstream version 3.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
coregrind/m_debuginfo/readelf.c
8
8
   This file is part of Valgrind, a dynamic binary instrumentation
9
9
   framework.
10
10
 
11
 
   Copyright (C) 2000-2006 Julian Seward 
 
11
   Copyright (C) 2000-2007 Julian Seward 
12
12
      jseward@acm.org
13
13
 
14
14
   This program is free software; you can redistribute it and/or
35
35
*/
36
36
 
37
37
#include "pub_core_basics.h"
 
38
#include "pub_core_vki.h"
38
39
#include "pub_core_libcbase.h"
39
40
#include "pub_core_libcprint.h"
40
41
#include "pub_core_libcassert.h"
45
46
#include "pub_core_options.h"
46
47
#include "pub_core_oset.h"
47
48
#include "pub_core_tooliface.h"    /* VG_(needs) */
 
49
#include "pub_core_xarray.h"
48
50
#include "priv_storage.h"
49
51
#include "priv_readelf.h"          /* self */
50
52
#include "priv_readdwarf.h"        /* 'cos ELF contains DWARF */
232
234
   if (!plausible
233
235
       && ELFXX_ST_TYPE(sym->st_info) == STT_NOTYPE
234
236
       && sym->st_size > 0
235
 
       && si->opd_start_vma != 0
236
 
       && sym_addr >= si->opd_start_vma
237
 
       && sym_addr <  si->opd_start_vma + si->opd_size)
 
237
       && si->opd_start_avma != 0
 
238
       && sym_addr >= si->opd_start_avma
 
239
       && sym_addr <  si->opd_start_avma + si->opd_size)
238
240
      plausible = True;
239
241
#  endif
240
242
 
242
244
      return False;
243
245
 
244
246
   /* Ignore if nameless, or zero-sized. */
245
 
   if (sym->st_name == (ElfXX_Word)NULL
 
247
   if (sym->st_name == (ElfXX_Word)0
246
248
       || /* VG_(strlen)(sym_name) == 0 */
247
249
          /* equivalent but cheaper ... */
248
250
          sym_name[0] == 0
261
263
 
262
264
   /* If it's apparently in a GOT or PLT, it's really a reference to a
263
265
      symbol defined elsewhere, so ignore it. */
264
 
   if (si->got_start_vma != 0
265
 
       && sym_addr >= si->got_start_vma 
266
 
       && sym_addr <  si->got_start_vma + si->got_size) {
 
266
   if (si->got_start_avma != 0
 
267
       && sym_addr >= si->got_start_avma 
 
268
       && sym_addr <  si->got_start_avma + si->got_size) {
267
269
      TRACE_SYMTAB("    ignore -- in GOT: %s\n", sym_name);
268
270
      return False;
269
271
   }
270
 
   if (si->plt_start_vma != 0
271
 
       && sym_addr >= si->plt_start_vma
272
 
       && sym_addr <  si->plt_start_vma + si->plt_size) {
 
272
   if (si->plt_start_avma != 0
 
273
       && sym_addr >= si->plt_start_avma
 
274
       && sym_addr <  si->plt_start_avma + si->plt_size) {
273
275
      TRACE_SYMTAB("    ignore -- in PLT: %s\n", sym_name);
274
276
      return False;
275
277
   }
284
286
   */
285
287
   is_in_opd = False;
286
288
 
287
 
   if (si->opd_start_vma != 0
288
 
       && sym_addr >= si->opd_start_vma
289
 
       && sym_addr <  si->opd_start_vma + si->opd_size) {
 
289
   if (si->opd_start_avma != 0
 
290
       && sym_addr >= si->opd_start_avma
 
291
       && sym_addr <  si->opd_start_avma + si->opd_size) {
290
292
#     if !defined(VGP_ppc64_linux)
291
293
      TRACE_SYMTAB("    ignore -- in OPD: %s\n", sym_name);
292
294
      return False;
306
308
         the vma of the opd section start, so we can figure out how
307
309
         far into the opd section this is. */
308
310
 
309
 
      offset_in_opd = (Addr)sym_addr - (Addr)(si->opd_start_vma);
 
311
      offset_in_opd = (Addr)sym_addr - (Addr)(si->opd_start_avma);
310
312
      if (offset_in_opd < 0 || offset_in_opd >= si->opd_size) {
311
313
         TRACE_SYMTAB("    ignore -- invalid OPD offset: %s\n", sym_name);
312
314
         return False;
345
347
   /* Here's yet another ppc64-linux hack.  Get rid of leading dot if
346
348
      the symbol is outside .opd. */
347
349
#  if defined(VGP_ppc64_linux)
348
 
   if (si->opd_start_vma != 0
 
350
   if (si->opd_start_avma != 0
349
351
       && !is_in_opd
350
352
       && sym_name[0] == '.') {
351
353
      vg_assert(!(*from_opd_out));
355
357
 
356
358
   /* If no part of the symbol falls within the mapped range,
357
359
      ignore it. */
358
 
   if (*sym_addr_out + *sym_size_out <= si->start
359
 
       || *sym_addr_out >= si->start+si->size) {
 
360
   if (*sym_addr_out + *sym_size_out <= si->text_start_avma
 
361
       || *sym_addr_out >= si->text_start_avma + si->text_size) {
360
362
      TRACE_SYMTAB( "ignore -- %p .. %p outside mapped range %p .. %p\n",
361
363
                    *sym_addr_out, *sym_addr_out + *sym_size_out,
362
 
                    si->start, si->start+si->size);
 
364
                    si->text_start_avma,
 
365
                    si->text_start_avma + si->text_size);
363
366
      return False;
364
367
   }
365
368
 
368
371
      section.  This would completely mess up function redirection and
369
372
      intercepting.  This assert ensures that any symbols that make it
370
373
      into the symbol table on ppc64-linux don't point into .opd. */
371
 
   if (si->opd_start_vma != 0) {
372
 
      vg_assert(*sym_addr_out + *sym_size_out <= si->opd_start_vma
373
 
                || *sym_addr_out >= si->opd_start_vma + si->opd_size);
 
374
   if (si->opd_start_avma != 0) {
 
375
      vg_assert(*sym_addr_out + *sym_size_out <= si->opd_start_avma
 
376
                || *sym_addr_out >= si->opd_start_avma + si->opd_size);
374
377
   }
375
378
#  endif
376
379
 
417
420
      sym_name = (Char*)(o_strtab + sym->st_name);
418
421
      sym_addr = o_symtab_offset + sym->st_value;
419
422
 
420
 
      if (VG_(clo_trace_symtab))
 
423
      if (si->trace_symtab)
421
424
         show_raw_elf_symbol(i, sym, sym_name, sym_addr, False);
422
425
 
423
426
      if (get_elf_symbol_info(si, sym, sym_name, sym_addr,
436
439
         vg_assert(risym.tocptr == 0); /* has no role except on ppc64-linux */
437
440
         ML_(addSym) ( si, &risym );
438
441
 
439
 
         if (VG_(clo_trace_symtab)) {
 
442
         if (si->trace_symtab) {
440
443
            VG_(printf)("    record [%4d]:          "
441
444
                        " val %010p, sz %4d  %s\n",
442
445
                        i, (void*)risym.addr, (Int)risym.size, 
513
516
   TRACE_SYMTAB("\nReading (ELF, ppc64-linux) %s (%d entries)\n", tab_name, 
514
517
                o_symtab_sz/sizeof(ElfXX_Sym) );
515
518
 
516
 
   oset = VG_(OSet_Create)( offsetof(TempSym,key), 
517
 
                            (OSetCmp_t)cmp_TempSymKey, 
518
 
                            oset_malloc, oset_free );
 
519
   oset = VG_(OSetGen_Create)( offsetof(TempSym,key), 
 
520
                               (OSetCmp_t)cmp_TempSymKey, 
 
521
                               oset_malloc, oset_free );
519
522
   vg_assert(oset);
520
523
 
521
524
   /* Perhaps should start at i = 1; ELF docs suggest that entry
525
528
      sym_name = (Char*)(o_strtab + sym->st_name);
526
529
      sym_addr = o_symtab_offset + sym->st_value;
527
530
 
528
 
      if (VG_(clo_trace_symtab))
 
531
      if (si->trace_symtab)
529
532
         show_raw_elf_symbol(i, sym, sym_name, sym_addr, True);
530
533
 
531
534
      if (get_elf_symbol_info(si, sym, sym_name, sym_addr,
539
542
         /* Check if we've seen this (name,addr) key before. */
540
543
         key.addr = sym_addr_really;
541
544
         key.name = sym_name_really;
542
 
         prev = VG_(OSet_Lookup)( oset, &key );
 
545
         prev = VG_(OSetGen_Lookup)( oset, &key );
543
546
 
544
547
         if (prev) {
545
548
 
578
581
            /* Only one or the other is possible (I think) */
579
582
            vg_assert(!(modify_size && modify_tocptr));
580
583
 
581
 
            if (modify_size && VG_(clo_trace_symtab)) {
 
584
            if (modify_size && si->trace_symtab) {
582
585
               VG_(printf)("    modify (old sz %4d)    "
583
586
                           " val %010p, toc %010p, sz %4d  %s\n",
584
587
                           old_size,
588
591
                           (HChar*)prev->key.name
589
592
               );
590
593
            }
591
 
            if (modify_tocptr && VG_(clo_trace_symtab)) {
 
594
            if (modify_tocptr && si->trace_symtab) {
592
595
               VG_(printf)("    modify (upd tocptr)     "
593
596
                           " val %010p, toc %010p, sz %4d  %s\n",
594
597
                            (void*) prev->key.addr, 
601
604
         } else {
602
605
 
603
606
            /* A new (name,addr) key.  Add and continue. */
604
 
            elem = VG_(OSet_AllocNode)(oset, sizeof(TempSym));
 
607
            elem = VG_(OSetGen_AllocNode)(oset, sizeof(TempSym));
605
608
            vg_assert(elem);
606
609
            elem->key      = key;
607
610
            elem->tocptr   = sym_tocptr;
608
611
            elem->size     = sym_size;
609
612
            elem->from_opd = from_opd;
610
 
            VG_(OSet_Insert)(oset, elem);
611
 
            if (VG_(clo_trace_symtab)) {
 
613
            VG_(OSetGen_Insert)(oset, elem);
 
614
            if (si->trace_symtab) {
612
615
               VG_(printf)("   to-oset [%4d]:          "
613
616
                           " val %010p, toc %010p, sz %4d  %s\n",
614
617
                           i, (void*) elem->key.addr,
626
629
      build a "standard" symbol table, and nuke the oset. */
627
630
 
628
631
   i = 0;
629
 
   VG_(OSet_ResetIter)( oset );
 
632
   VG_(OSetGen_ResetIter)( oset );
630
633
 
631
 
   while ( (elem = VG_(OSet_Next)(oset)) ) {
 
634
   while ( (elem = VG_(OSetGen_Next)(oset)) ) {
632
635
      risym.addr   = elem->key.addr;
633
636
      risym.size   = elem->size;
634
637
      risym.name   = ML_(addStr) ( si, elem->key.name, -1 );
636
639
      vg_assert(risym.name != NULL);
637
640
 
638
641
      ML_(addSym) ( si, &risym );
639
 
      if (VG_(clo_trace_symtab)) {
 
642
      if (si->trace_symtab) {
640
643
         VG_(printf)("    record [%4d]:          "
641
644
                     " val %010p, toc %010p, sz %4d  %s\n",
642
645
                     i, (void*) risym.addr,
648
651
      i++;
649
652
   }
650
653
 
651
 
   VG_(OSet_Destroy)( oset, NULL );
 
654
   VG_(OSetGen_Destroy)( oset );
652
655
}
653
656
 
654
657
 
737
740
   if (fd.isError)
738
741
      return 0;
739
742
 
740
 
   if (VG_(fstat)(fd.val, &stat_buf) != 0) {
741
 
      VG_(close)(fd.val);
 
743
   if (VG_(fstat)(fd.res, &stat_buf) != 0) {
 
744
      VG_(close)(fd.res);
742
745
      return 0;
743
746
   }
744
747
 
748
751
   *size = stat_buf.st_size;
749
752
   
750
753
   sres = VG_(am_mmap_file_float_valgrind)
751
 
             ( *size, VKI_PROT_READ, fd.val, 0 );
 
754
             ( *size, VKI_PROT_READ, fd.res, 0 );
752
755
 
753
 
   VG_(close)(fd.val);
 
756
   VG_(close)(fd.res);
754
757
   
755
758
   if (sres.isError)
756
759
      return 0;
757
760
 
758
 
   calccrc = calc_gnu_debuglink_crc32(0, (UChar*)sres.val, *size);
 
761
   calccrc = calc_gnu_debuglink_crc32(0, (UChar*)sres.res, *size);
759
762
   if (calccrc != crc) {
760
 
      SysRes res = VG_(am_munmap_valgrind)(sres.val, *size);
 
763
      SysRes res = VG_(am_munmap_valgrind)(sres.res, *size);
761
764
      vg_assert(!res.isError);
762
765
      if (VG_(clo_verbosity) > 1)
763
766
         VG_(message)(Vg_DebugMsg, "... CRC mismatch (computed %08x wanted %08x)", calccrc, crc);
764
767
      return 0;
765
768
   }
766
769
   
767
 
   return sres.val;
 
770
   return sres.res;
768
771
}
769
772
 
770
773
/*
825
828
   oimage = (Addr)NULL;
826
829
   if (VG_(clo_verbosity) > 1 || VG_(clo_trace_redir))
827
830
      VG_(message)(Vg_DebugMsg, "Reading syms from %s (%p)", 
828
 
                                si->filename, si->start );
 
831
                                si->filename, si->text_start_avma );
829
832
 
830
833
   /* mmap the object image aboard, so that we can read symbols and
831
834
      line number info out of it.  It will be munmapped immediately
837
840
      return False;
838
841
   }
839
842
 
840
 
   n_oimage = VG_(fsize)(fd.val);
 
843
   n_oimage = VG_(fsize)(fd.res);
841
844
   if (n_oimage < 0) {
842
845
      ML_(symerr)("Can't stat .so/.exe (to determine its size)?!");
843
 
      VG_(close)(fd.val);
 
846
      VG_(close)(fd.res);
844
847
      return False;
845
848
   }
846
849
 
847
850
   sres = VG_(am_mmap_file_float_valgrind)
848
 
             ( n_oimage, VKI_PROT_READ, fd.val, 0 );
 
851
             ( n_oimage, VKI_PROT_READ, fd.res, 0 );
849
852
 
850
 
   VG_(close)(fd.val);
 
853
   VG_(close)(fd.res);
851
854
 
852
855
   if (sres.isError) {
853
856
      VG_(message)(Vg_UserMsg, "warning: mmap failed on %s", si->filename );
855
858
      return False;
856
859
   }
857
860
 
858
 
   oimage = sres.val;
 
861
   oimage = sres.res;
 
862
 
 
863
   if (0) {
 
864
      VG_(printf)("read_elf_debug_info: OIMAGE = %p - %p\n", 
 
865
                  (void*)oimage, (void*)(oimage + (UWord)n_oimage));
 
866
   }
859
867
 
860
868
   /* Ok, the object image is safely in oimage[0 .. n_oimage-1]. 
861
869
      Now verify that it is a valid ELF .so or executable image.
926
934
 
927
935
         if (!offset_set) {
928
936
            offset_set = True;
929
 
            offset_oimage = si->start - o_phdr->p_vaddr;
 
937
            offset_oimage = si->text_start_avma - o_phdr->p_vaddr;
930
938
            baseaddr = o_phdr->p_vaddr;
931
939
         }
932
940
 
940
948
         // Get the data and bss start/size if appropriate
941
949
         mapped = o_phdr->p_vaddr + offset_oimage;
942
950
         mapped_end = mapped + o_phdr->p_memsz;
943
 
         if (si->data_start_vma == 0 &&
 
951
         if (si->data_start_avma == 0 &&
944
952
             (o_phdr->p_flags & (PF_R|PF_W|PF_X)) == (PF_R|PF_W)) {
945
 
            si->data_start_vma = mapped;
946
 
            si->data_size      = o_phdr->p_filesz;
947
 
            si->bss_start_vma  = mapped + o_phdr->p_filesz;
 
953
            si->data_start_avma = mapped;
 
954
            si->data_size       = o_phdr->p_filesz;
 
955
            si->bss_start_avma  = mapped + o_phdr->p_filesz;
948
956
            if (o_phdr->p_memsz > o_phdr->p_filesz)
949
957
               si->bss_size = o_phdr->p_memsz - o_phdr->p_filesz;
950
958
            else
954
962
         mapped = mapped & ~(VKI_PAGE_SIZE-1);
955
963
         mapped_end = (mapped_end + VKI_PAGE_SIZE - 1) & ~(VKI_PAGE_SIZE-1);
956
964
 
957
 
         if (VG_(needs).data_syms &&
958
 
             (mapped >= si->start && mapped <= (si->start+si->size)) &&
959
 
             (mapped_end > (si->start+si->size))) {
960
 
            UInt newsz = mapped_end - si->start;
961
 
            if (newsz > si->size) {
 
965
         if (VG_(needs).data_syms 
 
966
             && mapped >= si->text_start_avma 
 
967
             && mapped <= (si->text_start_avma + si->text_size)
 
968
             && mapped_end > (si->text_start_avma + si->text_size)) {
 
969
            /* XXX jrs 2007 Jan 11: what's going on here?  If data
 
970
               syms are involved, surely we shouldn't be messing with
 
971
               the segment's text_size unless there is an assumption
 
972
               that the data segment has been mapped immediately after
 
973
               the text segment.  Which doesn't sound good to me. */
 
974
            UInt newsz = mapped_end - si->text_start_avma;
 
975
            if (newsz > si->text_size) {
962
976
               if (0)
963
977
                  VG_(printf)("extending mapping %p..%p %d -> ..%p %d\n", 
964
 
                              si->start, si->start+si->size, si->size,
965
 
                              si->start+newsz, newsz);
 
978
                              si->text_start_avma, 
 
979
                              si->text_start_avma + si->text_size, 
 
980
                              si->text_size,
 
981
                              si->text_start_avma + newsz, newsz);
966
982
 
967
 
               si->size = newsz;
 
983
               si->text_size = newsz;
968
984
            }
969
985
         }
970
986
      }
971
987
   }
972
988
 
973
 
   si->offset = offset_oimage;
 
989
   si->text_bias = offset_oimage;
 
990
 
 
991
   if (VG_(clo_verbosity) > 2 || VG_(clo_trace_redir))
 
992
      VG_(message)(Vg_DebugMsg, "   svma %010p, avma %010p", 
 
993
                                si->text_start_avma - si->text_bias,
 
994
                                si->text_start_avma );
974
995
 
975
996
   /* If, after looking at all the program headers, we still didn't 
976
997
      find a soname, add a fake one. */
993
1014
   /* Find interesting sections, read the symbol table(s), read any debug
994
1015
      information */
995
1016
   {
996
 
      /* Pointers to start of sections (in the oimage, not in the
997
 
         running image) */
998
 
      UChar*     o_strtab     = NULL; /* .strtab */
999
 
      ElfXX_Sym* o_symtab     = NULL; /* .symtab */
1000
 
      UChar*     o_dynstr     = NULL; /* .dynstr */
1001
 
      ElfXX_Sym* o_dynsym     = NULL; /* .dynsym */
1002
 
      Char*      debuglink    = NULL; /* .gnu_debuglink */
1003
 
      UChar*     stab         = NULL; /* .stab         (stabs)  */
1004
 
      UChar*     stabstr      = NULL; /* .stabstr      (stabs)  */
1005
 
      UChar*     debug_line   = NULL; /* .debug_line   (dwarf2) */
1006
 
      UChar*     debug_info   = NULL; /* .debug_info   (dwarf2) */
1007
 
      UChar*     debug_abbv   = NULL; /* .debug_abbrev (dwarf2) */
1008
 
      UChar*     debug_str    = NULL; /* .debug_str    (dwarf2) */
1009
 
      UChar*     dwarf1d      = NULL; /* .debug        (dwarf1) */
1010
 
      UChar*     dwarf1l      = NULL; /* .line         (dwarf1) */
1011
 
      UChar*     ehframe      = NULL; /* .eh_frame     (dwarf2) */
1012
 
      UChar*     opd_filea    = NULL; /* .opd          (dwarf2, ppc64-linux) */
1013
 
      UChar*     dummy_filea  = NULL;
 
1017
      /* IMAGE addresses: pointers to start of sections (in the
 
1018
         oimage, not in the running image) -- image addresses */
 
1019
      UChar*     strtab_img      = NULL; /* .strtab */
 
1020
      ElfXX_Sym* symtab_img      = NULL; /* .symtab */
 
1021
      UChar*     dynstr_img      = NULL; /* .dynstr */
 
1022
      ElfXX_Sym* dynsym_img      = NULL; /* .dynsym */
 
1023
      Char*      debuglink_img   = NULL; /* .gnu_debuglink */
 
1024
      UChar*     stab_img        = NULL; /* .stab         (stabs)  */
 
1025
      UChar*     stabstr_img     = NULL; /* .stabstr      (stabs)  */
 
1026
      UChar*     debug_line_img  = NULL; /* .debug_line   (dwarf2) */
 
1027
      UChar*     debug_info_img  = NULL; /* .debug_info   (dwarf2) */
 
1028
      UChar*     debug_abbv_img  = NULL; /* .debug_abbrev (dwarf2) */
 
1029
      UChar*     debug_str_img   = NULL; /* .debug_str    (dwarf2) */
 
1030
      UChar*     dwarf1d_img     = NULL; /* .debug        (dwarf1) */
 
1031
      UChar*     dwarf1l_img     = NULL; /* .line         (dwarf1) */
 
1032
      UChar*     ehframe_img     = NULL; /* .eh_frame     (dwarf2) */
 
1033
      UChar*     opd_filea_img   = NULL; /* .opd          (dwarf2, ppc64-linux) */
 
1034
      UChar*     dummy_filea_img = NULL;
1014
1035
 
1015
 
      OffT       o_symtab_offset = offset_oimage;
1016
 
      OffT       o_dynsym_offset = offset_oimage;
 
1036
      OffT       symtab_offset   = offset_oimage;
 
1037
      OffT       dynsym_offset   = offset_oimage;
1017
1038
      OffT       debug_offset    = offset_oimage;
1018
1039
      OffT       opd_offset      = offset_oimage;
1019
1040
 
1020
1041
      /* Section sizes, in bytes */
1021
 
      UInt       o_strtab_sz     = 0;
1022
 
      UInt       o_symtab_sz     = 0;
1023
 
      UInt       o_dynstr_sz     = 0;
1024
 
      UInt       o_dynsym_sz     = 0;
 
1042
      UInt       strtab_sz       = 0;
 
1043
      UInt       symtab_sz       = 0;
 
1044
      UInt       dynstr_sz       = 0;
 
1045
      UInt       dynsym_sz       = 0;
1025
1046
      UInt       debuglink_sz    = 0;
1026
1047
      UInt       stab_sz         = 0;
1027
1048
      UInt       stabstr_sz      = 0;
1033
1054
      UInt       dwarf1l_sz      = 0;
1034
1055
      UInt       ehframe_sz      = 0;
1035
1056
 
1036
 
      /* Section virtual addresses */
1037
 
      Addr       dummy_vma       = 0;
1038
 
      Addr       ehframe_vma     = 0;
 
1057
      /* Section actual virtual addresses */
 
1058
      Addr       dummy_avma      = 0;
 
1059
      Addr       ehframe_avma    = 0;
1039
1060
 
1040
1061
      /* Find all interesting sections */
1041
1062
 
1073
1094
 
1074
1095
         /* Nb: must find where .got and .plt sections will be in the
1075
1096
          * executable image, not in the object image transiently loaded. */
1076
 
         /*   NAME              SIZE           ADDR_IN_OIMAGE  ADDR_WHEN_MAPPED */
1077
 
         FIND(".dynsym",        o_dynsym_sz,   o_dynsym,       dummy_vma)
1078
 
         FIND(".dynstr",        o_dynstr_sz,   o_dynstr,       dummy_vma)
1079
 
         FIND(".symtab",        o_symtab_sz,   o_symtab,       dummy_vma)
1080
 
         FIND(".strtab",        o_strtab_sz,   o_strtab,       dummy_vma)
1081
 
 
1082
 
         FIND(".gnu_debuglink", debuglink_sz,  debuglink,      dummy_vma)
1083
 
 
1084
 
         FIND(".stab",          stab_sz,       stab,           dummy_vma)
1085
 
         FIND(".stabstr",       stabstr_sz,    stabstr,        dummy_vma)
1086
 
 
1087
 
         FIND(".debug_line",    debug_line_sz, debug_line,     dummy_vma)
1088
 
         FIND(".debug_info",    debug_info_sz, debug_info,     dummy_vma)
1089
 
         FIND(".debug_abbrev",  debug_abbv_sz, debug_abbv,     dummy_vma)
1090
 
         FIND(".debug_str",     debug_str_sz,  debug_str,      dummy_vma)
1091
 
 
1092
 
         FIND(".debug",         dwarf1d_sz,    dwarf1d,        dummy_vma)
1093
 
         FIND(".line",          dwarf1l_sz,    dwarf1l,        dummy_vma)
1094
 
         FIND(".eh_frame",      ehframe_sz,    ehframe,        ehframe_vma)
1095
 
 
1096
 
         FIND(".got",           si->got_size,  dummy_filea,    si->got_start_vma)
1097
 
         FIND(".plt",           si->plt_size,  dummy_filea,    si->plt_start_vma)
1098
 
         FIND(".opd",           si->opd_size,  opd_filea,      si->opd_start_vma)
 
1097
         /*   NAME              SIZE           IMAGE addr       AVMA */
 
1098
         FIND(".dynsym",        dynsym_sz,     dynsym_img,      dummy_avma)
 
1099
         FIND(".dynstr",        dynstr_sz,     dynstr_img,      dummy_avma)
 
1100
         FIND(".symtab",        symtab_sz,     symtab_img,      dummy_avma)
 
1101
         FIND(".strtab",        strtab_sz,     strtab_img,      dummy_avma)
 
1102
 
 
1103
         FIND(".gnu_debuglink", debuglink_sz,  debuglink_img,   dummy_avma)
 
1104
 
 
1105
         FIND(".stab",          stab_sz,       stab_img,        dummy_avma)
 
1106
         FIND(".stabstr",       stabstr_sz,    stabstr_img,     dummy_avma)
 
1107
 
 
1108
         FIND(".debug_line",    debug_line_sz, debug_line_img,  dummy_avma)
 
1109
         FIND(".debug_info",    debug_info_sz, debug_info_img,  dummy_avma)
 
1110
         FIND(".debug_abbrev",  debug_abbv_sz, debug_abbv_img,  dummy_avma)
 
1111
         FIND(".debug_str",     debug_str_sz,  debug_str_img,   dummy_avma)
 
1112
 
 
1113
         FIND(".debug",         dwarf1d_sz,    dwarf1d_img,     dummy_avma)
 
1114
         FIND(".line",          dwarf1l_sz,    dwarf1l_img,     dummy_avma)
 
1115
         FIND(".eh_frame",      ehframe_sz,    ehframe_img,     ehframe_avma)
 
1116
 
 
1117
         FIND(".got",           si->got_size,  dummy_filea_img, si->got_start_avma)
 
1118
         FIND(".plt",           si->plt_size,  dummy_filea_img, si->plt_start_avma)
 
1119
         FIND(".opd",           si->opd_size,  opd_filea_img,   si->opd_start_avma)
1099
1120
 
1100
1121
#        undef FIND
1101
1122
      }
1102
1123
         
1103
1124
      /* Did we find a debuglink section? */
1104
 
      if (debuglink != NULL) {
1105
 
         UInt crc_offset = VG_ROUNDUP(VG_(strlen)(debuglink)+1, 4);
 
1125
      if (debuglink_img != NULL) {
 
1126
         UInt crc_offset = VG_ROUNDUP(VG_(strlen)(debuglink_img)+1, 4);
1106
1127
         UInt crc;
1107
1128
 
1108
1129
         vg_assert(crc_offset + sizeof(UInt) <= debuglink_sz);
1109
1130
 
1110
1131
         /* Extract the CRC from the debuglink section */
1111
 
         crc = *(UInt *)(debuglink + crc_offset);
 
1132
         crc = *(UInt *)(debuglink_img + crc_offset);
1112
1133
 
1113
1134
         /* See if we can find a matching debug file */
1114
 
         if ((dimage = find_debug_file(si->filename, debuglink, crc, &n_dimage)) != 0) {
 
1135
         dimage = find_debug_file(si->filename, debuglink_img, crc, &n_dimage);
 
1136
         if (dimage != 0) {
1115
1137
            ehdr = (ElfXX_Ehdr*)dimage;
1116
1138
 
1117
1139
            if (n_dimage >= sizeof(ElfXX_Ehdr) 
1119
1141
                && ehdr->e_phoff + ehdr->e_phnum*sizeof(ElfXX_Phdr) <= n_dimage
1120
1142
                && ehdr->e_shoff + ehdr->e_shnum*sizeof(ElfXX_Shdr) <= n_dimage)
1121
1143
            {
1122
 
               Bool need_symtab = (NULL == o_symtab);
 
1144
               Bool need_symtab = (NULL == symtab_img);
 
1145
               Bool need_stabs = (NULL == stab_img);
 
1146
               Bool need_dwarf2 = (NULL == debug_info_img);
 
1147
               Bool need_dwarf1 = (NULL == dwarf1d_img);
1123
1148
 
1124
1149
               for (i = 0; i < ehdr->e_phnum; i++) {
1125
1150
                  ElfXX_Phdr *o_phdr = &((ElfXX_Phdr *)(dimage + ehdr->e_phoff))[i];
1126
1151
                  if (o_phdr->p_type == PT_LOAD) {
1127
 
                     offset_dimage = si->start - o_phdr->p_vaddr;
 
1152
                     offset_dimage = si->text_start_avma - o_phdr->p_vaddr;
1128
1153
                     break;
1129
1154
                  }
1130
1155
               }
1131
1156
 
1132
1157
               debug_offset = offset_dimage;
1133
1158
               if (need_symtab)
1134
 
                  o_symtab_offset = offset_dimage;
 
1159
                  symtab_offset = offset_dimage;
1135
1160
 
1136
1161
               shdr = (ElfXX_Shdr*)(dimage + ehdr->e_shoff);
1137
1162
               sh_strtab = (UChar*)(dimage + shdr[ehdr->e_shstrndx].sh_offset);
1138
1163
 
1139
1164
               /* Same deal as previous FIND, except simpler - doesn't
1140
 
                  look for vma, only oimage address. */
 
1165
                  look for avma, only oimage address. */
1141
1166
 
1142
1167
               /* Find all interesting sections */
1143
1168
               for (i = 0; i < ehdr->e_shnum; i++) {
1161
1186
                     } \
1162
1187
                  }
1163
1188
 
1164
 
                  FIND(need_symtab, ".symtab",       o_symtab_sz,   o_symtab)
1165
 
                  FIND(need_symtab, ".strtab",       o_strtab_sz,   o_strtab)
1166
 
                  FIND(1,           ".stab",         stab_sz,       stab)
1167
 
                  FIND(1,           ".stabstr",      stabstr_sz,    stabstr)
1168
 
                  FIND(1,           ".debug_line",   debug_line_sz, debug_line)
1169
 
                  FIND(1,           ".debug_info",   debug_info_sz, debug_info)
1170
 
                  FIND(1,           ".debug_abbrev", debug_abbv_sz, debug_abbv)
1171
 
                  FIND(1,           ".debug_str",    debug_str_sz,  debug_str)
1172
 
                  FIND(1,           ".debug",        dwarf1d_sz,    dwarf1d)
1173
 
                  FIND(1,           ".line",         dwarf1l_sz,    dwarf1l)
 
1189
                  /*   ??           NAME             SIZE           IMAGE addr */
 
1190
                  FIND(need_symtab, ".symtab",       symtab_sz,     symtab_img)
 
1191
                  FIND(need_symtab, ".strtab",       strtab_sz,     strtab_img)
 
1192
                  FIND(need_stabs,  ".stab",         stab_sz,       stab_img)
 
1193
                  FIND(need_stabs,  ".stabstr",      stabstr_sz,    stabstr_img)
 
1194
                  FIND(need_dwarf2, ".debug_line",   debug_line_sz, debug_line_img)
 
1195
                  FIND(need_dwarf2, ".debug_info",   debug_info_sz, debug_info_img)
 
1196
                  FIND(need_dwarf2, ".debug_abbrev", debug_abbv_sz, debug_abbv_img)
 
1197
                  FIND(need_dwarf2, ".debug_str",    debug_str_sz,  debug_str_img)
 
1198
                  FIND(need_dwarf1, ".debug",        dwarf1d_sz,    dwarf1d_img)
 
1199
                  FIND(need_dwarf1, ".line",         dwarf1l_sz,    dwarf1l_img)
1174
1200
 
1175
1201
#                 undef FIND
1176
1202
               }
1179
1205
      }
1180
1206
 
1181
1207
      /* Check some sizes */
1182
 
      vg_assert((o_dynsym_sz % sizeof(ElfXX_Sym)) == 0);
1183
 
      vg_assert((o_symtab_sz % sizeof(ElfXX_Sym)) == 0);
 
1208
      vg_assert((dynsym_sz % sizeof(ElfXX_Sym)) == 0);
 
1209
      vg_assert((symtab_sz % sizeof(ElfXX_Sym)) == 0);
1184
1210
 
1185
1211
      /* Read symbols */
1186
1212
      {
1192
1218
         read_elf_symtab = read_elf_symtab__normal;
1193
1219
#        endif
1194
1220
         read_elf_symtab(si, "symbol table",
1195
 
                         o_symtab, o_symtab_sz, o_symtab_offset,
1196
 
                         o_strtab, o_strtab_sz, opd_filea, opd_offset);
 
1221
                         symtab_img, symtab_sz, symtab_offset,
 
1222
                         strtab_img, strtab_sz, 
 
1223
                         opd_filea_img, opd_offset);
1197
1224
 
1198
1225
         read_elf_symtab(si, "dynamic symbol table",
1199
 
                         o_dynsym, o_dynsym_sz, o_dynsym_offset,
1200
 
                         o_dynstr, o_dynstr_sz, opd_filea, opd_offset);
 
1226
                         dynsym_img, dynsym_sz, dynsym_offset,
 
1227
                         dynstr_img, dynstr_sz, 
 
1228
                         opd_filea_img, opd_offset);
1201
1229
      }
1202
1230
 
1203
1231
      /* Read .eh_frame (call-frame-info) if any */
1204
 
      if (ehframe) {
1205
 
         ML_(read_callframe_info_dwarf2) ( si, ehframe, ehframe_sz, ehframe_vma );
 
1232
      if (ehframe_img) {
 
1233
         ML_(read_callframe_info_dwarf3)
 
1234
            ( si, ehframe_img, ehframe_sz, ehframe_avma );
1206
1235
      }
1207
1236
 
1208
1237
      /* Read the stabs and/or dwarf2 debug information, if any.  It
1209
1238
         appears reading stabs stuff on amd64-linux doesn't work, so
1210
1239
         we ignore it. */
1211
1240
#     if !defined(VGP_amd64_linux)
1212
 
      if (stab && stabstr) {
1213
 
         ML_(read_debuginfo_stabs) ( si, debug_offset, stab, stab_sz, 
1214
 
                                         stabstr, stabstr_sz );
 
1241
      if (stab_img && stabstr_img) {
 
1242
         ML_(read_debuginfo_stabs) ( si, debug_offset, stab_img, stab_sz, 
 
1243
                                         stabstr_img, stabstr_sz );
1215
1244
      }
1216
1245
#     endif
1217
1246
      /* jrs 2006-01-01: icc-8.1 has been observed to generate
1219
1248
         debuginfo reading for that reason, but, in
1220
1249
         read_unitinfo_dwarf2, do check that debugstr is non-NULL
1221
1250
         before using it. */
1222
 
      if (debug_info && debug_abbv && debug_line /* && debug_str */) {
 
1251
      if (debug_info_img && debug_abbv_img && debug_line_img
 
1252
                                           /* && debug_str_img */) {
1223
1253
         ML_(read_debuginfo_dwarf2) ( si, debug_offset, 
1224
 
                                      debug_info,   debug_info_sz,
1225
 
                                      debug_abbv,
1226
 
                                      debug_line,   debug_line_sz,
1227
 
                                      debug_str );
 
1254
                                      debug_info_img,   debug_info_sz,
 
1255
                                      debug_abbv_img,
 
1256
                                      debug_line_img,   debug_line_sz,
 
1257
                                      debug_str_img );
1228
1258
      }
1229
 
      if (dwarf1d && dwarf1l) {
1230
 
         ML_(read_debuginfo_dwarf1) ( si, dwarf1d, dwarf1d_sz, 
1231
 
                                          dwarf1l, dwarf1l_sz );
 
1259
      if (dwarf1d_img && dwarf1l_img) {
 
1260
         ML_(read_debuginfo_dwarf1) ( si, dwarf1d_img, dwarf1d_sz, 
 
1261
                                          dwarf1l_img, dwarf1l_sz );
1232
1262
      }
1233
1263
   }
1234
1264
   res = True;