balib.s

vxworks source code, used for develop vxworks system.

	tst	#0x1,r0		/*     are we on a word boundary? */
	bt	cBakLongWord
	add	#-1,r4		/*     one-byte copy, force word alignment */
	mov.b	@r4,r1;
	add	#-1,r6
	mov.b	r1,@-r5
cBakLongWord:
	mov	r5,r0
	tst	#0x3,r0		/*     are we on a long boundary? */
	bt	cBakLongAligned
	add	#-2,r4		/*     one-word copy, force long alignment */
	mov.w	@r4,r1;
	add	#-2,r6
	mov.w	r1,@-r5
cBakLongAligned:
	mova	cBakLongCopy,r0
	mov	r0,r3
	bra	cLong;
	mov	r6,r0		/* r0: nbytes */

	/* Word copy setup */

cFwdWord:			
	mov	r5,r0
	tst	#0x1,r0		/*     are we on a odd boundary? */
	bt	cFwdWordAligned
	mov.b	@r4+,r1;	/*     one-byte copy, force word alignment */
	add	#-1,r6
	mov.b	r1,@r5
	add	#1,r5
cFwdWordAligned:		/*     here we are on a word boundary */
	mova	cFwdWordCopy,r0
	mov	r0,r3
	mov	r6,r0		/* r0: nbytes */
cWord:
	and	#0x1e,r0	/* if r0 = 2 */
	neg	r0,r2		/* r2: -2 */
	shll	r0		/* r0:  4 */
	sub	r0,r2		/* r2: -6 */
	add	r3,r2
	mov	r6,r0		/* r0: nbytes */
#if (CPU==SH7000 || CPU==SH7600)
	shlr2	r6
	shlr2	r6
	shlr	r6
#else
	mov	#-5,r1
	shld	r1,r6
#endif
	jmp	@r2;
	add	#1,r6		/* r6: nbytes/32 + 1 */

cBakWord:
	mov	r5,r0
	tst	#0x1,r0		/*     are we on a odd boundary? */
	bt	cBakWordAligned
	add	#-1,r4		/*     one-byte copy, force word alignment */
	mov.b	@r4,r1;
	add	#-1,r6
	mov.b	r1,@-r5
cBakWordAligned:		/*     here we are on a word boundary */
	mova	cBakWordCopy,r0
	mov	r0,r3
	bra	cWord;
	mov	r6,r0		/* r0: nbytes */

	/* Byte copy setup */

cFwdByte:
	mova	cFwdByteCopy,r0
	mov	r0,r3
	mov	r6,r0		/* r0: nbytes */
cByte:
	and	#0xf,r0		/* if r0 = 1 */
	shll	r0		/* r0:  2 */
	neg	r0,r2		/* r2: -2 */
	shll	r0		/* r0:  4 */
	sub	r0,r2		/* r2: -6 */
	add	r3,r2
#if (CPU==SH7000 || CPU==SH7600)
	shlr2	r6
	shlr2	r6
#else
	mov	#-4,r1
	shld	r1,r6
#endif
	jmp	@r2;
	add	#1,r6		/* r6: nbytes/16 + 1 */

cBakByte:
	mova	cBakByteCopy,r0
	mov	r0,r3
	bra	cByte;
	mov	r6,r0		/* r0: nbytes */

	/* Forward copy section */

	.align	_ALIGN_TEXT
cFwdLongLoop:
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
	mov.l   @r4+,r1;    mov.l   r1,@r5;    add   #4,r5
cFwdLongCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cFwdLongLoop
	tst	#0x2,r0		/*     nbytes % 4 ? */
	bt	cFwdLongLastByte
	mov.w	@r4+,r1;
	mov.w	r1,@r5
	add	#2,r5
cFwdLongLastByte:
	tst	#0x1,r0		/*     nbytes % 2 ? */
cFwdLastByte:
	bt	cFwdDone
	mov.b	@r4+,r1;
	rts;
	mov.b	r1,@r5

	.align	_ALIGN_TEXT
cFwdWordLoop:
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
	mov.w   @r4+,r1;    mov.w   r1,@r5;    add     #2,r5
cFwdWordCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cFwdWordLoop
	bra	cFwdLastByte;
	tst	#0x1,r0		/*     nbytes % 2 ? */

	.align	_ALIGN_TEXT
cFwdByteLoop:
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
	mov.b   @r4+,r1;    mov.b   r1,@r5;    add     #1,r5
cFwdByteCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cFwdByteLoop
cFwdDone:
	rts;
	nop

	/* Backward copy section */

	.align	_ALIGN_TEXT
cBakLongLoop:
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
	add	#-4,r4;    mov.l   @r4,r1;    mov.l   r1,@-r5
cBakLongCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cBakLongLoop
	tst	#0x2,r0		/*     nbytes % 4 ? */
	bt	cBakLongLastByte
	add	#-2,r4
	mov.w	@r4,r1;
	mov.w	r1,@-r5
cBakLongLastByte:
	tst	#0x1,r0		/*     nbytes % 2 ? */
cBakLastByte:
	bt	cBakDone
	add	#-1,r4
	mov.b	@r4,r1;
	rts;
	mov.b	r1,@-r5

	.align	_ALIGN_TEXT
cBakWordLoop:
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
	add     #-2,r4;    mov.w   @r4,r1;    mov.w   r1,@-r5
cBakWordCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cBakWordLoop
	bra	cBakLastByte;
	tst	#0x1,r0		/*     nbytes % 2 ? */

	.align	_ALIGN_TEXT
cBakByteLoop:
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
	add     #-1,r4;    mov.b   @r4,r1;    mov.b   r1,@-r5
cBakByteCopy:
#if (CPU==SH7000)
	add	#-1,r6
	tst	r6,r6
#else
	dt	r6
#endif
	bf	cBakByteLoop
cBakDone:
	rts;
	nop

/*******************************************************************************
*
* bfill - fill buffer with character
*
* This routine fills the first `nbytes' characters of the specified buffer
* with the specified character.
* The fill is optimized by filling 4 bytes at a time if possible,
* (see bfillBytes (2) for filling a byte at a time only).
*
* SEE ALSO: bfillBytes (2)
*
* NOMANUAL - manual entry in bLib (1)

* void bfill
*     (
*     char *buf,		/@ pointer to buffer              @/
*     int   nbytes,		/@ number of bytes to fill        @/
*     int   ch			/@ char with which to fill buffer @/
*     )

* NOTE:	This routine is USED at boot time.
*
*
*   [usec]|
*      25 |    o: bfill (16-longs loop)                                     x
*      24 |    v: bfill ( 1-longs loop)                                  x
*      23 |    x: bfillBytes                                          x  x
*      22 |                                                        x  x
*      21 |                                                        x
*      20 |    DVE-SH7032  timexN                               x
*      19 |    benchmarks                                    x
*      18 |                                               x
*      17 |                 :                          x
*      16 |                 :                       x                       v
*      15 |                 :                    x              v        v
*      14 |                 :                 x  x  v        v        v
*      13 |                 :           v  x  x  v        v        v        v
*      12 |                 :           v  x           v        v  v
*      11 |                 :        v  x     v        v        v       vo  o
*      10 |                 :     v  x     v       vo  o  o vo  o  o vo  o  o
*	9 |                 :  vo xo o vo  o  o vo  o  o  v
*	8 |                 :  xo o  o  o     v
*	7 |              o vxo           
*	6 |             vxo :            
*	5 |          vxo    :            
*	4 |        vo       :            
*	3 |     vo x        :            
*	2 |  vo x           :            
*	1 vo x              :            
*	  x--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
*         0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22
*                                                                     [nbytes]
*/
	.align	_ALIGN_TEXT
	.type	_bfill,@function

				/* r4: buf    */
				/* r5: nbytes */
_bfill:				/* r6: ch     */
	mov	#6,r0
	cmp/gt	r0,r5
	bf	_bfillBytes	/* if (nbytes <= 6), do byte fill */

	cmp/pl	r5
	bf	fbDone		/* if (nbytes <= 0), then we are done */

	mov	r4,r0
	add	r5,r0		/* r0: buf + nbytes */
	tst	#0x1,r0		/*     are we on an word boundary?        */
	bt	fbWord
	mov.b	r6,@-r0		/*     fill one-byte, force word boundary */
	add	#-1,r5
fbWord:				/*    byte3  byte2  byte1  byte0 */
	extu.b	r6,r6		/* r6: 0x00 | 0x00 | 0x00 | (ch) */
	swap.b	r6,r1		/* r1: 0x00 | 0x00 | (ch) | 0x00 */
	or	r1,r6		/* r6: 0x00 | 0x00 | (ch) | (ch) */

	tst	#0x3,r0		/*     are we on an long boundary?        */
	bt	fbLong
	mov.w	r6,@-r0		/*     fill one-word, force long boundary */
	add	#-2,r5
fbLong:				/*    byte3  byte2  byte1  byte0 */
	swap.w	r6,r1		/* r1: (ch) | (ch) | 0x00 | 0x00 */
	or	r1,r6		/* r6: (ch) | (ch) | (ch) | (ch) */

	mov	r0,r7		/* r7: (end of buffer) + 1 */
	mov	r5,r0		/* r0: nbytes */
	and	#0x3c,r0	/* if (r0 == 4) */
	neg	r0,r2		/* r2: -4 */
	shar	r2		/* r2: -2 */
	mova	fbStart,r0
	add	r0,r2
	mov	r5,r0		/* r0: nbytes */
#if (CPU==SH7000 || CPU==SH7600)
	shlr2	r5
	shlr2	r5
	shlr2	r5
#else
	mov	#-6,r1
	shld	r1,r5
#endif
	jmp	@r2;
	add	#1,r5		/* r5: nbytes/64 + 1 */

	.align	_ALIGN_TEXT
fbLoop:
	mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7
	mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7
	mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7
	mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7;  mov.l r6,@-r7
fbStart:
#if (CPU==SH7000)
	add	#-1,r5
	tst	r5,r5
#else
	dt	r5
#endif
	bf	fbLoop
	tst	#0x2,r0		/*     nbytes % 4 ? */
	bt	fbLastByte
	mov.w	r6,@-r7
fbLastByte:
	tst	#0x1,r0		/*     nbytes % 2 ? */
	bt	fbDone
	mov.b	r6,@-r7
fbDone:
	rts;
	nop

#if		FALSE
_bfill:		mov	#6,r0		/*** THIS BFILL IS SMALL, BUT SLOW. ***/
		cmp/gt	r0,r5
		bf	_bfillBytes	/* if (6 >= nbytes), do byte fill */
		cmp/pl	r5
		bf	fbDone		/* if (nbytes <= 0), then we are done */
		mov	r4,r0
		bra	fbTailChk;
		add	r5,r0		/* r0: buf + nbytes */
fbTailLoop:	mov.b	r6,@-r0
fbTailChk:	tst	#3,r0
		bf	fbTailLoop
		mov	r0,r7		/* r7: end of buffer */
		bra	fbHeadChk;
		mov	r4,r0
fbHeadLoop:	mov.b	r6,@r0
		add	#1,r0
fbHeadChk:	tst	#3,r0		/* r0: start of buffer */
		bf	fbHeadLoop	/*    byte3  byte2  byte1  byte0 */
fbBody:		extu.b	r6,r6		/* r6: 0x00 | 0x00 | 0x00 | (ch) */
		swap.b	r6,r1		/* r1: 0x00 | 0x00 | (ch) | 0x00 */
		or	r1,r6		/* r6: 0x00 | 0x00 | (ch) | (ch) */
		swap.w	r6,r1		/* r1: (ch) | (ch) | 0x00 | 0x00 */
		bra	fbBodyChk;
		or	r1,r6		/* r6: (ch) | (ch) | (ch) | (ch) */
fbBodyLoop:	mov.l	r6,@-r7
fbBodyChk:	cmp/hi	r0,r7
		bt	fbBodyLoop
fbDone:		rts;
		nop
#endif		/* FALSE */

/*******************************************************************************
*
* bfillBytes - fill buffer with character a byte at a time
*
* This routine fills the first `nbytes' characters of the
* specified buffer with the specified character.
* It is identical to bfill (2) except that the fill is always performed
* a byte at a time.  This may be desirable if the buffer
* can only be accessed with byte instructions, as in certain byte-wide
* memory-mapped peripherals.
*
* SEE ALSO: bfill (2)
*
* NOMANUAL - manual entry in bLib (1)

* void bfillBytes
*     (
*     char *buf,	/@ pointer to buffer              @/
*     int   nbytes,	/@ number of bytes to fill        @/
*     int   ch		/@ char with which to fill buffer @/
*     )

* NOTE:  This routine is not used at boot time.  Be careful!
*/
	.align	_ALIGN_TEXT
	.type	_bfillBytes,@function

				/* r4: buf    */
_bfillBytes:			/* r5: nbytes */
	cmp/pl	r5
	bf	fby2
#if (CPU==SH7000)
	add	r4,r5		/* r5: buf + nbytes */
fby1:	mov.b	r6,@-r5		/* r6: ch           */
	cmp/hi	r4,r5
	bt	fby1
#else
	mov	r5,r0
fby1:	dt	r0
	bf.s	fby1
	mov.b	r6,@(r0,r4)
#endif
fby2:	rts;
	nop

#endif	/* !PORTABLE */