==== Aufgabe 1 ====

  * 1) w, f , f, f, w, w, w, w
  * 2) w, w, f, w, f, w, f(edit: zero-bit hat nichts mit rechten zu tun), f(edit:adressirungsart ist doch egal es geht nur darum ob ich auf die speicheadresse zugreifen darf oder nicht. das wie ist doch egal)
  * 3) mov für Speicherzugriff; in/out für IO-Zugriff - ist aber privilegierte Operation (vgl. Tastatur-Blinker-Aufgabe!)
  * 4) Die Behandlung eines Interrupts darf nicht durch einen anderen Interrupt unterbrochen werden, da sie nicht neu aufgesetzt werden kann.

==== Aufgabe 2 ====

1.
  * A E X
  * A E X
  * A X E
  * A X E
  * EA EA EA
  * A E E
  * E X A

2. Da gibt's bestimmt eine schöne Zeichnung im Skript.
  * Eingänge: IOR, IOW, Adressbus
  * Ein-/Ausgang: Datenbus
  * Fest: Adresse des Geräts
  * Adresse am Adressbus wird durch Komparator mit Geräteadresse verglichen. Ausgang des Komparators wird verundet mit IOR (-> Leitung zu Sensor) und IOW (-> Leitung zu Aktor).
  * Sensor hat Ausgang auf Datenbus, Aktor Eingang von Datenbus.

==== Aufgabe 3 ====

  * 1)
 Größe einer Struktur: 2 + 10 + 4 = 16 Bytes\\ 
 Größe des Adressraums: 2^16 Bytes = 64 kB; 48 kB für Programm => 16 kB frei für Daten\\ 
 16 kB / 16 Bytes = 1024

  * 2) Neue Strukturgröße: 4 + 10 + 2 (Alignment) + 4 = 20 Bytes; 1024 Datensätze: 20 kB
  * 3)

<code>
movl 8(%esp), %eax
xorl %ebx, %ebx
orb %al, %bl
shrl $8, %eax
shll $8, %ebx
orb %al, %bl
shrl $8, %eax
shll $8, %ebx
orb %al, %bl
shrl $8, %eax
shll $8, %ebx
orb %al, %bl
movl %ebx, 4(%esp)
ret
</code>

==== Aufgabe 4 ====

  * 1) tanx -> Taylorreihe; div -> Newton-Rphson / Shift / Subtraktion; mul -> Addition / Shift
  * 2) (steht nirgends schnell):

<code c>
#define unsigned int ui
#define unsigned short us

ui mult(us x, us y) {
    ui sum = 0;
    for (int i = 0; i < y; i++) sum += x;
    return sum;
}
</code>

Das funktioniert so nicht. Hierbei muss immer geshiftet werden.
Am besten ein Beispiel rechnen und dann sieht man es.

==== Aufgabe 5 ====

  * 1)

<code c>
#define unsigned int ui

ui fibo(ui x) {
    ui res;
    if (x < 2) {
        res = 1;
        goto more;
    }
    x = x - 1;
    res = fibo(x);
    x = x - 1;
    res = res + fibo(x);
    more: return res;
}

</code>

  * 2)
<code>
 movl 4(%esp), %ebx
 cmpl $2, %ebx
 jge else                             //unsigned -> jae ?
 movl $1, %eax
 ret
else:
 subl $1, %ebx
 pushl %ebx
 call fibo
 addl $4, %esp
 movl %eax, %ecx
 subl $1, %ebx
 pushl %ebx
 call fibo
 addl $4, %esp
 addl %ecx, %eax
 ret
</code>

Das funktioniert so nicht... Wegen der tiefen Rekursion werden die Register immer wieder ueberschrieben. Man muss hierbei den Stack verwenden, in em da das Zwischenergebnis gespeichert wird.

Ich denke, bei call werden die Register automatisch auf dem Stack gesichert und bei ret wiederhergestellt. Ist das nicht gerade der Unterschied zu iret?

==== Aufgabe 6 ====

???

==== Aufgabe 7 ====