NOLIST
	ppc604
	SUPER


;	include	"powerup/misc/ppcmacros.i"
	include	"powerup/misc/ppcsymbols.i"

	bopt	uf


	xdef	memreadlinetime
memreadlinetime:
;memreadlinetime(address,lines,loop)
;memreadlinetime(gpr3,gpr4,gpr5)
	srwi	gpr4,gpr4,#2		;/4 == 4 lines each loop
.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
;	lwz	gpr0,0(gpr6)
;	lwz	gpr7,32(gpr6)
;	lwz	gpr8,64(gpr6)
;	lwz	gpr9,96(gpr6)
	addi	gpr6,gpr6,#4*32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	blr
memreadlinetime_end:

	.size	memreadlinetime,memreadlinetime_end-memreadlinetime
	.type	memreadlinetime,@function

	xdef	memreadline
memreadline:
;memreadline(address,lines,loop)
;memreadline(gpr3,gpr4,gpr5)
	srwi	gpr4,gpr4,#2		;/4 == 4 lines each loop
.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
;Only load first long word, so it doesn`t stall until the whole line is read
;doesn`t matter if it`s the last instruction because of the Retry*Size loop this
;small speed up doesn`t matter
	lwz	gpr0,0(gpr6)
	lwz	gpr7,32(gpr6)
	lwz	gpr8,64(gpr6)
	lwz	gpr9,96(gpr6)
	addi	gpr6,gpr6,#4*32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	blr
memreadline_end:

	.size	memreadline,memreadline_end-memreadline
	.type	memreadline,@function



**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memwritelinetime
memwritelinetime:
;memwritelinetime(address,lines,loop)
;memwritelinetime(gpr3,gpr4,gpr5)
;A copyback write means
;loop:
;READ LINE
;CHANGE IT
;WRITE DIRTY LINE IF NO EMPTY PLACE
;goto loop
;so we have to subtract the read burst performance
	srwi	gpr4,gpr4,#2		;/4 == 4 lines each loop
.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
;Only load first long word, so it doesn`t stall until the whole line is read
;doesn`t matter if it`s the last load instruction because of the Retry*Size loop this
;small speed up doesn`t matter if the chip is able to pass the data while the cache
;line isn`t fully loaded yet.
	lwz	gpr0,0(gpr6)
	lwz	gpr7,32(gpr6)
	lwz	gpr8,64(gpr6)
	lwz	gpr9,96(gpr6)
	addi	gpr6,gpr6,#4*32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop
	blr
memwritelinetime_end:

	.size	memwritelinetime,memwritelinetime_end-memwritelinetime
	.type	memwritelinetime,@function


	xdef	memwriteline
memwriteline:
;memwriteline(address,lines,loop)
;memwriteline(gpr3,gpr4,gpr5)
	srwi	gpr4,gpr4,#2		;/4 == 4 lines each loop
.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	stw	gpr0,0(gpr6)
	stw	gpr7,32(gpr6)
	stw	gpr8,64(gpr6)
	stw	gpr9,96(gpr6)
	addi	gpr6,gpr6,#4*32		;4 Lines
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop
	blr
memwriteline_end:

	.size	memwriteline,memwriteline_end-memwriteline
	.type	memwriteline,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************

;This routine writes long in a linear way, so
;that a possible writebuffer could combine the
;writes to a line burst which would be useful
;to access a gfxcard.
;the ppc could do this for a non guard(non synchronized)
;non cache area....gfxcard`s framebuffer
;COULD is the magic word here.


	xdef	memwritelinetime2
memwritelinetime2:
;memwritelinetime2(address,lines,loop)
;memwritelinetime2(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritelinetime2_end:

	.size	memwritelinetime2,memwritelinetime2_end-memwritelinetime2
	.type	memwritelinetime2,@function


	xdef	memwriteline2
memwriteline2:
;memwriteline2(address,lines,loop)
;memwriteline2(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	stw	gpr0,0(gpr6)
	stw	gpr7,4(gpr6)
	stw	gpr8,8(gpr6)
	stw	gpr9,12(gpr6)
	stw	gpr10,16(gpr6)
	stw	gpr31,20(gpr6)
	stw	gpr30,24(gpr6)
	stw	gpr29,28(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwriteline2_end:

	.size	memwriteline2,memwriteline2_end-memwriteline2
	.type	memwriteline2,@function



**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memwritelongtime
memwritelongtime:
;memwritelongtime(address,lines,loop)
;memwritelongtime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritelongtime_end:

	.size	memwritelongtime,memwritelongtime_end-memwritelongtime
	.type	memwritelongtime,@function


	xdef	memwritelong
memwritelong:
;memwritelong(address,lines,loop)
;memwritelong(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	stw	gpr0,0(gpr6)
	stw	gpr7,4(gpr6)
	stw	gpr8,8(gpr6)
	stw	gpr9,12(gpr6)
	stw	gpr10,16(gpr6)
	stw	gpr31,20(gpr6)
	stw	gpr30,24(gpr6)
	stw	gpr29,28(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritelong_end:

	.size	memwritelong,memwritelong_end-memwritelong
	.type	memwritelong,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memwritewordtime
memwritewordtime:
;memwritewordtime(address,lines,loop)
;memwritewordtime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritewordtime_end:

	.size	memwritewordtime,memwritewordtime_end-memwritewordtime
	.type	memwritewordtime,@function


	xdef	memwriteword
memwriteword:
;memwriteword(address,lines,loop)
;memwriteword(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	sth	gpr0,0(gpr6)
	sth	gpr7,2(gpr6)
	sth	gpr8,4(gpr6)
	sth	gpr9,6(gpr6)
	sth	gpr10,8(gpr6)
	sth	gpr31,10(gpr6)
	sth	gpr30,12(gpr6)
	sth	gpr29,14(gpr6)
	sth	gpr0,16+0(gpr6)
	sth	gpr7,16+2(gpr6)
	sth	gpr8,16+4(gpr6)
	sth	gpr9,16+6(gpr6)
	sth	gpr10,16+8(gpr6)
	sth	gpr31,16+10(gpr6)
	sth	gpr30,16+12(gpr6)
	sth	gpr29,16+14(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwriteword_end:

	.size	memwriteword,memwriteword_end-memwriteword
	.type	memwriteword,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memwritebytetime
memwritebytetime:
;memwritebytetime(address,lines,loop)
;memwritebytetime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritebytetime_end:

	.size	memwritebytetime,memwritebytetime_end-memwritebytetime
	.type	memwritebytetime,@function


	xdef	memwritebyte
memwritebyte:
;memwritebyte(address,lines,loop)
;memwritebyte(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	stb	gpr0,0(gpr6)
	stb	gpr7,1(gpr6)
	stb	gpr8,2(gpr6)
	stb	gpr9,3(gpr6)
	stb	gpr10,4(gpr6)
	stb	gpr31,5(gpr6)
	stb	gpr30,6(gpr6)
	stb	gpr29,7(gpr6)
	stb	gpr0,8(gpr6)
	stb	gpr7,9(gpr6)
	stb	gpr8,10(gpr6)
	stb	gpr9,11(gpr6)
	stb	gpr10,12(gpr6)
	stb	gpr31,13(gpr6)
	stb	gpr30,14(gpr6)
	stb	gpr29,15(gpr6)

	stb	gpr0,16+0(gpr6)
	stb	gpr7,16+1(gpr6)
	stb	gpr8,16+2(gpr6)
	stb	gpr9,16+3(gpr6)
	stb	gpr10,16+4(gpr6)
	stb	gpr31,16+5(gpr6)
	stb	gpr30,16+6(gpr6)
	stb	gpr29,16+7(gpr6)
	stb	gpr0,16+8(gpr6)
	stb	gpr7,16+9(gpr6)
	stb	gpr8,16+10(gpr6)
	stb	gpr9,16+11(gpr6)
	stb	gpr10,16+12(gpr6)
	stb	gpr31,16+13(gpr6)
	stb	gpr30,16+14(gpr6)
	stb	gpr29,16+15(gpr6)

	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memwritebyte_end:

	.size	memwritebyte,memwritebyte_end-memwritebyte
	.type	memwritebyte,@function




**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memreadlonglongtime
memreadlonglongtime:
;memreadlonglongtime(address,lines,loop)
;memreadlonglongtime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadlonglongtime_end:

	.size	memreadlonglongtime,memreadlonglongtime_end-memreadlonglongtime
	.type	memreadlonglongtime,@function


	xdef	memreadlonglong
memreadlonglong:
;memreadlonglong(address,lines,loop)
;memreadlonglong(gpr3,gpr4,gpr5)
;->Size     =4096
;->LoopCount=10000
;->(4096>>5) * (4*2+2) * 10000 + 10000
;->128 * 10 *10000 + 10000
;->12810000 cycles
;->200*10^6 Mhz / 12810000 = 15.613
;->10000 * 4096 * 15.613(64bit accesses) = 640MB
;with Cachemem the max bandwidth would be
;at 200Mhz with 64bit fpu transfers
;800MB(200/(2+2+2+2)*32)


	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	lfd	fpr0,0(gpr6)
	lfd	fpr3,8(gpr6)
	lfd	fpr4,16(gpr6)
	lfd	fpr5,24(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadlonglong_end:

	.size	memreadlonglong,memreadlonglong_end-memreadlonglong
	.type	memreadlonglong,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************

	xdef	memreadlongtime
memreadlongtime:
;memreadlongtime(address,lines,loop)
;memreadlongtime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadlongtime_end:

	.size	memreadlongtime,memreadlongtime_end-memreadlongtime
	.type	memreadlongtime,@function


	xdef	memreadlong
memreadlong:
;memreadlong(address,lines,loop)
;memreadlong(gpr3,gpr4,gpr5)
;->Size     =4096
;->LoopCount=10000
;->(4096>>5) * (8*2+2) * 10000 + 10000
;->128 * 18 *10000 + 10000
;->2305000 cycles
;->200*10^6 / 2305000 = 8.68
;->10000 * 4096 * 8.68(32bit accesses) = 355MB
;with Cachemem the max bandwidth would be
;at 200Mhz with 64bit fpu transfers
;400MB(200/(2+2+2+2+2+2+2+2)*32)


	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	lwz	gpr0,0(gpr6)
	lwz	gpr7,4(gpr6)
	lwz	gpr8,8(gpr6)
	lwz	gpr9,12(gpr6)
	lwz	gpr10,16(gpr6)
	lwz	gpr31,20(gpr6)
	lwz	gpr30,24(gpr6)
	lwz	gpr29,28(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadlong_end:

	.size	memreadlong,memreadlong_end-memreadlong
	.type	memreadlong,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memreadwordtime
memreadwordtime:
;memreadwordtime(address,lines,loop)
;memreadwordtime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadwordtime_end:

	.size	memreadwordtime,memreadwordtime_end-memreadwordtime
	.type	memreadwordtime,@function


	xdef	memreadword
memreadword:
;memreadword(address,lines,loop)
;memreadword(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	lhz	gpr0,0(gpr6)
	lhz	gpr7,2(gpr6)
	lhz	gpr8,4(gpr6)
	lhz	gpr9,6(gpr6)
	lhz	gpr10,8(gpr6)
	lhz	gpr31,10(gpr6)
	lhz	gpr30,12(gpr6)
	lhz	gpr29,14(gpr6)
	lhz	gpr0,16+0(gpr6)
	lhz	gpr7,16+2(gpr6)
	lhz	gpr8,16+4(gpr6)
	lhz	gpr9,16+6(gpr6)
	lhz	gpr10,16+8(gpr6)
	lhz	gpr31,16+10(gpr6)
	lhz	gpr30,16+12(gpr6)
	lhz	gpr29,16+14(gpr6)
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadword_end:

	.size	memreadword,memreadword_end-memreadword
	.type	memreadword,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************


	xdef	memreadbytetime
memreadbytetime:
;memreadbytetime(address,lines,loop)
;memreadbytetime(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	ori	0,0,0
	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadbytetime_end:

	.size	memreadbytetime,memreadbytetime_end-memreadbytetime
	.type	memreadbytetime,@function


	xdef	memreadbyte
memreadbyte:
;memreadbyte(address,lines,loop)
;memreadbyte(gpr3,gpr4,gpr5)
	stwu	1,-16(1)
	stw	31,12(1)
	stw	30,8(1)
	stw	29,4(1)

.retryloop:
	mr	gpr6,gpr3		;reload buffer address
	mtctr	gpr4			;load datamove counter
.loop:
	lbz	gpr0,0(gpr6)
	lbz	gpr7,1(gpr6)
	lbz	gpr8,2(gpr6)
	lbz	gpr9,3(gpr6)
	lbz	gpr10,4(gpr6)
	lbz	gpr31,5(gpr6)
	lbz	gpr30,6(gpr6)
	lbz	gpr29,7(gpr6)
	lbz	gpr0,8(gpr6)
	lbz	gpr7,9(gpr6)
	lbz	gpr8,10(gpr6)
	lbz	gpr9,11(gpr6)
	lbz	gpr10,12(gpr6)
	lbz	gpr31,13(gpr6)
	lbz	gpr30,14(gpr6)
	lbz	gpr29,15(gpr6)

	lbz	gpr0,16+0(gpr6)
	lbz	gpr7,16+1(gpr6)
	lbz	gpr8,16+2(gpr6)
	lbz	gpr9,16+3(gpr6)
	lbz	gpr10,16+4(gpr6)
	lbz	gpr31,16+5(gpr6)
	lbz	gpr30,16+6(gpr6)
	lbz	gpr29,16+7(gpr6)
	lbz	gpr0,16+8(gpr6)
	lbz	gpr7,16+9(gpr6)
	lbz	gpr8,16+10(gpr6)
	lbz	gpr9,16+11(gpr6)
	lbz	gpr10,16+12(gpr6)
	lbz	gpr31,16+13(gpr6)
	lbz	gpr30,16+14(gpr6)
	lbz	gpr29,16+15(gpr6)

	addi	gpr6,gpr6,#32
	bdnz	.loop
	addic.	gpr5,gpr5,#-1
	bne	.retryloop

	lwz	29,4(1)
	lwz	30,8(1)
	lwz	31,12(1)
	addi	1,1,16
	blr
memreadbyte_end:

	.size	memreadbyte,memreadbyte_end-memreadbyte
	.type	memreadbyte,@function


**********************************************************************
**********************************************************************
**********************************************************************
**********************************************************************