Algorithmen in Assemblerprogramme mit möglichst geringer Codegröße umzusetzen, sowie der Umgang Debugger und Simulator.

Arbeitsverzeichnis:

Kopieren Sie sich das Verzeichnis, welches Ihnen im Praktikum zur Verfügung gestellt wird, in Ihr persönliches Verzeichnis. Dort stehen Ihnen dann alle benötigten Dateien zur Verfügung.

Vorbereitung

Überlegen Sie sich ein Unterprogramm (Funktion), welches eine Zeichenkette in einem Text suchen soll. Die Funktion bekommt die Anfangsadresse des zu durchsuchenden Textes und die Anfangsadresse der zu suchenden Zeichenkette in den Registern R0 und R1 übergeben. Im Register R0 soll zurückgegeben werden , wie oft die zu suchende Zeichenkette im Text gefunden wurde. Bei einer leeren zu suchenden Zeichenkette liefert  die Funktion den Wert 0 zurück. Handelt es sich bei dem zu durchsuchenden Text um eine leere Zeichenkette, so liefert die Funktion den Wert 0 zurück.

Mögliche Aufrufe:

int searchStringInString(char*, char*);

int main (void)
{
int Anzahl;
char* Text="hallo Alles klar?";
char* Suchstring="ll";
char* Leerstring=““;
Anzahl = searchStringInString(Text, Suchstring);
Anzahl = searchStringInString(Text, Leersrtring);
Anzahl = searchStringInString(Leerstring, Suchstring);
Anzahl = searchStringInString(Leerstring, Leerstring);
return 0;
}

Überlegen Sie sich noch weitere Testfälle

Aufgabe 1:

Schreiben Sie Ihr Programm und testen es bevor Sie es im Praktikum vorführen.

.file "searchStringInString.s"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function
searchStringInString:
..
..
..

Lösung 1

@ in R0 wird die Adresse des zu durchsuchenden Text erwartet.
@ in R1 wird die Adresse des zu suchendenn Text erwartet.
@ sollte R0 auf einen leeren String zeigen,
@ oder der gesuchte Text nicht gefunden werden,
@ so wird in R0 der Wert 0 zurueck geliefert.
@ zeigt R1 auf einen leeren String so wird in R0 der Wert 0 zurueck gegeben

.file "searchStringInString.S"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function

searchStringInString:

stmfd sp!, {r4,r5,lr}

mov r4, r0 // Neues Register für den zu durchsuchenden Text

ldr r5,[r0]
cmp r5,#0x0
mov r0,#0x0 // Zähler auf 0 setzen
ldmeqfd sp!, {r4,r5,pc}

mov r3, r1 // Neues Register für den zu suchenden Text
mov r5, r3 // Sicherung der Adresse des zu suchenden Textes

//ldrb r1,[r3]
loop: // Schleife

LDRB r2, [r4],#1 // Erstes bzw. nächstes Zeichen des zu durchsuchenden Strings laden

CMP r1,r2 // Vergleich zu suchendes Zeichen = Zeichen in Zeichenkette
LDREQB r1, [r3],#1 // Wenn r1=r2 dann nächstes zu suchendes Zeichen laden

CMP r1,#0x0 // Vergleich ob r1 das letzte Zeichen war
ADDEQ r0,#0x1 // Zähler um 1 erhöhen
MOVEQ r3, r5 // r1 zurücksetzen

CMP r3, r5
LDREQB r1, [r3],#1

CMP r2, #0x0 // Prüfen ob r2 das letzte Zeichen war

BNE loop // Schleifenaufruf, wenn r2 nicht fertig ist

ldmfd sp!, {r4,r5,pc}

.size searchStringInString, .-searchStringInString

Zusatzaufgabe:

Überlegen Sie sich ein Unterprogramm (Funktion), welches eine Zeichenkette in einem Text suchen soll. Die Funktion bekommt die Anfangsadresse des zu durchsuchenden Textes und die Anfangsadresse der zu suchenden Zeichenkette in den Registern R0 und R1 übergeben. Im Register R0 soll zurückgegeben werden , wie oft die zu suchende Zeichenkette im Text gefunden wurde. Bei einer leeren zu suchenden Zeichenkette liefert die Funktion die Länge des zu durchsuchenden Text zurück. Handelt es sich bei dem zu durchsuchenden Text um eine leere Zeichenkette, so liefert die Funktion den Wert 0 zurück.

Lösung Zusatzaufgabe

@ in R0 wird die Adresse des zu durchsuchenden Text erwartet.
@ in R1 wird die Adresse des zu suchendenn Text erwartet.
@ sollte R0 auf einen leeren String zeigen,
@ oder der gesuchte Text nicht gefunden werden,
@ so wird in R0 der Wert 0 zurueck geliefert.
@ zeigt R1 auf einen leeren String so wird in R0 der Wert 0 zurueck gegeben

.file "searchStringInString.S"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function

searchStringInString:

stmfd sp!, {r4,r5,lr}

mov r4, r0 // Neues Register für den zu durchsuchenden Text

ldr r5,[r0]
cmp r5,#0x0
mov r0,#0x0 // Zähler auf 0 setzen
ldmeqfd sp!, {r4,r5,pc}

mov r3, r1 // Neues Register für den zu suchenden Text
mov r5, r3 // Sicherung der Adresse des zu suchenden Textes

loop: // Schleife

LDRB r2, [r4],#1 // Erstes bzw. nächstes Zeichen des zu durchsuchenden Strings laden

CMP r1,r2 // Vergleich zu suchendes Zeichen = Zeichen in Zeichenkette
LDREQB r1, [r3],#1 // Wenn r1=r2 dann nächstes zu suchendes Zeichen laden

CMP r1,#0x0 // Vergleich ob r1 das letzte Zeichen war
ADDEQ r0,#0x1 // Zähler um 1 erhöhen
MOVEQ r3, r5 // r1 zurücksetzen

CMP r3, r5
LDREQB r1, [r3],#1

CMP r2, #0x0 // Prüfen ob r2 das letzte Zeichen war

BNE loop // Schleifenaufruf, wenn r2 nicht fertig ist

ldmfd sp!, {r4,r5,pc}

.size searchStringInString, .-searchStringInString

Der Beitrag Rechnerarchitektur (Praktikum 6) erschien zuerst auf Maximilian Krieg.

Verständnis für STACK Befehle und deren Nutzung bei Unterprogrammen. Ziel ist es Programme mit möglichst geringer Codegröße zu implementieren, sowie der Umgang mit einem Debugger/Simulator.

Arbeitsverzeichnis:

Kopieren Sie sich das Verzeichnis, welches Ihnen im Praktikum zur Verfügung gestellt wird, in Ihr persönliches Verzeichnis. Dort stehen Ihnen dann alle benötigten Dateien zur Verfügung.

Vorbereitung

Arbeiten Sie sich in folgende Befehle des ARM-Prozessors und in den ARM Procedure Call Standard (APCS) ein:

Instruktion := Bedeutung
STMFD R13, {R1-R4, LR} := Speichert die Registerwerte R1 bis R4 sowie LR (=R14) an die Adresse, die in R13 (=SP) steht, als voll absteigender Stack

LDMFD R13, {R1-R4, PC} := Lädt den Speicherinhalt von der Adresse, die in R13 (=SP) steht, in Form eines voll absteigenden Stacks in die Register R1 bis R4 sowie PC (=R15)

Aufgabe 1:

In folgenden Tabellen ist jeweils ein Speicherauszug gezeigt. Welche Werte stehen in den Registern nach Ausführung des Blocktransferbefehls? R9 = 0x8000

LDMDA R9, {R1, R2, R6}
R1: 4
R2: 5
R6: 6

LDMFD R9, {R1, R2, R6}
R1: 6
R2: 7
R6: 8

// Aufgabe 1: Blocktransferbefehle"
// Name: Matrikelnummer: 
// Datum: 

.file "aufgabe1.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:
stmfd sp!, {r6, r9, lr}
ldr r9, =0x8000

ldmda r9, {r1, r2, r6}
ldmfd r9, {r1, r2, r6}

ldmfd sp!, {r6, r9, pc}
.Lfe1:
.size main,.Lfe1-main

// End of File

Aufgabe 2:

Schreiben Sie ein beliebiges, kleines Programm in ARM Assembler, das durch Unterprogramme strukturiert wird. Folgende Anforderungen werden an das Programm gestellt:

• Die APCS Konvention wird eingehalten
• Das Programm benutzt (mindestens) drei Unterprogramme (UP):
  • UP1 benutzt nur Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf)
  • UP2 benutzt nur Scratchregister und stellt eine Blattroutine dar (ruft somit keine weiteren Unterprogramme auf)
  • UP3 benutzt Nicht-Scratchregister und stellt keine Blattroutine dar

// Befehle = 19, Programmgröße = 19*4 Byte= 76 Byte
.file "aufgabe2.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main: // 5 Befehle
push {lr}
bl up1 // Unterprogramm 1 aufrufen
bl up2 // Unterprogramm 2 aufrufen
bl up3 // Unterprogramm 3 aufrufen
pop {pc}

// UP1 benutzt nur Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf
up1: // 7 Befehle
push {lr}
MOV r0, #0x0 // r0=0
MOV r1, #0x1 // r1=1
bl up2 // Unterprogramm 2 aufrufen
MOV r1,#0x2
bl up2 // Unterprogramm 2 aufrufen
pop {pc}

// UP2 benutzt nur Scratchregister und stellt eine Blattroutine dar (ruft somit keine weiteren Unterprogramme auf)
up2: // 3 Befehle
push {lr}
ADD R0, R0, R1 // r0 und r1 addieren, Ergebnis nach r0 schreiben
pop {pc}

//UP3 benutzt Nicht-Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf)
up3: // 4 Befehle
stmfd sp!, {r4, lr} // r4 und lr sichern
ADD r4, r4, #0x1 // r4 um 1 erhöhen
bl up2 // Unterprogramm 2 aufrufen
ldmfd sp!, {r4, pc} // r4 und lr -> pc zurück laden

.Lfe1:
.size main,.Lfe1-main

// End of File

Aufgabe 3:

Schreiben Sie das Programmbeispiel aus Termin 2 (selbst modifizierender Code )in ARM7-Assembler und testen Sie dieses. Beobachten Sie die sich ändernden Speicherstellen/Befehle. Beschäftigen Sie sich mit den Problemen, welches dieses Programm machen kann.

Warum funktioniert das Programm im Simulator?

• Das Programm funktioniert, da innerhalb des Simulators alle Programme im RAM stehen.

Wie groß dürfte die Werteliste werden?

// Befehle = 16, Programmgröße = 16*4 Byte = 64 Byte

.file "aufgabe3.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:

loop:
ADR r0, Total // Accumulate total
LDR r1, [r0]

Add_instr: // Add_instr

ADR r2, Table
LDR r3, [r2],#4

add r5, r1, r3 // Speichere r3 + r1 in r5
str r5, Total // Speichere r5 unter „Total“

LDR r3, Add_instr
add r3, r3,#4 //Speichere r3 + 4 in r3
str r3, Add_instr // Speichere r3 unter „Add_instr“

ldr r6, Count
subs r6,r6,#1 // Speichere r6 – 1 in r6, setze die Statusbits
str r6, Count // Speichere r6 unter „Count“
BGE loop
STR r5, Total // Speichere r5 unter „Total“
b Halt // STP ; Halt execution

Halt:
b Halt

Total: .word 0
One: .word 4
Count: .word 4
Table: .word 39, 25, 4, 98, 17

.Lfe1:
.size main,.Lfe1-main
// End of File

Aufgabe 4:

Berichtigen Sie das Programm nun so, dass der Programmcode (kein sich selbst
modifizierenden Code) im ROM (Read Only Memory) und die sich ändernden Daten im RAM (Random Acces Memory) stehen.

// Befehle = 10  Programmgröße = 10 * 4 Byte = 40 Byte
.file "aufgabe4.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function

main:

LDR r1, =Table // Laden der Adresse von Table
MOV r0, #0x0 // Ergebnisregister auf 0 setzen
LDR r3, =Count // Laden der Adresse der Zähl-Variable
LDR r3, [r3] // Laden des Wertes der Zähl-Variable

loop:
LDR r2, [r1], #4 // Laden des ersten Wertes der Tabelle nach r2, inkrement danach
ADD r0, r2, r0 // Ergebniswert = Ergebniswert + Tabellenwert
SUBS r3, r3, #1 // Zählvariable dekrementieren mit Status
BPL loop // Solange r3 >=0 ist wiederhole die Loop
STR r0, Total // r0 nach Total speichern

BX LR

.Lfe1:
.size main,.Lfe1-main

.data
Total: .word 0
Count: .word 4
Table: .word 39, 25, 4, 98, 17

// End of File

Der Beitrag Rechnerarchitektur (Praktikum 5) erschien zuerst auf Maximilian Krieg.

Verständnis für LOAD und STORE Befehle, bedingte Befehle und die verschiedenen Speicherbereiche. Ziel ist die Implementierung mit möglichst geringer Codegröße sowie der Umgang mit einem Debugger/Simulator und der Entwicklungsumgebung.

Arbeitsverzeichnis:

Kopieren Sie sich das Verzeichnis, welches Ihnen im Praktikum zur Verfügung gestellt wird, in Ihr persönliches Verzeichnis. Dort stehen Ihnen dann alle benötigten Dateien zur Verfügung.

Vorbereitung

Arbeiten Sie sich in folgende Befehle des ARM-Prozessors ein:

Instruktion := Bedeutung
ADDNE R1, R2, #1 R1 := R2 + 1, falls das Z-Bit im Prozessorstatuswort nicht gesetzt ist
LDR R1, [R2] R1 := mem32[R2]
LDREQ R1, [R2] R1 := mem32[R2], falls das Z-Bit im Prozessorstatuswort gesetzt ist
LDRB R1, [R2] R1 := mem8[R2]
STR R1, [R2] mem32[R2] := R1
STRB R1, [R2] mem8[R2] := R1
ADR R1, Marke R1:=PC+(Offset zur Marke)
B Marke PC wird auf Adresse der Marke gesetzt
BEQ Marke PC wird auf Adresse der Marke gesetzt, falls das Z-Bit im Prozessorstatuswort gesetzt ist
BNE Marke PC wird auf Adresse der Marke gesetzt, falls das Z-Bit imProzessorstatuswort nicht gesetzt ist

Aufgabe 1:

.file "aufgabe1.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:
// Hier bitte Ihren ProgrammCode einfuegen

mov r0, #0 // r0=0x0; r1=0x1ffff8 zu diesem Zeitpunkt
str r1, [r0], #4 // Inhalt von r1 auf Adresse 0x00000000. Danach steht in r0 0x4
eor r0, r0, r0 // r0=0x0
str r1, [r0, #4] // Inhalt von r1 auf Adresse 0x00000004, danach steht in r0 0x0
mov r0, #0 // r0=0x0
str r1, [r0]! // Inhalt von r1 auf Adresse 0x00000000, danach steht in r0 0x0
sub r0, r0, r0 // r0=0x0
str r1, [r0, #4]! // Inhalt von r1 auf Adresse 0x00000004, danach steht in r0 0x4
and r0, r0, #0 // r0=0x0
strb r1, [r0, #1]! // Inhalt von r1 auf Adresse 0x00000001 (nur hintere 8bit), danach steht in r0 0x1
mov r1, #4 // r1=0x4
strb r1, [r0, r1]! // Inhalt von r1 auf Adresse 0x00000005 (nur hintere 8 bit), danach steht in r0 0x5

bx lr
.Lfe1:
.size main,.Lfe1-main

// End of File

Aufgabe 2:

Bearbeiten Sie schriftlich die Zusatzfragen.

a) Auf welche Weise kann man die Condition-Code-Flags NZCV (Bedingungsbits) des Prozessorstatuswort (CPSR) setzen?

Lösung: Indem man an die ARM-Befehle ein „S“ anhängt (z.B. ADDS, SUBS …) oder die Befehle TST, TEQ, CMP oder CMN verwendet.

b) Wie wird die Pseudoinstruktion “ADR R1, Marke” vom Assembler umgesetzt? Schreiben Sie hierzu den Befehl in einen der vorgegebenen Programmrahmen und schauen Sie ihn sich im Debugger in der Mixed-Darstellung an (rechts oben Source auswählen). → Vollziehen Sie die Umsetzung des Compiler nach und informieren Sie sich auch über Pipelining.

Lösung

Ein Befehl kann in einem Zyklus gefetched werden. Wird er im nächsten Zyklus decoded, kann man bereits im selben Zyklus den nächsten Befehl fetchen. ADR wird entweder in ein ADD oder SUB umgesetzt, da ADR eigentlich keine Instruktion ist.

In diesem Fall erzeugt ADR diesen Befehl:
ADD r1, PC, 0x8

• PC steht für den Wert, nachdem das ADR ausgeführt wurde (somit nochmals um 8 erhöht wurde).
• 0x8 steht für die Distanz zu Marke vom PC, (4x Anzahl der Befehle zwischen PC und Marke)

Programm Aufgabe2

.file "aufgabe2.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:

ADR r1, Marke // PC+0 = Fetch von ADR
mov r0,#0 // PC+4 = Decode von ADR
mov r0,#1 // PC +8 = Execute von ADR
mov r0,#2 // Execute +4
Marke: .word 0x00000000 // Execute +8
.Lfe1:
.size main,.Lfe1-main
// End of File

c) Das Prozessorstatuswort hat den Wert 0xa00013, wenn der Befehl “BNE Marke” ausgeführt wird. Würde dann der Sprung an die (symbolische) Adresse Marke ausgeführt? Weisen Sie Ihre Antwort mit einem Programm nach.

Lösung: Ja, da BNE bedeutet, dass etwas ausgeführt wird, wenn das Zero-Bit nicht gesetzt ist. Zum Zeitpunkt des Befehls steht im CPSR 0x00a00013, somit ist das Zero-Bit 0 und der Sprung wird ausgeführt.

Aufgabe 3:

Es ist ein Programm zu entwickeln, welches alle Werte einer Liste1 nach Liste2 kopiert. In den Listen steht an erster Stelle die Anzahl der Elemente der jeweiligen Liste. Liste1 ist, bis auf die erste Zahl (Anzahl der Elemente max. 255) eine Liste mit 8Bit großen vorzeichenbehafteten Zahlen (-128 bis +127). In Liste2 sollen die Zahlen aus Liste1, ausser die Anzahl der Elemente (die bleibt vorzeichelos), als 32Bit große vorzeichenbehaftete Zahlen abgelegt werden.

Lösung

• 8 Bit Zahlen in Register laden
• Zahlen mit 24 Bit Verschiebung in den Speicher schreiben
• Vorzeichenwechsel mit ASR erzeugen (Laden, Verschieben, ASR mit 0/1 auffüllen lassen)

Aufgabe 4:

Nach dem Kopiervorgang soll in einem weiteren Schritt die Liste2 aufsteigend sortiert werden. Hierzu erweitern Sie Ihr Programm von Aufgabe 3. Es gibt verschiedene Sortieralgorithmen (z.B. Bubblesort). Denken Sie daran, dass die Länge der Liste an erster Stelle stehen bleiben muss.

Lösung

.file "aufgabe3.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:
stmfd sp!, {r4, r5, lr} @ Ruecksprungadresse und Register sichern
kopieren:
@ hier Ihr Programm zum Kopieren einer Byte-Tabelle (je 8Bit) in eine Word-Tabelle (je 32Bit) einfuegen

LDR r1, =Liste1 // Position von Liste1 bestimmen
ADR r2, TAB2 // Position von TAB2 bestimmen
LDR r2, [r2] // Position der Werte für Tab2 bestimmten
LDRb r3, [r1] // Zähler für Loop

loop0: // Schleife für Einlesen der Werte
LDRB r0, [r1], #1 // Nächstes Element einlesen (8 Bit Zahl)

vorzeichen:
MOV r0, r0, LSL #24
MOV r0, r0, ASR #24

// Bereich für Speichern der Liste
STR r0, [r2], #4 // Wert von r0 nach Liste2 speichern
sub r3, r3, #1 // Dekrementierung des "loop0"-Counters um 1
CMP r3, #0 // Vergleich ob r3-0=0 und Statusbits setzen

BNE loop0 // Sprung zu loop0, wenn r3 nicht null war
BEQ sortieren // Aufruf der "Sortieren"-Funktion, wenn r3 null war

sortieren: // hier Ihr Programm um die vorzeichenrichtige Zahlen in Liste2 zu sortieren

ADR r0, TAB2 // Position von TAB2 bestimmen
LDR r0, [r0] // Position der Werte von TAB2 bestimmen (r0 ist die Laufvariable)

LDR r3, [r0],#4 // Zähler (1. Element) für Schleifen laden und auf nächstes Element setzen
sub r3,r3,#2 // Zähler um 2 dekrementieren
mov r6,r0 // r0 nach r6 sichern

mov r1, r3 // Zähler für die äußere Schleife setzen

loop1: // Funktion der äußeren Schleife

mov r0,r6 // r0 auf die Position der Tabelle2 setzen
mov r2, r3 // Innere Schleife zurücksetzen

loop2: // Funktion für die innere Schleife
sub r2,r2,#1 // Zähler der inneren Schleife um 1 dekrementieren

LDR r4,[r0] // Aktuelles Element laden nach r4
LDR r5,[r0,#4]! // Folgendes Element laden nach r5

cmp r4,r5 // Vergleich: r4-r5
STRGT r5,[r0,#-4] // Speichern von r5 an die Position von r4
STRGT r4,[r0] // Speichern von r4 an die Position von r5

cmp r2,#0 // Vergleich: r2-0
bne loop2 // Aufruf der inneren Schleife, wenn r2 nicht null ist

sub r1, r1,#1 // Zähler der äußeren Schleife um 1 dekrementieren
cmp r1,#0 // Vergleich r1-0
bne loop1 // Aufruf der äußeren Schleife, wenn r1 nicht null ist
beq fertig // Ende des Sortierens und Aufruf von "fertig", wenn r1 null ist.

fertig:
ldmfd sp!, {r4, r5, pc} @ Ruecksprungadresse und Register

TAB2: .word Liste2 @ Beispiel um an Adressen aus anderen Segmenten zu kommen

.Lfe1:
.size main,.Lfe1-main

// .data-Section fuer initialisierte Daten
.data
// Erster Wert der Tabelle steht fuer die Anzahl (max. 64) der Werte der Tabelle
Liste1: .byte (Liste1Ende-Liste1), -7, 8, -9, 6, -5, 4, -3, 2, -1, 0, 127, 128 //128
Liste1Ende:

// .comm-Section fuer nicht initialisierte Daten
.comm Liste2, ((Liste1Ende-Liste1)*4) @ Speicherbereich mit der Groesse*4 von Liste1 reservieren

// End of File

Bericht

Der erforderliche Praktikumsbericht dient zu Ihrer Nachbereitung des Praktikums und wird stichprobenhaft überprüft. Er beinahltet auch den zeilenweisen kommentierten Quelltext. Haben Sie Ihre Berichte zu den Praktikumsterminen dabei.

Der Beitrag Rechnerarchitektur (Praktikum 4) erschien zuerst auf Maximilian Krieg.

.file "aufgabe2.S"
.text
.align 2
.global main
.type main,function
main:
@ args = 0, pretend = 0, frame = 12
@ frame_needed = 1, uses_anonymous_args = 0

MOV R0, #5 // Belegen des Registers R0 mit dem dezimalen Wert 5
RSB R3, R0, R0, LSL#4 // R3 = (R0*16)-R0
MOV R0, R3, LSL#4 // Multipliziere R3 mit 16 und schreibe das Ergebnis in R0

MOV R0, #5 // Belege Register R0 mit dem dezimalen Wert 5
RSB R0, R0, R0, LSL#9 // R0 = (R0*512)-R0

MOV PC, LR

.Lfe1:
.size main,.Lfe1-main

Der Beitrag Rechnerarchitektur (Praktikum 3) erschien zuerst auf Maximilian Krieg.

Erweitern sie den Befehlssatz des MU0-2 Prozessors um die Befehle PUSH, POP, LDR und STR. Füllen Sie die Steuerungstabelle aus und malen Sie in die Diagramme den jeweiligen Datenfluss.

Befehlstabelle

PUSH

• Der Befehl PUSH dekrementiert (SP=SP-1) den Stackpointer (Register SP) und speichert den aktuellen Akkumulatorinhalt (Register A) auf dem Stack.

POP

• Der Befehl POP lädt den Wert auf den der Stackpointer zeigt in den Akkumulator und inkrementiert (SP=SP+1) den Stackpointer. 

STR S

• Der Befehl STR S speichert den Inhalt des Akkumulator auf die Adresse, auf den die Variable S zeigt.

LDR S

• Der Befehl LDR S lädt den Akkumulator mit dem Inhalt der Adresse, auf die die Variable S zeigt.

Der Beitrag Rechnerarchitektur (Praktikum 2) erschien zuerst auf Maximilian Krieg.