mirror/nasm
2
0
Fork 0
mirror of https://github.com/netwide-assembler/nasm.git synced 2024-12-03 08:41:02 +08:00
Code Issues Packages Projects Releases Wiki Activity
80d18b5555
nasm/test/floatx.asm

526 lines
12 KiB
NASM
Raw Normal View History

Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
;
; floatx.asm
;
; Test hexadecimal floating-point numbers
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
%define Inf __Infinity__
%define NaN __QNaN__
Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
; 16-bit
dw 1.0
dw 0x1.0
dw 2.0
dw 0x2.0
dw 0x1.0p+1
dw 0x1.0p-1
dw 0x0.0
dw 0x1.23456789
dw 0x0.123456789
dw 0x0.0000123456789
dw 0x1.23456789p10
dw 0x1.23456789p+10
dw 0x1.23456789p-10
dw 0x0.123456789p10
dw 0x0.123456789p+10
dw 0x0.123456789abcdef0123456789abcdef012345p-10
dw 0x0.0000123456789
dw 0x0.0000123456789p+10
dw 0x0.0000123456789p-10
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dw 0x1.0p-25 ; Underflow
floatx.asm: add tests for "rounds up to smallest denorm" Add tests for the case where we round upwards to reach the smallest possible denorm, i.e. "saved from underflow by rounding."
2007-10-30 16:17:57 +08:00
dw 0x1.01p-25 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dw 0x1.0p-24 ; Smallest denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dw 0x1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dw 0x1.0p-15 ; Denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dw 0x1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dw 0x1.0p-14 ; Smallest non-denorm
dw 0x1.0p+15 ; Biggest possible exponent
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dw 0x1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
dw Inf ; Infinity
dw NaN
Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
; 32-bit
dd 1.0
dd 0x1.0
dd 2.0
dd 0x2.0
dd 0x1.0p+1
dd 0x1.0p-1
dd 0x0.0
dd 0x1.23456789
dd 0x0.123456789
dd 0x0.0000123456789
dd 0x1.23456789p10
dd 0x1.23456789p+10
dd 0x1.23456789p-10
dd 0x0.123456789p10
dd 0x0.123456789p+10
dd 0x0.123456789abcdef0123456789abcdef012345p-10
dd 0x0.0000123456789
dd 0x0.0000123456789p+10
dd 0x0.0000123456789p-10
dd 0x123456789.0
dd 0x0000123456789.0
dd 0x123456789.0p+0
dd 0x123456789.0p+64
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dd 0x1.0p-150 ; Underflow
floatx.asm: add tests for "rounds up to smallest denorm" Add tests for the case where we round upwards to reach the smallest possible denorm, i.e. "saved from underflow by rounding."
2007-10-30 16:17:57 +08:00
dd 0x1.01p-150 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dd 0x1.0p-149 ; Smallest denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dd 0x1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dd 0x1.0p-127 ; Denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dd 0x1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dd 0x1.0p-126 ; Smallest non-denorm
dd 0x1.0p+127 ; Biggest possible exponent
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dd 0x1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
dd Inf ; Infinity
dd NaN
Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
; 64-bit
dq 1.0
dq 0x1.0
dq 2.0
dq 0x2.0
dq 0x1.0p+1
dq 0x1.0p-1
dq 0x0.0
dq 0x1.23456789
dq 0x0.123456789
dq 0x0.0000123456789
dq 0x1.23456789p10
dq 0x1.23456789p+10
dq 0x1.23456789p-10
dq 0x0.123456789p10
dq 0x0.123456789p+10
dq 0x0.123456789abcdef0123456789abcdef012345p-10
dq 0x0.0000123456789
dq 0x0.0000123456789p+10
dq 0x0.0000123456789p-10
dq 0x123456789.0
dq 0x0000123456789.0
dq 0x123456789.0p+0
dq 0x123456789.0p+300
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dq 0x1.0p-1075 ; Underflow
floatx.asm: add tests for "rounds up to smallest denorm" Add tests for the case where we round upwards to reach the smallest possible denorm, i.e. "saved from underflow by rounding."
2007-10-30 16:17:57 +08:00
dq 0x1.01p-1075 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dq 0x1.0p-1074 ; Smallest denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dq 0x1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dq 0x1.0p-1023 ; Denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dq 0x1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dq 0x1.0p-1022 ; Smallest non-denorm
dq 0x1.0p+1023 ; Biggest possible exponent
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dq 0x1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
dq Inf ; Infinity
dq NaN
Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
; 80-bit
dt 1.0
dt 0x1.0
dt 2.0
dt 0x2.0
dt 0x1.0p+1
dt 0x1.0p-1
dt 0x0.0
dt 0x1.23456789
dt 0x0.123456789
dt 0x0.0000123456789
dt 0x1.23456789p10
dt 0x1.23456789p+10
dt 0x1.23456789p-10
dt 0x0.123456789p10
dt 0x0.123456789p+10
dt 0x0.123456789abcdef0123456789abcdef012345p-10
dt 0x0.0000123456789
dt 0x0.0000123456789p+10
dt 0x0.0000123456789p-10
dt 0x123456789.0
dt 0x0000123456789.0
dt 0x123456789.0p+0
dt 0x123456789.0p+1024
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dt 0x1.0p-16446 ; Underflow
floatx.asm: add tests for "rounds up to smallest denorm" Add tests for the case where we round upwards to reach the smallest possible denorm, i.e. "saved from underflow by rounding."
2007-10-30 16:17:57 +08:00
dt 0x1.01p-16446 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dt 0x1.0p-16445 ; Smallest denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dt 0x1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dt 0x1.0p-16383 ; Denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
dt 0x1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
dt 0x1.0p-16382 ; Smallest non-denorm
dt 0x1.0p+16383 ; Biggest possible exponent
test/floatx.asm: fix test case "dq" should have been "dt"
2007-10-20 05:26:52 +08:00
dt 0x1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
dt Inf ; Infinity
dt NaN
Simple test for hexadecimal floating-point numbers Very trivial test for hexadecimal floating-point numbers
2007-09-19 09:37:36 +08:00
; 128-bit
do 1.0
do 0x1.0
do 2.0
do 0x2.0
do 0x1.0p+1
do 0x1.0p-1
do 0x0.0
do 0x1.23456789
do 0x0.123456789
do 0x0.0000123456789
do 0x1.23456789p10
do 0x1.23456789p+10
do 0x1.23456789p-10
do 0x0.123456789p10
do 0x0.123456789p+10
do 0x0.123456789abcdef0123456789abcdef012345p-10
do 0x0.0000123456789
do 0x0.0000123456789p+10
do 0x0.0000123456789p-10
do 0x123456789.0
do 0x0000123456789.0
do 0x123456789.0p+0
do 0x123456789.0p+1024
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
do 0x1.0p-16495 ; Underflow
floatx.asm: add tests for "rounds up to smallest denorm" Add tests for the case where we round upwards to reach the smallest possible denorm, i.e. "saved from underflow by rounding."
2007-10-30 16:17:57 +08:00
do 0x1.01p-16495 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
do 0x1.0p-16494 ; Smallest denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
do 0x1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
do 0x1.0p-16383 ; Denorm
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
do 0x1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal
floatx.asm: add specific tests for exponent boundary conditions Add tests for the exponent boundaries (underflow, denorm, normal).
2007-10-05 14:09:19 +08:00
do 0x1.0p-16382 ; Smallest non-denorm
do 0x1.0p+16383 ; Biggest possible exponent
Handle rounding of denorms correctly; make fp overflow a warning - Handle rounding of denorms correctly - Make fp overflow a warning, not an error (produces Inf) - Make fp warnings controllable
2007-10-17 02:32:58 +08:00
do 0x1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
floatx.asm: add Inf and NaN to the boundary condition tests
2007-10-05 14:51:08 +08:00
do Inf ; Infinity
do NaN
Allow $-prefixed hexadecimal FP as an alternative to 0x Since we allow the prefix $ instead of 0x for integer constants, do the same for floating point. No suffix support at this time; we may want to consider if that would be appropriate.
2007-10-20 09:33:57 +08:00
More consistent handling of radix letters Allow any radix letter from the set [bydtoqhx] to be used either "Intel-style" (0...x) or "C-style" (0x...). In Intel style, the leading 0 remains optional as long as the first digit is in the range 0-9. As a consequence, allow the prefix "0h" for hexadecimal floating point.
2007-10-23 07:53:48 +08:00
; 16-bit
dw 1.0
dw 0h1.0
dw 2.0
dw 0h2.0
dw 0h1.0p+1
dw 0h1.0p-1
dw 0h0.0
dw 0h1.23456789
dw 0h0.123456789
dw 0h0.0000123456789
dw 0h1.23456789p10
dw 0h1.23456789p+10
dw 0h1.23456789p-10
dw 0h0.123456789p10
dw 0h0.123456789p+10
dw 0h0.123456789abcdef0123456789abcdef012345p-10
dw 0h0.0000123456789
dw 0h0.0000123456789p+10
dw 0h0.0000123456789p-10
dw 0h1.0p-25 ; Underflow
dw 0h1.0p-24 ; Smallest denorm
dw 0h1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm
dw 0h1.0p-15 ; Denorm
dw 0h1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal
dw 0h1.0p-14 ; Smallest non-denorm
dw 0h1.0p+15 ; Biggest possible exponent
dw 0h1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity
dw Inf ; Infinity
dw NaN
; 32-bit
dd 1.0
dd 0h1.0
dd 2.0
dd 0h2.0
dd 0h1.0p+1
dd 0h1.0p-1
dd 0h0.0
dd 0h1.23456789
dd 0h0.123456789
dd 0h0.0000123456789
dd 0h1.23456789p10
dd 0h1.23456789p+10
dd 0h1.23456789p-10
dd 0h0.123456789p10
dd 0h0.123456789p+10
dd 0h0.123456789abcdef0123456789abcdef012345p-10
dd 0h0.0000123456789
dd 0h0.0000123456789p+10
dd 0h0.0000123456789p-10
dd 0h123456789.0
dd 0h0000123456789.0
dd 0h123456789.0p+0
dd 0h123456789.0p+64
dd 0h1.0p-150 ; Underflow
dd 0h1.0p-149 ; Smallest denorm
dd 0h1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm
dd 0h1.0p-127 ; Denorm
dd 0h1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal
dd 0h1.0p-126 ; Smallest non-denorm
dd 0h1.0p+127 ; Biggest possible exponent
dd 0h1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity
dd Inf ; Infinity
dd NaN
; 64-bit
dq 1.0
dq 0h1.0
dq 2.0
dq 0h2.0
dq 0h1.0p+1
dq 0h1.0p-1
dq 0h0.0
dq 0h1.23456789
dq 0h0.123456789
dq 0h0.0000123456789
dq 0h1.23456789p10
dq 0h1.23456789p+10
dq 0h1.23456789p-10
dq 0h0.123456789p10
dq 0h0.123456789p+10
dq 0h0.123456789abcdef0123456789abcdef012345p-10
dq 0h0.0000123456789
dq 0h0.0000123456789p+10
dq 0h0.0000123456789p-10
dq 0h123456789.0
dq 0h0000123456789.0
dq 0h123456789.0p+0
dq 0h123456789.0p+300
dq 0h1.0p-1075 ; Underflow
dq 0h1.0p-1074 ; Smallest denorm
dq 0h1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm
dq 0h1.0p-1023 ; Denorm
dq 0h1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal
dq 0h1.0p-1022 ; Smallest non-denorm
dq 0h1.0p+1023 ; Biggest possible exponent
dq 0h1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity
dq Inf ; Infinity
dq NaN
; 80-bit
dt 1.0
dt 0h1.0
dt 2.0
dt 0h2.0
dt 0h1.0p+1
dt 0h1.0p-1
dt 0h0.0
dt 0h1.23456789
dt 0h0.123456789
dt 0h0.0000123456789
dt 0h1.23456789p10
dt 0h1.23456789p+10
dt 0h1.23456789p-10
dt 0h0.123456789p10
dt 0h0.123456789p+10
dt 0h0.123456789abcdef0123456789abcdef012345p-10
dt 0h0.0000123456789
dt 0h0.0000123456789p+10
dt 0h0.0000123456789p-10
dt 0h123456789.0
dt 0h0000123456789.0
dt 0h123456789.0p+0
dt 0h123456789.0p+1024
dt 0h1.0p-16446 ; Underflow
dt 0h1.0p-16445 ; Smallest denorm
dt 0h1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
dt 0h1.0p-16383 ; Denorm
dt 0h1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal
dt 0h1.0p-16382 ; Smallest non-denorm
dt 0h1.0p+16383 ; Biggest possible exponent
dt 0h1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
dt Inf ; Infinity
dt NaN
; 128-bit
do 1.0
do 0h1.0
do 2.0
do 0h2.0
do 0h1.0p+1
do 0h1.0p-1
do 0h0.0
do 0h1.23456789
do 0h0.123456789
do 0h0.0000123456789
do 0h1.23456789p10
do 0h1.23456789p+10
do 0h1.23456789p-10
do 0h0.123456789p10
do 0h0.123456789p+10
do 0h0.123456789abcdef0123456789abcdef012345p-10
do 0h0.0000123456789
do 0h0.0000123456789p+10
do 0h0.0000123456789p-10
do 0h123456789.0
do 0h0000123456789.0
do 0h123456789.0p+0
do 0h123456789.0p+1024
do 0h1.0p-16495 ; Underflow
do 0h1.0p-16494 ; Smallest denorm
do 0h1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
do 0h1.0p-16383 ; Denorm
do 0h1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal
do 0h1.0p-16382 ; Smallest non-denorm
do 0h1.0p+16383 ; Biggest possible exponent
do 0h1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
do Inf ; Infinity
do NaN
Allow $-prefixed hexadecimal FP as an alternative to 0x Since we allow the prefix $ instead of 0x for integer constants, do the same for floating point. No suffix support at this time; we may want to consider if that would be appropriate.
2007-10-20 09:33:57 +08:00
; 16-bit
dw 1.0
dw $1.0
dw 2.0
dw $2.0
dw $1.0p+1
dw $1.0p-1
dw $0.0
dw $1.23456789
dw $0.123456789
dw $0.0000123456789
dw $1.23456789p10
dw $1.23456789p+10
dw $1.23456789p-10
dw $0.123456789p10
dw $0.123456789p+10
dw $0.123456789abcdef0123456789abcdef012345p-10
dw $0.0000123456789
dw $0.0000123456789p+10
dw $0.0000123456789p-10
dw $1.0p-25 ; Underflow
dw $1.0p-24 ; Smallest denorm
dw $1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm
dw $1.0p-15 ; Denorm
dw $1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal
dw $1.0p-14 ; Smallest non-denorm
dw $1.0p+15 ; Biggest possible exponent
dw $1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity
dw Inf ; Infinity
dw NaN
; 32-bit
dd 1.0
dd $1.0
dd 2.0
dd $2.0
dd $1.0p+1
dd $1.0p-1
dd $0.0
dd $1.23456789
dd $0.123456789
dd $0.0000123456789
dd $1.23456789p10
dd $1.23456789p+10
dd $1.23456789p-10
dd $0.123456789p10
dd $0.123456789p+10
dd $0.123456789abcdef0123456789abcdef012345p-10
dd $0.0000123456789
dd $0.0000123456789p+10
dd $0.0000123456789p-10
dd $123456789.0
dd $0000123456789.0
dd $123456789.0p+0
dd $123456789.0p+64
dd $1.0p-150 ; Underflow
dd $1.0p-149 ; Smallest denorm
dd $1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm
dd $1.0p-127 ; Denorm
dd $1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal
dd $1.0p-126 ; Smallest non-denorm
dd $1.0p+127 ; Biggest possible exponent
dd $1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity
dd Inf ; Infinity
dd NaN
; 64-bit
dq 1.0
dq $1.0
dq 2.0
dq $2.0
dq $1.0p+1
dq $1.0p-1
dq $0.0
dq $1.23456789
dq $0.123456789
dq $0.0000123456789
dq $1.23456789p10
dq $1.23456789p+10
dq $1.23456789p-10
dq $0.123456789p10
dq $0.123456789p+10
dq $0.123456789abcdef0123456789abcdef012345p-10
dq $0.0000123456789
dq $0.0000123456789p+10
dq $0.0000123456789p-10
dq $123456789.0
dq $0000123456789.0
dq $123456789.0p+0
dq $123456789.0p+300
dq $1.0p-1075 ; Underflow
dq $1.0p-1074 ; Smallest denorm
dq $1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm
dq $1.0p-1023 ; Denorm
dq $1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal
dq $1.0p-1022 ; Smallest non-denorm
dq $1.0p+1023 ; Biggest possible exponent
dq $1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity
dq Inf ; Infinity
dq NaN
; 80-bit
dt 1.0
dt $1.0
dt 2.0
dt $2.0
dt $1.0p+1
dt $1.0p-1
dt $0.0
dt $1.23456789
dt $0.123456789
dt $0.0000123456789
dt $1.23456789p10
dt $1.23456789p+10
dt $1.23456789p-10
dt $0.123456789p10
dt $0.123456789p+10
dt $0.123456789abcdef0123456789abcdef012345p-10
dt $0.0000123456789
dt $0.0000123456789p+10
dt $0.0000123456789p-10
dt $123456789.0
dt $0000123456789.0
dt $123456789.0p+0
dt $123456789.0p+1024
dt $1.0p-16446 ; Underflow
dt $1.0p-16445 ; Smallest denorm
dt $1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
dt $1.0p-16383 ; Denorm
dt $1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal
dt $1.0p-16382 ; Smallest non-denorm
dt $1.0p+16383 ; Biggest possible exponent
dt $1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
dt Inf ; Infinity
dt NaN
; 128-bit
do 1.0
do $1.0
do 2.0
do $2.0
do $1.0p+1
do $1.0p-1
do $0.0
do $1.23456789
do $0.123456789
do $0.0000123456789
do $1.23456789p10
do $1.23456789p+10
do $1.23456789p-10
do $0.123456789p10
do $0.123456789p+10
do $0.123456789abcdef0123456789abcdef012345p-10
do $0.0000123456789
do $0.0000123456789p+10
do $0.0000123456789p-10
do $123456789.0
do $0000123456789.0
do $123456789.0p+0
do $123456789.0p+1024
do $1.0p-16495 ; Underflow
do $1.0p-16494 ; Smallest denorm
do $1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm
do $1.0p-16383 ; Denorm
do $1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal
do $1.0p-16382 ; Smallest non-denorm
do $1.0p+16383 ; Biggest possible exponent
do $1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity
do Inf ; Infinity
do NaN
Reference in New Issue Copy Permalink