Discussion :

[Jean-Michel Ormes]

Bonsoir. Je voudrais savoir s'il est possible de modéliser la récursivité d'un programme en assembleur via la pile??

[3asfoura]

oui on pourra utiliser une pile pour traiter une version récursive d'un programme

[jeremya]

Lors de l'appel d'une fonction, l'adresse de retour est empilée, puis la fonction est exécutée.
A la fin de la fonction (ret), l'adresse de retour est dépilée et le flux du programme est redirigé vers cette adresse.

[Jean-Michel Ormes]

Merci de vos réponses

[dapounet]

Salut,
Voilà un équivalent en assembleur de la fonction factorielle habituelle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
; unsigned long factorielle (unsigned int);
; retourne dans EAX la factorielle du nombre en EBP+8
; Registres détruits : EAX, ECX, EDX
_factorielle proc
        push ebp
        mov ebp, esp
 
; Sauvegarde des registes conventionnelle
        push ebx
 
        mov ebx, [ebp+8]
        test ebx, ebx
        jnz appel_recursif
 
; Si n == 0 on retourne 1
        mov eax, 1
        jmp fin
 
; Sinon on retourne n*factorielle(n-1)
appel_recursif:
        lea ecx, [ebx-1]   ;
        push ecx           ;
        call _factorielle  ; EAX = factorielle (n-1)
        add esp, 4         ;
 
        mul ebx            ; EDX:EAX = EAX*EBX
 
fin:
; Restauration des registre
        pop ebx
        pop ebp
 
        ret
_factorielle endp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
unsigned long factorielle (unsigned int n)
{
   if (n == 0)
   {
      return 1;
   }
   else
   {
      return n*factorielle(n-1);
   }
}

Pose des questions si il y a quelque chose que tu ne comprends pas.

Edit : corrigé quelques trucs.