Lösungen der alten Klausuren

Moderator: Moderatoren

Antworten
Manuelito
Administrator
Beiträge: 157
Registriert: Mi 3. Mär 2010, 15:11

Lösungen der alten Klausuren

Beitrag von Manuelito » Di 6. Sep 2011, 14:05

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?

Manuelito
Administrator
Beiträge: 157
Registriert: Mi 3. Mär 2010, 15:11

Re: Lösungen der alten Klausuren

Beitrag von Manuelito » Di 6. Sep 2011, 14:50

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
  • 2) y = (++z*++z);
  • 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 :D (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 :-D (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]
  • 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

Antworten

Zurück zu „Info IV“