---
# System prepended metadata

title: RA - Praktikum 4
tags: [RA]

---

# RA - Praktikum 4 
###### tags: `RA`

## Aufgabe 1
* str r~z~, \[r~x~\], v 
* Speicher den Wert von r~z~ an die Speiceradresse aus der Klammer und Addiere v zum Wert der Adresse r~x~. Wenn ein ! am Ende dann speichere den neuen Wert an die Adresse r~x~.  


```
MOV      R0, #0
STR      r1, [R0, #4]    ; an die Adresse 0x4; R0 = 0x0

EOR      R0, R0, R0
STR      R1, [R0], #4    ; an die Adresse 0x0; R0 = 0x4

MOV      R0, #0
STR      R1, [R0]!       ; an die Adresse 0x0; R0 = 0x0

SUB  	 R0, R0, R0
STR  	 R1, [R0, #4]!   ; an die Adresse 0x4; R0 = 0x4

ANDS 	 R0, R0, #0
STRB 	 R1, [R0, #2]!   ; an die Adresse 0x2; R0 = 0x2
; STRB Speichert nur das letzte byte in den Speicher, was im hexbereich die letzten zwei chars sind
MOV  	 R1, #4
STRB 	 R1, [R0, R1]!   ; an die Adresse 0x6; R0 = 0x6
```

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

* Auf folgende Weisen kann man die Condition-Code-Flags NZCV setzen:
    1. arimetrische oder logische Operatoren mit einem S am Ende des Befehlsnamen 
    2. Vergleichsoperatoren

### (b) Wie wird die Pseudoinstruktion “ADR R1, Marke” vom Assembler umgesetzt?
* ADR R1, Marke -> lässt sich umschreiben in ADD R1, pc, #0 
Der PC ist immer 2 Befehle dem aktuellen Befehl voraus. Daraus lässt sich schließen, dass unsere ARM eine 3er Pipline verwendet. Das bedeutet wenn ein Befehl ausgeführt wird, dann ist der nachfolgende Befehl schon in der Decodephase und der nachfolgende vom nachfolgenden Befehl in der Fetchphase.


.text
ADR r1, adr_marke1

adr_marke1: .word marke1

.data
marke1: .word 0x87...

!Fehler:
adr r1, marke1
-> Symbol .data is in a different section


### \(c\) Das Prozessorstatuswort hat den Wert 0x40000013, wenn der Befehl “SUBEQS R1, R1, R1” ausgeführt wird. Was steht danach im Register R1 und im CPSR? Weisen Sie Ihre Antwort nach.
In unserem Beispiel steht danach eine 0 in dem Register R1, das liegt an dem compare Befehl, welchen wir davor ausgeführt haben. Ohne den Comparebefehl bleiben die Flags unbearbeitet. Das CPSR Register hat im Anschluss den Wert 0x60000013, also ist das Carrybit und das Zerobit gesetzt.

```
    MOV R3, #0
    CMP R3, #0        // wenn R3 = 0 (eq) dann wird das Z-Bit gesetzt
    SUBEQS r1,r1,r1   // wenn Z-Bit gesetzt, dann führe SUB aus
```

Frage: Warum werden die Flags nicht geupdated

## Aufgabe 3(kopieren)

```
loop_copy:
LDRB R3, [R0], #1
STRB R3, [R1], #1
CMP R3, #0 // check for end
BNE loop_copy

bx lr
```


## Aufgabe 4(reduzieren)
```
reduzieren:
@ hier Ihr Programm zum Wandeln in Grossbuchstaben
@
LDR R1, Adr_StringB
MOV R2, R1 //copy value from r1 into r2
MOV R4, #0 //reset register to 0


loop_reduce:

LDRB R3, [R1], #1
CMP R3, #0
BEQ reset_byte

CMP R3, #65
BMI save

CMP R3, #91
BPL save
BLE loop_reduce // else


save:
STRB R3, [R2], #1
BAL loop_reduce

reset_byte:
STRB R4, [R2], #1
LDRB R3, [R2]

bx lr

```

## Aufgabe 5(Sortieren)
* Selection-Sort

```asm
// selectionsort
sortieren:
// hier Ihr Programm zum alphabetisch sortieren
// ..
LDR R1, Adr_StringB    // R1 = Adresse zum String
// IN R2 ist die erste adresse also i
MOV R2, R1 // R2 ist iterator und R1 ist speicherstelle mit der wir swappen
//
// äußere Schleife
outer_loop:
LDRB R3, [R2] // R3 entsprciht i (wird in der äußeren Schleife iteriert)
              // R2 Position der äußeren Schleife
MOV R5, R3    // R5 enthält immer das min Element
CMP R3, #0 // Ist das Ende erreicht?
BEQ exit   // Wenn ja dann exit
MOV R4, R2 // int j = i
//
// innere Schleife
inner_loop:
// In R4 ist die zweite adresse also j
LDRB R6, [R4] // R6 entspricht j (wird in der inneren Schleife iteriert)
              // R4 Position der inneren Schleife

CMP R6, #0    // Ist innere Schleife am Ende?
BEQ swap      // Dann tausche akt pos mit kleinstem Element

CMP R5, R6    // R5 - R6 // wenn positiv dann ist R6 kleiner
MOVPL R5, R6  // R6 in R5 moven, wenn R6 kleiner
MOVPL R7, R4  // ebenfalls Speicherstelle zwischenspeichern zum swappen

ADD R4, #1    // R4 (Speicherstelle von j inkrementieren)
BAL inner_loop // erneut in innerloop, diesmal mit erhöhtem Zähler
//
// swap 
swap:
STRB R5, [R2] // Wert von R5(kleinstem Element) an Stelle R2(pos von äußerer Schleif
STRB R3, [R7] // Wert von R3(Wert von i) an Stelle R7 (pos von kleinstem Element)

ADD R2, #1 // inkrementieren von R2 für den nächsten durchlauf
BAL outer_loop

exit:

bx lr
```