;  testdata.asm  a program to demonstrate data types and values
;
; assemble:	nasm -f elf -l testdata.lst  testdata.asm
; link:		gcc -o testdata  testdata.o
; run:	        testdata 
; Look at the list file, testdata.lst

; 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 or DWORD [dd01]

	
	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	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

	
	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	al,BYTE [db01]	; redundant, yet allowed

	mov	ax,[db01]	; no warning, loads two bytes
	mov	eax,[dw01]	; no warning, loads two words

;	mov	ax,BYTE [db01]	; error, size miss match
;	mov	eax,WORD [dw01]	; 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]	; "push" needs to know size 4-byte
;	push	QWORD [dq01]	; error, can not push a quad word
	push	DWORD [dq01+4]	; push a floating point, half of it
	push	DWORD [dq01]	; push other half of floating point
	fld	DWORD [dd05]	; floating load 32-bit
	fld	QWORD [dq01]	; floating load 64-bit
		
	mov	ebx,0		; exit code, 0=normal
	mov	eax,1		; exit command to kernel
	int	0x80		; interrupt 80 hex, call kernel

; end testdata.asm