He estado tratando de que funcione esta función factorial recursiva en el ensamblaje IA32, pero siempre obtengo un factorial menor que el que paso en la función.

Por ejemplo, el factorial de 5 es 120 pero obtengo 24, que es el factorial de 4

Lo que tengo actualmente es lo siguiente:

public factorial                ; int factorial(int N)
factorial:                      ; { 
    push ebp                    ;   push return addr    
    mov ebp, esp                ;   update SP

    mov eax, [ebp+8]            ;   N.getFromStack()
    dec eax                     ;       n--

    cmp eax, 0                  ;   if (N == 0)
    je n0                       ;   {

    push eax                    ;       push(n)
    call factorial              ;       factorial(n-1)
    pop ebx                     ;       pop result

    imul eax, ebx               ;       N*factorial(n-1)
    jmp re                      ;   }

n0: mov eax, 1                  ;   result = 1

re: mov esp, ebp                ;   update SP
    pop ebp                     ;   pop ret. addr.
    ret 0                       ;   return factorial(N) }

¿Qué estoy haciendo mal?

0
Little Ball 26 oct. 2020 a las 01:49

1 respuesta

La mejor respuesta

Está corrompiendo ebx, que es un registro de guardado de llamadas, por lo que su código que llama a esto probablemente hará algo extraño. También está multiplicando el valor de retorno de la llamada recursiva por ese valor emergente en lugar de por n como debería.

Así que reemplace el pop ebx con add esp, 4 y reemplace el imul por imul dword ptr [ebp+8]

Puede hacer que el código sea más pequeño y más simple al deshacerse de todas las cosas ebp / framepointer; no necesita un framepointer o un frame en una función tan pequeña.

1
Chris Dodd 26 oct. 2020 a las 00:09