; testdata_64.asm  a program to demonstrate data types and values
; assemble:	nasm -f elf64 -l testdata_64.lst  testdata_64.asm
; link:		gcc -m64 -o testdata_64  testdata_64.o
; run:	        ./testdata_64
; Look at the list file, testdata_64.lst
; no output
; Note! nasm ignores the type of data and type of reserved
; space when used as memory addresses.
; You may have to use qualifiers BYTE, WORD, DWORD or QWORD

	section .data		; data section
				; initialized, writeable

				; db for data byte, 8-bit 
db01:	db	255,1,17	; decimal values for bytes
db02:	db	0xff,0ABh	; hexadecimal values for bytes
db03:	db	'a','b','c'	; character values for bytes
db04:	db	"abc"		; string value as bytes 'a','b','c'
db05:	db	'abc'		; same as "abc" three bytes
db06:	db	"hello",13,10,0 ; "C" string including cr and lf

				; dw for data word, 16-bit
dw01:	dw	12345,-17,32	; decimal values for words
dw02:	dw	0xFFFF,0abcdH	; hexadecimal values for words
dw03:	dw	'a','ab','abc'	; character values for words
dw04:	dw	"hello"		; three words, 6-bytes allocated

				; dd for data double word, 32-bit
dd01:	dd	123456789,-7	; decimal values for double words
dd02:	dd	0xFFFFFFFF	; hexadecimal value for double words
dd03:	dd	'a'		; character value in double word
dd04:	dd	"hello"		; string in two double words
dd05:	dd	13.27E30	; floating point value 32-bit IEEE

				; dq for data quad word, 64-bit
dq01:	dq	123456789012,-7	; decimal values for quad words
dq02:	dq	0xFFFFFFFFFFFFFFFF ; hexadecimal value for quad words
dq03:	dq	'a'		; character value in quad word
dq04:	dq	"hello_world"	; string in two quad words
dq05:	dq	13.27E300	; floating point value 64-bit IEEE

				; dt for data ten of 80-bit floating point
dt01:	dt	13.270E3000	; floating point value 80-bit in register


	section .bss		; reserve storage space
				; uninitialized, writeable
	
s01:	resb	10		; 10 8-bit bytes reserved
s02:	resw	20		; 20 16-bit words reserved
s03:	resd	30		; 30 32-bit double words reserved
s04:	resq	40		; 40 64-bit quad words reserved
s05:	resb	1		; one more byte
	
	SECTION .text		; code section
        global main		; make label available to linker 
main:				; standard  gcc  entry point

	push	rbp		; initialize stack
	
	mov	al,[db01]	; correct to load a byte
	mov	ah,[db01]	; correct to load a byte
	mov	ax,[dw01]	; correct to load a word
	mov	eax,[dd01]	; correct to load a double word
	mov	rax,[dq01]	; correct to load a quad word

	mov	al,BYTE [db01]	; redundant, yet allowed
	mov	ax,[db01]	; no warning, loads two bytes
	mov	eax,[dw01]	; no warning, loads two words
	mov	rax,[dd01]	; no warning, loads two double words

;	mov	ax,BYTE [db01]	; error, size miss match
;	mov	eax,WORD [dw01]	; error, size miss match
;	mov	rax,WORD [dd01]	; error, size miss match

;	push	BYTE [db01]	; error, can not push a byte
	push	WORD [dw01]	; "push" needs to know size 2-byte
;	push	DWORD [dd01]	; error, can not push a 4-byte
	push	QWORD [dq01]	; OK

;	push	eax		; error, wrong size, need 64-bit
	push	rax
	
	fld	DWORD [dd05]	; floating load 32-bit
	fld	QWORD [dq05]	; floating load 64-bit
		
	mov	rbx,0		; exit code, 0=normal
	mov	rax,1		; exit command to kernel
	int	0x80		; interrupt 80 hex, call kernel

; end testdata_64.asm