sleeping_kangaroo12 0.0.3 → 0.0.4

data/ext/xkcp/lib/low/Xoodoo/ARMv7A-NEON/Xoodoo-uf-armv7a-neon-le-gcc.s

@@ -1,485 +0,0 @@
-@
-@ The eXtended Keccak Code Package (XKCP)
-@ https://github.com/XKCP/XKCP
-@
-@ The Xoodoo permutation, designed by Joan Daemen, Seth Hoffert, Gilles Van Assche and Ronny Van Keer.
-@
-@ Implementation by Ronny Van Keer, hereby denoted as "the implementer".
-@
-@ For more information, feedback or questions, please refer to the Keccak Team website:
-@ https://keccak.team/
-@
-@ To the extent possible under law, the implementer has waived all copyright
-@ and related or neighboring rights to the source code in this file.
-@ http://creativecommons.org/publicdomain/zero/1.0/
-@
-
-@ WARNING: These functions work only on little endian CPU with@ ARMv7a + NEON architecture (Cortex-A8, ...).
-
-
-.text
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_Initialize(void *state)
-@
-    .align 8
-.global Xoodoo_Initialize
-.type	Xoodoo_Initialize, %function;
-Xoodoo_Initialize:
-    vmov.i32    q0, #0
-    vstm        r0!, { d0 - d1 }
-    vstm        r0!, { d0 - d1 }
-    vstm        r0!, { d0 - d1 }
-    bx          lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-@
-.global Xoodoo_AddBytes
-.type	Xoodoo_AddBytes, %function;
-Xoodoo_AddBytes:
-    push    {r4,lr}
-    adds    r0, r0, r2                              @ state += offset
-    subs    r3, r3, #4                              @ .if length >= 4
-    bcc     Xoodoo_AddBytes_Bytes
-Xoodoo_AddBytes_LanesLoop:                           @ then, perform on lanes
-    ldr     r2, [r0]
-    ldr     r4, [r1], #4
-    eors    r2, r2, r4
-    str     r2, [r0], #4
-    subs    r3, r3, #4
-    bcs     Xoodoo_AddBytes_LanesLoop
-Xoodoo_AddBytes_Bytes:
-    adds    r3, r3, #3
-    bcc     Xoodoo_AddBytes_Exit
-Xoodoo_AddBytes_BytesLoop:
-    ldrb    r2, [r0]
-    ldrb    r4, [r1], #1
-    eors    r2, r2, r4
-    strb    r2, [r0], #1
-    subs    r3, r3, #1
-    bcs     Xoodoo_AddBytes_BytesLoop
-Xoodoo_AddBytes_Exit:
-    pop     {r4,pc}
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-@
-.global Xoodoo_OverwriteBytes
-.type	Xoodoo_OverwriteBytes, %function;
-Xoodoo_OverwriteBytes:
-    adds    r0, r0, r2                              @ state += offset
-    subs    r3, r3, #4                              @ .if length >= 4
-    bcc     Xoodoo_OverwriteBytes_Bytes
-Xoodoo_OverwriteBytes_LanesLoop:                     @ then, perform on words
-    ldr     r2, [r1], #4
-    str     r2, [r0], #4
-    subs    r3, r3, #4
-    bcs     Xoodoo_OverwriteBytes_LanesLoop
-Xoodoo_OverwriteBytes_Bytes:
-    adds    r3, r3, #3
-    bcc     Xoodoo_OverwriteBytes_Exit
-Xoodoo_OverwriteBytes_BytesLoop:
-    ldrb    r2, [r1], #1
-    strb    r2, [r0], #1
-    subs    r3, r3, #1
-    bcs     Xoodoo_OverwriteBytes_BytesLoop
-Xoodoo_OverwriteBytes_Exit:
-    bx      lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_OverwriteWithZeroes(void *state, unsigned int byteCount)
-@
-.global Xoodoo_OverwriteWithZeroes
-.type	Xoodoo_OverwriteWithZeroes, %function;
-Xoodoo_OverwriteWithZeroes:
-    movs    r3, #0
-    lsrs    r2, r1, #2
-    beq     Xoodoo_OverwriteWithZeroes_Bytes
-Xoodoo_OverwriteWithZeroes_LoopLanes:
-    str     r3, [r0], #4
-    subs    r2, r2, #1
-    bne     Xoodoo_OverwriteWithZeroes_LoopLanes
-Xoodoo_OverwriteWithZeroes_Bytes:
-    ands    r1, #3
-    beq     Xoodoo_OverwriteWithZeroes_Exit
-Xoodoo_OverwriteWithZeroes_LoopBytes:
-    strb    r3, [r0], #1
-    subs    r1, r1, #1
-    bne     Xoodoo_OverwriteWithZeroes_LoopBytes
-Xoodoo_OverwriteWithZeroes_Exit:
-    bx      lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_ExtractBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
-@
-.global Xoodoo_ExtractBytes
-.type	Xoodoo_ExtractBytes, %function;
-Xoodoo_ExtractBytes:
-    adds    r0, r0, r2                              @ state += offset
-    subs    r3, r3, #4                              @ .if length >= 4
-    bcc     Xoodoo_ExtractBytes_Bytes
-Xoodoo_ExtractBytes_LanesLoop:                       @ then, handle words
-    ldr     r2, [r0], #4
-    str     r2, [r1], #4
-    subs    r3, r3, #4
-    bcs     Xoodoo_ExtractBytes_LanesLoop
-Xoodoo_ExtractBytes_Bytes:
-    adds    r3, r3, #3
-    bcc     Xoodoo_ExtractBytes_Exit
-Xoodoo_ExtractBytes_BytesLoop:
-    ldrb    r2, [r0], #1
-    strb    r2, [r1], #1
-    subs    r3, r3, #1
-    bcs     Xoodoo_ExtractBytes_BytesLoop
-Xoodoo_ExtractBytes_Exit:
-    bx      lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_ExtractAndAddBytes(void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
-@
-.global Xoodoo_ExtractAndAddBytes
-.type	Xoodoo_ExtractAndAddBytes, %function;
-Xoodoo_ExtractAndAddBytes:
-    push    {r4,r5}
-    adds    r0, r0, r3                                  @ state += offset (offset register no longer needed, reuse for length)
-    ldr     r3, [sp, #8]                                @ get length argument from stack
-    subs    r3, r3, #4                                  @ .if length >= 4
-    bcc     Xoodoo_ExtractAndAddBytes_Bytes
-Xoodoo_ExtractAndAddBytes_LanesLoop:                     @ then, handle words
-    ldr     r5, [r0], #4
-    ldr     r4, [r1], #4
-    eors    r5, r5, r4
-    str     r5, [r2], #4
-    subs    r3, r3, #4
-    bcs     Xoodoo_ExtractAndAddBytes_LanesLoop
-Xoodoo_ExtractAndAddBytes_Bytes:
-    adds    r3, r3, #3
-    bcc     Xoodoo_ExtractAndAddBytes_Exit
-Xoodoo_ExtractAndAddBytes_BytesLoop:
-    ldrb    r5, [r0], #1
-    ldrb    r4, [r1], #1
-    eors    r5, r5, r4
-    strb    r5, [r2], #1
-    subs    r3, r3, #1
-    bcs     Xoodoo_ExtractAndAddBytes_BytesLoop
-Xoodoo_ExtractAndAddBytes_Exit:
-    pop     {r4,r5}
-    bx      lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-
-.macro    mRound
-
-    @ Theta: Column Parity Mixer
-    veor.32     q4, q0, q1
-    veor.32     q4, q4, q2
-    vext.32     q4, q4, q4, #3
-    vshl.u32    q3, q4, #5
-    vsri.u32    q3, q4, #32-5
-    vshl.u32    q5, q4, #14
-    vsri.u32    q5, q4, #32-14
-    veor.32     q3, q3, q5
-    veor.32     q0, q0, q3
-    veor.32     q1, q1, q3
-    veor.32     q5, q2, q3           @ q2 resides in q5
-
-    @ Rho-west: Plane shift
-    @ Iota: add round constant
-    vshl.u32    q2, q5, #11
-    vext.32     q1, q1, q1, #3
-    vldmia      r1!, {d6}             @ iota
-    vsri.u32    q2, q5, #32-11
-    veor.32     d0, d0, d6        @ iota
-
-    @ Chi: non linear step, on colums
-    vbic.32     q3, q2, q1
-    vbic.32     q4, q0, q2
-    vbic.32     q5, q1, q0
-    veor.32     q0, q0, q3
-    veor.32     q4, q1, q4           @ q1 resides in q4
-    veor.32     q2, q2, q5
-
-    @ Rho-east: Plane shift
-    vext.32     q5, q2, q2, #2
-    vshl.u32    q1, q4, #1
-    vshl.u32    q2, q5, #8
-    vsri.u32    q1, q4, #32-1
-    vsri.u32    q2, q5, #32-8
-    .endm
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_Permute_6rounds( void *state )
-@
-.global Xoodoo_Permute_6rounds
-.type	Xoodoo_Permute_6rounds, %function;
-Xoodoo_Permute_6rounds:
-    vpush       {q4-q5}
-    vldmia      r0, {q0-q2}
-    adr         r1, _rc6
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    vstmia      r0, {q0-q2}
-    vpop        {q4-q5}
-    bx          lr
-    .ltorg
-    .align  8
-_rc12:
-    .quad          0x00000058
-    .quad          0x00000038
-    .quad          0x000003C0
-    .quad          0x000000D0
-    .quad          0x00000120
-    .quad          0x00000014
-_rc6:
-    .quad          0x00000060
-    .quad          0x0000002C
-    .quad          0x00000380
-    .quad          0x000000F0
-    .quad          0x000001A0
-    .quad          0x00000012
-
-
-@ ----------------------------------------------------------------------------
-@
-@  void Xoodoo_Permute_12rounds( void *state )
-@
-.global Xoodoo_Permute_12rounds
-.type	Xoodoo_Permute_12rounds, %function;
-Xoodoo_Permute_12rounds:
-    vpush       {q4-q5}
-    vldmia      r0, {q0-q2}
-    adr         r1, _rc12
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    vstmia      r0, {q0-q2}
-    vpop        {q4-q5}
-    bx          lr
-    .align  8
-
-
-.equ Xoofff_BlockSize   , 3*4*4
-
-@ ----------------------------------------------------------------------------
-@
-@ void Xoofff_AddIs(BitSequence *output, const BitSequence *input, BitLength bitLen)
-.global Xoofff_AddIs
-.type	Xoofff_AddIs, %function;
-Xoofff_AddIs:
-    subs        r2, r2, #Xoofff_BlockSize*8
-    bcc         Xoofff_AddIs_LessThanBlock
-Xoofff_AddIs_BlockLoop:
-    vld1.32     {q0, q1}, [r1]!
-    vld1.32     {q2}, [r1]!
-    vld1.32     {q8, q9}, [r0]!
-    vld1.32     {q10}, [r0]!
-    veor.32     q8, q8, q0
-    sub         r0, r0, #Xoofff_BlockSize
-    veor.32     q9, q9, q1
-    veor.32     q10, q10, q2
-    vst1.32     {q8, q9}, [r0]!
-    vst1.32     {q10}, [r0]!
-    subs        r2, r2, #Xoofff_BlockSize*8
-    bcs         Xoofff_AddIs_BlockLoop
-Xoofff_AddIs_LessThanBlock:
-    adds        r2, r2, #Xoofff_BlockSize*8
-    beq         Xoofff_AddIs_Return
-    subs        r2, r2, #16*8
-    bcc         Xoofff_AddIs_LessThan16
-Xoofff_AddIs_16Loop:
-    vld1.32     {q0}, [r1]!
-    vld1.32     {q1}, [r0]
-    veor.32     q1, q1, q0
-    vst1.32     {q1}, [r0]!
-    subs        r2, r2, #16*8
-    bcs         Xoofff_AddIs_16Loop
-Xoofff_AddIs_LessThan16:
-    adds        r2, r2, #16*8
-    beq         Xoofff_AddIs_Return
-    subs        r2, r2, #4*8
-    bcc         Xoofff_AddIs_LessThan4
-Xoofff_AddIs_4Loop:
-    ldr         r3, [r0]
-    ldr         r12, [r1], #4
-    eors        r3, r3, r12
-    str         r3, [r0], #4
-    subs        r2, r2, #4*8
-    bcs         Xoofff_AddIs_4Loop
-Xoofff_AddIs_LessThan4:
-    adds        r2, r2, #4*8
-    beq         Xoofff_AddIs_Return
-    subs        r2, r2, #8
-    bcc         Xoofff_AddIs_LessThan1
-Xoofff_AddIs_1Loop:
-    ldrb        r3, [r0]
-    ldrb        r12, [r1], #1
-    eors        r3, r3, r12
-    strb        r3, [r0], #1
-    subs        r2, r2, #8
-    bcs         Xoofff_AddIs_1Loop
-Xoofff_AddIs_LessThan1:
-    adds        r2, r2, #8
-    beq         Xoofff_AddIs_Return
-    ldrb        r3, [r0]
-    ldrb        r12, [r1]
-    movs        r1, #1
-    eors        r3, r3, r12
-    lsls        r1, r1, r2
-    subs        r1, r1, #1
-    ands        r3, r3, r1
-    strb        r3, [r0]
-Xoofff_AddIs_Return:
-    bx          lr
-    .align  8
-
-
-@ ----------------------------------------------------------------------------
-@
-@ size_t Xoofff_CompressFastLoop(unsigned char *kRoll, unsigned char *xAccu, const unsigned char *input, size_t length)
-@
-.global Xoofff_CompressFastLoop
-.type	Xoofff_CompressFastLoop, %function;
-Xoofff_CompressFastLoop:
-    subs        r3, #Xoofff_BlockSize       @ length must be greater than block size
-    push        {r4,r5,r6,lr}
-    vpush       {q4-q7}
-    mov         r4, r0                      @ kRoll
-    mov         r5, r1                      @ xAccu
-    mov         r6, r2                      @ initial input
-    vld1.32     {q6,q7}, [r0]!            @ get kRoll
-    vld1.32     {q8}, [r0]
-    vld1.32     {q9,q10}, [r1]!            @ get xAccu
-    vld1.32     {q11}, [r1]
-Xoofff_CompressFastLoop_Loop:
-    vld1.32     {q0,q1}, [r2]!            @ get input
-    adr         r1, _rc6b
-    vld1.32     {q2}, [r2]!
-    veor.32     q0, q0, q6
-    veor.32     q1, q1, q7
-    veor.32     q2, q2, q8
-    mRound                                  @ permutation
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    veor.32     q9, q9, q0               @ add into xAccu
-    veor.32     q10, q10, q1
-    veor.32     q11, q11, q2
-    vshl.u32    q3, q6, #13               @ roll-c kRoll
-    veor.32     q3, q3, q6
-    vshl.u32    q4, q7, #3
-    vsri.u32    q4, q7, #32-3
-    veor.32     q3, q3, q4
-    vext.32     q3, q6, q3, #1
-    vmov        q6, q7
-    vmov        q7, q8
-    vmov        q8, q3
-    subs        r3, #Xoofff_BlockSize
-    bcs         Xoofff_CompressFastLoop_Loop
-    vst1.32     {q6,q7}, [r4]!            @ save kRoll
-    vst1.32     {q8}, [r4]
-    vst1.32     {q9,q10}, [r5]!            @ save xAccu
-    vst1.32     {q11}, [r5]
-    sub         r0, r2, r6                  @ return number of bytes processed
-    vpop        {q4-q7}
-    pop         {r4,r5,r6,pc}
-    .ltorg
-    .align  8
-_rc6b:
-    .quad          0x00000060
-    .quad          0x0000002C
-    .quad          0x00000380
-    .quad          0x000000F0
-    .quad          0x000001A0
-    .quad          0x00000012
-
-
-@ ----------------------------------------------------------------------------
-@
-@ size_t Xoofff_ExpandFastLoop(unsigned char *yAccu, const unsigned char *kRoll, unsigned char *output, size_t length)
-@
-.global Xoofff_ExpandFastLoop
-.type	Xoofff_ExpandFastLoop, %function;
-Xoofff_ExpandFastLoop:
-    subs        r3, #Xoofff_BlockSize       @ length must be greater than block size
-    push        {r4,r5,r6,lr}
-    vpush       {q4-q7}
-    mov         r5, r0                      @ yAccu
-    mov         r6, r2                      @ initial output
-    vld1.32     {q6,q7}, [r1]!            @ get kRoll
-    vld1.32     {q8}, [r1]
-    vld1.32     {q9,q10}, [r0]!            @ get yAccu
-    vld1.32     {q11}, [r0]
-Xoofff_ExpandFastLoop_Loop:
-    vmov        q0, q9
-    vmov        q1, q10
-    vmov        q2, q11
-    adr         r1, _rc6b
-    mRound                                  @ permutation
-    mRound
-    mRound
-    mRound
-    mRound
-    mRound
-    veor.32     q0, q0, q6               @ add k and extract
-    veor.32     q1, q1, q7
-    veor.32     q2, q2, q8
-    vst1.32     {q0,q1}, [r2]!            @ save output
-    vst1.32     {q2}, [r2]!
-    vshl.u32    q3, q9, #5                @ roll-e yAccu
-    vsri.u32    q3, q9, #32-5
-    vshl.u32    q4, q10, #13
-    vsri.u32    q4, q10, #32-13
-    veor.32     q3, q3, q4
-    vand.32     q4, q10, q11
-    veor.32     q3, q3, q4
-    vmov.i32    q4, #7
-    veor.32     q3, q3, q4
-    vext.32     q3, q9, q3, #1
-    vmov        q9, q10
-    vmov        q10, q11
-    vmov        q11, q3
-    subs        r3, #Xoofff_BlockSize
-    bcs         Xoofff_ExpandFastLoop_Loop
-    vst1.32     {q9,q10}, [r5]!            @ save yAccu
-    sub         r0, r2, r6                  @ return number of bytes processed
-    vst1.32     {q11}, [r5]
-    vpop        {q4-q7}
-    pop         {r4,r5,r6,pc}
-    .align  8
-
-