.include "DS.S"
#-----------------------------------------------
#	A B S T R A C T  S T R U C T U R E S
#-----------------------------------------------
#-----------------------------------------------
#	S T A T I C   V A R I A B L E S
#-----------------------------------------------
	.data
D.t0:	.int	0				# initial timestamp in usecs
D.semP:	.int	0				# -->semaphore for debug output
	.globl	D.prgNameP
D.prgNameP:
	.int	0				# -->prog name
#-----------------------------------------------
#	D E B U G   I N I T
#-----------------------------------------------
# initialize static debug vars
	ARGS
 	DS	prgP				# -->program name
# returns:	nothing
	PROLOC
	EPILOC
#-----------------------------------------------
	.text
	.global D.init
D.init:
	PROLOG
	push	prgP(bp)
	call	strlen
	inc	a
	push	a
	call	malloc
	mov	a, D.prgNameP			# save -->prog name for debugging
	push	prgP(bp)
	push	a
	call	strcpy
	movl	$0, D.t0
	call	D.getTs				# get actual time - t0 = actual time
	mov	a, D.t0				# set t0 to actual time

	jmp	3f
	push	$0
	push	$t
	call	gettimeofday			# get initial timestamp t0
	cmp	$0, a
	jz	0f
	ERR	"gettimeofday"
0:	lea	t, b				# compute (1000000*secs+usecs)
	mov	secs(b), c
	mov	$1000000, a
	mul	c				# 1000000*secs
	add	usecs(b), a			# 1000000*secs+usecs
	movl	a, D.t0				# save low 32 bits of timestamp in t0
3:
	push	$0				# allocate semaphore for debug output
	push	$-1
	push	$0x21				# PROT_READ | PROT_WRITE
	push	$0x03				# MAP_SHARED | MAP_ANONYMOUS
	push	$16				# semaphore size
	push	$0
	call	mmap				# get shared storage for semaphore
	cmp	$-1, a
	jne	0f
	ERR	"mmap"
0:	mov	a, D.semP			# save -->semaphore

	push	$1				# initial semaphore value
	push	$1				# semaphore shared between processes
	pushl	D.semP
	call	sem_init			# initialize semaphore
	cmp	$0, a
	jz	0f
	ERR	"sem_init of debug semaphore"
0:
	EPILOG
#-----------------------------------------------
#	S E T   D E B U G   I D
#-----------------------------------------------
# sets debug ID according to format
	ARGS
 	DS	deP 				# -->Debug instance
	DS	argc				# # of values to be put into deb ID
	DS	formP				# -->format
#	...					# values
# returns:	nothing
	PROLOC
	EPILOC
#-----------------------------------------------
	.global D.setId
D.setId:
	PROLOG
# format debug ID
	mov	argc(bp), c			# no. of values
0:	mov	formP(bp,c,4), a		# push values and format
	push	a
	dec	c
	jns	0b				# iterate on values
	pushl	$D.idL				# max deb ID len
	mov	deP(bp), b			# -->Debug instance
	lea	D.id(b), a			# -->DebId
	push	a
	call	snprintf			# construct DebId
	cmp	$0, a
	jnl	0f
	ERR	"DEBID snprintf"
0:
	LOG	6, "debid '%s' set", 1
	EPILOG
#-----------------------------------------------
#	P R I N T   D E B U G   M S G
#-----------------------------------------------
# outputs to stderr the synchronized debug msg with time diff from program start
# 	on appripriate debug level, flushes stderr
	ARGS
	ac = 40
 	DS	deP 				# -->Debug instance
 	DS	level				# msg debug level
	DS	argc				# # of values to be used in msg
	DS	form				# -->format
#	...					# values
# returns:	nothing
	PROLOC
	ac = 0
	EPILOC
#-----------------------------------------------
	.global D.log
D.log:
	PROLOG

	mov	C.csP, c
	mov	level(bp), a			# msg debug level
	cmp	C.debMaxLev(c), a		# max debug level >= msg debug level ?
	jg	3f				# nothing to print, leave
	cmp	$7, C.debMaxLev(c)		# on max debug level = 7 print level 7 only
	jne	0f
	cmp	$7, a				# msg debug level = 7 ?
	jne	3f
# prepare output string of msg
0:	mov	argc(bp), c			# no. of values
0:	mov	form(bp,c,4), a			# copy values and format
	push	a
	dec	c
	jns	0b
	push	$D.msgL				# msg buffer len
	mov	deP(bp), b			# -->Debug instance
	lea	D.msg(b), a			# -->msg buffer
	push	a
	call	snprintf			# construct msg in buffer
	cmp	$0, a
	jnl	0f
	ERR	"LOG snprintf"
# synchronize with other tasks
0:	pushl	D.semP
	call	sem_wait			# synchronize
	cmp	$0, a
	jz	0f
	ERR	"LOG sem_wait"
# get timestamp
0:	call	D.getTs				# time from beg of program in usecs
# print debug msg
	mov	deP(bp), b			# -->Debug instance
	lea	D.msg(b), c			# -->msg text
	push	c
	lea	D.id(b), c			# -->instance debug ID
	push	c
	push	a				# tdiff in usecs
	push	$1f
	push	stderr
	call	fprintf
	jmp	2f
1:	.ascii	"%09u %s: %s\n\0"
# flush stderr
2:	push	stderr
	call	fflush				# flush stderr
# free semaphore
	pushl	D.semP
	call	sem_post			# free semaphore
	cmp	$0, a
	jz	3f
	ERR	"LOG sem_post"
3:
	EPILOG
#-----------------------------------------------
#	G E T   T I M E S T A M P   I N   U S E C S
#-----------------------------------------------
# returns timestamp in usecs from beg of program
# returns:	int value
	PROLOC
	DL	t, timevalL			# timestamp buffer
	EPILOC
#-----------------------------------------------
	.global D.getTs
D.getTs:
	PROLOG
	push	$0
	lea	t(bp), b			# -->timeval buffer
	push	b
	call	gettimeofday
# compute time delta from program start = t-t0 in usecs
# tdiff = (1000000*ts.secs+ts.usecs)-t0
	lea	t(bp), b			# actual timestamp
	mov	secs(b), c			# t.secs
	mov	$1000000, a
	mul	c				# 1000000*t.secs
	add	usecs(b), a			# 1000000*t.secs+t.usecs
	sub	D.t0, a				# 1000000*t.secs+t.usecs-t0
	EPILOG_R
#-----------------------------------------------
#	S U B R O U T I N E S   L I S T
#-----------------------------------------------
# print subroutines names and addresses
# localize address from env ADDR= in subroutine
	PROLOC
	DL	wAddr				# wanted addr
	EPILOC
#-----------------------------------------------
	.global	 D.subr
D.subr:
	PROLOG
	movl	$0, wAddr(bp)
	pushl	$0f
	call	getenv				# get env ADDR
	lea	4(sp), sp
	jmp	1f
0:	.ascii "ADDR\0"
1:	cmp	$0, a
	jz	0f				# no addr wanted
	pushl	$16
	pushl	$0
	push	a
	call	strtol				# convert str to hex
	lea	12(sp), sp
	mov	a, wAddr(bp)			# searched addr
0:
	pushl	$0				# end of list
	SUBRLIST				# print and push list of subroutines
	cmp	$0, wAddr(bp)			# address wanted ?
	je	D.subrR
	mov	wAddr(bp), d
	mov	sp, b				# -->beg of subr list
	xor	a, a
	jmp	1f
0:	lea	8(b), b
1:	cmpl	$0, (b)				# end of list ?
	je	2f				# yes
	cmp	4(b), d				# -->subr > wanted addr ?
	jb	0b				# yes, next
	cmp	4(b), a				# -->subr > last found ?
	jnb	0b				# no, next
	mov	(b), c				# get subr name
	mov	4(b), a				# get subr addr
	jmp	0b				# next
2:	test	a, a
	jnz	1f
	push	d
	push	$0f
	push	stderr
	call	fprintf
	jmp	D.subrR
0:	.ascii	"addr %p not found in subroutines\n\0"
1:	sub	a, d
	push	d				# offset in subr
	push	c				# subroutine name
	pushl	wAddr(bp)			# wanted addr
	push	$0f
	push	stderr
	call	fprintf
	jmp	D.subrR
0:	.ascii	"searched addr %p in subroutine %s at offset %x\n\0"
D.subrR:
	EPILOG
#-----------------------------------------------
	.end