arch/sparc/lib/M7memset.S - linux-mtk - Git at Google

 /*
  * M7memset.S: SPARC M7 optimized memset.
  *
  * Copyright (c) 2016, Oracle and/or its affiliates.  All rights reserved.
  */

 /*
  * M7memset.S: M7 optimized memset.
  *
  * char *memset(sp, c, n)
  *
  * Set an array of n chars starting at sp to the character c.
  * Return sp.
  *
  * Fast assembler language version of the following C-program for memset
  * which represents the `standard' for the C-library.
  *
  *	void *
  *	memset(void *sp1, int c, size_t n)
  *	{
  *	    if (n != 0) {
  *		char *sp = sp1;
  *		do {
  *		    *sp++ = (char)c;
  *		} while (--n != 0);
  *	    }
  *	    return (sp1);
  *	}
  *
  * The algorithm is as follows :
  *
  *	For small 6 or fewer bytes stores, bytes will be stored.
  *
  *	For less than 32 bytes stores, align the address on 4 byte boundary.
  *	Then store as many 4-byte chunks, followed by trailing bytes.
  *
  *	For sizes greater than 32 bytes, align the address on 8 byte boundary.
  *	if (count >= 64) {
  *      	store 8-bytes chunks to align the address on 64 byte boundary
  *		if (value to be set is zero && count >= MIN_ZERO) {
  *              	Using BIS stores, set the first long word of each
  *			64-byte cache line to zero which will also clear the
  *			other seven long words of the cache line.
  *       	}
  *       	else if (count >= MIN_LOOP) {
  *       		Using BIS stores, set the first long word of each of
  *              	ST_CHUNK cache lines (64 bytes each) before the main
  *			loop is entered.
  *              	In the main loop, continue pre-setting the first long
  *              	word of each cache line ST_CHUNK lines in advance while
  *              	setting the other seven long words (56 bytes) of each
  * 			cache line until fewer than ST_CHUNK*64 bytes remain.
  *			Then set the remaining seven long words of each cache
  * 			line that has already had its first long word set.
  *       	}
  *       	store remaining data in 64-byte chunks until less than
  *       	64 bytes remain.
  *       }
  *       Store as many 8-byte chunks, followed by trailing bytes.
  *
  * BIS = Block Init Store
  *   Doing the advance store of the first element of the cache line
  *   initiates the displacement of a cache line while only using a single
  *   instruction in the pipeline. That avoids various pipeline delays,
  *   such as filling the miss buffer. The performance effect is
  *   similar to prefetching for normal stores.
  *   The special case for zero fills runs faster and uses fewer instruction
  *   cycles than the normal memset loop.
  *
  * We only use BIS for memset of greater than MIN_LOOP bytes because a sequence
  * BIS stores must be followed by a membar #StoreStore. The benefit of
  * the BIS store must be balanced against the cost of the membar operation.
  */

 /*
  * ASI_STBI_P marks the cache line as "least recently used"
  * which means if many threads are active, it has a high chance
  * of being pushed out of the cache between the first initializing
  * store and the final stores.
  * Thus, we use ASI_STBIMRU_P which marks the cache line as
  * "most recently used" for all but the last store to the cache line.
  */

 #include <asm/asi.h>
 #include <asm/page.h>

 #define ASI_STBI_P      ASI_BLK_INIT_QUAD_LDD_P
 #define ASI_STBIMRU_P   ASI_ST_BLKINIT_MRU_P


 #define ST_CHUNK        24   /* multiple of 4 due to loop unrolling */
 #define MIN_LOOP        16320
 #define MIN_ZERO        512

 	.section	".text"
 	.align		32

 /*
  * Define clear_page(dest) as memset(dest, 0, PAGE_SIZE)
  * (can create a more optimized version later.)
  */
 	.globl		M7clear_page
 	.globl		M7clear_user_page
 M7clear_page:		/* clear_page(dest) */
 M7clear_user_page:
 	set	PAGE_SIZE, %o1
 	/* fall through into bzero code */

 	.size		M7clear_page,.-M7clear_page
 	.size		M7clear_user_page,.-M7clear_user_page

 /*
  * Define bzero(dest, n) as memset(dest, 0, n)
  * (can create a more optimized version later.)
  */
 	.globl		M7bzero
 M7bzero:		/* bzero(dest, size) */
 	mov	%o1, %o2
 	mov	0, %o1
 	/* fall through into memset code */

 	.size		M7bzero,.-M7bzero

 	.global		M7memset
 	.type		M7memset, #function
 	.register	%g3, #scratch
 M7memset:
 	mov     %o0, %o5                ! copy sp1 before using it
 	cmp     %o2, 7                  ! if small counts, just write bytes
 	bleu,pn %xcc, .wrchar
 	 and     %o1, 0xff, %o1          ! o1 is (char)c

 	sll     %o1, 8, %o3
 	or      %o1, %o3, %o1           ! now o1 has 2 bytes of c
 	sll     %o1, 16, %o3
 	cmp     %o2, 32
 	blu,pn  %xcc, .wdalign
 	 or      %o1, %o3, %o1           ! now o1 has 4 bytes of c

 	sllx    %o1, 32, %o3
 	or      %o1, %o3, %o1           ! now o1 has 8 bytes of c

 .dbalign:
 	andcc   %o5, 7, %o3             ! is sp1 aligned on a 8 byte bound?
 	bz,pt   %xcc, .blkalign         ! already long word aligned
 	 sub     %o3, 8, %o3             ! -(bytes till long word aligned)

 	add     %o2, %o3, %o2           ! update o2 with new count
 	! Set -(%o3) bytes till sp1 long word aligned
 1:	stb     %o1, [%o5]              ! there is at least 1 byte to set
 	inccc   %o3                     ! byte clearing loop
 	bl,pt   %xcc, 1b
 	 inc     %o5

 	! Now sp1 is long word aligned (sp1 is found in %o5)
 .blkalign:
 	cmp     %o2, 64                 ! check if there are 64 bytes to set
 	blu,pn  %xcc, .wrshort
 	 mov     %o2, %o3

 	andcc   %o5, 63, %o3            ! is sp1 block aligned?
 	bz,pt   %xcc, .blkwr            ! now block aligned
 	 sub     %o3, 64, %o3            ! o3 is -(bytes till block aligned)
 	add     %o2, %o3, %o2           ! o2 is the remainder

 	! Store -(%o3) bytes till dst is block (64 byte) aligned.
 	! Use long word stores.
 	! Recall that dst is already long word aligned
 1:
 	addcc   %o3, 8, %o3
 	stx     %o1, [%o5]
 	bl,pt   %xcc, 1b
 	 add     %o5, 8, %o5

 	! Now sp1 is block aligned
 .blkwr:
 	andn    %o2, 63, %o4            ! calculate size of blocks in bytes
 	brz,pn  %o1, .wrzero            ! special case if c == 0
 	 and     %o2, 63, %o3            ! %o3 = bytes left after blk stores.

 	set     MIN_LOOP, %g1
 	cmp     %o4, %g1                ! check there are enough bytes to set
 	blu,pn  %xcc, .short_set        ! to justify cost of membar
 	                                ! must be > pre-cleared lines
 	 nop

 	! initial cache-clearing stores
 	! get store pipeline moving
 	rd	%asi, %g3		! save %asi to be restored later
 	wr     %g0, ASI_STBIMRU_P, %asi

 	! Primary memset loop for large memsets
 .wr_loop:
 	sub     %o5, 8, %o5		! adjust %o5 for ASI store alignment
 	mov     ST_CHUNK, %g1
 .wr_loop_start:
 	stxa    %o1, [%o5+8]%asi
 	subcc   %g1, 4, %g1
 	stxa    %o1, [%o5+8+64]%asi
 	add     %o5, 256, %o5
 	stxa    %o1, [%o5+8-128]%asi
 	bgu     %xcc, .wr_loop_start
 	 stxa    %o1, [%o5+8-64]%asi

 	sub     %o5, ST_CHUNK*64, %o5	! reset %o5
 	mov     ST_CHUNK, %g1

 .wr_loop_rest:
 	stxa    %o1, [%o5+8+8]%asi
 	sub     %o4, 64, %o4
 	stxa    %o1, [%o5+16+8]%asi
 	subcc   %g1, 1, %g1
 	stxa    %o1, [%o5+24+8]%asi
 	stxa    %o1, [%o5+32+8]%asi
 	stxa    %o1, [%o5+40+8]%asi
 	add     %o5, 64, %o5
 	stxa    %o1, [%o5-8]%asi
 	bgu     %xcc, .wr_loop_rest
 	 stxa    %o1, [%o5]ASI_STBI_P

 	! If more than ST_CHUNK*64 bytes remain to set, continue
 	! setting the first long word of each cache line in advance
 	! to keep the store pipeline moving.

 	cmp     %o4, ST_CHUNK*64
 	bge,pt  %xcc, .wr_loop_start
 	 mov     ST_CHUNK, %g1

 	brz,a,pn %o4, .asi_done
 	 add     %o5, 8, %o5             ! restore %o5 offset

 .wr_loop_small:
 	stxa    %o1, [%o5+8]%asi
 	stxa    %o1, [%o5+8+8]%asi
 	stxa    %o1, [%o5+16+8]%asi
 	stxa    %o1, [%o5+24+8]%asi
 	stxa    %o1, [%o5+32+8]%asi
 	subcc   %o4, 64, %o4
 	stxa    %o1, [%o5+40+8]%asi
 	add     %o5, 64, %o5
 	stxa    %o1, [%o5-8]%asi
 	bgu,pt  %xcc, .wr_loop_small
 	 stxa    %o1, [%o5]ASI_STBI_P

 	ba      .asi_done
 	 add     %o5, 8, %o5             ! restore %o5 offset

 	! Special case loop for zero fill memsets
 	! For each 64 byte cache line, single STBI to first element
 	! clears line
 .wrzero:
 	cmp     %o4, MIN_ZERO           ! check if enough bytes to set
 					! to pay %asi + membar cost
 	blu     %xcc, .short_set
 	 nop
 	sub     %o4, 256, %o4

 .wrzero_loop:
 	mov     64, %g3
 	stxa    %o1, [%o5]ASI_STBI_P
 	subcc   %o4, 256, %o4
 	stxa    %o1, [%o5+%g3]ASI_STBI_P
 	add     %o5, 256, %o5
 	sub     %g3, 192, %g3
 	stxa    %o1, [%o5+%g3]ASI_STBI_P
 	add %g3, 64, %g3
 	bge,pt  %xcc, .wrzero_loop
 	 stxa    %o1, [%o5+%g3]ASI_STBI_P
 	add     %o4, 256, %o4

 	brz,pn  %o4, .bsi_done
 	 nop

 .wrzero_small:
 	stxa    %o1, [%o5]ASI_STBI_P
 	subcc   %o4, 64, %o4
 	bgu,pt  %xcc, .wrzero_small
 	 add     %o5, 64, %o5
 	ba,a	.bsi_done

 .asi_done:
 	wr	%g3, 0x0, %asi		! restored saved %asi
 .bsi_done:
 	membar  #StoreStore             ! required by use of Block Store Init

 .short_set:
 	cmp     %o4, 64                 ! check if 64 bytes to set
 	blu     %xcc, 5f
 	 nop
 4:                                      ! set final blocks of 64 bytes
 	stx     %o1, [%o5]
 	stx     %o1, [%o5+8]
 	stx     %o1, [%o5+16]
 	stx     %o1, [%o5+24]
 	subcc   %o4, 64, %o4
 	stx     %o1, [%o5+32]
 	stx     %o1, [%o5+40]
 	add     %o5, 64, %o5
 	stx     %o1, [%o5-16]
 	bgu,pt  %xcc, 4b
 	 stx     %o1, [%o5-8]

 5:
 	! Set the remaining long words
 .wrshort:
 	subcc   %o3, 8, %o3             ! Can we store any long words?
 	blu,pn  %xcc, .wrchars
 	 and     %o2, 7, %o2             ! calc bytes left after long words
 6:
 	subcc   %o3, 8, %o3
 	stx     %o1, [%o5]              ! store the long words
 	bgeu,pt %xcc, 6b
 	 add     %o5, 8, %o5

 .wrchars:                               ! check for extra chars
 	brnz    %o2, .wrfin
 	 nop
 	retl
 	 nop

 .wdalign:
 	andcc   %o5, 3, %o3             ! is sp1 aligned on a word boundary
 	bz,pn   %xcc, .wrword
 	 andn    %o2, 3, %o3             ! create word sized count in %o3

 	dec     %o2                     ! decrement count
 	stb     %o1, [%o5]              ! clear a byte
 	b       .wdalign
 	 inc     %o5                     ! next byte

 .wrword:
 	subcc   %o3, 4, %o3
 	st      %o1, [%o5]              ! 4-byte writing loop
 	bnz,pt  %xcc, .wrword
 	 add     %o5, 4, %o5

 	and     %o2, 3, %o2             ! leftover count, if any

 .wrchar:
 	! Set the remaining bytes, if any
 	brz     %o2, .exit
 	 nop
 .wrfin:
 	deccc   %o2
 	stb     %o1, [%o5]
 	bgu,pt  %xcc, .wrfin
 	 inc     %o5
 .exit:
 	retl                            ! %o0 was preserved
 	 nop

 	.size		M7memset,.-M7memset
	/*
	* M7memset.S: SPARC M7 optimized memset.
	*
	* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
	*/

	/*
	* M7memset.S: M7 optimized memset.
	*
	* char *memset(sp, c, n)
	*
	* Set an array of n chars starting at sp to the character c.
	* Return sp.
	*
	* Fast assembler language version of the following C-program for memset
	* which represents the `standard' for the C-library.
	*
	* void *
	* memset(void *sp1, int c, size_t n)
	* {
	* if (n != 0) {
	* char *sp = sp1;
	* do {
	* *sp++ = (char)c;
	* } while (--n != 0);
	* }
	* return (sp1);
	* }
	*
	* The algorithm is as follows :
	*
	* For small 6 or fewer bytes stores, bytes will be stored.
	*
	* For less than 32 bytes stores, align the address on 4 byte boundary.
	* Then store as many 4-byte chunks, followed by trailing bytes.
	*
	* For sizes greater than 32 bytes, align the address on 8 byte boundary.
	* if (count >= 64) {
	* store 8-bytes chunks to align the address on 64 byte boundary
	* if (value to be set is zero && count >= MIN_ZERO) {
	* Using BIS stores, set the first long word of each
	* 64-byte cache line to zero which will also clear the
	* other seven long words of the cache line.
	* }
	* else if (count >= MIN_LOOP) {
	* Using BIS stores, set the first long word of each of
	* ST_CHUNK cache lines (64 bytes each) before the main
	* loop is entered.
	* In the main loop, continue pre-setting the first long
	* word of each cache line ST_CHUNK lines in advance while
	* setting the other seven long words (56 bytes) of each
	* cache line until fewer than ST_CHUNK*64 bytes remain.
	* Then set the remaining seven long words of each cache
	* line that has already had its first long word set.
	* }
	* store remaining data in 64-byte chunks until less than
	* 64 bytes remain.
	* }
	* Store as many 8-byte chunks, followed by trailing bytes.
	*
	* BIS = Block Init Store
	* Doing the advance store of the first element of the cache line
	* initiates the displacement of a cache line while only using a single
	* instruction in the pipeline. That avoids various pipeline delays,
	* such as filling the miss buffer. The performance effect is
	* similar to prefetching for normal stores.
	* The special case for zero fills runs faster and uses fewer instruction
	* cycles than the normal memset loop.
	*
	* We only use BIS for memset of greater than MIN_LOOP bytes because a sequence
	* BIS stores must be followed by a membar #StoreStore. The benefit of
	* the BIS store must be balanced against the cost of the membar operation.
	*/

	/*
	* ASI_STBI_P marks the cache line as "least recently used"
	* which means if many threads are active, it has a high chance
	* of being pushed out of the cache between the first initializing
	* store and the final stores.
	* Thus, we use ASI_STBIMRU_P which marks the cache line as
	* "most recently used" for all but the last store to the cache line.
	*/

	#include <asm/asi.h>
	#include <asm/page.h>

	#define ASI_STBI_P ASI_BLK_INIT_QUAD_LDD_P
	#define ASI_STBIMRU_P ASI_ST_BLKINIT_MRU_P


	#define ST_CHUNK 24 /* multiple of 4 due to loop unrolling */
	#define MIN_LOOP 16320
	#define MIN_ZERO 512

	.section ".text"
	.align 32

	/*
	* Define clear_page(dest) as memset(dest, 0, PAGE_SIZE)
	* (can create a more optimized version later.)
	*/
	.globl M7clear_page
	.globl M7clear_user_page
	M7clear_page: /* clear_page(dest) */
	M7clear_user_page:
	set PAGE_SIZE, %o1
	/* fall through into bzero code */

	.size M7clear_page,.-M7clear_page
	.size M7clear_user_page,.-M7clear_user_page

	/*
	* Define bzero(dest, n) as memset(dest, 0, n)
	* (can create a more optimized version later.)
	*/
	.globl M7bzero
	M7bzero: /* bzero(dest, size) */
	mov %o1, %o2
	mov 0, %o1
	/* fall through into memset code */

	.size M7bzero,.-M7bzero

	.global M7memset
	.type M7memset, #function
	.register %g3, #scratch
	M7memset:
	mov %o0, %o5 ! copy sp1 before using it
	cmp %o2, 7 ! if small counts, just write bytes
	bleu,pn %xcc, .wrchar
	and %o1, 0xff, %o1 ! o1 is (char)c

	sll %o1, 8, %o3
	or %o1, %o3, %o1 ! now o1 has 2 bytes of c
	sll %o1, 16, %o3
	cmp %o2, 32
	blu,pn %xcc, .wdalign
	or %o1, %o3, %o1 ! now o1 has 4 bytes of c

	sllx %o1, 32, %o3
	or %o1, %o3, %o1 ! now o1 has 8 bytes of c

	.dbalign:
	andcc %o5, 7, %o3 ! is sp1 aligned on a 8 byte bound?
	bz,pt %xcc, .blkalign ! already long word aligned
	sub %o3, 8, %o3 ! -(bytes till long word aligned)

	add %o2, %o3, %o2 ! update o2 with new count
	! Set -(%o3) bytes till sp1 long word aligned
	1: stb %o1, [%o5] ! there is at least 1 byte to set
	inccc %o3 ! byte clearing loop
	bl,pt %xcc, 1b
	inc %o5

	! Now sp1 is long word aligned (sp1 is found in %o5)
	.blkalign:
	cmp %o2, 64 ! check if there are 64 bytes to set
	blu,pn %xcc, .wrshort
	mov %o2, %o3

	andcc %o5, 63, %o3 ! is sp1 block aligned?
	bz,pt %xcc, .blkwr ! now block aligned
	sub %o3, 64, %o3 ! o3 is -(bytes till block aligned)
	add %o2, %o3, %o2 ! o2 is the remainder

	! Store -(%o3) bytes till dst is block (64 byte) aligned.
	! Use long word stores.
	! Recall that dst is already long word aligned
	1:
	addcc %o3, 8, %o3
	stx %o1, [%o5]
	bl,pt %xcc, 1b
	add %o5, 8, %o5

	! Now sp1 is block aligned
	.blkwr:
	andn %o2, 63, %o4 ! calculate size of blocks in bytes
	brz,pn %o1, .wrzero ! special case if c == 0
	and %o2, 63, %o3 ! %o3 = bytes left after blk stores.

	set MIN_LOOP, %g1
	cmp %o4, %g1 ! check there are enough bytes to set
	blu,pn %xcc, .short_set ! to justify cost of membar
	! must be > pre-cleared lines
	nop

	! initial cache-clearing stores
	! get store pipeline moving
	rd %asi, %g3 ! save %asi to be restored later
	wr %g0, ASI_STBIMRU_P, %asi

	! Primary memset loop for large memsets
	.wr_loop:
	sub %o5, 8, %o5 ! adjust %o5 for ASI store alignment
	mov ST_CHUNK, %g1
	.wr_loop_start:
	stxa %o1, [%o5+8]%asi
	subcc %g1, 4, %g1
	stxa %o1, [%o5+8+64]%asi
	add %o5, 256, %o5
	stxa %o1, [%o5+8-128]%asi
	bgu %xcc, .wr_loop_start
	stxa %o1, [%o5+8-64]%asi

	sub %o5, ST_CHUNK*64, %o5 ! reset %o5
	mov ST_CHUNK, %g1

	.wr_loop_rest:
	stxa %o1, [%o5+8+8]%asi
	sub %o4, 64, %o4
	stxa %o1, [%o5+16+8]%asi
	subcc %g1, 1, %g1
	stxa %o1, [%o5+24+8]%asi
	stxa %o1, [%o5+32+8]%asi
	stxa %o1, [%o5+40+8]%asi
	add %o5, 64, %o5
	stxa %o1, [%o5-8]%asi
	bgu %xcc, .wr_loop_rest
	stxa %o1, [%o5]ASI_STBI_P

	! If more than ST_CHUNK*64 bytes remain to set, continue
	! setting the first long word of each cache line in advance
	! to keep the store pipeline moving.

	cmp %o4, ST_CHUNK*64
	bge,pt %xcc, .wr_loop_start
	mov ST_CHUNK, %g1

	brz,a,pn %o4, .asi_done
	add %o5, 8, %o5 ! restore %o5 offset

	.wr_loop_small:
	stxa %o1, [%o5+8]%asi
	stxa %o1, [%o5+8+8]%asi
	stxa %o1, [%o5+16+8]%asi
	stxa %o1, [%o5+24+8]%asi
	stxa %o1, [%o5+32+8]%asi
	subcc %o4, 64, %o4
	stxa %o1, [%o5+40+8]%asi
	add %o5, 64, %o5
	stxa %o1, [%o5-8]%asi
	bgu,pt %xcc, .wr_loop_small
	stxa %o1, [%o5]ASI_STBI_P

	ba .asi_done
	add %o5, 8, %o5 ! restore %o5 offset

	! Special case loop for zero fill memsets
	! For each 64 byte cache line, single STBI to first element
	! clears line
	.wrzero:
	cmp %o4, MIN_ZERO ! check if enough bytes to set
	! to pay %asi + membar cost
	blu %xcc, .short_set
	nop
	sub %o4, 256, %o4

	.wrzero_loop:
	mov 64, %g3
	stxa %o1, [%o5]ASI_STBI_P
	subcc %o4, 256, %o4
	stxa %o1, [%o5+%g3]ASI_STBI_P
	add %o5, 256, %o5
	sub %g3, 192, %g3
	stxa %o1, [%o5+%g3]ASI_STBI_P
	add %g3, 64, %g3
	bge,pt %xcc, .wrzero_loop
	stxa %o1, [%o5+%g3]ASI_STBI_P
	add %o4, 256, %o4

	brz,pn %o4, .bsi_done
	nop

	.wrzero_small:
	stxa %o1, [%o5]ASI_STBI_P
	subcc %o4, 64, %o4
	bgu,pt %xcc, .wrzero_small
	add %o5, 64, %o5
	ba,a .bsi_done

	.asi_done:
	wr %g3, 0x0, %asi ! restored saved %asi
	.bsi_done:
	membar #StoreStore ! required by use of Block Store Init

	.short_set:
	cmp %o4, 64 ! check if 64 bytes to set
	blu %xcc, 5f
	nop
	4: ! set final blocks of 64 bytes
	stx %o1, [%o5]
	stx %o1, [%o5+8]
	stx %o1, [%o5+16]
	stx %o1, [%o5+24]
	subcc %o4, 64, %o4
	stx %o1, [%o5+32]
	stx %o1, [%o5+40]
	add %o5, 64, %o5
	stx %o1, [%o5-16]
	bgu,pt %xcc, 4b
	stx %o1, [%o5-8]

	5:
	! Set the remaining long words
	.wrshort:
	subcc %o3, 8, %o3 ! Can we store any long words?
	blu,pn %xcc, .wrchars
	and %o2, 7, %o2 ! calc bytes left after long words
	6:
	subcc %o3, 8, %o3
	stx %o1, [%o5] ! store the long words
	bgeu,pt %xcc, 6b
	add %o5, 8, %o5

	.wrchars: ! check for extra chars
	brnz %o2, .wrfin
	nop
	retl
	nop

	.wdalign:
	andcc %o5, 3, %o3 ! is sp1 aligned on a word boundary
	bz,pn %xcc, .wrword
	andn %o2, 3, %o3 ! create word sized count in %o3

	dec %o2 ! decrement count
	stb %o1, [%o5] ! clear a byte
	b .wdalign
	inc %o5 ! next byte

	.wrword:
	subcc %o3, 4, %o3
	st %o1, [%o5] ! 4-byte writing loop
	bnz,pt %xcc, .wrword
	add %o5, 4, %o5

	and %o2, 3, %o2 ! leftover count, if any

	.wrchar:
	! Set the remaining bytes, if any
	brz %o2, .exit
	nop
	.wrfin:
	deccc %o2
	stb %o1, [%o5]
	bgu,pt %xcc, .wrfin
	inc %o5
	.exit:
	retl ! %o0 was preserved
	nop

	.size M7memset,.-M7memset