//
// 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)


//++
//
// RtlCompareMemory
//
//--
        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 32.
//
// 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, 5
        ;;

        cmp.gtu     pt0, pt1 = 32, a2
        add         t0 = -1, t0
        add         t1 = 16, a1
        ;;

        PROLOGUE_END
#if DBG
        and         t4 = 0x1f, a2 
        ;;
        cmp.ne      pt2 = 0, t4
        ;;
(pt2)   break.i     BREAKPOINT_STOP                
#endif 
        add         t2 = 16, a0
(pt1)   mov         ar.lc = t0
(pt0)   br.ret.spnt brp

Rcf10:

        ldf.fill    ft0 = [a1], 32
        ldf.fill    ft1 = [t1], 32
        nop.i       0
        ;;

        stf.spill   [a0] = ft0, 32
        stf.spill   [t2] = ft1, 32
        br.cloop.dptk Rcf10
        ;;

        nop.m       0
        mov         ar.lc = t22
        br.ret.sptk brp
        ;;

        NESTED_EXIT(RtlCopyIa64FloatRegisterContext)


//++
//
// 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)