Technische Informatik II -...

J. Kaiser, IVS-EOS Technische Informatik II Sommersemester 2014

Otto-von-Guericke-Universität Magdeburg

Technische Informatik II

Prozessornahe Programmiertechniken


Prozessornahe Programmiertechniken !

Variablen und Zuweisungen!!

Positionsunabhängiger Code!

Unterprogrammtechniken!

Datenstrukturen und Zeiger!

2!

Assembler, Binder, Lader: !Von der Hochsprache zum ausführbaren Speicherabbild!


Sp.- Adr OPC OP-Adr. ! ! !HEX! ! ! ! !00010000 1001 10000001 ! ! !10 9 81! ! !00010001 1000 00000000 ! ! !11 8 00! !00010010 1011 10000010 ! ! !12 B 82! !00010011 1011 10000100 ! ! !13 B 84! !00010100 1010 10000011 ! ! !14 A 83! !00010101 1001 10000000 ! ! !15 9 80! !00010110 0101 00000000 ! ! !16 5 00! !00010111 1010 10000000 ! ! !17 A 80! !00011000 1001 10000010 ! ! !18 9 82! !00011001 1000 00000000 ! ! !19 8 00! !00011010 1011 10000010 ! ! !1A B 82! !00011011 1011 10000011 ! ! !1B B 83! !00011100 0001 00011110 ! ! !1C 1 1E! !00011101 0010 00010101 ! ! !1D 2 15! !00011110 0000 00000000 ! ! !1E 0 00! !

Maschinencode des !Beispielprogramms: !“!Rotate Right“!

Von der Hochsprache zum ausführbaren Speicherabbild!


Proz

esso

r-!ab

häng

ig!

Programm in einer Hochsprache!Pr

ozes

sor-!

unab

häng

ig!

!int fact (int n)!{! f = 1;! i = 1;! while (i++ < n)! f = f * i;! return (f);!}!Übersetzer (Compiler)!

Assemblerprogramm!LDB -1, X!CMPB ,X!BGE OUT!INCB!STB -1, X!LDA -2 ,X!MUL !STB -2 ,X !BRA REPEAT!Übersetzer (Assembler)!

Maschinenprogramm!0100110 01101111 01010101!0000100 01010110 01000010!0011111 11000110 11111000!0000000 00100100 01110001!


An welche Speicherstelle wird ein ausführbares Programm geladen?!!Wann werden die Adressen (Sprungadressen, Adressen von Daten) festgelegt?!!Was passiert, wenn man ein Programm im Speicher verschiebt?!


?!

?!

?!


Assembler ist der „Compiler“ für die Maschinensprache eines Prozessors.!Unterstützt werden:!

!Symbolische Befehle eines Prozessors (Mnemotechnische Codes)!

!Notation für Adressierungsarten!!Festlegen von Speicheradressen für Programme und Daten!!Symbolische Speicheradressen (Labels)!!Durchführung von Adreßrechnungen!

!!Vorteil gegenüber Maschinenprogrammen:!

!leichter schreibbar!!leichter lesbar!!weniger fehleranfällig!

Eingabe: Textdatei(en) Quellprogramm Ausgabe: Maschinen

Code

Assembler



Quelltext!Ausführ- !bares !Programm!

Speicher!foo.as!

Einfache Assemblierung!

Assembler! Lader !Binder/!

•  Zuordnung von Namen zu Binärzahlen •  Mnemotechnische Codes •  Statische Reservierung von Speicherplatz •  Berechnung von Sprungadressen •  Erstellen der Speicherbelegung

LOOP LDA 16, PCR ADDA LABEL BHI LOOP

LABEL some data

A6 8C 16 BB label ? label ? 22 FA

10100110 10001100 00010000 10111011 xxxxxxxx xxxxxxxx 00100010 11111000

10100110 10001100 00010000 10111011 01101101 01101101 00100010 11111000

7



modul 1

modul 2

modul n

Bibliothek

Binder Lade- modul

Lader

Speicher- abbild

Assemblieren und Binden mehrerer Objektcode Moduln

Aufgabe: Auflösen externer Referenzen

Aufgabe: Erzeugen der physischen Speicheradressen

8

J. Kaiser, IVS-EOS Technische Informatik II Sommersemester 2014 9

Wo? 6 Byte vom Programm-start !


J. Kaiser, IVS-EOS Technische Informatik II Sommersemester 2014 10

E848010000 + 2100 != E848220000!

Offset = 48010000!







11!



C Programmsegment:!..!uint8_t a, b, c;! !/*Deklaration des Bedarfs an Speicherplatz */ ! !/*vom Datentyp z.B. unsigned integer, 8 Bit */!..!..!a = b + c; ! !/* addiere b und c und speichere das Resultat in a */

In impera*ven Sprachen ist "a = b + c" kein mathema*scher Ausdruck, sondern eine Vorschri9, wie mit Inhalten von Speicherplätzen umzugehen ist! Fragen:

-‐ wo befinden sich die Operanden ?

-‐ welcher Operator wird angewendet?

-‐ wo wird das Ergebnis gespeichert?


12!


C Programmsegment:!..!uint8_t a, b, c;! !/*Deklaration des Bedarfs an Speicherplatz */ ! !/*vom Datentyp z.B. unsigned integer, 8 Bit */!..!..!a = b + c; ! !/* addiere b und c und speichere das Resultat in a */

a, b, und c sind Variablen, die im Rechner durch Speicherplätze repräsen*ert sind, die entsprechende Werte enthalten. Dieser Bedarf an Speicherplätzen wird durch die Deklara*on "uint8_t a, b, c;" spezifiziert. Der Compiler wird dieses Konstrukt in Anweisungen übersetzen, die: 1.   Für die Variablen a, b,und c entsprechende Speicherplätze oder Register reservieren. Durch die Deklara*on der Datentypen ist die Größe der Speicherworte festgelegt. 2. Die entsprechende Opera*on (gemäß den Datentypen) durchführen. 3.   Das Resultat auf einem spezifizierten Speicherplatz ablegen. Daher bezeichnet "=" nicht Gleichheit sondern ist die Zuweisung "ß".

13!


a ← b + c

Ein Compiler würde für die 6809 folgende Assemblersequenz erzeugen und Reservierungen vornehmen. .. .. Start LDA var-‐b /*lade den Wert in var-‐b in den Accumulator

ADD var-‐c /*addiere den Wert var-‐c (aus dem Speicher) STA var-‐a /* speichere das Resultat auf Speicherplatz var-‐a

..

..

.. var-‐a RMB var-‐b RMB var-‐c RMB

Falls man einen Operanden nach der Addi*on nicht mehr benö*gt, kann er mit dem Resultat überschrieben werden, z.B. b ← b+c. Das spart Speicherplatz und zeigt nochmal deutlich, dass "=" ein Zuweisung bezeichnet. Anstelle “b = b + c” kann man auch schreiben: “b+ = c”.


14!


2-‐Adress-‐Befehle 3 Adress-‐Befehle z.B. 68K oder Pen*um RISC-‐CPUs wie Sparc,

MIPS, Alpha, ARM, . Code Sequenz: Code Sequenz: ld r2, b ld r2, b ld r3, c ld r3, c mv r1, r2 add r1, r2, r3 add r1, r3 st a, r1 st a, r1 r2 und/oder r3 die Quellregister und r1 das Zielregister. a, b, und c sind Speicherplätze.

Fazit: Das Programmstatement "a = b + c" ist kein mathema*sch oder logischer Ausdruck, sondern a, b, und c sind Container für Daten und "=" ist die Zuweisung des Resultat-‐Containers.Die Architektur des Rechners beeinflusst in erheblichem Maß die Umsetzung.


15!


C-Programm "simple_add_char.c"""static char a, b, c;"int main() "{"a=b+c;"}"

GAS LISTING simple_add_char.s ! ! !!! 1 ! !.file !"simple_add_char.c"! 2 ! !.version !"01.01"! 3 !gcc2_compiled.:! 4 !.text! 5 ! !.align 16! 6 !.globl main! 7 ! !.type ! main,@function! 8 !main:! 9 0000 55 ! !pushl %ebp! 10 0001 89E5 ! !movl %esp,%ebp! 11 0003 A0010000 ! !movb b,%al! 11 00! 12 0008 8A150200 ! !movb c,%dl! 12 0000! 13 000e 88C1 ! !movb %al,%cl! 14 0010 00D1 ! !addb %dl,%cl! 15 0012 880D0000 ! !movb %cl,a! 15 0000! 16 !.L2:! 17 0018 89EC ! !movl %ebp,%esp! 18 001a 5D ! !popl %ebp! 19 001b C3 ! !ret! 20 !.Lfe1:! 21 ! !.size ! main,.Lfe1-main! 22 ! !.local !a! 23 ! !.comm !a,1,1! 24 ! !.local !b! 25 ! !.comm !b,1,1! 26 ! !.local !c! 27 ! !.comm !c,1,1! 28 001c 8D742600 !.ident !"GCC: (GNU) 2.95.3 20010315 (SuSE)"!!DEFINED SYMBOLS! *ABS*:00000000 simple_add_char.c! simple_add_char.s:3 .text:00000000 gcc2_compiled.! simple_add_char.s:8 .text:00000000 main! simple_add_char.s:23 .bss:00000001 b! simple_add_char.s:25 .bss:00000002 c! simple_add_char.s:21 .bss:00000000 a!!NO UNDEFINED SYMBOLS!!

(globale) Variablen werden im !Speicher angelegt. ! !Für ein "char” wird 1 Byte reserviert.!


16!


GAS LISTING simple_add_int.s ! ! !!! 1 ! !.file !"simple_add_int.c"! 2 ! !.version !"01.01"! 3 !gcc2_compiled.:! 4 !.text! 5 ! !.align 16! 6 !.globl main! 7 ! !.type ! main,@function! 8 !main:! 9 0000 55 ! !pushl %ebp! 10 0001 89E5 ! !movl %esp,%ebp! 11 0003 A1040000 ! !movl b,%eax! 11 00! 12 0008 8B150800 ! !movl c,%edx! 12 0000! 13 000e 8D0C02 ! !leal (%edx,%eax),%ecx! 14 0011 890D0000 ! !movl %ecx,a! 14 0000! 15 !.L2:! 16 0017 89EC ! !movl %ebp,%esp! 17 0019 5D ! !popl %ebp! 18 001a C3 ! !ret! 19 !.Lfe1:! 20 ! !.size ! main,.Lfe1-main! 21 ! !.local !a! 22 ! !.comm !a,4,4! 23 ! !.local !b! 24 ! !.comm !b,4,4! 25 ! !.local !c! 26 ! !.comm !c,4,4! 27 001b 908D7426 !.ident !"GCC: (GNU) 2.95.3 20010315 (SuSE)"! 27 00!!DEFINED SYMBOLS! *ABS*:00000000 simple_add_int.c! simple_add_int.s:3 .text:00000000 gcc2_compiled.! simple_add_int.s:8 .text:00000000 main! simple_add_int.s:24 .bss:00000004 b! simple_add_int.s:26 .bss:00000008 c! simple_add_int.s:22 .bss:00000000 a!!NO UNDEFINED SYMBOLS!!

C-Programm "simple_add_int.c"""static int a, b, c;"int main() "{"a=b+c;"}"

(globale) Variablen werden im !Speicher angelegt. Für ein "int" !werden 4 Byte reserviert.!


17!







18!



Zeiger und Vektoren (Pointer und Arrays)!!Motivierendes Beispiel: Vertauschen von Werten in einer Liste.!

Swap-Funktion soll Inhalte beliebiger!Listenplätze vertauschen.!!swap(x,y); !

0x20!

0x21!

0x22!

0x23!

0x24!

0x25!

0x26!

0x27!

0x28!

45!

67! S.-Platz von x!

S.-Platz von y!

Speicher!

19!


int a,b;!.!.!!swap (a, b);!!.!.!.!!swap(int x, int y)!{! int temp;! temp = x;! x = y;! y = temp;!}!

was bewirkt diese Funktion?!

1. Versuch der swap Funktion!



Swap-Funktion soll Inhalte beliebiger!Listenplätze vertauschen.!!swap(x,y); ??!

0x20!

0x21!

0x22!

0x23!

0x24!

0x25!

0x26!

0x27!

0x28!

45!

67! S.-Platz von x!

S.-Platz von y!

Speicher!

21!

😕!Was sollen die Übergabe-Parameter !x und y spezifizieren? Eine Funktion!übergibt standardmäßig nur Werte!(keine Adressen).!!Wie kann die Funktion eine dauerhafte!Änderung der Liste bewirken, die für das!aufrufende Programm sichtbar ist?!!1. Lösung x und y sind globale Variablen.!2. Lösung das aufrufende Programm ! übergibt die Zeiger auf x und y. !


static int a,b!swap ();!!.!.!.!!swap()!{! int temp;! temp = a;! a = b;! b = temp;!}!


Zeiger und Vektoren (Pointer und Arrays)!!Das Konzept des Pointers!

C-Notation: pointer_auf_x = &x /*Deklaration einer Zeigervariablen */ !

Der Adress-Operator "&" liefert die Adresse einer Variablen. &x liefert daher!die Speicheradresse der Variablen x und NICHT den Wert der Variablen x!!!Das Statement weist diese Adresse der Zeigervariablen "pointer_auf_x" zu.!

0x25!0x26!0x27!0x28!0x29!0x2a!

0x45! für x reservierter!Speicherplatz.!Adresse: 0x27!Inhalt: 0x45!

Das C-Statement:!!wert_von_x = x weist der Variablen!wert_von_x den Wert "0x45" zu.!!Das Statement:!!pointer_auf_x = &x weist der Variablen!pointer_auf_x den Wert 0x27 zu.!

Beispiel:!

23!


Zeiger und Vektoren (Pointer und Arrays)!!Frage: Wenn ich die Adresse &x einer Variablen habe, ! wie greife ich dann auf ihren Wert zu?!Verweis-Operator "*": !!Mit y= *pointer_auf_x wird y der Wert auf den "pointer_auf_x"zeigt,!zugewiesen. !

0x25!0x26!0x27!0x28!0x29!0x2a!

0x45! für x reservierter!Speicherplatz.!Adresse: 0x27!Inhalt: 0x45!

Das C-Statement:!!pointer_auf_x = &x y = *pointer_auf_x !ist äquivalent zu y = x !

Beispiel:!

24!



0x20!

0x21!

0x22!

0x23!

0x24!

0x25!

0x26!

0x27!

0x28!

45!

67! S.-Platz von x!

S.-Platz von y!

Speicher!

swap (&a, &b);!!.!.!.!!swap(int *px, int *py)!{! int temp;! temp = *px;! *px = *py;! *py = temp;!}!

als Pointer definiert!

25!


int a[10]!!(Intel IA-32!)!

a[1]!

a[2]!a[3]!a[4]!

x+0!

x+4!

x+8!

x+12!

0! 1! 2! 3!

a[5]!

a[6]!a[7]!a[8]!

x+16!

x+20!

x+24!

x+28!

a[9]!

a[10]!

x+32!

x+36!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

x+3!

x+7!

x+11!

x+15!

x+19!

x+23!

x+27!

x+31!

x+35!

x+39!

Zeiger und Vektoren (Pointer und Arrays)!!

26!


Zeiger und Vektoren (Pointer vs. Arrays)!!

array[0]!

array[size]!

array[i]!

.!

.!

.!

.!

.!!

memory!Programm zum!Beschreiben des Arrays!mit "0".!

clear(int array[], int size;!{! int i;! for (i=0; i < size; i += 1)!

!array[i] = 0;!}!


a[1]!

a[2]!a[3]!a[4]!

x+0!

x+4!

x+8!

x+12!

3!2!1!0!

a[5]!

a[6]!a[7]!a[8]!

x+16!

x+20!

x+24!

x+28!

a[9]!

a[10]!

x+32!

x+36!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

a[1]!

a[2]!a[3]!a[4]!

a[5]!

a[6]!a[7]!a[8]!

a[9]!

a[10]!

x+3!

x+7!

x+11!

x+15!

x+19!

x+23!

x+27!

x+31!

x+35!

x+39!

Indexregister oder!Speicherwort (bei indirekter!Adressierung)!

Basisadresse!

Adressierung über !Basis + Offset !!Bei mehrdimensionalen Arrays!kann die Adressierung über mehrere!Indexregister, feste Offsets usw. erfolgen.!

Umsetzung durch die!Rechnerarchitektur:!

Zeiger und Vektoren (Pointer und Arrays)!!

28!


struct my_date{!int day;!int hoj;!long ssjcb;!char month;!int year;!long dsbb;!}!!(Intel IA-32!)!!

day!

hoj!ssjcb!

ssjcb!

x+0!

x+4!

x+8!

x+12!

3!2!1!0!

Structuren (Structures)!Speicherlayout!

Strukturen werden im Speicher angelegt!!Die Elemente werden meist auf Wortgrenzen angeordnet (alignment)!!Der Compiler kann mit festem Offset die Elemente der Struktur adressieren!

month!

year!x+16!

x+20!

day!day!day!

ssjcb!ssjcb!ssjcb!ssjcb!ssjcb!ssjcb!

dsbb!x+24!

x+28!

year!year!year!

dsbb!

dsbb!

dsbb!

dsbb!

dsbb!

dsbb!

dsbb!

hoj!hoj!hoj!

29!







30!



Freie Verschiebbarkeit im Speicher ! ! !Nutzung von Objekt-Code Bibliotheken !Unabhängiges Laden!

Ziele und Vorteile positionsunabhängigen Codes:!


31!


Unterstützung positionsunabhängigen Codes durch die CPU: !

!Relative Sprünge !

Adressierung von Speicher durch “Konstante Distanz“ vom Programmzähler !

Nutzung des Hardware-Stacks als temporären Speicher !


Ausnutzung der indizierten Adressierung !

32!


LEA DST ,SRC (DST: Zielregister, SRC: Quellregister, Adr - Modus)!!LEA(r2)! offset ,r1 (Offset, Skalierung etc. wird durch Adr-Modus bestimmt)!!

effektive!Adresse!

(Index-) Register r1!

offset!

Speicher!

Die Instruktion "Load Effective Address" LEA !

(Index-) Register r2!

33!

Variable V!Wert!


LEAX !(offset, scale) ,Y!

V!

(Index-) Register Y!

offset!

Speicher!Bezug zum Adreßoperator in C: x = &V!

Bezug zum Pointerkonzept !

Register X!

34!

25!effektive!Adresse!


(Index-) Register Y!Offset = 516!Scale = 416!

int V[10]; !deklariert ein integer array (int ist ein 32-Bit Wert)!...!...!x = &V[5];!.....! !

Bezug zum Pointerkonzept (Beispiel) !

(Index-) Register X!

2000!

2014!

2014!

25!

35!

Variable V!effektive!Adresse = 201416!

LEAX !(5�4) ,Y (offset�scale),Y!!

Speicher!


(Index-) Register Y!

int V[10]; !deklariert ein integer array (int ist ein 32-Bit Wert)!...!x = &V[5];!a = *x;!.....! !

Bezug zum Pointerkonzept (Beispiel) !

Register A!

2000!

25!

25!

36!

Variable V!effektive!Adresse = 201416!

LEAX (5�4) ,Y (offset�scale),Y!LDA ! ,X!!

Speicher!

(Index-) Register X!2014!

2014!

Offset = 516!Scale = 416!


Nutzung des System Stacks als temporärer Speicher ! !Statische Zuordnung: ! !Speicher wird fest reserviert, z.B. durch die Assemblerdirektiven : RMB, FCC, FCB, etc. !(static allocation,!Globale Variablen)!

!Dieser Speicher kann während der Programmlaufzeit nicht (ohne Gefahr) anderweitig ! ! ! !genutzt werden. Auch wenn das entpr. Programm nicht aktiv ist, ist es gefährlich, diesen ! ! ! !Speicherbereich zu benutzen, da ein Aktivieren des Programms die dort abgelegten !

! ! ! !Daten anderer Programme überschreibt. ! !Dyn. Zuordnung:! ! !Speicher wird während der Laufzeit genutzt und dann wieder freigegeben. Die !(dynamic allocation.!Lokale Varibalen)!

!Nutzung zertört keine Daten von anderen Programmen.!

Stack als temporärer, dyn. zugeordneter !Speicher:! Daten anderer !

Programme!

dieser Speicherbereich !kann temporär ohne Wechselwirkung !mit anderen Prog. genutzt werden!

SP!

SP -256!

LEAS! !-256,S reserviert den Speicher ! ! !LEAS 256,S gibt den Speicher frei!

dieser Stackbereich steht für Unterprogramm- !aufrufe und Interrupt-Behandlung zur Verfügun!

Stack !wächst !in diese !Richtung!

37!







38!



Unterprogrammtechniken !

Unterprogramme, (Sub-) Routinen, Funktionen!

Ziele: !

!•  Wiederverwendung von Programmen oder Programmstücken!

•  Unterprogrammbibliotheken!

•  Reduzierung des Speicherbedarfs durch Code-Sharing !

•  Modulare Strukturierung nach funktionalen Gesichtspunkten!

•  Verbesserung der Testbarkeit!

39!


Unterstützung beim Unterprogramm-Aufruf!

•  Automatische Speicherung der Rücksprungadresse!

•  Mögliche Speicherung von Teilen oder des gesamten Programmstatus (Register + Variablen)!

•  Unterstützung bei der Isolierung von aufrufendem und aufgerufenen Programm!

•  Unterstützung bei der Parameterübergabe!

•  Automatische Rückkehr an die entprechende Stelle im aufrufenden Programm!

•  Unterstützung rekursiver Unterprogrammaufrufe!

•  !

•  !

!



Abspeichern des Prozessorzustands ! !Abspeichern lokaler Variablen!

Der Stack ist die bevorzugte Speicherstruktur!zur “Rettung“ des Programmstatus, da er Positionsunabhängigkeit und Schachtelung unterstützt.!!

41!

Ein (Unter-) Programm in Ausführung hat einen aktuellen Zustand, repräsentiert durch:! !

-  Programmzähler (zeigt auf den nächsten Befehl im Programm)!-  Wert der Variablen!-  Registerinhalte der CPU!


!

Speicherstruktur für die Übertragung von Parametern!!•  Register!•  Parameter in einem gemeinsamen Speicherbereich!•  Stack !

: !Problem: Positionsunabhängigkeit, Schachtelung von Unterprogrammen (rekursive UP)!


42!

! ! ! ! !


Schachtelung von Unterprogrammen erfordert: ! !•  Parameter, lokale Variablen und Rückgabewerte dürfen nicht überschrieben

werden!

•  Abspeichern des Programm-Status und der Rücksprungadressen in geordneter Weise !

•  Dynamische Zuordnung von temporärem Speicherplatz!

!


43!

! ! ! ! !

Nutzung des Stacks!


FP!

aktueller!Stack-!Frame!

SP: Stack-Pointer!FP: Frame-Pointer!

Parameter werden!durch negativen Versatz!zum FP adressiert!

letzter FP!

PC!

44!

Parameter!Übergabe!Bereich!

Vorhergehender!Stack-Frame!

SP!

temporärer!dynamischer!Speicherbereich!

temporäre Daten werden!durch positivenn Versatz!zum FP adressiert!

Register!Status beim!Aufruf!

Evaluations!Stack!Bereich!

Aufruf-Stack!


int add3(int a, int b, int c) { int result=0; result=result+a+b+c; return result; } int main() { int result; result=add3(1,2,3); return result; }

Beispiel für den Aufbau eines !Prozedur-Rahmens!(Stack-Frame)!


00000000 <add3>: 0: 55 push %ebp //Alten Basepointer sichern 1: 89 e5 mov %esp ,%ebp //Neuen Basepointer setzen 3: 83 ec 10 sub $0x10,%esp //Lokale Variablen anlegen(result,a,b,c(4x4 Byte)) 6: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) //result mit 0 initialisieren d: 8b 45 0c mov 0xc(%ebp),%eax //b aus Parameterliste nach eax laden 10: 8b 55 08 mov 0x8(%ebp),%edx //a aus Parameterliste nach edx laden 13: 01 d0 add %edx,%eax //b = b+a 15: 03 45 10 add 0x10(%ebp),%eax //b= b+c (c aus Parameterliste) 18: 01 45 fc add %eax,-0x4(%ebp) //result=result + a (result in lokalen Variablen) 1b: 8b 45 fc mov -0x4(%ebp),%eax //result nach eax kopieren(Rückgabewert) 1e: c9 leave //Stack aufraeumen(ebp -> esp, pop ebp) 1f: c3 ret //Ruecksprung 00000020 <main>: 20: 55 push %ebp //Stack initalisierung 21: 89 e5 mov %esp,%ebp 23: 83 ec 1c sub $0x1c,%esp 26: c7 44 24 08 03 00 00 movl $0x3,0x8(%esp) //3 in Parameterliste schreiben 2d: 00 2e: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) //2 in Parameterliste schreiben 35: 00 36: c7 04 24 01 00 00 00 movl $0x1,0x0(%esp) //1 in Parameterliste schreiben 3d: e8 fc ff ff ff call add3 //add3 aufrufen 42: 89 45 fc mov %eax,-0x4(%ebp) //Ergebnis(eax) nach result kopieren 45: 8b 45 fc mov -0x4(%ebp),%eax //Result in Rueckgabewert kopieren 48: c9 leave //Stack aufraeumen 49: c3 ret //Ende


00000020 <main>: 20: 55 push %ebp 21: 89 e5 mov %esp,%ebp 23: 83 ec 1c sub $0x1c,%esp 26: c7 44 24 08 03 00 00 movl $0x3,0x8(%esp) 2d: 00 2e: c7 44 24 04 02 00 00 movl $0x2,0x4(%esp) 35: 00 36: c7 04 24 01 00 00 00 movl $0x1,0x0(%esp) 3d: e8 fc ff ff ff call add3 42: 89 45 fc mov %eax,-0x4(%ebp) 45: 8b 45 fc mov -0x4(%ebp),%eax 48: c9 leave 49: c3 ret

Kopieren der Parameter (immediate values) auf den Stack!

// Aufruf


00000000 <add3>: 0: 55 push %ebp 1: 89 e5 mov %esp ,%ebp 3: 83 ec 10 sub $0x10,%esp 6: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) d: 8b 45 0c mov 0xc(%ebp),%eax 10: 8b 55 08 mov 0x8(%ebp),%edx 13: 01 d0 add %edx,%eax 15: 03 45 10 add 0x10(%ebp),%eax 18: 01 45 fc add %eax,-0x4(%ebp) 1b: 8b 45 fc mov -0x4(%ebp),%eax 1e: c9 leave 1f: c3 ret

stack vorb. 16 byte reserv. result =0 b in eax holen a in edx holen add add mit c result à stack result à eax


Beispiel: Berechnung der Fakultätsfunktion: n ! für n ≤ 5

Diese Einschränkung wurde gemacht, weil bei größeren n eine aufwendige Mehrbyte-Multiplikation erforderlich wäre, was hier nicht Gegenstand des Problems ist.

Def. : !0! = 1, !! !n! = n • (n-1)!

Funktion FACT ist rekursiv definiert:

!FACT(0) =1, !!FACT(N) = N FACT( N-1 ) !


49!


main () { printf ("die Fakultät von 5 ist: %d\n", fact (5)); } int fact (int n) { if (n < 1) return (1); else return (n * fact (n-1)); }

Rekursives C - Programm zur Berechnung der Fakultät


50!


LEAX 1,S

Zuordnung eines temporären Speicherplatzes TEMP auf dem Stack LEAS ,S

Speichern des Stackpointers in Register X ( äquivalent zu : TFR S,X )

LDA #1 Initialisiere TEMP mit 1 STA ,S LDA ,X Lade den Parameter N (=5) vom Stack INCA Erhöhe um 1, um korrekte Abbruchbedingung zu erzeugen BSR FACT Springe zum Unterprogramm FACT LDA 1 ,X “Retten“ des Ergebnisses in A LEAS ,X Freigeben des temporären Speicherplatzes auf dem Stack

END • • • FACT DECA Decrementiere N

BLE RET IF (N-1) ≤ 0 THEN RETURN PSHS A Speichere das aktuelle N des Unterprogramms auf dem Stack BSR FACT Rufe FACT zur Berechnung des nächsten N auf PULS B Lade ein N vom Stack nach B LDA 1 ,X Lade das bisherige Produkt von F nach A MUL A•B STB 1 ,X Speichere das Produkt (LSByte von Acc D) in F

RET RTS

Rekursives Assembler - Programm zur Berechnung der Fakultätsfunktion

N: Parameter der Funktion FACT (N = 5) S F: Funktionswert S-1

51!


5!SP! Parameter N!

FACT DECA BLE RET PSHS A BSR FACT PULS B LDA 1 ,X MUL STB 1 ,X

RET RTS

LEAX LEAS ,S LDA #1 STA ,S LDA ,X INCA BSR FACT LDA 1 ,X LEAS ,X

END • • •

1,S!


52!


1 SP!

PC (0) SP!TEMP!

5!X!

N = 5 SP!

PC (1) SP!N = 4 SP!

PC (2) SP!

N = 3 SP!

PC (3) SP!

N = 2 SP!

PC (4) SP!

N = 1 SP!

PC (5) SP!

Parameter N!


53!


RET RTS


END • • •

1,S!


1!

PC (0) TEMP!

5!X!

N = 5

PC (4)

PC (5) N = 1

N = 2 PC (3) N = 3

PC (2) N = 4

PC (1)

SP!

Parameter N!

SP!

SP!

SP!

2!

SP!

SP!

6!

SP!

SP!

24!

SP!

SP!

120!

SP!

SP!


54!


RET RTS


END • • •

1,S!


0804848c <main>:! 804848c: !push %ebp !// Basepointer sichern! 804848d: !mov %esp,%ebp !// Stackpointer in Basepointer sichern! 804848f:! !and $0xfffffff0,%esp !// Stack auf 16 Byte alignen! 8048492: !sub $0x10,%esp !// Platz für lokale Variablen und Parameter !

! ! ! ! ! anlegen! 8048495: !movl $0x5,(%esp) !// Index 5 als Parameter auf den Stack !

! ! ! ! ! schreiben! 804849c: !call 8048468 <fact> !// Fakultätsfunktion aufrufen! 80484a1: !mov %eax,0x8(%esp) !// Ergebnis des Aufrufs als Parameter auf den !

! ! ! ! ! Stack schreiben! 80484a5: !movl $0x8048558,0x4(%esp) ! // Pointer zum Format-String für!

! ! ! ! ! ! printf auf den Stack schreiben! 80484b4: !call 8048340 <printf> !// printf aufrufen! 80484b9: !mov $0x0,%eax !// 0 als Rückgabewert festlegen! 80484be: !leave !// Stack abräumen! 80484bf:!ret ! ! !// Rücksprung !

x86 Assembler!


08048468 !<fact>:! 8048468: !push %ebx !// Basepointer sichern! 8048469: !sub $0x18,%esp !// Platz für lokale Variablen!

! ! ! ! ! und Parameter anlegen! 804846c: !mov 0x20(%esp),%ebx !// Index aus Übergabeparameter! ! ! ! ! ! laden! 8048470: !mov $0x1,%eax !// Konstante 1 laden! 8048475: !test %ebx,%ebx !// Index auf 0 testen! 8048477: !jle 8048487 !// Sprung wenn Index 0! 8048479: !lea -0x1(%ebx),%eax !// Index um 1 dekrementieren! 804847c: !mov %eax,(%esp) !// Neuen Index als!

! ! ! ! ! Übergabeparameter auf den Stack schreiben! 804847f:! !call 8048468 <fact> !// Rekursiver Aufruf von fact! 8048484: !imul %ebx,%eax !// Multiplikation des Ergebnisses mit dem Index! 8048487: !add $0x18,%esp !// Stack abräumen! 804848a: !pop %ebx !// Basepointer wiederherstellen! 804848b: !ret ! !// Rücksprung!!

x86 Assembler!


link: Link and Allocate! ulnk: Unlink!

SP ß SP- 4 !Dekrementieren des SP!SP ß An! !Speichern des alten FP!An ß SP! !Inhalt des SP wird neuer FP!SP ß SP + d !Allokation von Speicher !

! !d: negativer Versatz (!)!

SP ß An! !FP wird neuer SP!An ß [SP] !alter FP wird neuer FP!SP ß SP + 4 !SP zeigt auf Adr. vor Link!

PSHS ! X!LEAX !,S!LEAS -d, S!!PSHS Register Liste!

PULS ! Register Liste!!!TFR !X, S!LDX ! , S!LEAS !2 , S!RTS!

Motorola 68K Architektur: Stack Verwaltung bei Unterprogrammsprüngen !

MC 6809 Realisierung! MC 6809 Realisierung!

57!

J. Kaiser, IVS-EOS Technische Informatik II Sommersemester 2014 58!

J. Kaiser, IVS-EOS Technische Informatik II Sommersemester 2014 59!


Lernziele!Verständnis für die Unterstützung der Systemprogrammierung durch die Prozessorarchitektur. Grundlegende Datenstrukturen und ihre Abbildung auf Assemblerebene:

•  Zuweisung, Arrays und Structures Unterstützung positionsunabhängiger Adressierungsmethoden Unterprogrammtechniken: •  Prozedurstatus •  Parameterübergabe •  Aufbau eines Prozedurrahmens auf dem Stack •  Rekursive (und wiedereintrittsfähige (re-entrant)) Programme

60!

Technische Informatik II -...

Documents

Transcript of Technische Informatik II -...