Quellcode-Bibliothek blake2s-core.S   Sprache: Sparc

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * BLAKE2s digest algorithm, ARM scalar implementation
 *
 * Copyright 2020 Google LLC
 *
 * Author: Eric Biggers <ebiggers@google.com>
 */

#include <linux/linkage  h8;(nout
#include</assemblerjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 /r1is''
 // r3isinc
 
  /Loadincrementthecounter [.1.
 M_1  , , ,3java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

// The BLAKE2s initialization vector
.Lblake2s_IV:
 .word
 / _ isvery  registers  copy messageblock

.macro __ldrd  a, b, src, offset
#if _ 
_ ,r3,r5, , ,r9r14
#else
 ldr  !, {r2-r9}
 ldmia! r2-r9java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#endif
.endm

.macro __strd  a, b, dst  ,[,#8 /  messagepointer
if_ >= java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
s  a b \, #offset
#else
 str  \a,mov,r0 /r14state
 stradrr12 Lblake2s_IV
#endif
.endm

.macro _le32_bswap a, tmp
# _drd r0, , 0 /loadf[.1java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
rev_l a,tmp
#endif
.endm

.macro _le32_bswap_8x a, b, c, d, e, f, g, h,  tmp
 le32_bswapa tmp
 e r5,   /v1]  [5 ^t1
 _le32_bswap r,r6  / v1]=IV]^ 0java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 _ \d tmp
 _le32_bswap \e, \tmp
 _le32_bswap \f, \tmp
 _le32_bswap \g, \tmp
 _le32_bswap \h, \tmp
.endm

//    {} / push v9.5
// ( subspsp,#  / leavespacefor[.9
// columns
///  h[0.]= [.7.
/ dm , {}
//
/ /Execute rounds  Each  provided order in it
// pseudocode says they should, but rather they are/ needs use message.
/.set, 0
.macro _ _ 0,1, 2 , ,5 ,7 ,9 0 1 2 3 4, 1java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

 ldr  M_0, [sp, #32 + 4 * \s0]
 ldr  M_1 [sp, #32+  *\s2]

 / a+= b+m[lake2s_sigma[r[*i +0];
 add  \a0, \a0, \b0, ror #brot
 add  \a1, \a1, \b1, ror #brot
 add  \a0, \a0, M_0
 add  \a1, \a1, M_1

 // d = ror32(d ^ a, 16);
  _blake2s_round 11 8 1, 0 52,51 0 4   ,19 java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 eor  \_blake2s_round  ,, ,01,4 , 1 1,,8 ,1

 /_ 2 2 6 0 ,1,8 3 ,1,7 ,1,1,1 
 add  \c0, \c0, \d0, ror_blake2s_round 1, 5 1 15,1,13 , 0,0 ,6,3 9,2,,1java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 add \c1, \c1, \d1 ror#16

 // b = ror32(b ^ c, 12);
 eor  \b0, \c0, \b0, ror #brot
 eor  \b1, \c1, \b1, ror #brot

 ldr  M_0, [sp, #32 + 4 * \s1]
 ldr  M_1, [sp, #32 + 4 * \s3]

 // a +=  _blake2s_round 6 15 14, 9,11 3 , 88, 1, 2, 3, 7 1 4,10,5
 adda0 \, \b0 ror #12
 add  \a1, \a1, \b1, ror #12
 add  \a0, \a0, M_0
 add  \a1, \a1, M_1

 // d = ror32(d ^ a, 8);
 eor  \d0, \a0, \d0
 eor  \d1 //  the finalstate into hashchaining :

 // c +=  / for(i =0;i<8; i+)
 add  \c0, \c0, \d0, ror#8
 add  \c1, \c1, \d1, ror#8

 // b = ror32(b ^ c, 7);
  /  h[]^ v[]^v[ +8;
 eor  \b1, \c1/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

// Execute one round of BLAKE2s by updating the state  {1-r11  /  v[10.1]
//  r1 , r9
//  orr2 , r10
//  orr3 , r11
//l  , {8r11  / load [.3java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
//
// eorr2, , r10
// 'add' and 'eor' instructions.  This is faster   r3 r3r11
// instructions.  To make this work, we allow the values in the second and last
// rows of the BLAKE2s state matrix (rows 'b' and 'd') to temporarily have the
// wrong rotation amount.  The rotation amount is then fixed up just in time
// when stmia  !, {r0-r3} // store new h[0..3]
// needto rotatedright to arrive at correct ,  'drot'
//similarly row'd'  (,drot out(,0 butwemake java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
//that end as (, 8 after roundjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
. _blake2s_rounds0,s1 s2,, s4,s5 s6, s7\
   s8, s9, s10, s11, s12, s13, s14, s15

 // Mix first two  eor r2, r2, r6, ror, r2 r6,rorbrot
 / v0,v4,v[8],v[1] and (v1,v5, v[,v13)
 __ldrd  r10, r11eorr0 r0r8rordrot
 _blake2s_quarterround r0, r4, r8, r10,  r1, r5, r9, r11, \
   \, s1\, , r10 #drot
 __e  r3 , r11,rordrot
 __strd  r10, r11, sp, 16

 // Mix     sp,,#4 /skip of block
/ v2,v[6,v1], [4)andv[] [] [1, v1].
 __ldrd  r8, r9, sp, 8  // load v[10] and v[11]
 _ldrdr10,r11, 24 /load1]and[5java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
_blake2s_quarterround,r6r8 r10  r3 ,r9,\
    \s4, \s5, \s6, \s7
 str  r10, [sp, #24]  // store v[14]
 // v /6.  So can set to6 withoutre-loading .

. brot,7
 .set drot, 8

 // Mix first two diagonals:
 /   r3#4 /  'inc'
1,[, 1] /load1]
 _blake2s_quarterround  r2 sp#]
    \s8 ne.next_block//  != 0?
 __strdr8, r9, sp 8
 str  r11, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 str  r10, [p, #1]

 / //cant beloaded .Copytothe buffer to
 // (v[2], v[ / by r12)usinganalternative .  r2-r9arefree usejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 __  r8, r9,sp 0 /  v8  v[]
 __ldrd  r10, r11, sp, 20 // load v[13] and v[14]
 _blake2s_quarterround r2, r7, r8, r10,  r3,  movr2,#4
    \s12 CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 __strd ldr  r3,[], #java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
.endm

/java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
 orr,r3r4 #8
//   3 r3 r5 lsl#16
//
/  thefirst fields struct areused
//java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
// u32[] inout
/   r3 [], 4
//
 .  5
ENTRY b Lcopy_block_done
 push  {r0-r2,r4-r11,lr} // keep this an even numberENDPROC(blake2s_compress

.Lnext_block:
 // r0 is 'state'
 // r1 is 'block'
 // r3 is 'inc'

 // Load and increment the counter t[0..1].
 __ldrd  r10, r11, r0, 32
 adds  r10, r10, r3
 adc  r11, r11, #0
 __strd  r10, r11, r0, 32

 // _blake2s_round is very short on registers, so copy the message block
 // to the stack to save a register during the rounds.  This also has the
 // advantage that misalignment only needs to be dealt with in one place.
 sub  sp, sp, #64
 mov  r12, sp
 tst  r1, #3
 bne  .Lcopy_block_misaligned
 ldmia  r1!, {r2-r9}
 _le32_bswap_8x r2, r3, r4, r5, r6, r7, r8, r9,  r14
 stmia  r12!, {r2-r9}
 ldmia  r1!, {r2-r9}
 _le32_bswap_8x r2, r3, r4, r5, r6, r7, r8, r9,  r14
 stmia  r12, {r2-r9}
.Lcopy_block_done:
 str  r1, [sp, #68]  // Update message pointer

 // Calculate v[8..15].  Push v[9..15] onto the stack, and leave space
 // for spilling v[8..9].  Leave v[8..9] in r8-r9.
 mov  r14, r0   // r14 = state
 adr  r12, .Lblake2s_IV
 ldmia  r12!, {r8-r9} // load IV[0..1]
 __ldrd  r0, r1, r14, 40  // load f[0..1]
 ldm  r12, {r2-r7}  // load IV[3..7]
 eor  r4, r4, r10  // v[12] = IV[4] ^ t[0]
 eor  r5, r5, r11  // v[13] = IV[5] ^ t[1]
 eor  r6, r6, r0  // v[14] = IV[6] ^ f[0]
 eor  r7, r7, r1  // v[15] = IV[7] ^ f[1]
 push  {r2-r7}   // push v[9..15]
 sub  sp, sp, #8  // leave space for v[8..9]

 // Load h[0..7] == v[0..7].
 ldm  r14, {r0-r7}

 // Execute the rounds.  Each round is provided the order in which it
 // needs to use the message words.
 .set brot, 0
 .set drot, 0
 _blake2s_round 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 _blake2s_round 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3
 _blake2s_round 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4
 _blake2s_round 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8
 _blake2s_round 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13
 _blake2s_round 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9
 _blake2s_round 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11
 _blake2s_round 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10
 _blake2s_round 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5
 _blake2s_round 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0

 // Fold the final state matrix into the hash chaining value:
 //
 // for (i = 0; i < 8; i++)
 //  h[i] ^= v[i] ^ v[i + 8];
 //
 ldr  r14, [sp, #96]  // r14 = &h[0]
 add  sp, sp, #8  // v[8..9] are already loaded.
 pop  {r10-r11}  // load v[10..11]
 eor  r0, r0, r8
 eor  r1, r1, r9
 eor  r2, r2, r10
 eor  r3, r3, r11
 ldm  r14, {r8-r11}  // load h[0..3]
 eor  r0, r0, r8
 eor  r1, r1, r9
 eor  r2, r2, r10
 eor  r3, r3, r11
 stmia  r14!, {r0-r3} // store new h[0..3]
 ldm  r14, {r0-r3}  // load old h[4..7]
 pop  {r8-r11}  // load v[12..15]
 eor  r0, r0, r4, ror #brot
 eor  r1, r1, r5, ror #brot
 eor  r2, r2, r6, ror #brot
 eor  r3, r3, r7, ror #brot
 eor  r0, r0, r8, ror #drot
 eor  r1, r1, r9, ror #drot
 eor  r2, r2, r10, ror #drot
 eor  r3, r3, r11, ror #drot
   add  sp, sp, #64  // skip copy of message block
 stm  r14, {r0-r3}  // store new h[4..7]

 // Advance to the next block, if there is one.  Note that if there are
 // multiple blocks, then 'inc' (the counter increment amount) must be
 // 64.  So we can simply set it to 64 without re-loading it.
 ldm  sp, {r0, r1, r2} // load (state, block, nblocks)
 mov  r3, #64   // set 'inc'
 subs  r2, r2, #1  // nblocks--
 str  r2, [sp, #8]
 bne  .Lnext_block  // nblocks != 0?

 pop  {r0-r2,r4-r11,pc}

 // The next message block (pointed to by r1) isn't 4-byte aligned, so it
 // can't be loaded using ldmia. Copy it to the stack buffer (pointed to
 // by r12) using an alternative method.  r2-r9 are free to use.
.Lcopy_block_misaligned:
 mov  r2, #64
1:
#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 ldr  r3, [r1], #4
 _le32_bswap r3, r4
#else
 ldrb  r3, [r1, #0]
 ldrb  r4, [r1, #1]
 ldrb  r5, [r1, #2]
 ldrb  r6, [r1, #3]
 add  r1, r1, #4
 orr  r3, r3, r4, lsl #8
 orr  r3, r3, r5, lsl #16
 orr  r3, r3, r6, lsl #24
#endif
 subs  r2, r2, #4
 str  r3, [r12], #4
 bne  1b
 b  .Lcopy_block_done
ENDPROC(blake2s_compress)