Klausur 07/2003

Bachelor Rechnerkommunikation
#1

(SoSem 2004)

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

#2

Klausur 07/2003
Aufgabe 4: Programmtransformation

Also ich bin bis jetzt auf sowas gekommen:

	i = 0;
l1:
	if (i >= 10) goto n1

	v1 = i < 5;
	v2a = a[i];
	v2a += 10;
	v2 = v2a < i;
	v3 = i >= y;
	v4 = v2 || v3;
	
	if (v1 && v4) goto n1;

	if (i >= 5) goto c1;
c1r:
	i++;
	goto l1;
	
c1:
	v1 = b;
	v1 += c;
	v1 *= a[i];
	v1 /= d;
	y += v1;
	goto c1r;

n1:

Aber die Vergleichsoperationen (Zeile 5-10) am Anfang konnte ich noch nicht auflösen in irgendwas Assembler-ähnliches für Ein-Adress-Maschinen. Jemand ne Idee?

#3

Aufgabe 5: Stack

Das ist ja nun ziemlicher Unsinn in der Aufgabenstellung. Also “[m]subl $x - func, %eax[/m]” ist für mich kein Assembler-Quelltext. Was soll dieses geniale Programm jenseits meines Verständnishorizonts also eigentlich tun?

#4

segfaulten g

keine ahnung, ich frag spaeter mal nach…

#5

Falls du damit sagen willst, dass du dieses Konstrukt nicht direkt in einen Opcode umwandeln kannst… da hast du recht. In der Tat handelt es sich aber bei x und func um zwei adressen (->Sprungmarken), und beim assemblieren werden daraus Konstanten, und die kann der Assembler gleich voneinander abziehen, so dass am Ende ein ganz “normaler” Opcode mit 2 Operanden herauskommt (nämlich eax und das Ergebnis von x-func).
Noch genauer stehts in dem anderen 7/2003 Thread…

#6

Oh, hm, OK. hatte ganz vergessen, dass vom letzten Semester/dem davor ja auch noch Themen da sind… :wink:

#7

Aufgabe 1
Ist folgendes richtig?

1a) adressierbarer Speicher ist 2^16 * 16 = 1048576 Bit = 131072 Byte = 128kByte
1b) Speicherverbrauch Little-Endian = Big-Endian
1c) manchmal mehr, da kleinere Variablen, z.B. Short-Int mit 2 Byte zu 4 Byte aufgefüllt werden
1d) 1024 Strukturen (4+4+4+20 = 32 Byte pro Struktur)

#8

Ich hätte gedacht, dass in %eax am Schluss dann func steht, denn

func:
   ...
   call x   /* aufm Stack Rücksprungadresse ablegen */
x:
   popl %eax   /* Rücksprungadresse vom Stack holen und in %eax ablegen */
   subl $x - func, %eax   /* von %eax $x abziegen und func addieren */

Die letzte Zeile ist etwas seltsam, und folgendes hab ich mir überlegt:
Auf %eax liegt die Rücksprungadresse, also x. Von der soll man ($x - func) abziehen, aufgelöst - $x + func. ergibt IMHO func.

Kann das jemand bestätigen / widerlegen? :slight_smile:

#9

ja genau das hattich auch

#10

func hatte ich auch.

Weil ich es grad schon mal geschrieben hatte hier meine aufgabe 3b:

max:
            movl 4(%esp),%edx        // N einlesen
            movl $0, %ecx                  // counter variable ecx
            movl 8(%esp), %eax     //erstes dingens einlesen
            jmp loop
next: 
           cmp 8(%esp,%ecx,4), %eax    //if nachstes dings <= bisher grösstes
           jle loop                                             // weitersuchen
           movl 8(%esp,%ecx,4), %eax     //sonst  nächstes dings gleich neues dings
           jmp loop                                //weiter
loop:
           addl $1, %ecx               // Counter++
           cmp  %ecx,%edx         // If counter < N -> next
           jl      next
end:
         ret            // !!! ENDE!!!

Ja, Assembler ist unleserlich wenn man es nicht selber geschrieben hat
:-/

#11

Ein C-Programm ist genauso unübersichtlich wie Assembler, wenn es nur groß genug wird. Sagen wir, ein Betriebssystem.

#12

Ja.