Faktorijel pomocu sabiranja u asembleru

[ g1l3 @ 28.02.2008. 21:24 ] @

pozz svima...moj prvi post...ugl..prosle nedelje sam dobio predmet arhitektura racunara..i naravno radi se u asemleru...dobili smo zadatak za domaci...da se napravi program za faktorijel..ali da se mnozenje napravi pomocu sabiranja...ugl algoritam za sabiranje znam..ali nikako da nekako to implemetiram u kod od faktorijela...pa bi molio bilo kakvu pomocu

Code:

.section .data
.section .text
.globl main

main:

    movl $1, %eax        #i pomocna
    movl $1, %ebx        #s pomocna
    movl $5, %ecx        #faktorijel od ovoga broja...i mislim da bi on ujedno morao da sluzi za neko ponavljanje tamo dole..ali nikako da skontam
    movl $0, %edx        #d pomocna pomocu koju vrsim mnozenje pomocu sabiranja
uslov :
    cmpl %ecx, %eax
    ja kraj

mnozenje :  # mozda je i bespotrebno ovo ali sam bio nemocan

    cmpl $0, %ecx
    je kraj

    add %eax, %edx        #dodao sam eax na edx
    inc %eax        #povecao sam eax za 1
    dec %ecx        #dekrementovao sam ecx za 1
    jmp uslov




kraj : nop

prilocno sam siguran da nesto ne valja u delu mnozenje...ugl nesto ne radi...i treba dodat..al pojma nemam sta..dovde sam stigao..pa ako bi mogla neka pomoc bio bih zahvalan..ugl sintaksa je at&t...hvala svima unapred

[ L710 @ 06.03.2008. 15:57 ] @

druze ja sam takodje skoro imao domaci iz asm i uradio sam na mnogo komplikovaniji nacin od tvog.
Tvoj program koliko sam ja uspeo da skontam ne radi uopste faktorijal nego dodavanje %eax na rezultat. Znaci ti radis operaciju + umesto operacije *

Code:

#Program racuna faktorijal od datog broja(7)
#Autor: Forbidden (forbidden.isgreat.org)
.section .data
.section .text
.globl main
main:
    movl $7,%eax    #faktorijal
    movl %eax,%ebx    #faktorijal i pomocni broj (x-1)
    movl $0,%ecx    #dodeljivanje vrednosti 0 rezultatu
    movl %eax,%edx    #faktorijal = pomocna vrednost
pocetak:
    movl %ecx,%edx    #rezultat = pomocni rezultat
    cmpl $0,%eax    #ako je faktorijal 0 onda skoci na kraj
    jb kraj
    cmpl $1,%ebx    #ako je pomocni broj faktorijala(x-1) manji od 1 onda skoci na medju_petlju
    jbe medju_petlja
    addl %eax,%ecx    #dodavanje pocetnog broja na rezultat
    decl %ebx    #umanjivanje ebx za 1
    jmp pocetak    #opet sve iz pocetka
medjupetlja:
    subl $2,%eax    #od faktorijala se oduzimaju 2 broja ciji sam rezultat dobio i smestio u %ecx
pred_petlja:
    cmpl $0,%eax    #ukoliko je faktorijal 0 onda skoci na kraj
    jbe kraj
    movl %edx,%ecx    #davanje vrednosti iz pomocnog rezultata u pravi rezultat
    movl %eax,%ebx    #davanje vrednosti faktorijalu kao pomocnom broju
    decl %eax    #umanjenje faktorijala za 1
petlja:
    cmpl $1,%ebx    #ukoliko je ebx manje ili jednako od 1 onda izvrsi pred_petlju
    jbe pred_petlja
    addl %ecx,%edx    #dodaj rezultat na pomocni rezultat
    decl %ebx    #umanji pomocni broj
    jmp petlja
kraj:
    nop

E sad objasnjenje...
Isao sam ovom logikom. Faktorijal od broja 6 je 720, a to znaci da je 6 * 5 * 4 * 3 * 2 * 1 = 720. Napisao sam program koji prvo pomnozi X sa X-1 (u ovom slucaju 6*5) i njihov rezultat zapise u registru %ecx. Nakon toga prebaci tu vrednost u registar %edx i onda mnozi sa taj rezultat sa x-2 i tako ide u krug.
Nadam se da ces ukapirati. Pozdrav

_{[Ovu poruku je menjao L710 dana 07.03.2008. u 00:43 GMT+1]}

[ g1l3 @ 08.03.2008. 10:05 ] @

e napokon da neko odg... ma tako sam i ja nesto kontao..ali nikako nisam uspeo da realizujem to ... thx again ;)

[ jonathan @ 08.03.2008. 11:16 ] @

Joooj... pisao sam to pre 20 i nešto godina za 8-bitni SC61860 (Sharp PC-1245), jer nije imao faktorijel u kalkulatorskim funkcijama, a BASIC mu je bio sporiji od konkurentskog TI-55-II :) Ako nekoga kojim pukim slučajem to zanima, mislim da bih čak i mogao da nađem listing...

p0z, Alek

[ L710 @ 10.03.2008. 23:38 ] @

ma np...znam kako je budjav osecaj kada imas zelju da uradis domaci, a ne znas na koji nacin ;)
pozz

[ EArthquake @ 20.03.2008. 08:55 ] @

evo i moja verzija :) moze jos malo da se smajni ...

Code:
#racunanje faktorijela , pocetna vr eax registra

.section .data
.section .text

.globl main

main:

    movl $4, %eax  #promeniti 4 za drugi faktorijel ...
    movl %eax, %ebx
    decl %ebx # ebx za 1 manji od eax

fact:
    xorl %edx, %edx #postavlja edx na NULL
    movl %ebx, %ecx
    cmpl $1, %ebx
    je kraj

mnozi:
    addl %eax, %edx
    decl %ebx
    cmpl $0, %ebx
    jne mnozi
    decl %ecx
    movl %ecx, %ebx
    movl %edx, %eax
    jmp  fact

kraj: nop

cini mi se da vam je novi domaci ovo isto samo rekurzivno :)

jonathan: pozdrav ...

[ lord_NIKON @ 21.03.2008. 20:11 ] @

Citat:

EArthquake: evo i moja verzija :) moze jos malo da se smajni ...

Code:
#racunanje faktorijela , pocetna vr eax registra

.section .data
.section .text

.globl main

main:

movl $4, êx #promeniti 4 za drugi faktorijel ...
movl êx, ëx
decl ëx # ebx za 1 manji od eax

fact:
xorl íx, íx #postavlja edx na NULL
movl ëx, ìx
cmpl $1, ëx
je kraj

mnozi:
addl êx, íx
decl ëx
cmpl $0, ëx
jne mnozi
decl ìx
movl ìx, ëx
movl íx, êx
jmp fact

kraj: nop

cini mi se da vam je novi domaci ovo isto samo rekurzivno :)

jonathan: pozdrav ...

naravno sve to u dvostrukoj preciznosti :)

[ FooLControL @ 25.04.2008. 13:49 ] @

Da ne otvaram novu temu...Postavicu jedan program koji isto racuna faktorijel samo pomocu rekurzije.Ne kontam bas kako on radi.malo me buni kako izgleda stek tokom izvrsavanja potprograma posto potprogram poziva samog sebe.

Code:

.section .data

a: .long 4

.section .text
.globl main

faktorijel:

    push %ebp
    movl %esp,%ebp
    movl 8(%ebp),%ebx
    andl %ebx,%ebx
    jz fakt_nula
    push %ebx
    decl %ebx
    push %ebx
    call faktorijel
    add $4,%esp
    pop %ebx
    mull %ebx
    jmp fakt_kraj

fakt_nula:

    movl $1,%eax

fakt_kraj:

    movl %ebp,%esp
    pop %ebp
    ret

main:
    push a
    call faktorijel
    addl $4,%esp

kraj:
    nop

Hvala unapred za bilo kakvu pomoc?

[ EArthquake @ 26.04.2008. 15:08 ] @

pa vrlo je jednostavno

pri svakom pozivu potrpograma stvara se novi frejm

Code:
    push %ebp
    movl %esp,%ebp
    movl 8(%ebp),%ebx

i uzima se vrednost sa steka , smesta u ebx i radi posao dok ne doddje do nule ...

stek izgleda potpuno isto kao kad bi pozvao mnogo pouta zaredom potprogram

rekurzije su mocna stvar , ali ponekad , za razliku od iterativnih verzija algoritama, umeju da budu nerazumljive

[ FooLControL @ 27.04.2008. 13:22 ] @

Hvala na pomoci,dosta je pomogla...A da ne znas mozda kako kada kompajliram program pa kad ga pokrenem u ddd da mogu da pratim i rad potprograma.Mislim da vidim kako rade reg,stek itd u potprogramu.Da ne bude samo ono u main programu push a,call potprogram i odmah izbaci rez...Nadam se da si skontao sta sam hteo da pitam?

[ EArthquake @ 27.04.2008. 18:17 ] @

mislim da znam sta te muci , probaj da singlestepujes program

nisam trenutno priu svom racurau da bih video tacno ali mislim da je u ddd to dugme stepi

posto kad kazes next ili step on ide liniju po liniju a kada naidje na potprogram , kroz njega prodje i ne vrati ti kontrolu dok se ne vrati iz potprograma

ono sto sigurno radi jeste da u onom cmd prozoru ukucavas stepi dok ne dodjes do potprograma

a mozes i da stavis breakpoint na pocetak potprograma pa ce ti n a tom mestu vratiti kontrolu

[ Buffy @ 29.04.2008. 12:13 ] @

Potpuno se slazem sa EArthquake-om ;)
Veliki pozdrav za Cou!

[ FooLControL @ 29.04.2008. 16:30 ] @

I ja se slazem :)
Sve radi kako treba,nisam znao za ovaj stepi dosta je pomoglo,ja sam isao stalno sa next!!!

[ L710 @ 23.05.2008. 01:16 ] @

ljudi jek moze neko objasniti kako se radi sabiranje binarnih brojeva uz pomoc logickih operacija and,xor i or i uz pomoc pomeranja?

[ Stojan Trifunovic @ 23.05.2008. 06:49 ] @

Pa nije bas da se tu vrsi sabiranje. Mislim da svi assembleri (bar svi
sa kojima sam se ja do sada sretao) imaju svoje instrukcije sabiranja
i oduzimanja, a da se jedino razlikuju u na primer prekoracenju (Carry
flagom) ili konverzijom u druge formate brojeva (BCD).

Samim tim neprakticno je koristiti logicke instrukcije umesto
(vec postojecih) aritmetickih.

Logicke instrukcije se mogu koristiti (i koriste se) prilikom tezih
matematickih operacija (mnozenje, deljenje, kvadratni koren, sinus...)
za assemblere kod kojih te operacije nisu hardverski podrzane.

Pretpostavljam da Vas interesuju funkcije i upotreba osnovnih logickih
operacija, odnosno bulova algebra. Mislim da su najbolje objasnjene
na sledecem sajtu:
http://www.ibiblio.org/obp/electricCircuits/Digital/index.html

A ukoliko Vas interesuje cisto hipoteticka upotreba logickih
instrukcija u cilju sabiranja, moguce je i to uraditi, medjutim onda
ce Vam biti potrebno i dosta testiranja rezultata (pre svega zbog
detekcije prekoracenja).

[ EArthquake @ 23.05.2008. 19:16 ] @

pa u sustini , implementacije svih instrukcija u procesorima se svode na kombinacije logickih kola

a iz bulovih algebri imas da uspomoc samo NILI ili NI mozes da opises bilo sta , samo je naravno komplikovano
kao sto je receno u prethodnom postu

http://www.play-hookey.com/digital/adder.html

[ L710 @ 24.05.2008. 00:12 ] @

e ljudi hvala na tako brzim odgovorima i na linkovima, ali mene bas zanima sabiranje pomocu logickih funkcija i pomeranja...tacnije sabiranje gde su 2 razlicita clana (1 i 0) vrsim pomocu xor, gde su 2 clana ista preko and-a.. Ali tu nastaje problem, kako da definisem da se carry poveca za 1 prilikom sabiranja 1 i 1. To me najvise zanima?
Ali i to sto kazete, zasto bih izmisljao toplu vodu, kada vec postoji.

[ Stojan Trifunovic @ 24.05.2008. 09:56 ] @

Aha, znaci tim principom. Nije toliko tesko. Dovoljno je nakon AND
operacije detektovati da li je rezultat 0 ili 1, i na osnovu toga
izazvati prekoracenje ili ne.

Evo primera za cetvorobitne vrednosti
0101 i
1001

Da bi se shvatio naredni postupak, bitno je utvrditi kada dolazi do
prekoracenja. Ukoliko je rezultat XOR jednak 1, onda su odgovarajuci
bitovi svakako razliciti, pa SIGURNO nema prekoracenja. Medjutim, ako
je rezultat 0, moguce su dve situacije. U prvoj su sabirci 0 i 0 i
tada nema prekoracenja, a u drugoj su sabirci 1 i 1, i tada ima
prekoracenja. Prekoracenje se testira preko AND nad sabircima.
Rezultat AND operacije bice 1 (ima prekoracenja) samo ako su oba
sabirka na logickoj 1.

Algoritam bi otprilike mogao izgledati ovako:

1. Odredite proizvoljnu adresu u kojoj cete cuvati SADASNJI i NAREDNI
flag prekoracenja, i inicijalizujte ih (obrisite).

2. Kopirajte oba sabirka u privremene adrese

3. Maskirajte sve bitove osim LSB (npr. sa AND 0001) u oba privremena
sabirka

4. Izvrsite XOR. Moguca su dva rezultata (0000 i 0001).

5. Ako je rezultat 0001 sabirci su razliciti pa prekoracenje
jednostavno nije moguce. Nastavite od koraka 9.

6. Sabirci su isti. Sada izvrsite AND nad kopijama. Moguca su dva
rezultata (0000 i 0001)

7. Ako je rezultat 0000 nema prekoracenja, pa nastavite od ...

8. Setujte NAREDNI flag prekoracenja u unapred odredjenoj adresi.

9. Sada je jedan sabirak REZULTAT prethodnog sabiranja (0000 ili
0001), a drugi SADASNJI flag prekoracenja (0 ili 1, tacnije 0000 ili
0001).

10. XOR nad novim sabircima, opet sa rezultatom 0000 ili 0001. Ako je
0001, nema prekoracenja, pa nastavi od koraka 12.

11. AND nad novim sabircima, opet sa rezultatom 0000 ili 0001. Ako je
0001 setuj NAREDNI flag prekoracenja.

12. Stanje NAREDNOG flaga prekoracenja prevedi u SADASNJI flag
prekoracenja, i obrisi NAREDNI flag prekoracenja.

13. U ovom trenutku imate i rezultat sabiranja (u LSB) i flag
prekoracenja (u SADASNJI). Snimite taj rezultat.

14. Da bi se sabrali naredni bitovi (bit1 i bit1), potrebno je
ORIGINALNE sabirke rotirati udesno, tako da oba bita1 dodju na mesto
LSB. Tako bi originalne vrednosti sabirka
0101 i
1001
postale
x010 i
x100

15. Ponovite postupak iz pocetka (od tacke 2).

Pod tackama 13 i 14 dodatni registri morali bi brinuti o prekoracenju
maksimalnog broja bitova (8 za osmobitne sabirke), kao i o smestanju
bitova rezultata na prava mesta, a to se opet lako moze uraditi
odgovarajucim rotacijama.