Assembly este un limbaj de programare de nivel jos, care oferă programatorilor control direct asupra hardware-ului. Spre deosebire de limbajele de nivel înalt, cum ar fi Python sau C++, assembly se ocupă direct cu instrucțiunile procesorului. În această lecție, vom explora cum să scriem un program simplu care afișează mesajul "Salut programatic" pe ecran folosind assembly.

Vom utiliza sintaxa NASM (Netwide Assembler), un assembler popular pentru x86. De asemenea, vom folosi un sistem de operare Linux, deoarece acesta oferă suport nativ pentru executabilele binare produse de NASM și folosirea syscall-urilor pentru interacțiunea cu kernel-ul.

Registrele Procesorului

Registrele sunt locații de stocare interne ale procesorului care sunt folosite pentru operații rapide. Cele mai utilizate registre în programarea assembly x86 includ:

• eax, ebx, ecx, edx: Registre generale pentru operații aritmetice și logice.
• esi, edi: Registre pentru operații de stringuri și indexare.
• ebp, esp: Registre de bază și stivă.
• eip: Registru de instrucțiuni (pointer la instrucțiunea curentă).

Instrucțiuni de Bază

• mov: Copiază date dintr-o locație în alta.
• int: Invocă o întrerupere software.
• syscall: Invocă un apel de sistem.
• section: Definește o secțiune a programului (de exemplu, .data, .text).

Syscall

În Linux, pentru a interacționa cu kernel-ul, folosim syscall-uri. Syscall-urile sunt identificate printr-un număr unic și se apelează prin setarea registrelor corespunzătoare. Pentru a scrie date pe ecran folosim syscall-ul write:

• eax: Setat la 4 (numărul syscall-ului pentru write).
• ebx: Descriptorul fișierului (1 pentru stdout).
• ecx: Adresa bufferului de date.
• edx: Lungimea datelor.

Exemplu Practic

Pasul 1: Secțiunea de Date

Începem prin a defini datele noastre, adică mesajul care va fi afișat. Vom folosi secțiunea .data pentru a declara variabile.

section .data
    message db 'Salut programatic', 0   ; Definim mesajul cu un terminator NULL (0)
    msg_len equ $ - message              ; Calculăm lungimea mesajului

- db definește un byte de date. - equ este un pseudo-instrucțiune pentru a defini constante. $ reprezintă adresa curentă, iar message este adresa de început a mesajului.

Pasul 2: Secțiunea de Cod

Secțiunea .text conține codul executabil al programului. Începem execuția programului cu eticheta global _start.

section .text
    global _start    ; Punctul de intrare al programului

_start:
    ; Scriem mesajul pe stdout
    mov eax, 4       ; Numărul syscall-ului pentru write
    mov ebx, 1       ; Descriptorul fișierului (1 = stdout)
    mov ecx, message ; Adresa bufferului
    mov edx, msg_len ; Lungimea mesajului
    int 0x80         ; Invocăm syscall-ul

    ; Închidem programul
    mov eax, 1       ; Numărul syscall-ului pentru exit
    xor ebx, ebx     ; Codul de ieșire (0)
    int 0x80         ; Invocăm syscall-ul

Explicații

1. Definirea Datelor

section .data
    message db 'Salut programatic', 0
    msg_len equ $ - message

- section .data: Începem secțiunea de date. - message db 'Salut programatic', 0: Declarăm un șir de caractere terminat cu NULL. - msg_len equ $ - message: Calculăm lungimea mesajului pentru a o folosi în syscall.

1. Scrierea Mesajului

section .text
    global _start

_start:
    mov eax, 4
    mov ebx, 1
    mov ecx, message
    mov edx, msg_len
    int 0x80

- mov eax, 4: Setăm eax la 4 pentru syscall-ul write. - mov ebx, 1: Setăm ebx la 1 pentru stdout. - mov ecx, message: Adresa bufferului cu mesajul. - mov edx, msg_len: Lungimea mesajului. - int 0x80: Invocăm syscall-ul.

1. Terminarea Programului

    mov eax, 1
    xor ebx, ebx
    int 0x80

• mov eax, 1: Setăm eax la 1 pentru syscall-ul exit.
• xor ebx, ebx: Setăm ebx la 0 pentru codul de ieșire.
• int 0x80: Invocăm syscall-ul pentru a termina programul.

Asamblare și Legare

Pentru a transforma codul assembly într-un executabil, utilizăm NASM și LD (linker).

1. Asamblare:

nasm -f elf32 salut.asm -o salut.o

1. Legare:

ld -m elf_i386 salut.o -o salut

1. Executare:

./salut

Aceste comenzi vor produce un executabil care afișează "Salut programatic" pe ecran.

În această lecție, am acoperit bazele programării în assembly, incluzând registre, instrucțiuni de bază și syscall-uri. Am creat un program simplu care afișează un mesaj pe ecran, explicând detaliat fiecare pas. Assembly oferă un nivel înalt de control și eficiență, dar necesită o bună înțelegere a arhitecturii hardware și a funcționării interne a procesorului.