Quelle  ev6-memset.S   Sprache: Sparc

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * arch/alpha/lib/ev6-memset.S
 *
 * This is an efficient (and relatively small) implementation of the C library
 * "memset()" function for the 21264 implementation of Alpha.
 *
 * 21264 version  contributed by Rick Gorton <rick.gorton@alpha-processor.com>
 *
 * Much of the information about 21264 scheduling/coding comes from:
 * Compiler Writer's Guide for the Alpha 21264
 * abbreviated as 'CWG' in other comments here
 * ftp.digital.com/pub/Digital/info/semiconductor/literature/dsc-library.html
 * Scheduling notation:
 * E - either cluster
 * U - upper subcluster; U0 - subcluster U0; U1 - subcluster U1
 * L - lower subcluster; L0 - subcluster L0; L1 - subcluster L1
 * The algorithm for the leading and trailing quadwords remains the same,
 * however the loop has been unrolled to enable better memory throughput,
 * and the code has been replicated for each of the entry points: __memset
 * and __memset16 to permit better scheduling to eliminate the stalling
 * encountered during the mask replication.
 * A future enhancement might be to put in a byte store loop for really
 * small (say < 32 bytes) memset()s.  Whether or not that change would be
 * a win in the kernel would depend upon the contextual usage.
 * WARNING: Maintaining this is going to be more work than the above version,
 * as fixes will need to be made in multiple places.  The performance gain
 * is worth it.
 */
#include <linux/export.h>
 .set noat
 .set noreorder
.text
 .globl memset
 .globl __memset
 .globl ___memset
 .globl __memset16
 .globl __constant_c_memset

 .ent ___memset
.align 5
___memset:
 .frame $30,0,$26,0
 .prologue 0

 /*
 * Serious stalling happens.  The only way to mitigate this is to
 * undertake a major re-write to interleave the constant materialization
 * with other parts of the fall-through code.  This is important, even
 * though it makes maintenance tougher.
 * Do this later.
 */
 and $17,255,$1  # E : 00000000000000ch
 insbl $17,1,$2  # U : 000000000000ch00
 bis $16,$16,$0  # E : return value
 ble $18,end_b  # U : zero length requested?

 addq $18,$16,$6  # E : max address to write to
 bis $1,$2,$17 # E : 000000000000chch
 insbl $1,2,$3  # U : 0000000000ch0000
 insbl $1,3,$4  # U : 00000000ch000000

 or $3,$4,$3 # E : 00000000chch0000
 inswl $17,4,$5 # U : 0000chch00000000
 xor $16,$6,$1 # E : will complete write be within one quadword?
 inswl $17,6,$2 # U : chch000000000000

 or $17,$3,$17 # E : 00000000chchchch
 or $2,$5,$2 # E : chchchch00000000
 bic $1,7,$1  # E : fit within a single quadword?
 and $16,7,$3 # E : Target addr misalignment

 or $17,$2,$17 # E : chchchchchchchch
 beq $1,within_quad_b # U :
 nop   # E :
 beq $3,aligned_b # U : target is 0mod8

 /*
 * Target address is misaligned, and won't fit within a quadword
 */
 ldq_u $4,0($16)  # L : Fetch first partial
 bis $16,$16,$5  # E : Save the address
 insql $17,$16,$2 # U : Insert new bytes
 subq $3,8,$3  # E : Invert (for addressing uses)

 addq $18,$3,$18  # E : $18 is new count ($3 is negative)
 mskql $4,$16,$4  # U : clear relevant parts of the quad
 subq $16,$3,$16  # E : $16 is new aligned destination
 bis $2,$4,$1  # E : Final bytes

 nop
 stq_u $1,0($5)  # L : Store result
 nop
 nop

.align 4
aligned_b:
 /*
 * We are now guaranteed to be quad aligned, with at least
 * one partial quad to write.
 */

 sra $18,3,$3  # U : Number of remaining quads to write
 and $18,7,$18  # E : Number of trailing bytes to write
 bis $16,$16,$5  # E : Save dest address
 beq $3,no_quad_b # U : tail stuff only

 /*
 * it's worth the effort to unroll this and use wh64 if possible
 * Lifted a bunch of code from clear_user.S
 * At this point, entry values are:
 * $16 Current destination address
 * $5 A copy of $16
 * $6 The max quadword address to write to
 * $18 Number trailer bytes
 * $3 Number quads to write
 */

 and $16, 0x3f, $2 # E : Forward work (only useful for unrolled loop)
 subq $3, 16, $4 # E : Only try to unroll if > 128 bytes
 subq $2, 0x40, $1 # E : bias counter (aligning stuff 0mod64)
 blt $4, loop_b # U :

 /*
 * We know we've got at least 16 quads, minimum of one trip
 * through unrolled loop.  Do a quad at a time to get us 0mod64
 * aligned.
 */

 nop   # E :
 nop   # E :
 nop   # E :
 beq $1, $bigalign_b # U :

$alignmod64_b:
 stq $17, 0($5) # L :
 subq $3, 1, $3 # E : For consistency later
 addq $1, 8, $1 # E : Increment towards zero for alignment
 addq $5, 8, $4 # E : Initial wh64 address (filler instruction)

 nop
 nop
 addq $5, 8, $5 # E : Inc address
 blt $1, $alignmod64_b # U :

$bigalign_b:
 /*
 * $3 - number quads left to go
 * $5 - target address (aligned 0mod64)
 * $17 - mask of stuff to store
 * Scratch registers available: $7, $2, $4, $1
 * we know that we'll be taking a minimum of one trip through
   * CWG Section 3.7.6: do not expect a sustained store rate of > 1/cycle
 * Assumes the wh64 needs to be for 2 trips through the loop in the future
 * The wh64 is issued on for the starting destination address for trip +2
 * through the loop, and if there are less than two trips left, the target
 * address will be for the current trip.
 */

$do_wh64_b:
 wh64 ($4)  # L1 : memory subsystem write hint
 subq $3, 24, $2 # E : For determining future wh64 addresses
 stq $17, 0($5) # L :
 nop   # E :

 addq $5, 128, $4 # E : speculative target of next wh64
 stq $17, 8($5) # L :
 stq $17, 16($5) # L :
 addq $5, 64, $7 # E : Fallback address for wh64 (== next trip addr)

 stq $17, 24($5) # L :
 stq $17, 32($5) # L :
 cmovlt $2, $7, $4 # E : Latency 2, extra mapping cycle
 nop

 stq $17, 40($5) # L :
 stq $17, 48($5) # L :
 subq $3, 16, $2 # E : Repeat the loop at least once more?
 nop

 stq $17, 56($5) # L :
 addq $5, 64, $5 # E :
 subq $3, 8, $3 # E :
 bge $2, $do_wh64_b # U :

 nop
 nop
 nop
 beq $3, no_quad_b # U : Might have finished already

.align 4
 /*
 * Simple loop for trailing quadwords, or for small amounts
 * of data (where we can't use an unrolled loop and wh64)
 */
loop_b:
 stq $17,0($5)  # L :
 subq $3,1,$3  # E : Decrement number quads left
 addq $5,8,$5  # E : Inc address
 bne $3,loop_b  # U : more?

no_quad_b:
 /*
 * Write 0..7 trailing bytes.
 */
 nop   # E :
 beq $18,end_b  # U : All done?
 ldq $7,0($5)  # L :
 mskqh $7,$6,$2  # U : Mask final quad

 insqh $17,$6,$4  # U : New bits
 bis $2,$4,$1  # E : Put it all together
 stq $1,0($5)  # L : And back to memory
 ret $31,($26),1  # L0 :

within_quad_b:
 ldq_u $1,0($16)  # L :
 insql $17,$16,$2 # U : New bits
 mskql $1,$16,$4  # U : Clear old
 bis $2,$4,$2  # E : New result

 mskql $2,$6,$4  # U :
 mskqh $1,$6,$2  # U :
 bis $2,$4,$1  # E :
 stq_u $1,0($16)  # L :

end_b:
 nop
 nop
 nop
 ret $31,($26),1  # L0 :
 .end ___memset
 EXPORT_SYMBOL(___memset)

 /*
 * This is the original body of code, prior to replication and
 * rescheduling.  Leave it here, as there may be calls to this
 * entry point.
 */
.align 4
 .ent __constant_c_memset
__constant_c_memset:
 .frame $30,0,$26,0
 .prologue 0

 addq $18,$16,$6  # E : max address to write to
 bis $16,$16,$0  # E : return value
 xor $16,$6,$1  # E : will complete write be within one quadword?
 ble $18,end  # U : zero length requested?

 bic $1,7,$1  # E : fit within a single quadword
 beq $1,within_one_quad # U :
 and $16,7,$3  # E : Target addr misalignment
 beq $3,aligned  # U : target is 0mod8

 /*
 * Target address is misaligned, and won't fit within a quadword
 */
 ldq_u $4,0($16)  # L : Fetch first partial
 bis $16,$16,$5  # E : Save the address
 insql $17,$16,$2 # U : Insert new bytes
 subq $3,8,$3  # E : Invert (for addressing uses)

 addq $18,$3,$18  # E : $18 is new count ($3 is negative)
 mskql $4,$16,$4  # U : clear relevant parts of the quad
 subq $16,$3,$16  # E : $16 is new aligned destination
 bis $2,$4,$1  # E : Final bytes

 nop
 stq_u $1,0($5)  # L : Store result
 nop
 nop

.align 4
aligned:
 /*
 * We are now guaranteed to be quad aligned, with at least
 * one partial quad to write.
 */

 sra $18,3,$3  # U : Number of remaining quads to write
 and $18,7,$18  # E : Number of trailing bytes to write
 bis $16,$16,$5  # E : Save dest address
 beq $3,no_quad  # U : tail stuff only

 /*
 * it's worth the effort to unroll this and use wh64 if possible
 * Lifted a bunch of code from clear_user.S
 * At this point, entry values are:
 * $16 Current destination address
 * $5 A copy of $16
 * $6 The max quadword address to write to
 * $18 Number trailer bytes
 * $3 Number quads to write
 */

 and $16, 0x3f, $2 # E : Forward work (only useful for unrolled loop)
 subq $3, 16, $4 # E : Only try to unroll if > 128 bytes
 subq $2, 0x40, $1 # E : bias counter (aligning stuff 0mod64)
 blt $4, loop # U :

 /*
 * We know we've got at least 16 quads, minimum of one trip
 * through unrolled loop.  Do a quad at a time to get us 0mod64
 * aligned.
 */

 nop   # E :
 nop   # E :
 nop   # E :
 beq $1, $bigalign # U :

$alignmod64:
 stq $17, 0($5) # L :
 subq $3, 1, $3 # E : For consistency later
 addq $1, 8, $1 # E : Increment towards zero for alignment
 addq $5, 8, $4 # E : Initial wh64 address (filler instruction)

 nop
 nop
 addq $5, 8, $5 # E : Inc address
 blt $1, $alignmod64 # U :

$bigalign:
 /*
 * $3 - number quads left to go
 * $5 - target address (aligned 0mod64)
 * $17 - mask of stuff to store
 * Scratch registers available: $7, $2, $4, $1
 * we know that we'll be taking a minimum of one trip through
   * CWG Section 3.7.6: do not expect a sustained store rate of > 1/cycle
 * Assumes the wh64 needs to be for 2 trips through the loop in the future
 * The wh64 is issued on for the starting destination address for trip +2
 * through the loop, and if there are less than two trips left, the target
 * address will be for the current trip.
 */

$do_wh64:
 wh64 ($4)  # L1 : memory subsystem write hint
 subq $3, 24, $2 # E : For determining future wh64 addresses
 stq $17, 0($5) # L :
 nop   # E :

 addq $5, 128, $4 # E : speculative target of next wh64
 stq $17, 8($5) # L :
 stq $17, 16($5) # L :
 addq $5, 64, $7 # E : Fallback address for wh64 (== next trip addr)

 stq $17, 24($5) # L :
 stq $17, 32($5) # L :
 cmovlt $2, $7, $4 # E : Latency 2, extra mapping cycle
 nop

 stq $17, 40($5) # L :
 stq $17, 48($5) # L :
 subq $3, 16, $2 # E : Repeat the loop at least once more?
 nop

 stq $17, 56($5) # L :
 addq $5, 64, $5 # E :
 subq $3, 8, $3 # E :
 bge $2, $do_wh64 # U :

 nop
 nop
 nop
 beq $3, no_quad # U : Might have finished already

.align 4
 /*
 * Simple loop for trailing quadwords, or for small amounts
 * of data (where we can't use an unrolled loop and wh64)
 */
loop:
 stq $17,0($5)  # L :
 subq $3,1,$3  # E : Decrement number quads left
 addq $5,8,$5  # E : Inc address
 bne $3,loop  # U : more?

no_quad:
 /*
 * Write 0..7 trailing bytes.
 */
 nop   # E :
 beq $18,end  # U : All done?
 ldq $7,0($5)  # L :
 mskqh $7,$6,$2  # U : Mask final quad

 insqh $17,$6,$4  # U : New bits
 bis $2,$4,$1  # E : Put it all together
 stq $1,0($5)  # L : And back to memory
 ret $31,($26),1  # L0 :

within_one_quad:
 ldq_u $1,0($16)  # L :
 insql $17,$16,$2 # U : New bits
 mskql $1,$16,$4  # U : Clear old
 bis $2,$4,$2  # E : New result

 mskql $2,$6,$4  # U :
 mskqh $1,$6,$2  # U :
 bis $2,$4,$1  # E :
 stq_u $1,0($16)  # L :

end:
 nop
 nop
 nop
 ret $31,($26),1  # L0 :
 .end __constant_c_memset
 EXPORT_SYMBOL(__constant_c_memset)

 /*
 * This is a replicant of the __constant_c_memset code, rescheduled
 * to mask stalls.  Note that entry point names also had to change
 */
 .align 5
 .ent __memset16

__memset16:
 .frame $30,0,$26,0
 .prologue 0

 inswl $17,0,$5  # U : 000000000000c1c2
 inswl $17,2,$2  # U : 00000000c1c20000
 bis $16,$16,$0  # E : return value
 addq $18,$16,$6 # E : max address to write to

 ble $18, end_w  # U : zero length requested?
 inswl $17,4,$3 # U : 0000c1c200000000
 inswl $17,6,$4 # U : c1c2000000000000
 xor $16,$6,$1 # E : will complete write be within one quadword?

 or $2,$5,$2 # E : 00000000c1c2c1c2
 or $3,$4,$17 # E : c1c2c1c200000000
 bic $1,7,$1  # E : fit within a single quadword
 and $16,7,$3 # E : Target addr misalignment

 or $17,$2,$17 # E : c1c2c1c2c1c2c1c2
 beq $1,within_quad_w # U :
 nop
 beq $3,aligned_w # U : target is 0mod8

 /*
 * Target address is misaligned, and won't fit within a quadword
 */
 ldq_u $4,0($16)  # L : Fetch first partial
 bis $16,$16,$5  # E : Save the address
 insql $17,$16,$2 # U : Insert new bytes
 subq $3,8,$3  # E : Invert (for addressing uses)

 addq $18,$3,$18  # E : $18 is new count ($3 is negative)
 mskql $4,$16,$4  # U : clear relevant parts of the quad
 subq $16,$3,$16  # E : $16 is new aligned destination
 bis $2,$4,$1  # E : Final bytes

 nop
 stq_u $1,0($5)  # L : Store result
 nop
 nop

.align 4
aligned_w:
 /*
 * We are now guaranteed to be quad aligned, with at least
 * one partial quad to write.
 */

 sra $18,3,$3  # U : Number of remaining quads to write
 and $18,7,$18  # E : Number of trailing bytes to write
 bis $16,$16,$5  # E : Save dest address
 beq $3,no_quad_w # U : tail stuff only

 /*
 * it's worth the effort to unroll this and use wh64 if possible
 * Lifted a bunch of code from clear_user.S
 * At this point, entry values are:
 * $16 Current destination address
 * $5 A copy of $16
 * $6 The max quadword address to write to
 * $18 Number trailer bytes
 * $3 Number quads to write
 */

 and $16, 0x3f, $2 # E : Forward work (only useful for unrolled loop)
 subq $3, 16, $4 # E : Only try to unroll if > 128 bytes
 subq $2, 0x40, $1 # E : bias counter (aligning stuff 0mod64)
 blt $4, loop_w # U :

 /*
 * We know we've got at least 16 quads, minimum of one trip
 * through unrolled loop.  Do a quad at a time to get us 0mod64
 * aligned.
 */

 nop   # E :
 nop   # E :
 nop   # E :
 beq $1, $bigalign_w # U :

$alignmod64_w:
 stq $17, 0($5) # L :
 subq $3, 1, $3 # E : For consistency later
 addq $1, 8, $1 # E : Increment towards zero for alignment
 addq $5, 8, $4 # E : Initial wh64 address (filler instruction)

 nop
 nop
 addq $5, 8, $5 # E : Inc address
 blt $1, $alignmod64_w # U :

$bigalign_w:
 /*
 * $3 - number quads left to go
 * $5 - target address (aligned 0mod64)
 * $17 - mask of stuff to store
 * Scratch registers available: $7, $2, $4, $1
 * we know that we'll be taking a minimum of one trip through
   * CWG Section 3.7.6: do not expect a sustained store rate of > 1/cycle
 * Assumes the wh64 needs to be for 2 trips through the loop in the future
 * The wh64 is issued on for the starting destination address for trip +2
 * through the loop, and if there are less than two trips left, the target
 * address will be for the current trip.
 */

$do_wh64_w:
 wh64 ($4)  # L1 : memory subsystem write hint
 subq $3, 24, $2 # E : For determining future wh64 addresses
 stq $17, 0($5) # L :
 nop   # E :

 addq $5, 128, $4 # E : speculative target of next wh64
 stq $17, 8($5) # L :
 stq $17, 16($5) # L :
 addq $5, 64, $7 # E : Fallback address for wh64 (== next trip addr)

 stq $17, 24($5) # L :
 stq $17, 32($5) # L :
 cmovlt $2, $7, $4 # E : Latency 2, extra mapping cycle
 nop

 stq $17, 40($5) # L :
 stq $17, 48($5) # L :
 subq $3, 16, $2 # E : Repeat the loop at least once more?
 nop

 stq $17, 56($5) # L :
 addq $5, 64, $5 # E :
 subq $3, 8, $3 # E :
 bge $2, $do_wh64_w # U :

 nop
 nop
 nop
 beq $3, no_quad_w # U : Might have finished already

.align 4
 /*
 * Simple loop for trailing quadwords, or for small amounts
 * of data (where we can't use an unrolled loop and wh64)
 */
loop_w:
 stq $17,0($5)  # L :
 subq $3,1,$3  # E : Decrement number quads left
 addq $5,8,$5  # E : Inc address
 bne $3,loop_w  # U : more?

no_quad_w:
 /*
 * Write 0..7 trailing bytes.
 */
 nop   # E :
 beq $18,end_w  # U : All done?
 ldq $7,0($5)  # L :
 mskqh $7,$6,$2  # U : Mask final quad

 insqh $17,$6,$4  # U : New bits
 bis $2,$4,$1  # E : Put it all together
 stq $1,0($5)  # L : And back to memory
 ret $31,($26),1  # L0 :

within_quad_w:
 ldq_u $1,0($16)  # L :
 insql $17,$16,$2 # U : New bits
 mskql $1,$16,$4  # U : Clear old
 bis $2,$4,$2  # E : New result

 mskql $2,$6,$4  # U :
 mskqh $1,$6,$2  # U :
 bis $2,$4,$1  # E :
 stq_u $1,0($16)  # L :

end_w:
 nop
 nop
 nop
 ret $31,($26),1  # L0 :

 .end __memset16
 EXPORT_SYMBOL(__memset16)

memset = ___memset
__memset = ___memset
 EXPORT_SYMBOL(memset)
 EXPORT_SYMBOL(__memset)