Recent Posts
Ah, I got it. You decrease the fractional part after each loop and check with theOf... since it seems you didn't got the three potential bugs there here they are:
Comiss xmm0, xmm3
If it gets no more smaller... This is nice. :-)
; main.asm
bits 64
default rel
section .text
extern printfloat
global _start
_start:
movss xmm0, [value]
xor edi, edi ; maximum precision.
call printfloat
; Prints a newline.
mov eax,1
mov edi,eax
lea rsi,[crlf]
mov edx,eax
syscall
; Exits the program with errorcode 0.
mov eax,60
xor edi,edi
syscall
section .rodata
align 4
value:
dd 123.45678 ; this isn't exact in floating point!
crlf:
db `\n`
section .note.GNU-stack noexec
; float.asm
bits 64
default rel
section .text
global printfloat
; Input: XMM0 = x; EDI = precision (maximum # of fractional digits - 0 if all).
printfloat:
cvttss2si r9, xmm0
mov byte [rsp-1], 0
mov r8d, edi
lea rsi, [rsp-1]
mov r10d, 0xcccccccd ; 1/10 scaled.
mov edx, r9d
align 4
.loop1:
mov eax, edx
mov ecx, edx
sub rsi, 1
imul rax, r10
shr rax, 35 ; EAX = n / 10.
lea edi, [rax+rax*4]
add edi, edi
sub ecx, edi ; ECX = n % 10.
add ecx, '0'
mov [rsi], cl
mov ecx, edx
mov edx, eax
cmp ecx, 9 ; reminder sill > 9?
ja .loop1 ; yes, stay in the loop.
mov eax, 1
mov rdx, rsp ; calc the string size.
sub rdx, rsi ;
mov edi, eax
syscall
mov eax,1
mov edi,eax
mov edx,eax
lea rsi, [dot]
syscall
pxor xmm1, xmm1
mov r9d, r9d
cvtsi2ss xmm1, r9
subss xmm0, xmm1
pxor xmm1, xmm1
cvttss2si rdx, xmm0
mov edx, edx
cvtsi2ss xmm1, rdx
subss xmm0, xmm1
movss xmm2, [ten]
mov r9d, r8d
lea rsi, [rsp-1]
pxor xmm3, xmm3
align 4
.loop2:
mulss xmm0, xmm2
pxor xmm1, xmm1
mov edx, edi
cvttss2si ecx, xmm0
movsx eax, cl
add ecx, '0'
cvtsi2ss xmm1, eax
mov [rsi], cl
mov eax, edi
subss xmm0, xmm1
syscall
; Precision testing...
test r8d, r8d
je .skip
sub r9d, 1
je .exit
.skip:
; if fractional part isn't zero yet...
comiss xmm0, xmm3
jne .loop2 ; stay in the loop.
.exit:
ret
section .rodata
dot:
db '.'
align 4
ten:
dd 10.0
section .note.GNU-stack noexec
$ nasm -felf64 main.asm -o main.o
$ nasm -felf64 float.asm -o float.o
$ ld -s -o main main.o float.o
$ ./main
123.45677947998046875
; try to print floating-point values via sse2
; nasm -f elf64 float-print.asm && ld -o float-print float-print.o
[bits 64]
global _start
section .data
val1 dq 123.454789 ;declare quad word (double precision)
zehn dq 10.0
ziffer db 0
crlf db 13,10
dezp db '.'
section .text
_start:
call newline
mov r9, 1 ; r9 starts to count the numbers after decimalpoint we want to write
movsd xmm1, qword [val1] ; our value, we want to write
movsd xmm2, xmm1
cvttsd2si rax, xmm2 ; rax is now val1 without numbers after decimalpoint
call print_dez
call dez_point
repeat_it:
cvtsi2sd xmm3, rax ; load the truncated value in xmm3
subsd xmm2, xmm3 ; xmm2 is now the value behind the decimalpoint
mulsd xmm2, [zehn] ; multiplic. by ten. (so get one number before the decimalpoint
cvttsd2si rax, xmm2 ; rax is the number before the decimalpoint (only one number)
call print_dez ; print this number
inc r9
cmp r9, 5 ; <=== check if the wanted amount of "Nachkommastellen" is reached
jle repeat_it
call newline
mov rax,60
syscall ;end program
print_dez: ; in rax should be the number to write
push rax
push rbx
push rcx
push rdx
xor rcx,rcx
mov rbx,10
schl1:
xor rdx,rdx
div rbx
push rdx
inc rcx
cmp rax,0
jnz schl1
schl2:
pop rdx
add dl,30h
mov [ziffer],dl
push rcx
mov rax, 1 ; Funktionsnummer : schreiben
mov rdi, 1 ; auf STDOUT
mov rsi, ziffer ; was schreiben wir
mov rdx, 1 ; wieviel Zeichen
syscall
pop rcx
loop schl2
pop rdx
pop rcx
pop rbx
pop rax
ret
dez_point: ; just to write the point.
push rax
push rdx
mov rax, 1 ; Funktionsnummer : schreiben
mov rdi, 1 ; auf STDOUT
mov rsi, dezp ; was schreiben wir
mov rdx, 1 ; wieviele Zeichen
syscall
pop rdx
pop rax
ret
newline:
push rax
push rdx
mov rax, 1 ; Funktionsnummer : schreiben
mov rdi, 1 ; auf STDOUT
mov rsi, crlf ; was schreiben wir
mov rdx, 2 ; wieviele Zeichen
syscall
pop rdx
pop rax
ret
a) if i have declared my points as integer values like "mydata dq 100" or whatever, I should not load them like "movsd xmm0, qword [mydata]" but with "cvtsi2sd xmm0, qword [mydata]"If you intend to use this data as a double, yes.
b) if I really work with my data as integer, they will get after a few rotation-calculations very fast unexact by the truncation/rounding. After a 360 degree-rotation in 360 steps I will have no more a cube, but some totally other formation. ;-) => Will have to do this with floating-point (also the storing of the coordinates)Floating point is ALWAYS an approximation. Most exact fractional values in decimal cannot be exactly represented in binary...
section .data...the point-table will be written to the points-array. Works, shifting to left, right, up, down, and in the depth worksall, but than comes a try of rotation ...
xs dq 0,0,0,0,0,0,0,0,0,0,0,0
ys dq 0,0,0,0,0,0,0,0,0,0,0,0
points resq 24
tempx dq 0
tempy dq 0
tempz dq 0
; reminder 960 x 720 window, haelfte 480 / 360
point dq -100, -100, 300,
dq 100, -100, 300,
dq -100, 100, 300,
dq 100, 100, 300,
dq -100, -100, 500,
dq 100, -100, 500,
dq -100, 100, 500,
dq 100, 100, 500
yaussen dq 700 ; war erst 900 und 400
yscreen dq 100 ; reminder 960 x 720 window, haelfte 480 / 360
cos1 dq 0.9998477 ; 0.9998477*x - 0.0174524*z;
sin1 dq 0.0174524
roty1:Rotation by y.
push rcx
push r15
mov rcx, 0
nochmal8: ; tempx:= 0.9998477*x - 0.0174524*z
movsd xmm0, qword [points+rcx*8] ; load x coordinate in xmm0
movsd xmm1, qword [cos1] ; load cos 1 from table in xmm1
mulsd xmm0, xmm1 ; multiply xmm0 and xmm1, store in xmm0
movsd xmm2, qword [points+rcx*8+16] ; load z coordinate in xmm2
movsd xmm3, qword [sin1] ; load sin 1 from table in xmm3
mulsd xmm2, xmm3 ; multiply xmm2 and xmm3, store in xmm2
subsd xmm0, xmm2 ; subtract xmm2 from xmm0, store in xmm0
mov r15, 0
cvtsd2si r15, xmm0 ; convert xmm0 to integer and store in r15
mov qword [tempx], r15 ; store tempx
; tempz:= 0.0174524*x + 0.9998477*z
movsd xmm0, qword [points+rcx*8] ; load x coordinate in xmm0
movsd xmm1, qword [sin1] ; load sin 1 from table
mulsd xmm0, xmm1 ; multiply and store in xmm0
movsd xmm2, qword [points+rcx*8+16] ; load z coordinate
movsd xmm3, qword [cos1] ; load cos 1 from table
mulsd xmm2, xmm3 ; multiply and store in xmm2
addsd xmm0, xmm2 ; add xmm0 and xmm2, store in xmm0
mov r15, 0
cvtsd2si r15, xmm0 ; convet xmm0 to integer and store in r15
mov qword [tempz], r15 ; store tempz
mov r15, 0
mov r15, [tempx]
mov [points+rcx*8], r15 ; write the new x coordinate to table
mov r15, 0
mov r15, [tempz]
mov [points+rcx*8+16], r15 ; same for z coordinate
inc rcx
inc rcx
inc rcx
cmp rcx, 24 ; eight point in the cube, each with three coordinates...
jne nochmal8
pop r15
pop rcx
ret