;==============================================================================================
; recursive procedure:
; supersum(int x)
; returns 1*2 + 2*3 + 3*4 + ... + i*(i+1)
supersum PROC
push ebp ; start of every procedure
mov ebp, esp
push ebx
; Actual subproc calc here
mov eax, [ebp +8] ; returning eax to the original called value
cmp eax,1
je basecase
dec eax ; (n-1) ; its just a lie...
mov recnum, eax ; saving dec val for call
mul double ; 2(n-1)
mov rhs, eax ; the right hand side is finished
push recnum
call sumseries ; a_(n-1)
add esp, 4
definition:
add eax, rhs ; a_(n-1)+ 2(n-1)
jmp skp
basecase: ; a_1 = 0
mov eax, 0
mov rhs, 2
jmp definition
skp:
pop ebx
pop ebp
ret
supersum ENDP
;============================================================================
The explicit definition of the serries I'm trying to get is 1*2 + 2*3 + 3*4 ... + i(i+1).
I've got the math for it down and I found that the recursive definition for the series is a_n = a_(n-1) + 2(n-1) with a_1 = 0 as a base case. I'm trying to figure out why this code keeps giving me the even series: {2,4,6,8,10 ...} instead of the series I'm trying to calculate
Related
%include "asm_io.inc"
segment .data
segment .bss
segment .text
global asm_main
asm_main:
enter 0,0
pusha
call read_int
push eax
call fak_rekursiv
add esp, 4
call print_int
call print_nl
popa
mov eax, 0
leave
ret
fak_rekursiv:
enter 4, 0
pusha
mov eax, [ebp + 8]
cmp eax, 0
je ergebnis_1
cmp eax, 1
je ergebnis_1
mov ebx, eax
dec ebx
mul ebx
push ebx
call fak_rekursiv
pop ebx
ergebnis:
mov [ebp - 4], eax
ergebnis_1:
mov [ebp - 4], dword 1
popa
mov eax, [ebp - 4]
leave
ret
I am learning to code on NASM and I was trying to understand recursion through using coding factorial but I got confused quickly.
How can I use Recursion in NASM to code factorial algorithm?
actually I have coded up factorial just for fun earlier. And now I have dug through my files to find that code :) here you go, but it is more like a pseudo-code which I only stepped through debugger.
factorial:
push eax
test eax, 07FFFFFFEh
jz .exit
dec eax
call factorial
mul dword [esp]
.exit:
pop edx
ret
put different values in eax and step through it in debugger.
Not too familiar with NASM, but here's a MASM solution which calls the factorial function recursively.
factorial.asm
.386
.model flat, stdcall
option casemap :none
includelib \masm32\lib\msvcrt.lib
printf PROTO C, :VARARG
.data
fmt db "%u! = %u", 13, 10, 0
.code
factorial proc
cmp eax, 0 ; Special-case to account for 0! = 1
je retone
cmp eax, 1
je retnow
push eax
dec eax
call factorial
pop edx
imul eax, edx ; eax = eax * edx
retnow:
ret
retone:
mov eax, 1
ret
factorial endp
main:
; Loop from 0 to 12 (max) factorial for 32-bit code.
mov ebx, 0
num:
mov eax, ebx
call factorial
invoke printf, OFFSET fmt, ebx, eax
inc ebx
cmp ebx,13
jne num
ret
end main
Displays all factorials from 0 to 12
New to assembly.
I'm trying to write an assembly code, that will do the following operation:
x/8 + 32 - y IF (x+y)/2>0
OR
2Y - 60 IF (x+y)/2<=0
While I was able to get the first operation to work ( even though, only when putting even numbers as X and Y, because otherwise I get results like ~+8000 ), I can't manage to make the second operation to work. When inserting in console something like : x= - 6, y=2, it should prind me out -56, but it prints me +30.
What did I do wrong there and how could I correct it?
INCLUDE Irvine32.inc
.data
mes1 byte "X:",0
mes2 byte "Y:",0
mes3 byte "Result:",0
vrx dword 0
vry dword 0
rez dword 0
doi dword 2
vxr dword 0
vyr dword 0
.code
main PROC
mov edx,OFFSET mes1
call WriteString ;
call ReadDec ;
mov vrx,eax ;
mov edx,OFFSET mes2
call WriteString ;
call ReadDec ;
mov vry,eax ;
;
xor eax,eax
mov edx,0
mov eax, vrx ;x
add eax, vry ;x+y
div doi ;(x+y)/2
cmp eax, 0 ; comparing
jb con1 ;
mov eax,vrx ; X/8+32-Y
mov ebx,8
div ebx
add eax,32
sub eax,vry
mov rez,eax
jmp ex ; jump to ex
con1: mov eax,vry ; 2Y-60
mov ebx,2
mul ebx
sub eax,60
mov rez,eax
ex: mov edx,OFFSET mes3
call WriteString ;
call WriteInt ;
call Crlf ;
exit
main ENDP
END main
I am trying to write classical fib(n) function in assembly (intel x86) that is returning a n-th element of Fibonacci sequence.
I have written iterative version quite easily, but I'm having trouble trying to manipulate with recursion. This is what I tried:
.intel_syntax noprefix
.text
# unsigned fib(unsigned)
.globl fib
fib_n:
enter 0, 0
mov eax, 0
# n = 0 or n = 1
cmp edi, 1
jbe end
mov eax, 1
# n == 2
cmp edi, 2
je end
# n > 2, entering recursion
# fib(n-1)
push rdi
dec edi
call fib_n
mov r8d, eax
pop rdi
# fib(n-2)
push rdi
sub edi, 2
call fib_n
mov r9d, eax
pop rdi
# fib(n) = fib(n-1) + fib(n-2)
mov eax, r8d
add eax, r9d
end:
leave
ret
I am expecting for calls marked #fib(n-1) and #fib(n-1) to store local eax results in r8d and r9d registers, and then just add them and return through eax, but this is what I get as output:
n = 1 (1st el): 0 (works fine)
n = 2: 1 (works fine)
n = 3: 1 (works fine)
(wrong results)
n = 4: 2
n = 5: 2
n = 6: 3
n = 7: 3
...
I also tried pushing rax to the stack as well as rdi, but I still get wrong results. What am I missing?
What am I missing?
Register r8d is not preserved across recursive calls.
You don't need enter nor leave. No parameters were pushed.
It's easier to preserve the index rdi at the entry of fib_n.
fib_n:
push rdi
xor eax, eax
cmp edi, 2
jb end ; fib(1) = 0
mov eax, 1
je end ; fib(2) = 1
dec edi
call fib_n ; -> EAX
push rax ; (1) Preserve intermediate result!
dec edi
call fib_n ; -> EAX
add eax, [rsp] ; fib(n) = fib(n-2) + fib(n-1)
add rsp, 8 ; (1)
end:
pop rdi
ret
EDIT
The below version of the code incorporates comments made by rcgldr and Peter Cordes.
This code now removes 5 base-cases and is much cleaner.
fib_n:
cmp edi, 5 ; n
jb .LT5 ; Base-cases
push rdi ; (1) Preserve n
dec edi ; n-1
call fib_n ; -> EAX
push rax ; (2) Preserve intermediate result!
dec edi ; n-2
call fib_n ; -> EAX
pop rdi ; (2) Restore intermediate result
add eax, edi ; fib(n) = fib(n-2) + fib(n-1)
pop rdi ; (1) Restore n
ret
.LT5:
mov eax, edi ; n < 5
cmp edi, 2
cmc
sbb eax, 0 ; fib(0) = 0, fib(1) = 1
ret ; fib(2) = 1, fib(3) = 2, fib(4) = 3
This is the format that I need:
F(3) = F(2) + F(1) =
F(2) = (F1) + F(0) =
F(1) = 1
F(0) = 1
F(2) = 1
F(1) = 1
F(3) = 2
and this is my code, how am I going to do to get the format I want?
Please give me a hint or something that may help, thank you. I just start learning assembly language.
I only know how to show the first line like f()= the answer, but don't know how to show the process.
.data
fib1 BYTE "f(",0
fib2 BYTE ") + f(",0
fib3 BYTE ") = ",0
intVal DWORD ?
main PROC
mov edx, OFFSET fib1 ;show f(intVal)=
call WriteString
mov edx, intVal
call WriteDec
mov edx, OFFSET fib3
call WriteString
mov ecx, intVal-1
push intVal
call fib
add esp, 4
call WriteDec ;show result
call crlf
mov edx, OFFSET msg5 ;show goodbye msg
call WriteString
mov edx, OFFSET username
call WriteString
exit
main ENDP
fib PROC c
add ecx, 1
push ebp
mov ebp, esp
sub esp,4
mov eax, [ebp+8] ;get value
cmp eax,2 ;if ((n=1)or(n=2))
je S4
cmp eax,1
je S4
dec eax ;do fib(n-1)+fib(n-2)
push eax ;fib(n-1)
call fib
mov [ebp-4], eax ;store first result
dec dword ptr [esp] ;(n-1) -> (n-2)
call fib
add esp,4 ;clear
add eax,[ebp-4] ;add result and stored first result
jmp Quit
S4:
mov eax,1 ;start from 1,1
Quit:
mov esp,ebp ;restore esp
pop ebp ;restore ebp
ret
fib ENDP
END main
The code needs to output a "newline" at the end of each line of output, which could be a carriage return (00dh) followed by a linefeed (00ah) or just a linefeed (00ah) depending on the system (I don't know the irvine setup).
The indented lines should be printed from within the fib function, which means you have to save (push/pop stack) any registers that the print functions use.
The fib function needs to print out a variable number of spaces depending on the level of recursion, based on the text, 2 spaces per level of recursion.
The fib function needs to handle an input of 0 and return 0.
Note that the number of recursive calls to the fib function will be 2 * fib(n) - 1, assuming fib checks for fib(0), fib(1), fib(2) (more if it doesn't check for fib(2) ), which would be 5.94 billion calls for fib(47) = 2971215073, the max value for 32 bit unsigned integers. You may want to limit inputs to something like fib(10) = 55 or fib(11) = 89 or fib(12) = 144.
I am trying to implement Fibonacci sequence in assembly by using recursion. This is my first time of trying to implement recursion in x86 Assembly.
The code compiles fine but it gives wrong outputs. The output for 1 is 1, output for 2 is 0, output for 3 is 1, output for 4 is 2, output for 5 is 3.
Only output it gives correct when you plug 5 in.
Is there something wrong with the algorithm?
.DATA
n1 DWORD ?
prompt1 BYTE "Please enter the first value", 0
prompt3 BYTE "No negative numbers!",0
string BYTE 40 DUP (?)
resultLbl BYTE "The Fib is: ", 0
fib BYTE 40 DUP (?), 0
.CODE
_MainProc PROC
input prompt1, string, 40
atod string
test eax, eax
js signed
mov n1, eax
jmp procName
signed:
output prompt3, string
jmp end1
procName:
mov eax, n1
push n1
call fib1
add esp,4
dtoa fib, eax
output resultLbl, fib
end1:
mov eax, 0
ret
_MainProc ENDP
Fib1 proc
PUSH EBP ; save previous frame pointer
MOV EBP, ESP ; set current frame pointer
MOV EAX, [EBP+8] ; get argument N
CMP EAX, 1 ; N<=1?
JA Recurse ; no, compute it recursively
MOV ECX, 1 ; yes, Fib(1)--> 1
JMP exit
Recurse:
DEC EAX ; = N-1
MOV EDX, EAX ; = N-1
PUSH EDX ; save N-1
PUSH EAX ; set argument = N-1
CALL Fib1 ; compute Fib(N-1) to ECX
POP EAX ; pop N-1
DEC EAX ; = N-2
PUSH ECX ; save Fib(N-1)
PUSH EAX ; set argument = N-2
CALL Fib1 ; compute Fib(N-2) to ECX
POP EAX ; = Fib(N-1)
ADD ECX, EAX ; = Fib(N-1)+FIB(N-2)
exit:
MOV ESP,EBP ; reset stack to value at function entry
POP EBP ; restore caller's frame pointer
RET
Fib1 endp
END