Aliase

Was sind Aliase?

Ein "Alias" ist eine alternative Schreibweise für eine Instruktion – sozusagen ein „freundlicher“ Name für komplexere Maschinenbefehle. Aliase machen den Code "lesbarer und intuitiver", verändern aber "nicht" den Maschinencode, der letztlich generiert wird.

Beispiel:

mov x0, x1

Dieser Befehl existiert "nicht als eigener Maschinenbefehl", sondern ist ein "Alias" für:

orr x0, x1, xzr

Der Befehl `orr` (bitweises ODER) mit dem Wert `xzr` (Zero-Register) ergibt effektiv `mov`.

Warum macht man das?

• Lesbarkeit: `mov x0, x1` ist leichter verständlich als `orr x0, x1, xzr`.
• Portabilität: Viele Architekturen haben einen `mov`, und Entwickler erwarten diesen.
• Compilerfreundlich: Auch Compiler wie `clang` oder `gcc` generieren „Alias-ähnlichen“ Code.

Was macht `objdump` daraus?

Beim Disassemblieren mit `objdump` oder `gdb` siehst du "immer den echten Maschinenbefehl", nicht den Alias.

mov x0, x1     // geschrieben im Assembler

Ergibt in `objdump -d`:

orr x0, x1, xzr

Das kann verwirrend sein, wenn du Quellcode und disassemblierten Code vergleichst!

Was wird wirklich generiert?

Nehmen wir `mov x0, x1`:

• Quelltext (Alias):

  mov x0, x1

• Assembler-Expansion:

  orr x0, x1, xzr

• Maschinencode (Hex):

  0xaa0103e0

Ob du `mov x0, x1` oder `orr x0, x1, xzr` schreibst, ergibt "denselben Maschinencode".

Bekannte Aliase im ARM64-Assembler

| Alias | Entsprechender Instruktionscode | Beschreibung | |----------------|------------------------------------------------|------------------------------------------| | `mov x0, x1` | `orr x0, x1, xzr` | Kopiere Register | | `mov x0, #0` | `movz x0, #0` | Setze Register auf 0 | | `cmp x0, x1` | `subs xzr, x0, x1` | Vergleich über Subtraktion ohne Ergebnis | | `neg x0, x1` | `sub x0, xzr, x1` | Negation | | `nop` | `hint #0` | Kein-Operation (für Alignment etc.) | | `ret` | `br x30` | Rücksprung aus Funktion | | `b label` | `b label` (kein Alias) | Unbedingter Sprung | | `bl label` | `bl label` (kein Alias) | Sprung mit Link (Funktionsaufruf) | | `movk/movz/movn`| Literalladen in 16-Bit-Chunks | Register initialisieren mit Immediate |

Warum ist das wichtig?

1. Disassembler zeigen keine Aliase → verwirrend bei Analyse.
2. Debugging wird leichter, wenn man den echten Maschinenbefehl kennt.
3. Assemblerfehler können entstehen, wenn man glaubt, `mov` sei ein „echter“ Befehl mit eigenen Regeln.

Beispiel: `alias_test.s`

Hier ist ein einfaches Beispielprogramm in ARM64-Assembler mit typischen "Alias-Instruktionen", das du kompilieren und mit `objdump` untersuchen kannst. Danach zeige ich dir, wie die `objdump`-Ausgabe dazu aussieht.

    .section .text
    .global _start

_start:
    // Alias: mov x0, x1 -> orr x0, x1, xzr
    mov x0, x1

    // Alias: mov x2, #0 -> movz x2, #0
    mov x2, #0

    // Alias: cmp x0, x1 -> subs xzr, x0, x1
    cmp x0, x1

    // Alias: neg x3, x4 -> sub x3, xzr, x4
    neg x3, x4

    // Alias: nop -> hint #0
    nop

    // Alias: ret -> br x30
    ret

Bauen und disassemblieren

as alias_test.s -o alias_test.o
ld alias_test.o -o alias_test
objdump -d alias_test

Beispielausgabe von `objdump -d alias_test`

0000000000401000 <_start>:
  401000:   aa0103e0    orr     x0, x1, xzr
  401004:   d2800002    movz    x2, #0x0
  401008:   eb01001f    subs    xzr, x0, x1
  40100c:   cb040060    sub     x3, xzr, x4
  401010:   d503201f    nop
  401014:   d65f03c0    ret

Du siehst:

| Quellcode Alias | Disassembler zeigt | Bedeutung | |----------------------|------------------------|---------------------------------------------| | `mov x0, x1` | `orr x0, x1, xzr` | Kopiere x1 nach x0 | | `mov x2, #0` | `movz x2, #0x0` | Setze x2 auf 0 | | `cmp x0, x1` | `subs xzr, x0, x1` | Vergleiche x0 mit x1 | | `neg x3, x4` | `sub x3, xzr, x4` | x3 = -x4 | | `nop` | `hint #0` | Kein Effekt | | `ret` | `ret` | Rücksprung über x30 |

Weitere Analyse

Wenn du "keine Aliase im Disassembly" möchtest (d. h. nur „echte“ Instruktionen), kannst du `objdump` so verwenden:

objdump -d -M no-aliases alias_test

Das zeigt dir, wie es "der CPU intern" wirklich vorliegt.