B.Sc./M.Sc. Elektrotechnik an der RWTH

Hallo,

Mangels Musterlösung würde ich gerne meine Lösung zur Aufgabe 3 aus der Klausur 2008f hier zur Diskussion stellen:

Code: Alles auswählen

Section .data
   length dd 0

Section .text

parseStr:
   push ebp
   mov ebp, esp
   pusha

   push [ebp-12]
   call strlen
   add esp, 4
   inc eax ; strlen zählt ohne \0
   mov dword[length], eax

   push 1
   push dword[length]
   call calloc
   mov [ebp-8], eax
   add esp, 8

   mov esi, dword[ebp-12] ; source string
   mov edi, dword[ebp-8] ; destination string
   mov edx, 0 ; counter für die Schleife
   mov eax, 0
   mov ecx, 0
schleife:
   cmp edx, dword[length]
   jae ende
   mov ebx, [esi+edx]
   cmp ebx, 48
   jb nan
   cmp ebx, 57
   ja, nan
   imul ecx, 10
   sub ebx, 48
   add ecx, ebx
   inc edx
   jmp schleife
nan:
   add eax, ecx
   mov ecx, 0
   mov [edi], ebx
   inc edi
   inc edx
   jmp schleife
ende:
   popa
   pop ebp
   ret

Schreibt mir bitte, falls ihr hierdrin Fehler findet

Edit: Achja, was ich auf jeden Fall nicht berücksichtigt habe, ist, dass der zweite übergebene Parameter p_dest ein Zeiger auf ein Zeiger ist... Weiß einer, wo/wie ich das unterbringen kann/muss?

Ich mach hier einfach mal weiter, in der Hoffnung, dass sich das irgendwer anschaut...

Werde die nächsten Stunden dann immer mal wieder ein paar neue Lösungen von mir hier reineditieren.

Klausur 2006f, Fragenteil

1) Die ESTAB des bindenden Laders entspricht der ST des Assemblers

2) Entweder wird ein Ausweichschlüssel gesucht oder an der Position zu dem Schlüssel wird eine Liste von Werten gespeichert

3) position-independent code - wird durch die M-Datensätze überflüssig gemacht

4) Hier fällt mir jetzt keine kurze und prägnante Antwort ein...

5) Die Anzahl der Zustände

6) Falls man über das Arrayende hinaus schreibt werden andere Daten überschrieben (wollen die das hier wirklich hören?)

7) ...

8) Das Geschlecht vor dem Alter definieren, damit passt das Byte fürs Geschlecht in den gleichen 4er Block wie zwei Characters vom Namen und es muss kein zusätzlicher 4er Block verschwendet werden.

9) STC

10) mov eax, dword[BIGTHING]
mov edx, 0
DIV 8
mov dword[BIGTHING], eax
Das sollte hier so gehen, da die ersten 4 Bytes von BIGHTING komplett aus 0en bestehen. Oder meint ihr, man darf an der Stelle nicht darauf bauen?

Klausur 2006f, Aufgabe 2

Code: Alles auswählen

Section .data
   groesse dd 0

Section .text
   push ebp
   mov ebp, esp

   mov eax, [ebp+12]  ;  Höhe
   mul eax, [ebp+16]  ;  Breite
   mul eax, 3  ;  3 Byte pro Pixel, eins für jede Farbe
   mov dword[groesse], eax

   mov edi, [ebp+8]
   mov ecx, 0
schleife:
   cmp ecx, dword[groesse]
   jae ende
   mov la, FFh
   sub la, byte[edi+ecx]
   mov byte[edi+ecx], la
   inc ecx
   jmp schleife
ende:
   pop ebp
   ret

Stackabbild:

Code: Alles auswählen

-------------  <- hohe Adressen
|   width   |
-------------
|   height  |
-------------
|  &bitmap  |
-------------
|  retAdr   |
-------------
|  oldEBP   |  <- EBP, ESP
-------------
|     .     |
|     .     |
|     .     |  <- niedrige Adressen

Klausur 2006f, Aufgabe 3

1) R, da die folgenden Symbole aus anderen Modulen noch importiert werden müssen

2) 10; die (hexadezimale) Zahl besagt, wieviele bytes die Befehle, die in dieser Zeile stehen, lang sind

3) 0000, die Startadresse des Moduls

4) Zeile 1: Das Modul startet an 0000
Zeile 3: Die globale Ftk. main starte an 0000
Zeile 16: die erste Anweisung ist bei 0000

5) Normalerweise push ebp, daher müsste hier auf jeden Fall schonmal 05 stehen - die beiden Zahlen dahinter passen aber nicht zu ebp; allgemein fehlt hier die Tabelle für die Register und die Überschrift der anderen Tabelle lautet "Adressmodus (4+4 Bits)" statt wie bei uns "Adressmodus (4 Bits)". Ich denke hier gab es damals ein anderes simple86-Format, was auch in noch kommenden Unterpunkten der Aufgabe einiges erklären würde

6) 1. Adressen zu externen Modulen anpassen
2. Adressen zu Codestellen innerhalb des Moduls anpassen
Hier wird allerdings ausschließlich Variante 1 benutzt, da als Namen der Symbole nur solche angegeben sind, die auch in Zeile 2 referenziert wurden

7) Hier komme ich auf nichts sinnvolles, liegt wahrscheinlich / hoffentlich daran, dass damals ein anderes Simple86-Format gelehrt wurde

8) siehe 7)

8a) wahrscheinlich little-Endian, da FCFFFFFFh dann (-4)_10 entspricht

9) Es fehlen noch die passenden Module für printf, exit und msg. Alles zusammen muss gebunden und geladen werden und dann kanns losgehen.

Klausur 2006f, Aufgabe 4

1) pdf-Datei

2) y = (++z*++z);

3) pdf-Datei

4) Nach Aufruf des Makros hat y den Wert 16 und z den Wert 4.
Nach Aufruf der Funktion hat y den Wert 9 und z den Wert 3.

Klausur 2003h, Fragenteil

1) Sobald keine Eingabe mehr kommt.

2) Complex Instruction Set Computer

3) DIV EAX, 10000h (was besseres fällt mir zumindest nicht ein)

4) jmp [ebx+8*eax+25]

5) Sie geben an, an welchen Positionen innerhalb des Moduls noch Adressen während dem Binden und Laden verändert werden müssen

6) Allocation und Loading/Reallocation/Linking

7) dynamisches Binden und/oder dynamisches Laden

8) Programmtabelle (PT), Makrodefinitionstabelle (MD), Makrorumpftabelle (MR)

9) Compiler

10) Interpreter

Klausur 2003h, Aufgabe 2

1) Übersichtlicher, nach Beenden der Prozedur wird zur letzten Position zurück gesprungen

2) ecx: Anzahl der öffnenden Klammern während der momentanen Suche nach der passenden schließenden Klammer
ebx: Location Counter innerhalb des Programms
edi: Zeiger auf dem Band

3) Ich hab zwar keine Ahnung von dem Microsoft-Assembler, aber ich machs einfach mal dadrin

(also halt wie in der Vorlage)

Code: Alles auswählen

plus:
   mov al, BYTE PTR [ebx]
   inc al
   mov BYTE PTR [ebx], al
   jmp schleife
   
minus:
   mov al, BYTE PTR [ebx]
   inc al
   mov BYTE PTR [ebx], al
   jmp schleife
   
fragezeichen:
   call read
   mov BYTE PTR [ebx], al
   jmp schleife

ausrufezeichen:
   push BYTE PTR [ebx]
   call printf
   add esp, 4
   jmp schleife

4) Hierauf und auf Aufgabe 5 hab ich keine Lust (Darf gerne ein anderer hochladen )

Klausur 2003h, Aufgabe 3

Klausur 2003h, Aufgabe 4

a1) H | LIB_A | 00000000 | 000000FF
H | LIB_B | 00004000 | 00000100

a2) D | _read_ | 00000010 | _write | 00000090 | _init_| 00000210
Wie können hier die einzelnen Funktionen länger sein als das ganze Modul?

a3) SYMBOL an Adresse 00400004

Code: Alles auswählen

Speicheradresse: 00400000 00400004 00400008 0040000C
Speicherinhalt:  D00D1531 237EAEFC 00000000 E1235555 

00400010 00400014 00400018 0040001C
1111AFFE 0044BB88 99004444 44844448

b1) Index, Name, Typ

b2)

Code: Alles auswählen

Name   Adresse
printf 8010
malloc 8050
exit   8120
free   8150
scanf  8180

b3) Normalerweise wird beim Sprung innerhalb eines Programms eine relative Adresse angegeben, also hier dann +6, daher ist das unabhängig von der Art des Bindens/Ladens.
(Hier bin ich mir recht unsicher..)

b4) einfach
Code: Alles auswählen
```
call printf
```
oder? Dem Assembler ist es ja noch egal, wie nachher gebunden/geladen wird?!

b5) Ähm, mit der Begründung aus b4 auch call printf?!

b6) Wenn eine Funktion aus einem anderen Modul, das noch nicht geladen wurde, aufgerufen wird und das Programm sich gerade in der entsprechenden Dummy-Funktion befindet.
(Hier bin ich mir auch wieder recht unsicher, ist nur geraten...)

b7) Steht dazu irgendwas im Skript?!

Klausur 2003f, Fragenteil

1) c

2) b

3) b

4) a

5) a

6) c

7) b

8) b

9) c

10) c

Klausur 2003f, Aufgabe 2

a1) Zeile B

a2)

Code: Alles auswählen

J: push ebp
G: mov ebp, esp
B: mov eax, [ebp + 8]
E: test eax, 1
H: jz D
A: imul eax, 3
F: inc eax
K: jmp C
D: shr eax, 1
C: pop ebp
I: ret

a3)

Code: Alles auswählen

-------------  <- hohe Adressen
|     x     |
-------------
|  retAdr   |  <- ESP
-------------
|     .     |
|     .     |
|     .     |  <- niedrige Adressen

a4) mov eax, [ebx + 4*ecx - 8]

a5)
Code: Alles auswählen
```
mov ebx, eax
shl eax, 1
add eax, ebx
```

a6) Ein Übertrag ins nächste Nibble erfolgt erst bei einem Wert über 15, nicht schon über 9:
Code: Alles auswählen
```
  4711  0100 0111 0001 0001
+ 0815  0000 1000 0001 0101
=       0100 1111 0010 0110  !=  5526
```

Klausur 2003f, Aufgabe 3

a1) 1. Feld ist der Name der Objektdatei, 2. Feld ist die Startposition dieses Moduls, 3. Feld die Länge des Moduls in Byte

a2) Jeweils 0000, da der Assembler noch nicht wissen kann, an welche Position die Module geladen werden - da ist 0000 das erstbeste Provisorium

a3) D | <Name> | <Startposition> ; wobei Name aus max. 6 Zeichen besteht und überlicherweise mit einem _ beginnt
D | _f1 | 0100h

a4) R | _f1 | _f2

a5) M | <zu modifizierende Adresse> | <Länge der zu modifizierenden Adresse> | +/- | <Funktion, dessen Offset addiert oder subtrahiert werden soll>
Code: Alles auswählen
```
M | 01C1 | 0002 | _f1
M | 11D2 | 0002 | _f2
```
An Adresse 21D2h steht dann 4100h

a6) T | <LC am Beginn dieser Zeile> | <Länge dieser Zeile> | <Funktionalität des Programms in Maschinencode>

a7) Ja, da dort die Adresse der ersten Befehlszeile aus der Funktion abgelegt wird. Dies ist abhängig davon, an welche Stelle der Lader die Funktion lädt.

Klausur 2003f, Aufgabe 4

a1) Ein Compiler übersetzt ein in L1 geschriebenes Programm in ein Programm in eine andere Sprache L2.
Ein Interpreter arbeitet zur Laufzeit des Programms und interpretiert den vorhandenen Quellcode.
(Falls einer eine bessere Definition von den beiden Dingern hat, nur her damit)

a2) Befehlsinterpreter bilden Code für einen hypothetischen Prozessor auf einen realen Prozessor ab. Dies ist meist eine 1:1-Beziehung. Der Befehlsinterpreter kann entweder Software (Emulator) oder aber ein Hardwareprozessor sein.
Sprachinterpreter sind eine höhere Form von Interpretern. Sie können auf dem Quellcode von komplexen Sprachstrukturen höherer problemorientierter Programmiersprachen.
(Beispiel fällt mir gerade keins ein)

a3) UST: Uniform Symbol Table - hier sind alle Tokens aus dem Programm aufgelistet, inkl. der anderen Tabelle (IDN, TRM oder LIB), in der sie näher definiert sind.
IDN: Identifier and Names - Hierdrin werden Bezeichner innerhalb der Eingabe verwaltet
LIT: Literals - Hier werden Konstanten und ihre Werte abgelegt
TRM: Terminals - Hier stehen die zulässigen Terminalsymbole der Eingabesprache

b) pdf-Datei

B.Sc./M.Sc. Elektrotechnik an der RWTH

Lösungen der alten Klausuren

Lösungen der alten Klausuren

Re: Lösungen der alten Klausuren