|
|
//// Module Name://// fillmem.s//// Abstract://// This module implements functions to move, zero, and fill blocks// of memory. If the memory is aligned, then these functions are// very efficient.//// Author:////// Environment://// User or Kernel mode.////--
#include "ksia64.h"
//++//// VOID// RtlFillMemory (// IN PVOID destination,// IN SIZE_T length,// IN UCHAR fill// )//// Routine Description://// This function fills memory by first aligning the destination address to// a qword boundary, and then filling 4-byte blocks, followed by any// remaining bytes.//// Arguments://// destination (a0) - Supplies a pointer to the memory to fill.//// length (a1) - Supplies the length, in bytes, of the memory to be filled.//// fill (a2) - Supplies the fill byte.//// N.B. The alternate entry memset expects the length and fill arguments// to be reversed. It also returns the Destination pointer//// Return Value://// None.////--
LEAF_ENTRY(RtlFillMemory)
lfetch.excl [a0] mov t0 = a0 add t4 = 64, a0
cmp.eq pt0 = zero, a1 // length == 0 ? add t1 = -1, a0 zxt1 a2 = a2
cmp.ge pt1 = 7, a1 mov v0 = a0 (pt0) br.ret.spnt brp // return if length is zero ;;
//// Align address on qword boundary by determining the number of bytes// before the next qword boundary by performing an AND operation on// the 2's complement of the address with a mask value of 0x7.//
lfetch.excl [t4], 64 andcm t1 = 7, t1 // t1 = # bytes before dword boundary
(pt1) br.cond.spnt TailSet // 1 <= length <= 3, br to TailSet ;;
cmp.eq pt2 = zero, t1 // skip HeadSet if t1 is zero mux1 t2 = a2, @brcst // t2 = all 8 bytes = [fill] sub a1 = a1, t1 // a1 = adjusted length ;;
lfetch.excl [t4], 64 (pt2) br.cond.sptk SkipHeadSet
//// Copy the leading bytes until t1 is equal to zero//
HeadSet: st1 [t0] = a2, 1 add t1 = -1, t1 ;;
cmp.ne pt0 = zero, t1
(pt0) br.cond.sptk HeadSet
//// now the address is qword aligned;
// fall into the QwordSet loop if remaining length is greater than 8;
// else skip the QwordSet loop//
SkipHeadSet:
cmp.gt pt1 = 16, a1 add t4 = 64, t0 cmp.le pt2 = 8, a1
add t3 = 8, t0 cmp.gt pt3 = 64, a1 (pt1) br.cond.spnt SkipQwordSet ;;
lfetch.excl [t4], 64 (pt3) br.cond.spnt QwordSet
nop.m 0 nop.m 0 nop.i 0
UnrolledQwordSet:
st8 [t0] = t2, 16 st8 [t3] = t2, 16 add a1 = -64, a1 ;;
st8 [t0] = t2, 16 st8 [t3] = t2, 16 cmp.le pt0 = 64, a1 ;;
st8 [t0] = t2, 16 st8 [t3] = t2, 16 cmp.le pt2 = 8, a1 ;;
st8 [t0] = t2, 16 nop.f 0 cmp.gt pt1 = 16, a1
st8 [t3] = t2, 16 (pt0) br.cond.sptk UnrolledQwordSet (pt1) br.cond.spnt SkipQwordSet ;;
//// fill 8 bytes at a time until the remaining length is less than 8//
QwordSet: st8 [t0] = t2, 16 st8 [t3] = t2, 16 add a1 = -16, a1 ;;
cmp.le pt0 = 16, a1 cmp.le pt2 = 8, a1(pt0) br.cond.sptk QwordSet ;;
SkipQwordSet:(pt2) st8 [t0] = t2, 8(pt2) add a1 = -8, a1 ;;
cmp.eq pt3 = zero, a1 // return now if length equals 0(pt3) br.ret.sptk brp ;;
//// copy the remaining bytes one at a time//
TailSet: st1 [t0] = a2, 1 add a1 = -1, a1 nop.i 0 ;;
cmp.ne pt0, pt3 = 0, a1(pt0) br.cond.dptk TailSet(pt3) br.ret.dpnt brp ;;
LEAF_EXIT(RtlFillMemory)
//++//// VOID// RtlFillMemoryUlong (// IN PVOID Destination,// IN SIZE_T Length,// IN ULONG Pattern// )//// Routine Description://// This function fills memory with the specified longowrd pattern// 4 bytes at a time.//// N.B. This routine assumes that the destination address is aligned// on a longword boundary and that the length is an even multiple// of longwords.//// Arguments://// Destination (a0) - Supplies a pointer to the memory to fill.//// Length (a1) - Supplies the length, in bytes, of the memory to be filled.//// Pattern (a2) - Supplies the fill pattern.//// Return Value://// None.////--
LEAF_ENTRY(RtlFillMemoryUlong)
.prologue .save ar.lc, t22 mov t22 = ar.lc extr.u a1 = a1, 2, 30 ;;
PROLOGUE_END
cmp.eq pt0, pt1 = zero, a1 add a1 = -1, a1 ;;
nop.m 0(pt1) mov ar.lc = a1(pt0) br.ret.spnt brp ;;
Rfmu10: st4 [a0] = a2, 4 br.cloop.dptk.few Rfmu10 ;;
nop.m 0 mov ar.lc = t22 br.ret.sptk brp
LEAF_EXIT(RtlFillMemoryUlong)
//++//// VOID// RtlFillMemoryUlonglong (// IN PVOID Destination,// IN SIZE_T Length,// IN ULONGLONG Pattern// )//// Routine Description://// This function fills memory with the specified pattern// 8 bytes at a time.//// N.B. This routine assumes that the destination address is aligned// on a longword boundary and that the length is an even multiple// of longwords.//// Arguments://// Destination (a0) - Supplies a pointer to the memory to fill.//// Length (a1) - Supplies the length, in bytes, of the memory to be filled.//// Pattern (a2,a3) - Supplies the fill pattern.//// Return Value://// None.////--
LEAF_ENTRY(RtlFillMemoryUlonglong)
.prologue .save ar.lc, t22 mov t22 = ar.lc extr.u a1 = a1, 3, 29 ;;
PROLOGUE_END
cmp.eq pt0, pt1 = zero, a1 add a1 = -1, a1 ;;
nop.m 0(pt1) mov ar.lc = a1(pt0) br.ret.spnt brp ;;
Rfmul10: st8 [a0] = a2, 8 br.cloop.dptk.few Rfmul10 ;;
nop.m 0 mov ar.lc = t22 br.ret.sptk brp ;;
LEAF_EXIT(RtlFillMemoryUlonglong)
//++//// VOID// RtlZeroMemory (// IN PVOID Destination,// IN SIZE_T Length// )//// Routine Description://// This function simply sets up the fill value (out2) and branches// directly to RtlFillMemory//// Arguments://// Destination (a0) - Supplies a pointer to the memory to zero.//// Length (a1) - Supplies the length, in bytes, of the memory to be zeroed.//// Return Value://// None.////-- LEAF_ENTRY(RtlZeroMemory)
alloc t22 = ar.pfs, 0, 0, 3, 0 mov out2 = 0 br RtlFillMemory
LEAF_EXIT(RtlZeroMemory)
//++//// VOID// RtlMoveMemory (// IN PVOID Destination,// IN PVOID Source,// IN SIZE_T Length// )//// Routine Description://// This function moves memory either forward or backward, aligned or// unaligned.//// Algorithm:// 1) Length equals zero, return immediately// 2) Source & Destination don't overlap, copy from low to high// else copy from high to low address one byte at a time// 3) if Source & Destination are both 8-byte aligned, copy 8 bytes// at a time and the remaining bytes are copied one at a time.// 4) if Source & Destination are both 4-byte aligned, copy 4 bytes// at a time and the remaining bytes are copied one at a time.// 5) else copy one byte at a time from low to high address.//// Arguments://// Destination (a0) - Supplies a pointer to the destination address of// the move operation.//// Source (a1) - Supplies a pointer to the source address of the move// operation.//// Length (a2) - Supplies the length, in bytes, of the memory to be moved.//// Return Value://// None.////-- LEAF_ENTRY(memcpy) ALTERNATE_ENTRY(memmove) ALTERNATE_ENTRY(RtlMoveMemory) ALTERNATE_ENTRY(RtlCopyMemory) ALTERNATE_ENTRY(RtlCopyMemoryNonTemporal) .prologue .regstk 3,7,0,8 alloc t17 = ar.pfs,3,31,0,32 .save pr, r64 mov r64 = pr and t3 = -32, a1 ;;
lfetch [t3], 32 //0 .save ar.lc, r65 mov.i r65 = ar.lc and t1 = 7, a1 ;;
.body lfetch [t3], 32 //32 mov v0 = a0 and t0 = 7, a0 ;;
add t21 = a1, a2 cmp.gtu pt0 = a0, a1 or t2 = t0, t1 ;;
(pt0) cmp.ltu.unc pt0 = a0, t21 cmp.eq pt1 = zero, a2 (pt1) br.ret.spnt brp
lfetch [t3], 32 //64 cmp.lt pt2 = 16, a2 (pt0) br.cond.spnt CopyDown ;;
lfetch [t3], 32 //96 cmp.lt pt6 = 127, a2 cmp.le pt4 = 8, a2 ;;
(pt6) lfetch [t3], 32 //128 (pt4) cmp.eq.unc pt3 = 0, t2 (pt4) cmp.eq.unc pt5 = t0, t1
(pt3) br.cond.sptk QwordMoveUp (pt5) br.cond.spnt AlignedMove (pt2) br.cond.sptk UnalignedMove
ByteMoveUpLoop: ld1 t10 = [a1], 1 nop.f 0 add a2 = -1, a2 ;;
st1 [a0] = t10, 1 cmp.ne pt1 = zero, a2 (pt1) br.cond.sptk ByteMoveUpLoop nop.m 0 nop.f 0 br.ret.sptk brp
UnalignedMove: cmp.eq pt0 = 0, t1 sub t1 = 8, t1 (pt0) br.cond.spnt SkipUnalignedMoveByteLoop ;;
UnalignedMoveByteLoop: ld1 t10 = [a1], 1 add t1 = -1, t1 add a2 = -1, a2 ;;
st1 [a0] = t10, 1 cmp.eq p0, pt1 = zero, t1 (pt1) br.cond.sptk UnalignedMoveByteLoop ;;
SkipUnalignedMoveByteLoop: and t0 = 7, a0 mov pr.rot = 3<<16 or t1 = a1, r0 ;;
add t2 = a2, t0 mov.i ar.ec = 32 sub t21 = 8, t0 ;;
sub t4 = a0, t0 shr t10 = t2, 3 shl t21 = t21, 3 ;;
ld8 r33 = [t4], 0 add t10 = -1,t10 and t2 = 7, t2 ;;
cmp.eq pt0 = 2, t0 cmp.eq pt3 = 4, t0 cmp.eq pt5 = 6, t0 ;;
nop.m 0 shl r33 = r33,t21 // Prime r39 mov.i ar.lc = t10
(pt0) br.cond.spnt SpecialLoop2 (pt3) br.cond.spnt SpecialLoop4 (pt5) br.cond.spnt SpecialLoop6
cmp.eq pt1 = 3, t0 cmp.eq pt4 = 5, t0 cmp.eq pt6 = 7, t0
(pt1) br.cond.spnt SpecialLoop3 (pt4) br.cond.spnt SpecialLoop5 (pt6) br.cond.spnt SpecialLoop7 ;;
SpecialLoop1: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop1E, SpecialLoop1
SpecialLoop1E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,56 br.ctop.sptk.many SpecialLoop1
br UnalignedByteDone
SpecialLoop2: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop2E, SpecialLoop2
SpecialLoop2E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,48 br.ctop.sptk.many SpecialLoop2
br UnalignedByteDone
SpecialLoop3: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop3E, SpecialLoop3
SpecialLoop3E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,40 br.ctop.sptk.many SpecialLoop3
br UnalignedByteDone
SpecialLoop4: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop4E, SpecialLoop4
SpecialLoop4E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,32 br.ctop.sptk.many SpecialLoop4
br UnalignedByteDone
SpecialLoop5: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop5E, SpecialLoop5
SpecialLoop5E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,24 br.ctop.sptk.many SpecialLoop5
br UnalignedByteDone
SpecialLoop6: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop6E, SpecialLoop6
SpecialLoop6E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,16 br.ctop.sptk.many SpecialLoop6
br UnalignedByteDone
SpecialLoop7: (p16) ld8 r32 = [t1], 8 nop.f 0 brp.sptk.imp SpecialLoop7E, SpecialLoop7
SpecialLoop7E: (p48) st8 [t4] = r10, 8 (p47) shrp r10 = r62,r63,8 br.ctop.sptk.many SpecialLoop7;;
UnalignedByteDone: sub t1 = t1, t0 mov pr = r64 mov.i ar.lc = r65 ;;
cmp.eq pt0 = zero, t2 (pt0) br.ret.spnt brp
UnAlignedByteDoneLoop: ld1 t10 = [t1], 1 add t2 = -1, t2 ;;
cmp.ne pt1 = zero, t2
st1 [t4] = t10, 1 (pt1) br.cond.sptk UnAlignedByteDoneLoop br.ret.spnt brp
AlignedMove: add t4 = 64, t3 (pt6) lfetch [t3], 32 //160 sub t22 = 8, t0 ;;
(pt6) lfetch [t3], 64 //192 (pt6) lfetch [t4], 96 //224 sub a2 = a2, t22 ;;
AlignedMoveByteLoop: ld1 t10 = [a1], 1 nop.f 0 add t22 = -1, t22 ;;
st1 [a0] = t10, 1 cmp.ne pt1 = zero, t22 (pt1) br.cond.sptk AlignedMoveByteLoop ;;
(pt6) lfetch [t3], 32 //256 cmp.eq.unc pt0 = zero, a2 cmp.gt pt2 = 8, a2
(pt6) lfetch [t4], 128 //320 (pt0) br.ret.spnt brp (pt2) br.cond.sptk ByteMoveUpLoop ;;
//// both src & dest are now 8-byte aligned//
QwordMoveUp: add t3 = 128, a1 add t4 = 288, a1 add t7 = 8, a1
add t8 = 8, a0 cmp.gt pt3 = 64, a2 (pt3) br.cond.spnt QwordMoveUpLoop ;;
UnrolledQwordMoveUpLoop:
ld8 t10 = [a1], 16 ld8 t11 = [t7], 16 add a2 = -64, a2 ;;
ld8 t12 = [a1], 16 ld8 t13 = [t7], 16 cmp.le pt3 = 128, a2 ;;
ld8 t14 = [a1], 16 ld8 t15 = [t7], 16 cmp.gt pt2 = 8, a2 ;;
ld8 t16 = [a1], 16 ld8 t17 = [t7], 16 ;;
(pt3) lfetch [t3], 64 (pt3) lfetch [t4], 64
st8 [a0] = t10, 16 st8 [t8] = t11, 16 ;;
st8 [a0] = t12, 16 st8 [t8] = t13, 16 ;;
st8 [a0] = t14, 16 st8 [t8] = t15, 16 ;;
st8 [a0] = t16, 16 st8 [t8] = t17, 16 (pt3) br.cond.dptk UnrolledQwordMoveUpLoop
(pt2) br.cond.spnt ByteMoveUp ;;
QwordMoveUpLoop:
ld8 t10 = [a1], 8 add a2 = -8, a2 ;;
cmp.le pt1 = 8, a2
st8 [a0] = t10, 8 (pt1) br.cond.sptk QwordMoveUpLoop ;;
ByteMoveUp: cmp.eq pt0 = zero, a2 (pt0) br.ret.spnt brp ;;
AlignedByteDoneLoop: ld1 t10 = [a1], 1 add a2 = -1, a2 ;;
cmp.ne pt1 = zero, a2
st1 [a0] = t10, 1 (pt1) br.cond.sptk AlignedByteDoneLoop br.ret.spnt brp ;;
CopyDown: cmp.eq pt0 = zero, a2 cmp.ne pt6 = t0, t1(pt0) br.ret.spnt brp // return if length is zero
cmp.gt pt4 = 16, a2 add t20 = a2, a0 add t21 = a2, a1
nop.m 0(pt4) br.cond.sptk ByteMoveDown // less than 16 bytes to copy(pt6) br.cond.spnt UnalignedMoveDown // incompatible alignment ;;
nop.m 0 nop.m 0 and t22 = 0x7, t21 ;;
add t20 = -1, t20 add t21 = -1, t21 sub a2 = a2, t22 ;;
TailMove: cmp.eq pt0, pt1 = zero, t22 ;;
(pt1) ld1 t10 = [t21], -1 (pt1) add t22 = -1, t22 ;;
(pt1) st1 [t20] = t10, -1 (pt1) br.cond.sptk TailMove
Block8Move: nop.m 0 add t20 = -7, t20 add t21 = -7, t21 ;;
Block8MoveLoop: cmp.gt pt5, pt6 = 8, a2 ;;
(pt6) ld8 t10 = [t21], -8(pt6) add a2 = -8, a2 ;;
(pt6) st8 [t20] = t10, -8(pt6) br.cond.sptk Block8MoveLoop
add t20 = 8, t20 // adjust dest add t21 = 8, t21 // adjust source br.cond.sptk ByteMoveDown ;;
UnalignedMoveDown: and t1 = 7, t21 ;;
cmp.eq pt0 = 0, t1 (pt0) br.cond.spnt SkipUnalignedMoveDownByteLoop ;;
add t20 = -1, t20 add t21 = -1, t21 ;;
UnalignedMoveDownByteLoop: ld1 t10 = [t21], -1 add t1 = -1, t1 add a2 = -1, a2 ;;
st1 [t20] = t10, -1 cmp.eq p0, pt1 = zero, t1 (pt1) br.cond.sptk UnalignedMoveDownByteLoop ;;
add t20 = 1, t20 add t21 = 1, t21 ;;
SkipUnalignedMoveDownByteLoop: add t21 = -8, t21 ;;
and t0 = 7, t20 mov pr.rot = 3<<16 or t1 = t21, r0 ;;
sub t7 = 8, t0 ;;
add t2 = a2, t7 mov.i ar.ec = 32 ;;
sub t4 = t20, t0 shr t10 = t2, 3 shl t6 = t0, 3 ;;
ld8 r33 = [t4], 0 add t10 = -1,t10 and t2 = 7, t2 ;;
cmp.eq pt0 = 2, t0 cmp.eq pt3 = 4, t0 cmp.eq pt5 = 6, t0 ;;
shr r33 = r33,t6 // Prime r39 mov.i ar.lc = t10
(pt0) br.cond.spnt SpecialLoopDown2 (pt3) br.cond.spnt SpecialLoopDown4 (pt5) br.cond.spnt SpecialLoopDown6
cmp.eq pt1 = 3, t0 cmp.eq pt4 = 5, t0 cmp.eq pt6 = 7, t0
(pt1) br.cond.spnt SpecialLoopDown3 (pt4) br.cond.spnt SpecialLoopDown5 (pt6) br.cond.spnt SpecialLoopDown7 ;;
SpecialLoopDown1: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown1E, SpecialLoopDown1
SpecialLoopDown1E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,56 br.ctop.sptk.many SpecialLoopDown1
br UnalignedByteDownDone
SpecialLoopDown2: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown2E, SpecialLoopDown2
SpecialLoopDown2E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,48 br.ctop.sptk.many SpecialLoopDown2
br UnalignedByteDownDone
SpecialLoopDown3: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown3E, SpecialLoopDown3
SpecialLoopDown3E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,40 br.ctop.sptk.many SpecialLoopDown3
br UnalignedByteDownDone
SpecialLoopDown4: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown4E, SpecialLoopDown4
SpecialLoopDown4E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,32 br.ctop.sptk.many SpecialLoopDown4
br UnalignedByteDownDone
SpecialLoopDown5: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown5E, SpecialLoopDown5
SpecialLoopDown5E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,24 br.ctop.sptk.many SpecialLoopDown5
br UnalignedByteDownDone
SpecialLoopDown6: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown6E, SpecialLoopDown6
SpecialLoopDown6E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,16 br.ctop.sptk.many SpecialLoopDown6
br UnalignedByteDownDone
SpecialLoopDown7: (p16) ld8 r32 = [t1], -8 nop.f 0 brp.sptk.imp SpecialLoopDown7E, SpecialLoopDown7
SpecialLoopDown7E: (p48) st8 [t4] = r10, -8 (p47) shrp r10 = r63,r62,8 br.ctop.sptk.many SpecialLoopDown7;;
UnalignedByteDownDone: add t1 = 7, t1 add t4 = 7, t4 ;;
add t1 = t1, t7 mov pr = r64 mov.i ar.lc = r65 ;;
cmp.eq pt0 = zero, t2 (pt0) br.ret.spnt brp ;;
UnAlignedByteDoneDownLoop: ld1 t10 = [t1], -1 add t2 = -1, t2 ;;
cmp.ne pt1 = zero, t2
st1 [t4] = t10, -1 (pt1) br.cond.sptk UnAlignedByteDoneDownLoop br.ret.spnt brp
ByteMoveDown: nop.m 0 add t20 = -1, t20 // adjust source add t21 = -1, t21 // adjust destination ;;
ByteMoveDownLoop: cmp.ne pt1 = zero, a2 ;;
(pt1) ld1 t10 = [t21], -1 (pt1) add a2 = -1, a2 ;;
(pt1) st1 [t20] = t10, -1 (pt1) br.cond.sptk ByteMoveDownLoop br.ret.spnt brp ;;
LEAF_EXIT(RtlMoveMemory)
LEAF_ENTRY(RtlCompareMemory)
cmp.eq pt0 = 0, a2 mov v0 = 0 (pt0) br.ret.spnt.many brp ;;
add t2 = -1, a2
Rcmp10: ld1 t0 = [a0], 1 ld1 t1 = [a1], 1 ;;
cmp4.eq pt2 = t0, t1 ;;
(pt2) cmp.ne.unc pt1 = v0, t2 (pt2) add v0 = 1, v0 (pt1) br.cond.dptk.few Rcmp10
br.ret.sptk.many brp
LEAF_EXIT(RtlCompareMemory)
//++//// VOID// RtlCopyIa64FloatRegisterContext (// PFLOAT128 Destination,// PFLOAT128 Source,// ULONGLONG Length// )//// Routine Description://// This routine copies floating point context from one place to// another. It assumes both the source and the destination are// 16-byte aligned and the buffer contains only memory image of// floating point registers. Note that Length must be greater// than 0 and a multiple of 16.//// Arguments://// a0 - Destination// a1 - Source// a2 - Length//// Return Value://// None.////--
NESTED_ENTRY(RtlCopyIa64FloatRegisterContext)
.prologue .save ar.lc, t22 mov t22 = ar.lc shr t0 = a2, 4 ;;
cmp.gtu pt0, pt1 = 16, a2 add t0 = -1, t0 ;;
PROLOGUE_END
(pt1) mov ar.lc = t0(pt0) br.ret.spnt brp
Rcf10:
ldf.fill ft0 = [a1], 16 nop.m 0 nop.i 0 ;;
stf.spill [a0] = ft0, 16 nop.i 0 br.cloop.dptk Rcf10 ;;
nop.m 0 mov ar.lc = t22 br.ret.sptk brp ;;
NESTED_EXIT(RtlCopyIa64FloatRegisterContext)
NESTED_ENTRY(RtlpCopyContextSubSet)
.prologue .save ar.lc, t22 mov t22 = ar.lc mov t0 = a0 mov t1 = a1 ;;
PROLOGUE_END
ld8 t3 = [t1], CxFltS0 ;;
st8 [t0] = t3, CxFltS0 mov t2 = 3
add t10 = CxFltS4, a0 add t11 = CxFltS4, a1 ;;
mov ar.lc = t2
Rcc10: ldf.fill ft0 = [t1], 16 ;;
stf.spill [t0] = ft0, 16 mov t2 = 15 br.cloop.dptk.few Rcc10 ;;
mov t0 = CxStIFS mov t1 = CxStFPSR mov ar.lc = t2
Rcc20: ldf.fill ft0 = [t11], 16 ;;
stf.spill [t10] = ft0, 16 sub t2 = t0, t1 br.cloop.dptk.few Rcc20 ;;
add t11 = CxStFPSR, a1 add t10 = CxStFPSR, a0 shr t2 = t2, 3 ;;
mov ar.lc = t2 ;;
Rcc30: ld8 t0 = [t11], 8 ;;
st8 [t10] = t0, 8 nop.i 0
br.cloop.dptk.few Rcc30 ;;
nop.m 0 mov ar.lc = t22 br.ret.sptk brp
NESTED_EXIT(RtlpCopyContextSubSet)
//++//// VOID// RtlPrefetchMemoryNonTemporal (// IN PVOID Source,// IN SIZE_T Length// )//// Routine Description://// This routine prefetches memory at Source, for Length bytes into// the closest cache to the processor.//// N.B. Currently this code assumes a line size of 32 bytes. At// some stage it should be altered to determine and use the processor's// actual line size.//// Arguments://// a0 - Source// a1 - Length//// Return Value://// None.////--
LEAF_ENTRY(RtlPrefetchMemoryNonTemporal) .prologue lfetch.nta [a0], 32 // get first line coming .save ar.lc, t0 mov.i t0 = ar.lc // save loop counter shr a1 = a1, 5 // determine loop count ;;
.body
add t2 = -1, a1 // subtract out already fetched line cmp.lt pt0, pt1 = 2, a1 // check if less than one line to fetch ;;
(pt0) mov ar.lc = t2 // set loop count (pt1) br.ret.spnt.few brp // return if no more lines to fetch ;;
Rpmnt10: lfetch.nta [a0], 32 // fetch next line br.cloop.dptk.many Rpmnt10 // loop while more lines to fetch ;;
mov ar.lc = t0 // restore loop counter br.ret.sptk.many brp // return
LEAF_EXIT(RtlPrefetchMemoryNonTemporal)
|
