Einführung in die Informatik I - fh-muenster.de...• Diese Konstrukte müssen mit Sprungziel (label) und goto Anweisung (jmp) selber codiert werden. • Assembler Code ist daher

Prof. Dr. Nikolaus Wulff

Einführung in die Informatik I

Prinzipieller Aufbau eines Rechners und Assembler Programmierung

Prof. Dr. Nikolaus Wulff Informatik I 2

Aufbau eines Rechners

1. LCD Bildschirm

2. Hauptplatine

3. Prozessor

4. Speicherbausteine

5. externe Controller

6. Netzteil

7. CD Laufwerk

8. Festplatte

9. Maus

10.Tastatur


Zentrale Bausteine• Rechenwerk / CPU (ALU)

• Arbeitsspeicher

• Festplatte(n)

• E/A Module– Grafikkarte

– Tastatur und Maus Controller

• Bus System– Datenbus

– Adressbus

– Steuerbus


Harvard Architektur

• Unterschiedlicher Speicher für Daten und Programme.

• Vorteil: Strikte Trennung von Daten und Programm.– Viren haben es schwerer Programme zu manipulieren

• Nachteil: Zwei verschiedene Speicher und unter Umständen „Verschwendung von Speicher“.


Die von Neumann Architektur

• Der Speicher beinhaltet Programm und Daten.

• Eine Bitfolge kann Datum oder Programm sein...


Prinzip des von Neumann-Rechners• Interne Befehlssignale sind binär codiert.

• Befehle, Adressen und Daten werden einheitlich im Speicher abgelegt.

• Es werden Worte fester Bit-Länge abgearbeitet.

• Der Daten- und Befehlsstrom wird von einem Bus auf Anforderung geliefert.

• Sequentielle, taktgesteuerte Verarbeitung.

• CPU und Bus haben unterschiedliche Taktfrequenzen.– Es gibt inzwischen mehrere Bussysteme: Grafikkarte AGP,

Hauptspeicher, L1 und L2 Cache, etc.


CPU & ALU


Aufteilung der CPU• Die CPU (central processing unit) unterteilt sich in

das Steuerwerk: – Befehlszähler (Adresse des nächsten Befehls)

– Befehlsregister (Menomic des aktuellen Befehls)

– Adressregister (Adresse des nächsten Datums)

• und das Rechenwerk:– ALU (arithmetic and logical unit)

– mehrere Register für Berechnungen (aktuelle Daten)• EAX, EBX, ECX, ...

– Zusatzregister (Flags) für Status• Over- & Underflow, Vorzeichen-Bit, Zero-Bit, etc.


Das BIOS• Damit der Rechner in einen betriebsbereiten Zustand

gelangt und mit den Peripheriegeräten kommunizieren kann, wird das Basic- Input-Output-System beim Start geladen.

• Hersteller hinterlegen hier ihre eigene Treiber z.B. für den Festplattencontroller und den Chipsatz.

• Dieses BIOS stellt durch (Software) Interrupts stan-dardisierte Schnittstellen zur Verfügung. Bei DOS ist das z. B. der Interrupt 21h. Linux Systeme verwenden Interrupt 80h.

• Interrupts werden direkt in Assembler angesprochen.


Register des 8086• Die modernen CPU's bauen auf ihren „Urvätern“ den

8086 16-Bit und 8008 8-Bit Prozessoren auf:

– Da sich mit 16-Bit nur 216=64 kByte adressieren lassen werden die DS,CS,SS,ES Register als Offset verwendet.

– Der 80386 hat 32-Bit Register EAX, EBX etc.

accumulator

instruction pointerloop counter

stack pointer

string sourcestring dest.

code segmentdata segment

status register

data i/o

stack segmentbase pointerextra segment

all purpose register


Prinzip von Maschinencode• Maschinencode wird sequentiell ausgeführt. Z.B. lade

den Wert der Variablen x in das Register EAX und addiere dazu den Wert 5, anschließend schreibe diesen Wert zurück in die Variable x.

• Maschinencode besteht aus ganz grundlegenden, einfachen Anweisungen.

• Das Ein- und Auslesen der Variablen x aus dem Hauptspeicher, erfolgt mittels entsprechender Kommunikation des Steuerwerks mit dem Datenbus.

• Jede CPU hat einen anderen Befehlssatz und entsprechend unterscheiden sich auch die Assemblerbefehle. Sie sind nicht plattformneutral.


Einige Assembler Befehle• add: Addition von Ganzzahlen. I.A. wird der Inhalt

eines Registers oder einer Speicheradresse zum Akkumulator addiert. add bx

• mov: Lese- oder Schreibbefehl von einer Speicheradresse zum Register oder zurück.

mov ax, ds:[bx]

• inc / dec: Inkrementiere oder Dekrementiere das angegebene Register. inc bx

• jmp: Fahre mit der Bearbeitung an der angegeben Stelle fort. jmp 010h oder jmp Label_A

• push/pop: Sichere/restauriere Register push bx


Intel und AT&T Syntax1. Assembler Sprache ist abhängig von der Ziel CPU.

2. Intel und AT&T (GNU) Assembler haben eine unterschiedliche Syntax:

• Assembler-Code ist meist unportabel und schwerer zu warten als Hochsprachen-Code.

mov eax, 1mov ebx,0ffhmov ebx, eax

mov eax,[ecx]add eax,[ebx+ecx]

movl $1, %eax movl $0xff, %ebxmovl %eax, %eax

movl (%ecx),%eaxaddl (%ebx,%ecx),%eax

Intel AT&T


• Alle Befehle liegen als Binärfolgen vor. Um z.B. den Assemblerbefehl: add word_array[bx+di],-3

• binär zu codieren, muss die entsprechende Befehls-folge aus den 8086 Datenblättern entnommen werden:– Befehl add: 100000sw mod reg rm

– (s: sign) (w: word) sw=112 10000011

2 = 83

16

– mod: indirect 16 bit = 102 , reg =000, rm=ds:[bx+di]=001

2

=> 100000012 = 81

16

– Addresse von word_array 10EF16

(als Beispiel)

– -310

= FD16

Befehlsfolge: 83 81 EF 10 FD

• So zu programmieren ist keine gute Idee...

Beispiel eines encoding


Maschinencode und Hochsprache• Der Vorteil von Hochsprachen wie C liegt auf der

Hand: Statt im „nackten Maschinenhexcode“

• oder als Assembleranweisung

• wird in C wesentlich lesbarer codiert:

– Variable i ist der Index, der im Register bx gehalten wird

– word_array und i sind woanders deklariert...

• Letztendlich wird der C Quelltext vom Compiler in den Maschinencode übersetzt.

83 81 EF 10 FD

add word_array[bx+di],-3

word_array[i] -= 3;


Assembler ohne Schleifen• Mit Assembler können nur Konstrukte verwendet

werden, die von der CPU direkt als Maschinencode abgearbeitet werden können.

• Es gibt keine if-else und switch-case Anweisungen und auch for- oder while-Schleifen fehlen.

• Diese Konstrukte müssen mit Sprungziel (label) und goto Anweisung (jmp) selber codiert werden.

• Assembler Code ist daher nicht nur unleserlich, sondern auch ziemlich fehlerträchtig im Vergleich zu Hochsprachen wie Java oder C. Allerdings lassen sich hier alle Vorteile der Hardware effizient ausnutzen.


Datenbereich

Codebereich org 100h mov ah, 01h ; Fkt 1: Wert über die Tastatur einlesen int 021h ; DOS Interrupt 21h ausfuehren cmp al, '5' ; Tastaturwert mit ASCII '5' vergleichen ja L1 ; Falls groesser 5 springe zu Label L1 mov dx,msg_1 ; Adresse der Zeichenkette laden mov ah,9h ; Fkt 9: Zeichenkette ausgeben int 021h ; Meldung 1 mit Interrupt 21h ausgeben jmp ende ; Sprung zum Label ende L1: mov dx,msg_2 mov ah,9h int 021h ; Meldung 2 ausgeben ende: mov ah,4Ch ; Fkt 4C: Beende das Programm int 21h ; Programm beenden

section .data msg_1: db 'Zahl <= 5', 10, '$' msg_2: db 'Zahl > 5' , 10, '$'

if-else mit Assembler

char *msg_1 = "Zahl <= 5\n";char *msg_2 = "Zahl >5\n";

int main() { int x = getchar(); if (x <= '5') printf(msg_1); else printf(msg_2); return 0;}


JMP Befehle• Die Sprungbefehle jmp ende und ja L1 sind gegen

symbolische Konstanten (Label) definiert, die vom Assembler in Sprungadressen umgesetzt werden, auf die der Instruktionszähler IP dann entsprechend gesetzt wird.

• Die Bearbeitung des Programms geht dann weiter mit den Befehlen, auf die der IP zeigt.

• Ähnlich aufwändig ist das Programmieren von Schleifen.


Assembler Schleife mov cx, 7 ; counter register auf 7 mov ax, 1 ; accumulator auf 1 mov bx, 1 ; multipikator auf 1

label_1: mul bx ; ax = ax*bx inc bx ; bx = bx + 1 = bx++ dec cx ; cx = cx – 1 = cx-- falls cx==0 wird ZF=1 jne label_1 ; (Jump Not Equal) ZF!=1, d.h. solange cx>0

int c=7, b=1, a=1;

while (c) { a *=b; b++; c--;}

int c, a=1;

for (c=2; c<=7; c++) { a *=c;}

a=∏c=1

7c ≡ 7!


C Code und Assembler• Der C Code wird in mehren Phasen übersetzt.

• Meist ist eines der Zwischenergebnisse Assembler-code, der mit dem Debugger angezeigt werden kann.

• Für zeitkritische Anwendungen kann hier optimiert werden. I. A. ist dies jedoch den Aufwand nicht wert.

• Der Assemblercode ist hilfreich, um zu verstehen, wie Maschinencode abgearbeitet wird und wo Optimier-ungsmöglichkeiten sind.

• Dies ist dies eine gute Möglichkeit, um das Zusam-menspiel der unterschiedlichen Register einer CPU zu verstehen.


C / Assembler Beispiel• Das folgende Beispiel wurde ohne Optimierung

übersetzt und zeigt C und Assembler Code parallel.

• Das Programm ruft eine C Unterroutine. Folgende Fragen stellen sich:– Wie und wo werden die Parameter übergeben?

– Wie werden die Rückgabeparameter zurückgegeben?

– Wie wird sichergestellt, das die Register des aufrufenden Programms nicht von der Subroutine verändert werden?

• Das Beispiel verwendet int Variablen zur Berechnung der Fakultät mit dem MS C Compiler.

• Methoden mit Gleitpunktzahlen oder mehr Para-metern werden entsprechend aufwendiger...


Der C Code

• Die main Routine ruft die C Unterroutine faculty und übergibt den Parameter x und erwartet das Ergebnis in der Variablen y...

int faculty(int x) { register int c=x; register int y=x; for (c--; c>0; c--) { y *=c; } return y;}void main() { int x, y; x = 5; y = faculty(x);}

Anweisung c und y möglichst im Register zu halten...


Unterroutinen Aufruf56: x = 5;0040113F mov dword ptr [ebp-4],557: y = faculty(x);00401146 mov eax,dword ptr [ebp-4]00401149 push eax0040114A call @ILT+30(faculty)(00401023)0040114F add esp,400401152 mov dword ptr [ebp-8],eax

• Das int Argument x =[ebp-4] wird mit dem Register eax auf den Stack gelegt (push), um es an die Sub-routine faculty zu übergeben.

• Der int Rückgabewert y =[ebp-8] wird nach der Ausführung aus dem Register eax wieder ausgelesen.

x 5

eax x

eax Stack


Parameterübgabe

21: int faculty(int x) {00401050 push ebp00401051 mov ebp,esp00401053 sub esp,48h00401056 push ebx00401057 push esi00401058 push edi22: register int c=x;00401068 mov eax,dword ptr [ebp+8]0040106B mov dword ptr [ebp-4],eax23: register int y=x;0040106E mov ecx,dword ptr [ebp+8]00401071 mov dword ptr [ebp-8],ecx

ebp StackzeigerBasezeiger sichern

neuer Stack für die Fkt.

Register sichern

eax xc eax

ecx xy ecx

• Am Anfang der Methode werden die verwendeten Register mit push gesichert...


Die for-Schleife

edx = c--edx c

c edx

c > 0 ?=> Ende

ecx yecx y*cecx y

eax = c--eax c

edx = c--edx c

c eax

24: for(c--; c>0; c--) {00401074 mov edx,dword ptr [ebp-4]00401077 sub edx,10040107A mov dword ptr [ebp-4],edx0040107D jmp faculty+38h (00401088)0040107F mov eax,dword ptr [ebp-4]00401082 sub eax,100401085 mov dword ptr [ebp-4],eax00401088 cmp dword ptr [ebp-4],00040108C jle faculty+4Ah (0040109a)25: y *= c;0040108E mov ecx,dword ptr [ebp-8]00401091 imul ecx,dword ptr [ebp-4]00401095 mov dword ptr [ebp-8],ecx26: }00401098 jmp faculty+2Fh (0040107f)


Beende der Funktion mit Rückgabe

21: int faculty(int x) {22: /** ... */27: return y;0040109A mov eax,dword ptr [ebp-8]28: }0040109D pop edi0040109E pop esi0040109F pop ebx004010A0 mov esp,ebp004010A2 pop ebp004010A3 ret

eax y

Basezeiger zurückladenalten Stack zurückladen

mit push gesicherteRegister zurückladen

• Am Ende der Routine sind alle Register (bis auf eax) wieder im ursprünglichen Zustand.

• eax dient zur Rückgabe des int Ergebnis.


Zusammenfassung• Assembler Code ist wesentlich schwieriger zu lesen

als C Code.

• Zeigt aber deutlich das Zusammenspiel von Code und dessen Umsetzung mit Hilfe von Modifikationen der CPU-Register.

• Die Einführung der Hochsprachen vereinfachte die Programmierung erheblich und erlaubte eine wesent-lich schnellere Entwicklung.

• Von Zeit zu Zeit ist es nützlich, sich beim Ausführen einfacher Anweisungen daran zu erinnern, welche komplexe Operationen sich innerhalb eines Rechners abspielen.

Documents

Einführung in die Informatik I - fh-muenster.de...• Diese Konstrukte müssen mit Sprungziel (label) und goto Anweisung (jmp) selber codiert werden. • Assembler Code ist daher