sleeping_kangaroo12 0.0.1

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

@@ -0,0 +1,485 @@
+@
+@ 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
+
+