Inhaltsverzeichnis. 9.1 Einführung 9.2 Die Objekt-Datei. 9.3 Der Linker. 9.4 Der Lader. Inhalt von Objekt-Dateien Beispiele:.COM, a.

Transkript

1 Inhaltsverzeichnis 9.1 Einführung Inhalt von Objekt-Dateien Beispiele:.COM, a.out, ELF 9.3 Der Linker Aufgabe und Arbeitsweise Speicherlayout Symbol-Management Relocation 9.4 Der Lader 1

2 9.1 Einführung Programm aus Sicht des Programmierers math.c const int DIV_OK = 0; const int DIV_BY_ZERO = 1; int errno = 0; int div( int a, int b ) { if (b==0) { errno = DIV_BY_ZERO; return -1; } else { errno = DIV_OK; return a/b; } } prog.c extern int errno; extern const int DIV_OK; extern const int DIV_BY_ZERO; int main( int argc, char *argv[] ) { int a = 21; int b = 3; } int c = div( a,b ); if (errno == DIV_OK) return 0; else return -1; Adressen sind durch Symbole repräsentiert (z.b. errno, div ) Programm ist unabhängig von späteren Lage im Speicher 2

3 9.1 Einführung Programm aus Sicht des Prozessors Dump of assembler code for function main: 0x <main+0>: push %ebp x e <main+26>: sub %eax,%esp 0x <main+28>: movl $0x15,0xfffffff4(%ebp) // int a=21a = 21; 0x <main+35>: movl $0x3,0xfffffff8(%ebp) // int b=3 b = 3; 0x e <main+42>: sub $0x8,%esp 0x <main+45>: pushl 0xfffffff8(%ebp) 0x <main+48>: pushl 0xfffffff4(%ebp) 0x <main+51>: call 0x80483b8 <div> // int div(a,b) c = div( a,b ); 0x c <main+56>: add $0x10,%esp 0x f <main+59>: mov %eax,0xfffffffc(%ebp) // c=... 0x <main+62>: mov 0x80496a4,%edx // if errno (errno == 0x <main+68>: mov 0x ,%eax // DIV_OK DIV_OK) 0x d <main+73>: cmp %eax,%edx // errno==div_ok 0x f <main+75>: jne 0x804845a <main+86> 0x <main+77>: movl $0x0,0xffffffec(%ebp) return 0; 0x <main+84>: jmp 0x <main+93> else 0x a <main+86>: movl $0xffffffff,0xffffffec(%ebp) return -1; 0x <main+93>: mov 0xffffffec(%ebp),%eax 0x <main+96>: leave 0x <main+97>: ret } Adressen sind absolute Zahlen int main(int argc,char *argv[]) { 3

4 Programmerzeugung: Schritt 1 Compilieren Source Object math.c prog.c Compiler math.o prog.o Source Adressen symbolisch ( errno, div ) Compiler Erzeugt Objekt-Datei text-segment: enthält Programmcode data-segment: enthält initialisierte globale Variablen und Datenstrukturen bss-segment (Block Started by Symbol): enthält uninitialisierte globale Daten... Bindet symbolische Adressen an relative numerische Adressen, z.b. div befindet sich 16 Bytes nach Beginn des.text-segments errno befindet sich 8 Bytes nach Beginn des.data-segments 4

5 Programmerzeugung: Schritt 2 Linken Source Object Executable math.c prog.c Compiler math.o prog.o Linker prog Linker Eingabe: Menge von Objekt-Dateien Ausgabe: Ausführbares Programm gemeinsames text-segment gemeinsames data-segment gemeinsames bss-segment Querbezüge zwischen den Objekt-Dateien sind aufgelöst Je nach Betriebssystem: - Executable: Adressen sind absolut; Programm kann geladen und direkt gestartet werden - Relocatable: Adressen sind noch relativ; Programm muss vor Start noch angepasst werden 5

6 Inhalt einer Objekt-Datei Header: Allgemeine Info, z.b. Größe des Codes Objekt-Code: binäre Instruktionen (Maschinencode) und Daten Relocation: Liste von Stellen innerhalb des Programmcodes oder der Daten, die angepasst werden müssen, wenn die Startadresse des Codes verschoben wird Symbole: globale Symbole, die definiert werden; Symbole, die importiert werden Debug-Informationen: z.b. Zeilennummern in Quelldatei, lokale Symbole,... Aufgaben Linkable: kann als Eingabe eines Linkers verwendet werden enthält Symbol- und Relocation-Informationen, die vom Linker benötigt werden Executable: kann in den Speicher geladen und ausgeführt werden enthält keine Symbol- und wenig/keine Relocation-Information Loadable: kann als Bibliothek mit anderem Programm in den Speicher geladen werden Kombinationen sind möglich. 6

7 Beispiele MS-DOS.COM a.out enthält nur ein zu ladenes Speicherabbild Datei wird an fest definierte Stelle geladen und gestartet Objektformat unter UNIX Neuer Adressraum für jeden Prozess Programm wird fest auf immer dieselbe Adresse gelinkt a.out-header int a_magic; // Definierte Zahl (0407) int a_text; // Größe des Textsegments (Programmcode) int a_data; // Größe des Datensegments int a_bss; // Größe der uninitialisierten Daten int a_syms; // Größe der Symboltabelle int a_entry; // Startadresse des Programms int a_trsize; // Größe der Text-Relocation-Informationen int a_drsize; // Größe der Daten-Relocation-Informationen a.out-objektformat a.out-header text Section (Maschinen- Code) data Section (Daten) Relocation Info (text + data) Symboltabelle Stringtabelle 7

8 Einschub: Logischer Physikalischer Adressraum Logischer Adressraum enthält die von der CPU angefragten Adressen auch virtueller Adressraum genannt Physikalischer Adressraum tatsächlich bei Speichereinheit angefragten Adressen (Inhalt Memory-Address-Register ) relocation Register CPU logische Adresse physikalische Adresse Memory Memory- Management- Unit (MMU) 8

9 Beispiele ELF (Executable and Linking Format) Objektformat unter UNIX 3 Objektarten: - relocatable: werden von Compilern erzeugt und benötigen Linkerdurchlauf bevor sie gestartet werden können - executable: Relocation durchgeführt, Symbole aufgelöst, startfähig - shared object: Enthalten sowohl Symbolinformation für Linker als auch direkt lauffähigen Code linkable sections ELF-Header Program Header Table.text.init.fini executable segments RO, EXEC Duale Natur: - Compiler und Linker interpretieren Datei als Menge von logischen Sektionen..data.bss RW - Lader interpretiert Datei als Menge von Segmenten..rodata RO Section Header Table 9

10 ELF-Header char magic[4] = "\177ELF"; // magic number char class; // address size, 1 = 32bit, 2 = 64bit char byteorder; // 1 = little endian, 2 = big endian char hversion; // header version, always 1 char pad[9]; short filetype; // 1 = reloc., 2 = exec., 3 = shared obj short archtype; // 2 = SPARC, 3 = x86, 4 = M68K,... int fversion; // file version, always 1 int entry; // entry point (if executable) int phdrpos; // file position of program header or 0 int shdrpos; // file position of section header or 0 int flags; // architecture specific flags; usually 0 short hdrsize; // size of this ELF header short phdrent; // size of an entry in program header short phdrcnt; // number of entries in program header or 0 short shdrent; // size of an entry in section header short shdrcnt; // number of entries in section header or 0 short strsec; // section number containing section name strings 10

11 ELF Relocatable Files - Menge von Sektionen, jeweils definiert durch Section-Header int sh_name; // name, index into the string table int sh_type; // section type int sh_flags; // flags int sh_addr; // base memory address (if loadable), or 0 int sh_offset; // file position of beginning of section int sh_size; // size in bytes int sh_link; // section number with related info or 0 int sh_info; // more section-specific info int sh_align; // alignment granularity if section is moved int sh_entsize; // size of entries if section holds table - jede Sektion enthält max. eine Art von Information, z.b. Programcode, RO-Data,... - Section Types: o PROGBITS: Programminhalte, z.b. Code, Data, Debug-Info,... o SYMTAB, DYNTAB: Normale Symboltabelle bzw. Symboltabelle für dynamisches Linken o STRTAB: Stringtabelle; enthält Sektionsamen, Symbolnamen o REL: Relocation Information o... - Flags: o ALLOC: Sektion verbraucht Speicher, wenn Datei geladen wird o WRITE: geladene Sektion ist beschreibbar o EXECINSTR: Sektion enthält ausführbaren Code 11

12 ELF-Sektionen: Beispiele -.text: Type PROGBITS, Flags ALLOC+EXECINSTR. Äquivalent zum a.out text-segment -.data: Type PROGBITS, Flags ALLOC+WRITE. Äquivalent zum a.out data-segment -.rodata: Type PROGBITS, Flags ALLOC. Read-only data -.bss: Type NOBITS, Flags ALLOC+WRITE. -.rel.text,.rel.data,.rel.rodata: Type REL. Relocation Informationen der jeweiligen Sektion -.init,.fini: Type PROGBITS, Flags ALLOC+EXECINSTR. Code für Programmstart u. ende (z.b. für C++/Java-Programme mit globalen Objekten, die Konstruktoren und Destruktoren besitzen) -.symtab,.dynsym: Type SYMTAB bzw. DYNSYM. Symboltabellen (normale und dynamische)..dynsym hat Flag ALLOC, da sie zur Laufzeit geladen werden muss. -.strtab,.dynstr: Type STRTAB Relocatable ELF file ELF header.text.data.rodata.bss.sym.rel.text.rel.data.rel.rodata.line.debug.strtab Section Header Table 12

13 ELF Executable Files - Ähnlicher Aufbau wie Relocatable Files - Daten sind so gespeichert, dass Datei direkt in den Hauptspeicher eingeblendet und gestartet werden kann - Program Header: Array von Beschreibungen der einzublendenden Segmente int type; // loadable code or data, dynamic linking info,... int offset; // file offset of segment int virtaddr; // virtual address of the segment int physaddr; // physical address, not used int filesize; // size of segment in file int memsize; // size of segment in memory int flags; // Read, Write, Execute bits int align; // required alignment - Ein ausführbares Programm enthält in der Regel nur wenige Segmente: ein Read-Only-Segment für Code und RO-Data und ein Read-Write-Segment für RW-Data - Alle zu ladenden Sektionen sind in den entsprechenden Segmenten definiert, sodass sie mit möglichst wenigen Operationen in den Hauptspeicher eingeblendet werden können. ELF Shared Object - Enthält Elemente von Relocatable und Executable Files 13

14 9.3 Der Linker Aufgabe Kombination von Objektdateien zu einem ausführbaren Programm. Statisches Binden Bibliotheksfunktionen werden in das ausführbare Programmobjekt kopiert. Große Programmdateien Aktualisieren der Bibl. aufwändig Programm 1 printf exit libc.a Programm 1 Programm 2 Dynamisches Binden zur Startzeit Bibliotheksfunktionen werden einmal in den Speicher geladen und beim Programmstart gebunden. Programm 2 printf exit libc.a printf exit libc.so Dynamisches Binden zur Laufzeit Binden findet erst beim Aufruf einer Bibliotheksfunktion statt. Statisches Binden Dynamisches Binden mit gemeinsam genutzter Bibliothek 14

15 9.3 Der Linker Zwei Phasen 1. Scannen aller Eingabedateien Größe der Text- und Datensegmente ( Segmenttabelle) Symboldefinitionen und -referenzen ( Symboltabelle) Layout der Ausgabedatei (Größe und Anordnung der Segmente) Symbole -> Numerische Adressen 2. Erzeugen der Ausgabedatei Einlesen der Objektdateien und Anpassen der Adressen im Code und in den Daten Schreiben des modifizierten Codes in die Ausgabedatei Numerische Adressen statt Symbole wenn möglich Symboltabelle erzeugen und schreiben (Relinking oder Debugging) Relocation-Informationen erzeugen und schreiben 15

16 9.3 Der Linker Speicher-Layout der Ausgabedatei Alle Sektionen gleichen Typs aus den Eingabedateien ergeben eine Sektion in der Ausgabedatei; in der Regel werden die einzelnen Sektionen hintereinander geschrieben 1. Durchlauf: Feststellen der Sektionsgrößen A text data bss B output text 2. Durchlauf: Anordnen der Sektionen a.out: funktioniert in der Art text data data ELF: Linker muss zusätzlich Program Header Table und Section Header Table anpassen/erzeugen bss C bss text data bss 16

17 9.3 Der Linker Symbol-Management Linker behandeln Symbolreferenzierungen zwischen Modulen Symbole werden in einer Symboltabelle gespeichert Verschiedene Arten von Symbolen in Eingabedateien: globale Symbole, die im Modul definiert werden globale Symbole, die im Modul verwendet, aber nicht definiert werden ( externals ) Segmentnamen Nicht-globale Symbole, die für Debugger und Crash- Analysen verwendet werden Zeilennummer-Informationen für Debugger Während des 1. Linker-Durchlaufs: Aufbau einer globalen Symboltabelle Enthält alle Symbole, die irgendwo definiert oder verwendet werden Zu jedem Symbol werden alle Orte gespeichert, an denen es verwendet oder definiert wird (nach erstem Durchlauf sollte jedes Symbol genau einmal definiert worden sein) Globale Symboltabelle ist i.d.r. als Hashtabelle realisiert Symboltabelle Modul_A 0 Info zu Symbol 0 1 Info zu Symbol 1 2 Info zu Symbol globale Symboltabelle 17

18 9.3 Der Linker Relocation Bisher: Segmentgrößen und Symbole eingelesen, Layout der Ausgabedatei Problem: Symbole und Adressen sind relativ zu Eingabedateien definiert Relocation Anpassen von Sprung- und Speicheradressen an Layout der Ausgabe Bsp.: Zeiger zeigt auf Position 100, Segment ist in Ausgabedatei an Position 1000 Zeiger muss auf 1100 zeigen Auflösen von externen Symbolen Bsp.: Anweisung ruft Prozedur div auf, die an Position 500 liegt in einem Segment, das an Position 1000 liegt Anweisung muss Adresse 1500 referenzieren mod1.c int b=7; extern int b; int a; 0x9A12 0x mod2.c b=a; Compiler mov mov Assembler Linker a,%eax %eax,b A A A A3 12 9A a: Pos. 0x1234.text.data 18

19 9.3 Der Linker Relocation Hardware + Software Relocation Betriebssystem kann jedem Prozess einen eigenen virtuellen Adressraum geben, der an einer definierten virtuellen Adresse beginnt Tatsächlicher Speicherzugriff über Memory Management Unit Linker kombiniert Eingabedateien zu einer großen Ausgabedatei, die ohne weitere Anpassungen in den virtuellen Adressraum geladen werden kann + Einfacher Ladevorgang + Fehlerhafte Programme können andere Programme nicht stören Link-Time- + Load-Time-Relocation Beispiel MS-DOS: Link-Time-Relocation: jedes Programm wird so gebunden, als würde es an Speicherposition Null geladen werden. Load-Time-Relocation: tatsächliche Adresse hängt vom verfügbaren Speicher ab und das Programm muss beim Start angepasst werden. Beispiel Windows: Link-Time-Relocation: jedes Programm wird so gebunden, als würde es an einer wohldefinierten Adresse geladen werden. Load-Time-Relocation: i.d.r. ist diese Adresse verfügbar, d.h. keine Anpassung notwendig. Selten: Adresse ist in Gebrauch und Anpassung muss vorgenommen werden. 19

20 9.4 Der Lader Aufgabe: Programm in den Hauptspeicher bringen und starten Segmentation Einlesen der Header-Informationen, um Speicheranforderungen zu bestimmen Prüfen, ob Programmtext bereits im Speicher; nein text-segment laden Privates Datensegment anlegen, Daten aus Datei laden, bss-bereich mit 0 belegen Stack-Segment anlegen, Kommandozeilenparameter ablegen Register initialisieren Zur Startadresse springen a.out-datei Prozess Paging Virtuellen Speicher für Daten und Code anlegen Teile der Datei direkt in den Hauptspeicher einblenden hdr text data text size bss size data size text data bss heap stack 20

21 9.2 Der Lader Paging und Virtueller Speicher Adressraum des Programms wird in Seiten fester Größe unterteilt ( Pages ) Physikalischer Speicher wird in Rahmen der gleichen Größe unterteilt ( Frames ) Page Table mit Eintrag für jede Seite des Adressraums Eintrag enthält Adresse der Seite im physikalischen Speicher oder not present Seite muss bei Zugriff von Hintergrundspeicher nachgeladen werden Inhalt einer Datei direkt in den Hauptspeicher einblenden Dieselbe Seite mehreren Prozessen zur Verfügung stellen Virtueller Adressraum Page Table Physikalischer Speicher Hintergrundspeicher 21