💻 Programmation Bas Niveau

Load Effective Address (LEA)

Instruction assembleur pour charger l'adresse effective d'un opérande.

Principe

• Calcule l'adresse réelle d'une variable/tableau
• Ne déréférence PAS comme MOV (plus rapide)
• Addition/multiplication décalage efficace

Exemples x86

; Charger adresse de "array" dans EAX
lea eax, [array]

; Multiplier par 2 (décalage) + addition
lea eax, [ebx + ecx * 2]  ; EAX = EBX + ECX×2

; Boucle efficace (sans mul)
lea eax, [eax + eax * 4]  ; EAX × 5
                        

Utilisé pour accès tableau, réduction instructions.

ALU (Arithmetic Logic Unit)

Cœur processeur exécutant opérations arithmétiques et logiques.

Composants

• Portes logiques (AND, OR, XOR, NOT)
• Additionneur complet (bits + retenue)
• Registres temporaires (entrées/sorties)
• FLAGS (indicateurs résultat)

Opérations

• Arithmétique : ADD, SUB, MUL, DIV, INC, DEC
• Logique : AND, OR, XOR, NOT, SHL, SHR
• Comparaison : CMP (soustraction, flags)

Flags (Drapeaux)

• ZF (Zero Flag) : résultat = 0
• SF (Sign Flag) : négatif
• CF (Carry Flag) : retenue
• OF (Overflow) : débordement

Instructions de Transfert

Mouvement de données entre registres, mémoire et ports.

MOV (Move)

• Copie source → destination (pas de suppression)
• Tailles : MOV (8b), MOVSX (signe), MOVZX (zero)
• Contrainte : pas deux opérandes mémoire

; Registre ↔ Registre
mov eax, ebx        ; EAX = EBX

; Valeur ↔ Registre
mov eax, 42         ; EAX = 42

; Mémoire ↔ Registre
mov eax, [var]      ; EAX = valeur à adresse "var"
mov [var], ebx      ; mémoire[var] = EBX

; Immédiat ↔ Mémoire
mov dword [array], 100  ; 32-bit = 100
                        

Autres Transferts

• XCHG : Échange (EAX↔EBX)
• PUSH/POP : Pile (stack)
• MOVSx : Chaîne de caractères

Structures de Contrôle

Branchements conditionnels et boucles en assembleur.

Instructions de Saut

• JMP : Saut inconditionnel
• JE/JZ : Jump if Equal/Zero
• JNE/JNZ : Jump if Not Equal
• JG/JL : Jump Greater/Less
• CALL : Appel fonction (empile adr retour)
• RET : Retour fonction

; Boucle WHILE (ex: i < 10)
loop_start:
    cmp ecx, 10
    jge loop_end        ; saut si ECX >= 10
    
    ; corps boucle
    inc ecx
    jmp loop_start
loop_end:

; IF-THEN-ELSE
    cmp eax, ebx
    jne else_branch     ; saut si EAX != EBX
    
    ; then
    mov ecx, 1
    jmp end_if
    
else_branch:
    mov ecx, 2
    
end_if:

; FOR avec ECX
    mov ecx, 0          ; init
for_loop:
    cmp ecx, 5          ; condition
    jge for_end
    
    ; corps boucle
    
    inc ecx             ; incrémentation
    jmp for_loop
for_end:
                        

Optimisation: LOOPZ/LOOPE pour boucles compactes.