Apple-2gs-SW/65816-crypto
1
0
Fork 0
mirror of https://github.com/sheumann/65816-crypto.git synced 2024-11-25 10:30:45 +00:00
Code Issues Projects Releases Wiki Activity
011628d3ce
65816-crypto/sha1.macros

358 lines
5.1 KiB
Plaintext
Raw Normal View History

Add comments and copyright notices, and rename chunk to block.
2017-07-01 22:39:26 +00:00
* Copyright (c) 2017 Stephen Heumann
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
* Right-rotate 32-bit value in &loc (DP or 16-bit address) by &n positions
macro
ROTR4 &loc,&n
aif &n>16,.dorotl
lda &loc+2
lcla &i
&i seta &n
.rotrloop
lsr a ;to set carry
ror &loc
ror &loc+2
&i seta &i-1
aif &i>0,.rotrloop
ago .end
.dorotl
ROTL4 &loc,32-&n
.end
mend
* Left-rotate 32-bit value in &loc (DP or 16-bit address) by &n positions
macro
ROTL4 &loc,&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &n>16,.dorotr2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
lda &loc
lcla &i
&i seta &n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.rotlloop2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
asl a ;to set carry
rol &loc+2
rol &loc
&i seta &i-1
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &i>0,.rotlloop2
ago .end2
.dorotr2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
ROTR4 &loc,32-&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.end2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
mend
* &to := &from ROTR4 &n
macro
ROTR4MOVE &to,&from,&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &n>16,.dorotl3
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
lda &from
sta &to
lda &from+2
sta &to+2
lcla &i
&i seta &n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.rotrloop3
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
lsr a ;to set carry
ror &to
ror &to+2
&i seta &i-1
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &i>0,.rotrloop3
ago .end3
Typos
2017-07-03 02:35:17 +00:00
.dorotl3
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
ROTL4MOVE &to,&from,32-&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.end3
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
mend
* &to := &from ROTL4 &n
macro
ROTL4MOVE &to,&from,&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &n>16,.dorotr4
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
lda &from+2
sta &to+2
lda &from
sta &to
lcla &i
&i seta &n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.rotlloop4
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
asl a ;to set carry
rol &to+2
rol &to
&i seta &i-1
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
aif &i>0,.rotlloop4
ago .end4
.dorotr4
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
ROTR4MOVE &to,&from,32-&n
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
.end4
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
mend
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
* This makes a function wrapper that is callable from C,
* taking a pointer to the context structure as its argument.
macro
CFunction &fn
phb
plx
ply
tdc
pld
plb
plb
phy
phx
plb
pha
jsl &fn
pld
rtl
mend
* Macros to operate on elements of the message schedule (W)
macro
&lab lda_w &i,&inc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
lcla &j
&j seta &i
.modloop1
aif &j<20,.goodidx1
&j seta &j-20
ago .modloop1
.goodidx1
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
aif C:&inc<>0,.haveinc
lcla &inc
.haveinc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
&lab lda w+(&j)*4+&inc
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
mend
macro
&lab eor_w &i,&inc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
lcla &j
&j seta &i
.modloop2
aif &j<20,.goodidx2
&j seta &j-20
ago .modloop2
.goodidx2
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
aif C:&inc<>0,.haveinc
lcla &inc
.haveinc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
&lab eor w+(&j)*4+&inc
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
mend
macro
&lab sta_w &i,&inc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
lcla &j
&j seta &i
.modloop3
aif &j<20,.goodidx3
&j seta &j-20
ago .modloop3
.goodidx3
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
aif C:&inc<>0,.haveinc
lcla &inc
.haveinc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
&lab sta w+(&j)*4+&inc
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
mend
macro
&lab rol_w &i,&inc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
lcla &j
&j seta &i
.modloop4
aif &j<20,.goodidx4
&j seta &j-20
ago .modloop4
.goodidx4
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
aif C:&inc<>0,.haveinc
lcla &inc
.haveinc
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
&lab rol w+(&j)*4+&inc
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
mend
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
* Compute one part of the message schedule (20 elements)
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
macro
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
ComputeSchedule &part
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
lcla &i
Add comments and copyright notices, and rename chunk to block.
2017-07-01 22:39:26 +00:00
; Flip the endianness of W_0 to W_15 (the current block of the message)
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
aif &part<>1,.skippart1
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
.loop1
lda w+&i*4
xba
ldx w+&i*4+2
sta w+&i*4+2
txa
xba
sta w+&i*4
&i seta &i+1
aif &i<16,.loop1
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
.skippart1
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
; compute the rest of the message schedule (W_16 to W_79)
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
aif &part=1,.loop2
&i seta (&part-1)*20
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
.loop2
lda_w &i-3
eor_w &i-8
eor_w &i-14
eor_w &i-16
sta_w &i
asl a ; to set carry
lda_w &i-3,2
eor_w &i-8,2
eor_w &i-14,2
eor_w &i-16,2
rol a
sta_w &i,2
rol_w &i
&i seta &i+1
Compute SHA-1 message schedule 20 elements at a time, reusing storage. The reduces the storage needed and boosts performance, since the whole schedule is contained in the direct page.
2017-06-30 03:22:06 +00:00
aif &i<&part*20,.loop2
Add implementation of the basic block-processing function for SHA-1.
2017-06-29 21:54:49 +00:00
mend
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
* One iteration of the loop for processing blocks.
Typos
2017-07-03 02:35:17 +00:00
* The a,b,c,d,e variables are given as parameters so we can avoid cycling them.
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
macro
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
BlockLoopIter &a,&b,&c,&d,&e,&iter
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
* f_0 to f_19
aif &part<>1,.skip1
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c
eor &d
and &b
eor &d
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
clc
adc #$7999
sta f_plus_k
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c+2
eor &d+2
and &b+2
eor &d+2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc #$5A82
sta f_plus_k+2
.skip1
* f_20 to f_39
aif &part<>2,.skip2
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &b
eor &c
eor &d
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
clc
adc #$EBA1
sta f_plus_k
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &b+2
eor &c+2
eor &d+2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc #$6ED9
sta f_plus_k+2
.skip2
* f_40 to f_59
aif &part<>3,.skip3
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c
ora &d
and &b
Small cleanups in SHA-1.
2017-06-30 18:23:29 +00:00
sta temp
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c
and &d
Small cleanups in SHA-1.
2017-06-30 18:23:29 +00:00
ora temp
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
clc
adc #$BCDC
sta f_plus_k
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c+2
ora &d+2
and &b+2
Small cleanups in SHA-1.
2017-06-30 18:23:29 +00:00
sta temp
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &c+2
and &d+2
Small cleanups in SHA-1.
2017-06-30 18:23:29 +00:00
ora temp
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc #$8F1B
sta f_plus_k+2
.skip3
* f_60 to f_79
aif &part<>4,.skip4
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &b
eor &c
eor &d
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
clc
adc #$C1D6
sta f_plus_k
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
lda &b+2
eor &c+2
eor &d+2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc #$CA62
sta f_plus_k+2
.skip4
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
ROTL4MOVE temp,&a,5
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
ldx idx
clc
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
lda w+&iter*4,x
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc temp
tay
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
lda w+&iter*4+2,x
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
adc temp+2
tax
clc
tya
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
adc &e
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
tay
txa
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
adc &e+2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
tax
clc
tya
adc f_plus_k
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
sta &e
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
txa
adc f_plus_k+2
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
sta &e+2
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
ROTL4 &b,30
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
mend
* One part of the loop for processing blocks (20 iterations)
macro
BlockLoopPart &part
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
Typos
2017-07-03 02:35:17 +00:00
stz idx
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
loop&part anop
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
BlockLoopIter a_,b,c,d,e,0
BlockLoopIter e,a_,b,c,d,1
BlockLoopIter d,e,a_,b,c,2
BlockLoopIter c,d,e,a_,b,3
BlockLoopIter b,c,d,e,a_,4
Unroll SHA-1 loop with variables substituted to avoid cycling values around. SHA-1 has five state variables (a,b,c,d,e), and each iteration of the core loop cycles their values around (e.g. a->b), in some cases with modifications. By unrolling the loop by a factor of five and appropriately substituting the values operated on in each iteration, we can avoid actually doing the copies implied by this cycling, which gives a fairly significant performance gain.
2017-06-30 05:15:47 +00:00
Don't update index value in each unrolled loop iteration.
2017-06-30 05:34:09 +00:00
clc
lda idx
adc #4*5
cmp #20*4
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
bge endloop&part
Small cleanups in SHA-1.
2017-06-30 18:23:29 +00:00
sta idx
Use separate loops for the four parts of the SHA-1 computation.
2017-06-30 01:51:36 +00:00
jmp loop&part
endloop&part anop
mend
Reference in New Issue Copy Permalink