IndexPROHARDVER!
PROHARDVER! informatika:   HARDVER  |  JÁTÉK  |  PROGRAMOZÁS  |  PDA  |  HÁZI-MOZI    
Keresés
Hírlevél
 
Társalgó
» Linuxos merénylőktől tart az SCO elnöke
» Nyílt forrásúvá válhat a Java
» Lapszabász algoritmus
» D3D
» Dev-C++
» Programozás feladatok
» Lehet-e Delphi-ben programot írni mobilra????
» Hogyan tilt le Windows opr. rendszer egy assembly utasítást?
» Saját OS fejleszgettyű
» OpenGL
» több téma
Tudástár
» Delphi exception
» Hibakeresés
» Nem összefüggő tartományokra való hivatkozás Excel makróban
» Két változó cseréje harmadik nélkül
» Beléptetés, kiléptetés
» Teljes sorkiválasztás
» VB program install
» DirListBox Visual C++-ban
» Mennyi felhasználó van?
» A programot csak a 'Bezárás' buttonnal lehessen bezárni
» több téma
Assembly  |  Basic  |  C  |  Delphi  |  Java  |  JavaScript  |  Pascal  |  Perl  |  PHP  |  Visual Basic  |  Visual C++  
Tudástár » Segítség !!! »
Segítség !!!
nyitotta: okokok , idő: 2003.11.19. , moderátor: bred
  Értesítés változás esetén Felvétel kedvencekhez Küldés emailben Nyomtatható verzió

Kategóriák: Programozási nyelvek » Assembly

Sziasztok

A következő a probléma:
-----------------------

Egy olyan assembly programot akarok írni, ami két 8 bájtos számot ad össze.

-----------------------

Ha valaki tud segíteni, akkor szívesen veszem és köszönöm szépen.

-----------------------

Tudom, elég banális feladat, de nagyon nem értek az assemblyhez, de ezt muszáj megcsinálnom.

mégegyszer köszi.
A "8 bájtos szám" alatt azt érted, hogy két 8 karakter hosszúságú szövegből kinyert számot akarsz összeadni,
vagy azt hogy két 256^8 nagyságú számot akarsz összadni?

Answ -- answ@freemail.hu
naja, vagy esetleg a bitet karakternek hivod? :))
ha a szamok "12345678" formatumban vannak, akkor at kell alakitanod, ha 0x1122334455667788 (tehat ket 64 bites szam) formatumban van (tehat 8 byteos szam), akkor azt ird es megoldjuk.
Ha síma mezei utasításkészlettel akarod megoldani akkor valahogy úgy néz ki hogy:

MOV EAX,OFFSET változó1
MOV ECX,OFFSET változó2
MOV EBX,DWORD PTR [EAX]
ADD EBX,DWORD PTR [ECX]
MOV EDX,DWORD PTR [EAX+4]
ADC EDX,DWORD PTR [ECX+4]

És akkor EBX-ben lesz az összeg alsó 4 bájtja EDX-ben a felső 4 bájtja és a carry flag mutatja majd a 65. bit állapotát.A fenti példa egyébként csak 32bites védett módban fogy működni.

De én nem így csinálnám hanem MMX -el ehhez viszont olyan assembler kell ami le is tudja majd fordítani, és persze csak MMX-es és attól jobb CPU-n fog működni!

EMMS
MOVQ MM0,QWORD PTR [változó1]
PADDQ MM0,QWORD PTR [változó2]

A változó1 és a változó2 a két 64bites változó. Az MMX-es megoldásnál viszont a PADDQ utasítás nem fogja beállítani neked a flag-eket szóval nem tudod majd hogy van-e túlcsordulás avagy nincs!

Hát köszi, de most nem nagyon lettem okasabb



Az a helyzet, hogy olyan programot kellene írni, amit egy C programból el lehet érni függvényként.

És valami olyasmit is tudok, hogy bájtonként kellene összeadni őket.
(loop ciklussal) vagy mi

szóval nagyon köszi a segítségeket, de még mindíg nem tudom mit csináljak.

Ha még ezek után is próbál valaki segíteni, akkor úgy próbálja elmagyarázni, mintha egy 3 éves kisgyereknek magyarázná.

köszi.
a 8 bájtos szám alatt azt értem, hogy egy olyan számról van szó, ami a memóriában 8 bájtot foglal el.
Pocsi ugye ezt nem nekem írtad?

naja, vagy esetleg a bitet karakternek hivod? :)) ..

Answ -- answ@freemail.hu
De minek kell neked egyáltalán ez a 64 bites assembly függvény?

Az újabb C/C++ fordítókban már van 64 bites szám típus: __int64, int64, vagy INT64 néven..

Azonban, ha neked nincs akkor itt egy platformfüggetlen kód a 64 bites számok kezeléséhez:
int64.h - Portable functions for arithmetic on 64-bit integers

Speciel itt pont egy régi NetBSD-s GCC bugra hívja fel a figyelmet , de a kód működik.

Answ -- answ@freemail.hu
Valami ilyesmi lehet ami neked kell:

add_8byte proc near
push bp
mov bp,sp
mov cx,8
lea bx,[bp+ARG1]
clc
vissza:
mov al,[bx]
mov dl,[bx+8]
adc al,dl
mov [bx+16],al
inc bx
loopnz vissza:
pop bp
ret


Segítenétek nekem? Az alábbi programot kellene megírni! Hol találhatnám meg? Valaki le tudná írni?

void string_sub(char *a, char *b, char *c)
Kivonja _a_-ból _b_-t (karakteresen tárolt számok), az eredményt _c_-be teszi.


KÖSZI! (előre is)
A procedura hivas elott be kell allitanod a AX es BX regisztereket hogy benne legyenek a karakterek.

kivon proc near
SUB AL, BL
MOV AL, CL
ret
kivon end
Nem nyertél:
karakteresen tárolt számok

Azaz *a *b és *c karaktertömbök ebben az esetben.
1. Ekkor viszont nem ártana átadni a méretet is.
2. Azonosító DELPIERO
Regisztrált 2003.11.26.
3. Azonosító okokok
Regisztrált 2003.11.19.
4. Answ írta:
De minek kell neked egyáltalán ez a 64 bites assembly függvény? Az újabb C/C++ fordítókban már van 64 bites szám típus: __int64, int64, vagy INT64 néven..
Azért kell neki, mivel ez iskolai beadandó feladat, és nem az a cél hogy kiszámolja, hanem hogy az assemblyt, C-s paraméterátadást, .. értse és ezt bebizonyítsa eme feladat által. Most ő az "értés/megcsinálás" részét nem nagyon komálja inkább lepasszolná neked (vagy valaki másnak) a feladatot.

Egy másik topikban már megírtam a véleményem.
Ide csak annyit: ha így haladunk ez a fórum lesz a kódolni/gondolkodni abszolút nem tudó és akaró "egyetemisták" kedvenc gyülekezőhelye, tele házifeladatokkal, ZH és vizsgakérdésekkel melyek legtöbbje a ciklus, változó, paraméterátadás, mutató, dinamikus memóriakezelés alapfogalmak nemértésének következményei és mint ilyenek elég színvonaltalan kérdéseket eredményeznek az oldal valódi "kérdéseihez" képest (meg ilyen frappáns topikcímeket).
Nah az viszont mar nem volt benne a kerdesben! ami viszont benne volt es hibas a valaszomban az az hogy a cx tartalmahoz hozza kell adni a 30H-et mert igy nem karakter!
De amugy teljesen igazad van, e problema megoldasahoz egy sima assembly help is elegendo!
Tanulj!
Sziasztok!

Nekem van egy ilyen programom (lemezkezelő) és azt a feladatot kaptam, hogy pofozzam ki egy kicsit, csináljak keretet a megjelenő adatok köré. Sajna lövésem sincs, hogyan kell ezt megcsinálni, de 17.-én le kell adnom. Légyszike segítsetek! Köszi!


.model small
.stack
.data?
block db 512 dup(?)
.code



public cr_lf
cr_lf proc
push dx
mov dl, 13
call write_char
mov dl, 10
call write_char
pop dx
ret
cr_lf endp

public write_hexa_digit
write_hexa_digit proc
push dx
cmp dl,10
jae hexa ; >=
add dl,'0'
jmp hexa_ki
hexa:
add dl,'A'-10
jmp hexa_ki
hexa_ki:
call write_char
pop dx
ret
write_hexa_digit endp


public write_hexa
write_hexa proc
push dx
push cx
mov dh, dl ;dl mentese dh-ba
mov cl,4
shr dl,cl
call write_hexa_digit
mov dl,dh
and dl,0fh
call write_hexa_digit
pop cx
pop dx
ret
write_hexa endp




public write_char
write_char proc
push ax
mov ah,2
int 21h
pop ax
ret
write_char endp



public write_block
write_block proc
push cx
push dx
mov cx, 40
w_b_new:
call write_line
call cr_lf
add dx, 16
loop w_b_new
pop dx
pop cx
ret
write_block endp

public write_line
write_line proc
push bx
push cx
push dx
mov bx, dx
push bx
mov cx, 16
w_l_new:
mov dl, block[bx]
call write_hexa
mov dl, ' '
call write_char
inc bx
loop w_l_new
mov dl, '|'
call write_char
mov dl, ' '
call write_char
pop bx
mov cx, 16
w_l_char:
mov dl, block[bx]
cmp dl, ' '
ja write
mov dl, ' '
write:
call write_char
inc bx
loop w_l_char
pop dx
pop cx
pop bx
ret
write_line endp

public cls
cls proc
push ax
push bx
push cx
push dx
xor ax, ax
xor cx, cx
mov dh, 49
mov dl, 79
mov bh, 7
mov ah, 6 ;sor gorgetese fel
int 10h
pop dx
pop cx
pop bx
pop ax
ret
;sorok szama, ha 0, torles
;ch:cl bal felso sor:oszlop
;dh:dl jobb also
cls endp


main proc
call cls
mov ax, dgroup
mov ds, ax
lea bx, block ;ds:bx
mov al, 0 ;0-a, 1-b meghajto
mov dx, 256 ;kezdo blokk
mov cx, 1 ;egyszerre beolvasott blokkok szama
int 25h ;hattertarakhoz ez kell, monitor/bill 21h
;ez egy blokkot beolvas a floppyrol
;hibajelzes ah-ba
;tobbi a stackba, ami emiatt no
popf ;flag regiszterbe tesz vissza
xor dx, dx ;ds:dx-ben lesz az adat
call write_block
mov ah, 4ch
int 21h
main endp
end main