ELF File Offset für Sektionen

[D. F. (Firma: EDF) (derdan)]

Hallo,
ich würde gerne ein Tool bauen, welches ein ELF File einlesen kann. 
Controler ist AVR32U3C3 und die GCC Toolchain von Atmel Studio 6.2 wird 
benutzt.

Mit dem tool arvr32-objdump -
C:\mingw\bin\objdump my.elf -h -p >dump.txt

SBS_Boot_Secondary_HW25.elf:     file format elf32-big

Program Header:
    LOAD off    0x00000400 vaddr 0x80000000 paddr 0x80000000 align 2**10
         filesz 0x00018980 memsz 0x00018980 flags rwx
    NULL off    0x00000000 vaddr 0x00000004 paddr 0x00000004 align 2**0
         filesz 0x00000000 memsz 0x00000004 flags rw-
    LOAD off    0x00019008 vaddr 0x00000008 paddr 0x80018328 align 2**10
         filesz 0x00000650 memsz 0x00000650 flags rw-
    NULL off    0x00000000 vaddr 0x00000658 paddr 0x00000658 align 2**2
         filesz 0x00000000 memsz 0x0000f9a8 flags rw-
    LOAD off    0x00019658 vaddr 0x00000000 paddr 0x00000000 align 2**10
         filesz 0x00000000 memsz 0x00000000 flags ---
    NULL off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2
         filesz 0x00000000 memsz 0x00000000 flags ---
    LOAD off    0x00019658 vaddr 0x00000000 paddr 0x00000000 align 2**10
         filesz 0x00000000 memsz 0x00000000 flags ---

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .reset        00008400  80000000  80000000  00000400  2**9
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .rela.got     00000000  80008400  80008400  00008800  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  2 .text         0000ff24  80008400  80008400  00008800  2**9
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  3 .lalign       00000004  80018324  80018324  00018724  2**0
                  ALLOC
  4 .dalign       00000004  00000004  00000004  00000000  2**0
                  ALLOC
  5 .ctors        00000008  00000008  80018328  00019008  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  6 .dtors        00000008  00000010  80018330  00019010  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  7 .jcr          00000004  00000018  80018338  00019018  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  8 .got          0000000c  0000001c  8001833c  0001901c  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  9 .data         00000630  00000028  80018348  00019028  2**2
                  CONTENTS, ALLOC, LOAD, DATA
 10 .bss          00001048  00000658  00000658  00000000  2**2
                  ALLOC
 11 .heap         0000d960  000016a0  000016a0  00000000  2**0
                  ALLOC
 12 .comment      00000030  00000000  00000000  00019658  2**0
                  CONTENTS, READONLY
 13 .debug_aranges 00001a08  00000000  00000000  00019688  2**0
                  CONTENTS, READONLY, DEBUGGING
 14 .debug_pubnames 0000380f  00000000  00000000  0001b090  2**0
                  CONTENTS, READONLY, DEBUGGING
 15 .debug_info   00035c10  00000000  00000000  0001e89f  2**0
                  CONTENTS, READONLY, DEBUGGING
 16 .debug_abbrev 000079e7  00000000  00000000  000544af  2**0
                  CONTENTS, READONLY, DEBUGGING
 17 .debug_line   0001dd3c  00000000  00000000  0005be96  2**0
                  CONTENTS, READONLY, DEBUGGING
 18 .debug_frame  00004adc  00000000  00000000  00079bd4  2**2
                  CONTENTS, READONLY, DEBUGGING
 19 .debug_str    00008889  00000000  00000000  0007e6b0  2**0
                  CONTENTS, READONLY, DEBUGGING
 20 .debug_loc    0000d300  00000000  00000000  00086f39  2**0
                  CONTENTS, READONLY, DEBUGGING
 21 .debug_macinfo 024bf56b  00000000  00000000  00094239  2**0
                  CONTENTS, READONLY, DEBUGGING
 22 .stack        00001000  0000f000  0000f000  00000000  2**0
                  ALLOC
 23 .checksum     00000008  80018978  80018978  00018d78  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 24 .debug_ranges 00001a08  00000000  00000000  025537a4  2**0
                  CONTENTS, READONLY, DEBUGGING

Mit meinem Versuch mit der ELFIO Biliothek http://elfio.sourceforge.net/ 
kommt folgende Ausgabe.
Die Unterschiede sind in der Sektion „.ctors“ dort ist die Adresse bei 
objdump bei 0x80018328 (das stimmt auch mit dem Heximage überein) bei 
ELFIO bei 0x000000008, was wohl nur ein Offset auf eine andere Adresse 
ist. Nun die Frage, wie bestimme ich diesen unbekannten Offset. Bzw. 
wie macht das Objdump von GCC das?

ELF Header

  Class:      ELF32
  Encoding:   Big endian
  ELFVersion: Current
  Type:       Executable file
  Machine:    Atmel Corporation 32-bit microprocessor family
  Version:    Current
  Entry:      0x80000000
  Flags:      0x0

Section Headers:
[  Nr ] Type              Addr     Size     ES Flg Lk Inf Al Name
[    0] NULL              00000000 00000000 00     00 000  0
[    1] PROGBITS          80000000 00008400 00 AX  00 000 10 .reset
[    2] RELA              80008400 00000000 0c A   00 009  3 .rela.got
[    3] PROGBITS          80008400 0000ff24 00 AX  00 000 10 .text
[    4] NOBITS            80018324 00000004 00 WA  00 000  1 .lalign
[    5] NOBITS            00000004 00000004 00 WA  00 000  1 .dalign
[    6] PROGBITS          00000008 00000008 00 WA  00 000  3 .ctors
[    7] PROGBITS          00000010 00000008 00 WA  00 000  3 .dtors
[    8] PROGBITS          00000018 00000004 00 WA  00 000  3 .jcr
[    9] PROGBITS          0000001c 0000000c 04 WA  00 000  3 .got
[   10] PROGBITS          00000028 00000630 00 WA  00 000  3 .data
[   11] NOBITS            00000658 00001048 00 WA  00 000  3 .bss
[   12] NOBITS            000016a0 0000d960 00 WA  00 000  1 .heap
[   13] PROGBITS          00000000 00000030 01     00 000  1 .comment
[   14] PROGBITS          00000000 00001a08 00     00 000  1 .debug_aranges
[   15] PROGBITS          00000000 0000380f 00     00 000  1 .debug_pubnames
[   16] PROGBITS          00000000 00035c10 00     00 000  1 .debug_info
[   17] PROGBITS          00000000 000079e7 00     00 000  1 .debug_abbrev
[   18] PROGBITS          00000000 0001dd3c 00     00 000  1 .debug_line
[   19] PROGBITS          00000000 00004adc 00     00 000  3 .debug_frame
[   20] PROGBITS          00000000 00008889 01     00 000  1 .debug_str
[   21] PROGBITS          00000000 0000d300 00     00 000  1 .debug_loc
[   22] PROGBITS          00000000 024bf56b 00     00 000  1 .debug_macinfo
[   23] NOBITS            0000f000 00001000 00 WA  00 000  1 .stack
[   24] PROGBITS          80018978 00000008 00 AX  00 000  1 .checksum
[   25] PROGBITS          00000000 00001a08 00     00 000  1 .debug_ranges
[   26] STRTAB            00000000 00000105 00     00 000  1 .shstrtab
[   27] SYMTAB            00000000 00002960 10     1c 141  3 .symtab
[   28] STRTAB            00000000 000028f9 00     00 000  1 .strtab
Key to Flags: W (write), A (alloc), X (execute)

[Volle (Gast)]

Hab ich schon gemacht

Da du keine Frage hast musst du es einfach nur machen.


Ach ja,  das Format lässt einige Freiräume die von Compilern und Linkern 
recht unterschiedlich ausgenutzt werden

[D. F. (Firma: EDF) (derdan)]

Na die Frage ist doch, wie dieser Offset auszurechnen ist.

[Volle (Gast)]

Beide Tools liefern nicht den Inhalt des ELF Files 1:1

es werden zum Teil schon Berechnungen durchgeführt
objdump ist sehr gut
elfio kenne ich nicht



Intern arbeiten das Elf mit vielen Tabellen  die über den File ofset 
miteienander verbunden sind

So sind Namen sind zB. einer eigen String Liste und es wird mit einem 
Ofset auf den Begin des Strings  gezeigt

[D. F. (Firma: EDF) (derdan)]

Vielen Dank für die Information.
Aber wie rechnet man den nun diesen Offset aus?

[Volle (Gast)]

Wenn ich es noch recht weiss bezieht sich der Fileoffset auf den Index 
der jeweiligen Tabelle. Deren Beginn steht in einer anderen Tabelle

Da must du aber direkt in der Formatbeschreibung nachschauen

die Tools liefern ja schon einer Auswertung und nicht Orginalteile des 
Files


aber der objdump  und readelf mir ihren vielen Optionen liefern recht 
viel  in vielen möglichen Formatierungen

http://www.cs.princeton.edu/courses/archive/spr08/cos217/reading/elf.pdf

https://en.wikipedia.org/wiki/Executable_and_Linkable_Format


ich habe es mit perl und java gelesen
besser geht es aber mit c++

Um  file lokale Sprungziele aufzulösen kann man auch die *.o file 
auszuwerten.
Selbes Format  andere Sections und relativ adressiert

Mühsam sind die DWARF Debug Infos