==== Aufgabe 1 ====

  * 1) 1, 2, 1, 2, 2, 1, 2 ,1
  * 2) Register; Immediate Operand; Direct Adress; Register Indirect (alle Variationen); Memory Indirect
  * 3) 1, 1, 2, 2, 2, 2, 2, 2
  * 4) 2, 1, 1, 2, 2, 1, 1, 2
  * 5) Weil die Reihenfolge der einzelnen Bytes falsch gelesen wird, z. B. 0x000000FF -> 0xFF000000
  * 6) 2, 1, 1, 2, 2, 1, 2, 1

==== Aufgabe 2 ====

  * 1) struct bla { char y; short x; long z; } ; Little-Endian
  * 2) Wenn er über Pointer Zugriff auf die Speicherinhalte hat.

==== Aufgabe 3 ====

  * 1) links vertikal Adressbus; rechts vertikal Datenbus; fehlend: IOR, IOW, MR, MW, Interrupt
  * 2) ?
  * 3) siehe Folien zu Rambaustein; MR, MW durch IOR, IOW ersetzen 

==== Aufgabe 4 ====

<code>
Multiply: .globl Multiply

    /* Mantisse der ersten Zahl laden (%eax) */
    movl 4(%esp), %eax

    /* Mantisse der zweiten Zahl laden (%ebx) */
    movl 8(%esp), %ebx

    /* Mantissen miteinander multiplizieren (%ax) */
    imulw %bx, %ax
    andl $0x0000ffff, %eax

    /* Exponent der ersten Zahl laden, Vorzeichenbit entfernen (%ebx) */
    movl 4(%esp), %ebx
    andl $0x7fff0000, %ebx

    /* Exponent der zweiten Zahl laden, Vorzeichenbit entfernen (%ecx) */
    movl 8(%esp), %ecx
    andl $0x7fff0000, %ecx

    /* Exponenten miteinander addieren, in Ergebnis einfuegen (%eax) */
    addl %ecx, %ebx
    orl %ebx, %eax

    /* Vorzeichen per XOR miteinander verknuepfen (%ebx) */
    movl 4(%esp), %ebx
    xorl 8(%esp), %ebx

    /* Neues Vorzeichen in Ergebnis einfuegen (%eax) */
    andl $0x800000, %ebx
    orl %ebx, %eax

    /* Ruecksprung */
    ret
</code>

==== Aufgabe 5 ====

  * 1) Man will dem User keinen direkten Zugriff auf die Hardware erlauben. Aufrufsyntax ist ähnlich; Kontext ist unterschiedlich
  * 2) Exceptions + Interrupts

==== Aufgabe 6 ====

  * 1)
<code>
int func(int v) {
    int i;
    for (i = 0; i*i < v; i++);
    return i;
}
</code>

Einspruch: Bei einer for-Schleife wird ja schon vor dem Betreten die Bedingung geprüft, das passiert im Assembler-Code da aber nicht.
Ich hätte da so was:

<code>
int func(int v) {
    int i;
    for (i = 0;; i++) {
        i *= i;
        if (i >= v) break;
    }
    return i;
}
</code>

Die letzte Variante ist falsch, weil die Multiplikation mit %eax ist und %eax nicht zwischengespeichert wird. Dementsprechend ist die erste Variante richtig.

Noch etwas: Ich glaube die Ints müssen unsigned Ints sein.

  * 2) ?
  * 3) 

<code>
unknown:
	pushl %ebp
	movl %esp, %ebp
	pushl $0
   .L2:
    movl  -4(%ebp), %eax
    imull -4(%ebp), %eax
    cmpl  8(%ebp), %eax
    jb    .L4
    jmp   .L3
.L4:
    incl  -4(%ebp)
    jmp   .L2
.L3:
    movl  -4(%ebp), %eax
   	movl %ebp, %esp
	popl %ebp
    ret
</code>

==== Aufgabe 7 ====

Funktionstabelle der Form: x_3 x_2 x_1 x_0 | c y_3 y_2 y_1 y_0

Mit Symmetriediagrammen vereinfacht:

  * y_0 = !x_0
  * y_1 = x_0 XOR x_1
  * y_2 = x_0 x_1 !x_2 + !x_0 x_2 + !x_1 x_2
  * y_3 = x_0 x_1 x_2 !x_3 + !x_2 x_3 + !x_0 x_3 + !x_1 x_3
  * c = x_0 x_1 x_2 x_3