Shiften und Rotation: Unterschied zwischen den Versionen

Aus C und Assembler mit Raspberry
VisuellWikitext
Die Seite wurde neu angelegt: „ mov x0, #0b00000011 // Lege 3 nach x0 (GDB p /t $x0) lsl x0,x0,#4 // -> 00110000 In der ARM64-Assemblerprogrammierung spielen Shift- und Rotationsoperationen sowie der Umgang mit dem Carry-Flag eine wichtige Rolle für die Manipulation von Bits in Registern. Hier ist eine detaillierte Übersicht: --- ### **1. Shiften (Bitverschiebung)** #### **Logical Shift Left (LSL)** - Verschiebt die Bits eines Registers nach links. -…“
 
KKeine Bearbeitungszusammenfassung
 
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
    mov x0, #0b00000011 // Lege 3 nach x0 (GDB p /t $x0)
    lsl x0,x0,#4
                    // -> 00110000
In der ARM64-Assemblerprogrammierung spielen Shift- und Rotationsoperationen sowie der Umgang mit dem Carry-Flag eine wichtige Rolle für die Manipulation von Bits in Registern. Hier ist eine detaillierte Übersicht:
In der ARM64-Assemblerprogrammierung spielen Shift- und Rotationsoperationen sowie der Umgang mit dem Carry-Flag eine wichtige Rolle für die Manipulation von Bits in Registern. Hier ist eine detaillierte Übersicht:


---
== Shiften (Bitverschiebung) ==


### **1. Shiften (Bitverschiebung)**
=== Logical Shift Left (LSL) ===
* Verschiebt die Bits eines Registers nach links.
* Mit jedem Shift-Schritt wird rechts eine `0` eingefügt.
* Kann verwendet werden, um Werte zu multiplizieren (z. B. mit Potenzen von 2).


#### **Logical Shift Left (LSL)**
Syntax:
- Verschiebt die Bits eines Registers nach links.
<syntaxhighlight lang="asm">
- Mit jedem Shift-Schritt wird rechts eine `0` eingefügt.
LSL Rd, Rn, #shift
- Kann verwendet werden, um Werte zu multiplizieren (z. B. mit Potenzen von 2).
</syntaxhighlight>


**Syntax:** 
* `Rd`: Zielregister   
```asm
* `Rn`: Quellregister   
LSL Rd, Rn, #shift
* `#shift`: Anzahl der Bitverschiebungen   
```
- `Rd`: Zielregister   
- `Rn`: Quellregister   
- `#shift`: Anzahl der Bitverschiebungen   


**Beispiel:** 
==== Beispiel ====
```asm
 
<syntaxhighlight lang="asm">
LSL X0, X1, #3  // X0 = X1 << 3
LSL X0, X1, #3  // X0 = X1 << 3
```
</syntaxhighlight>
Dies verschiebt die Bits in `X1` um 3 Stellen nach links.
Dies verschiebt die Bits in `X1` um 3 Stellen nach links.


---
=== Logical Shift Right (LSR) ===
* Verschiebt die Bits eines Registers nach rechts.
* Mit jedem Shift-Schritt wird links eine `0` eingefügt.
* Kann verwendet werden, um Werte zu dividieren (z. B. durch Potenzen von 2).


#### **Logical Shift Right (LSR)**
Syntax:   
- Verschiebt die Bits eines Registers nach rechts.
<syntaxhighlight lang="asm">
- Mit jedem Shift-Schritt wird links eine `0` eingefügt.
- Kann verwendet werden, um Werte zu dividieren (z. B. durch Potenzen von 2).
 
**Syntax:**  
```asm
LSR Rd, Rn, #shift
LSR Rd, Rn, #shift
```
</syntaxhighlight>


**Beispiel:** 
==== Beispiel ====
```asm
 
<syntaxhighlight lang="asm">
LSR X0, X1, #2  // X0 = X1 >> 2
LSR X0, X1, #2  // X0 = X1 >> 2
```
</syntaxhighlight>
Dies verschiebt die Bits in `X1` um 2 Stellen nach rechts.
Dies verschiebt die Bits in `X1` um 2 Stellen nach rechts.


---
=== Arithmetic Shift Right (ASR) ===
* Verschiebt die Bits eines Registers nach rechts, '''behält aber das Vorzeichen bei'''.
* Das höchstwertige Bit (Sign-Bit) wird aufgefüllt, um den Wert konsistent zu halten (z. B. bei negativen Zahlen im Zweierkomplement).


#### **Arithmetic Shift Right (ASR)**
Syntax:   
- Verschiebt die Bits eines Registers nach rechts, **behält aber das Vorzeichen bei**.
<syntaxhighlight lang="asm">
- Das höchstwertige Bit (Sign-Bit) wird aufgefüllt, um den Wert konsistent zu halten (z. B. bei negativen Zahlen im Zweierkomplement).
 
**Syntax:**  
```asm
ASR Rd, Rn, #shift
ASR Rd, Rn, #shift
```
</syntaxhighlight>


**Beispiel:**  
==== Beispiel ====  
```asm
<syntaxhighlight lang="asm">
ASR X0, X1, #2  // X0 = X1 arithmetisch >> 2
ASR X0, X1, #2  // X0 = X1 arithmetisch >> 2
```
</syntaxhighlight>
Dies eignet sich für signierte Division durch Potenzen von 2.
Dies eignet sich für signierte Division durch Potenzen von 2.


---
== Rotation ==
=== Rotate Right (ROR) ===
* Verschiebt die Bits eines Registers nach rechts und "dreht" die herausfallenden Bits zurück auf die linke Seite.
* Die Bitanzahl bleibt unverändert.


### **2. Rotation**
Syntax:   
 
<syntaxhighlight lang="asm">
#### **Rotate Right (ROR)**
- Verschiebt die Bits eines Registers nach rechts und **"dreht" die herausfallenden Bits zurück auf die linke Seite**.
- Die Bitanzahl bleibt unverändert.
 
**Syntax:**  
```asm
ROR Rd, Rn, #shift
ROR Rd, Rn, #shift
```
</syntaxhighlight>


**Beispiel:**  
==== Beispiel ====  
```asm
<syntaxhighlight lang="asm">
ROR X0, X1, #4  // X0 = X1 rotierte 4 Bits nach rechts
ROR X0, X1, #4  // X0 = X1 rotierte 4 Bits nach rechts
```
</syntaxhighlight>
Wenn `X1 = 0b1101_0001`, wird es zu `0b0001_1101`.
Wenn `X1 = 0b1101_0001`, wird es zu `0b0001_1101`.


---
== Carry-Flag und Rotation mit Carry ==
 
### **3. Carry-Flag und Rotation mit Carry**


Der Carry-Flag wird bei Shifts oder Rotationen verwendet, wenn:
Der Carry-Flag wird bei Shifts oder Rotationen verwendet, wenn:
1. Ein Bit aus dem Register "herausfällt".
# Ein Bit aus dem Register "herausfällt".
2. Dieses Bit in das Carry-Flag geschrieben wird.
# Dieses Bit in das Carry-Flag geschrieben wird.
 
#### **Einsatz von Carry-Flag**
- Wird vor allem für Mehrwort-Arithmetik (z. B. 128-Bit-Operationen mit zwei 64-Bit-Registern) oder für rotierende Operationen verwendet.


---
=== Einsatz von Carry-Flag ===
* Wird vor allem für Mehrwort-Arithmetik (z. B. 128-Bit-Operationen mit zwei 64-Bit-Registern) oder für rotierende Operationen verwendet.


### Zusammenfassung der Unterschiede:
== Zusammenfassung der Unterschiede ==


| Operation           | Verhalten                               | Auffüllung links/rechts |
{| class="wikitable"
|----------------------|------------------------------------------|-------------------------|
|-
| **LSL**            | Linksverschiebung, rechts `0`           | Rechts `0`             |
! Operation !! Verhalten !! Auffüllung links/rechts
| **LSR**            | Rechtsverschiebung, links `0`           | Links `0`             |
|-
| **ASR**            | Rechtsverschiebung mit Vorzeichenbit     | Links Vorzeichenbit   |
| LSL || Linksverschiebung, rechts `0` || Rechts `0`
| **ROR**            | Rotation nach rechts, wieder einfügen   | -                     |
|-
| LSR || Rechtsverschiebung, links `0` || Links `0`
|-
| ASR || Rechtsverschiebung mit Vorzeichenbit || Links Vorzeichenbit
|-
| ROR || Rotation nach rechts, wieder einfügen || -
|}

Aktuelle Version vom 8. April 2025, 12:23 Uhr

In der ARM64-Assemblerprogrammierung spielen Shift- und Rotationsoperationen sowie der Umgang mit dem Carry-Flag eine wichtige Rolle für die Manipulation von Bits in Registern. Hier ist eine detaillierte Übersicht:

Shiften (Bitverschiebung)

Logical Shift Left (LSL)

  • Verschiebt die Bits eines Registers nach links.
  • Mit jedem Shift-Schritt wird rechts eine `0` eingefügt.
  • Kann verwendet werden, um Werte zu multiplizieren (z. B. mit Potenzen von 2).

Syntax: 

 
LSL Rd, Rn, #shift
  • `Rd`: Zielregister
  • `Rn`: Quellregister
  • `#shift`: Anzahl der Bitverschiebungen

Beispiel

 
LSL X0, X1, #3  // X0 = X1 << 3

Dies verschiebt die Bits in `X1` um 3 Stellen nach links.

Logical Shift Right (LSR)

  • Verschiebt die Bits eines Registers nach rechts.
  • Mit jedem Shift-Schritt wird links eine `0` eingefügt.
  • Kann verwendet werden, um Werte zu dividieren (z. B. durch Potenzen von 2).

Syntax: 

LSR Rd, Rn, #shift

Beispiel

LSR X0, X1, #2  // X0 = X1 >> 2

Dies verschiebt die Bits in `X1` um 2 Stellen nach rechts.

Arithmetic Shift Right (ASR)

  • Verschiebt die Bits eines Registers nach rechts, behält aber das Vorzeichen bei.
  • Das höchstwertige Bit (Sign-Bit) wird aufgefüllt, um den Wert konsistent zu halten (z. B. bei negativen Zahlen im Zweierkomplement).

Syntax: 

ASR Rd, Rn, #shift

Beispiel

ASR X0, X1, #2  // X0 = X1 arithmetisch >> 2

Dies eignet sich für signierte Division durch Potenzen von 2.

Rotation

Rotate Right (ROR)

  • Verschiebt die Bits eines Registers nach rechts und "dreht" die herausfallenden Bits zurück auf die linke Seite.
  • Die Bitanzahl bleibt unverändert.

Syntax: 

ROR Rd, Rn, #shift

Beispiel

ROR X0, X1, #4  // X0 = X1 rotierte 4 Bits nach rechts

Wenn `X1 = 0b1101_0001`, wird es zu `0b0001_1101`.

Carry-Flag und Rotation mit Carry

Der Carry-Flag wird bei Shifts oder Rotationen verwendet, wenn:

  1. Ein Bit aus dem Register "herausfällt".
  2. Dieses Bit in das Carry-Flag geschrieben wird.

Einsatz von Carry-Flag

  • Wird vor allem für Mehrwort-Arithmetik (z. B. 128-Bit-Operationen mit zwei 64-Bit-Registern) oder für rotierende Operationen verwendet.

Zusammenfassung der Unterschiede

Operation Verhalten Auffüllung links/rechts
LSL Linksverschiebung, rechts `0` Rechts `0`
LSR Rechtsverschiebung, links `0` Links `0`
ASR Rechtsverschiebung mit Vorzeichenbit Links Vorzeichenbit
ROR Rotation nach rechts, wieder einfügen -
Abgerufen von „https://satyria.de/arm/index.php?title=Shiften_und_Rotation&oldid=999“