Jaka jest funkcja instrukcji push / pop używanych w rejestrach w asemblerze x86?

Czytając o assemblerze często spotykam ludzi, którzy piszą, że wciskają pewien rejestr procesora, a później ponownie go wyskakują , aby przywrócić jego poprzedni stan.

• Jak możesz pushować rejestr? Gdzie jest popychany? Dlaczego jest to potrzebne?
• Czy sprowadza się to do pojedynczej instrukcji procesora, czy jest to bardziej złożone?

przesunięcie wartości (niekoniecznie przechowywanej w rejestrze) oznacza zapisanie jej na stosie.

popping oznacza przywrócenie do rejestru wszystkiego, co znajduje się na szczycie stosu . To są podstawowe instrukcje:

push 0xdeadbeef      ; push a value to the stack
pop eax              ; eax is now 0xdeadbeef

; swap contents of registers
push eax
mov eax, ebx
pop ebx

Oto jak wypychasz rejestr. Zakładam, że mówimy o x86.

push ebx
push eax

Jest odkładany na stos. Wartość ESPrejestru jest zmniejszana do rozmiaru przekazanej wartości, gdy stos rośnie w dół w systemach x86.

Konieczne jest zachowanie wartości. Ogólne użycie to

push eax           ;   preserve the value of eax
call some_method   ;   some method is called which will put return value in eax
mov  edx, eax      ;    move the return value to edx
pop  eax           ;    restore original eax

A pushto pojedyncza instrukcja w x86, która wewnętrznie wykonuje dwie rzeczy.

1. Zmniejsz ESPrejestr o rozmiar przekazanej wartości.
2. Przechowuj wypchniętą wartość pod aktualnym adresem ESPrejestru.

Gdzie jest popychany?

esp - 4. Dokładniej:

• esp jest odejmowany przez 4
• wartość jest przenoszona do esp

pop odwraca to.

ABI Systemu V mówi Linuksowi, aby rspwskazał rozsądną lokalizację stosu, gdy program zacznie działać: Jaki jest domyślny stan rejestru podczas uruchamiania programu (asm, linux)? który jest tym, czego zwykle powinieneś używać.

Jak możesz pushować rejestr?

Przykład minimalnego GNU GAS:

.data
    /* .long takes 4 bytes each. */
    val1:
        /* Store bytes 0x 01 00 00 00 here. */
        .long 1
    val2:
        /* 0x 02 00 00 00 */
        .long 2
.text
    /* Make esp point to the address of val2.
     * Unusual, but totally possible. */
    mov $val2, %esp

    /* eax = 3 */
    mov $3, %ea 

    push %eax
    /*
    Outcome:
    - esp == val1
    - val1 == 3
    esp was changed to point to val1,
    and then val1 was modified.
    */

    pop %ebx
    /*
    Outcome:
    - esp == &val2
    - ebx == 3
    Inverses push: ebx gets the value of val1 (first)
    and then esp is increased back to point to val2.
    */

Powyższe na GitHubie z działającymi asercjami .

Dlaczego jest to potrzebne?

Prawdą jest, że instrukcje te mogą być łatwo realizowane za pośrednictwem mov, addi sub.

Powodem ich istnienia jest to, że te kombinacje instrukcji są tak częste, że Intel zdecydował się je nam dostarczyć.

Powodem, dla którego te kombinacje są tak częste, jest to, że ułatwiają tymczasowe zapisywanie i przywracanie wartości rejestrów do pamięci, aby nie zostały nadpisane.

Aby zrozumieć problem, spróbuj ręcznie skompilować kod C.

Główną trudnością jest podjęcie decyzji, gdzie będzie przechowywana każda zmienna.

Idealnie, wszystkie zmienne pasowałyby do rejestrów, które są najszybszymi dostępnymi pamięcią (obecnie około 100x szybciej niż pamięć RAM).

Ale oczywiście możemy z łatwością mieć więcej zmiennych niż rejestrów, szczególnie dla argumentów funkcji zagnieżdżonych, więc jedynym rozwiązaniem jest zapisywanie w pamięci.

Moglibyśmy pisać na dowolny adres pamięci, ale ponieważ zmienne lokalne i argumenty wywołań funkcji i zwrotów pasują do ładnego wzorca stosu, który zapobiega fragmentacji pamięci , jest to najlepszy sposób radzenia sobie z tym. Porównaj to z szaleństwem pisania alokatora sterty.

Następnie pozwalamy kompilatorom zoptymalizować alokację rejestrów za nas, ponieważ jest to NP zakończone i jedna z najtrudniejszych części pisania kompilatora. Ten problem nazywa się alokacją rejestrów i jest izomorficzny do kolorowania grafów .

Kiedy alokator kompilatora jest zmuszony do przechowywania rzeczy w pamięci, a nie tylko w rejestrach, jest to znane jako wyciek .

Czy sprowadza się to do pojedynczej instrukcji procesora, czy jest to bardziej złożone?

Jedyne, co wiemy na pewno, to to, że Intel dokumentuje pushi popinstrukcję, więc są one jedną instrukcją w tym sensie.

Wewnętrznie można go rozszerzyć na wiele mikrokodów, jeden do modyfikacji, espa drugi do wykonywania operacji we / wy pamięci i wykonywania wielu cykli.

Ale możliwe jest również, że pojedyncza pushinstrukcja jest szybsza niż równoważna kombinacja innych instrukcji, ponieważ jest bardziej szczegółowa.

Jest to głównie nieudokumentowane:

• Peter Cordes wspomina, że techniki opisane na http://agner.org/optimize/microarchitecture.pdf sugerują to pushi popwykonują jedną mikrooperację.
• Johan wspomina, że ​​skoro Pentium M Intel używa "silnika stosu", który przechowuje wstępnie obliczone wartości esp + regsize i esp-regsize, umożliwiając wykonanie push i pop w jednym uopie. Wspomniany również pod adresem : https://en.wikipedia.org/wiki/Stack_register
• Co to jest mikrokod Intel?
• /security/29730/processor-microcode-manipulation-to-change-opcodes
• Ile cykli procesora potrzeba na każdą instrukcję asemblera?

Wypychanie i otwieranie rejestrów jest odpowiednikiem tego:

push reg   <= same as =>      sub  $8,%rsp        # subtract 8 from rsp
                              mov  reg,(%rsp)     # store, using rsp as the address

pop  reg    <= same as=>      mov  (%rsp),reg     # load, using rsp as the address
                              add  $8,%rsp        # add 8 to the rsp

Zauważ, że jest to składnia x86-64 At & t.

Używany jako para, pozwala to zapisać rejestr na stosie i przywrócić go później. Są też inne zastosowania.

Prawie wszystkie procesory używają stosu. Stos programu jest techniką LIFO z zarządzaniem obsługiwanym sprzętowo.

Stos to ilość pamięci programu (RAM) normalnie alokowana na szczycie stosu pamięci procesora i rośnie (w instrukcji PUSH wskaźnik stosu jest zmniejszany) w przeciwnym kierunku. Standardowym terminem wstawiania do stosu jest PUSH, a usuwania ze stosu - POP .

Stos jest zarządzany przez odpowiedni rejestr procesora stosu, zwany także wskaźnikiem stosu, więc gdy procesor wykonuje POP lub PUSH, wskaźnik stosu załaduje / zapisze rejestr lub stałą w pamięci stosu, a wskaźnik stosu zostanie automatycznie zmniejszony x lub zwiększony zgodnie z liczbą wprowadzonych słów lub wskoczył do (z) stosu.

Za pomocą instrukcji asemblera możemy przechowywać w stosie:

1. Rejestry procesora, a także stałe.
2. Adresy zwrotne funkcji lub procedur
3. Funkcje / procedury zmienne wejścia / wyjścia
4. Funkcje / procedury zmienne lokalne.