crypto/sha/asm/sha1-c64xplus.pl

   1 #!/usr/bin/env perl
   2 #
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
   5 # project. The module is, however, dual licensed under OpenSSL and
   6 # CRYPTOGAMS licenses depending on where you obtain it. For further
   7 # details see http://www.openssl.org/~appro/cryptogams/.
   8 # ====================================================================
   9 #
  10 # SHA1 for C64x+.
  11 #
  12 # November 2011
  13 #
  14 # If compared to compiler-generated code with similar characteristics,
  15 # i.e. compiled with OPENSSL_SMALL_FOOTPRINT and utilizing SPLOOPs,
  16 # this implementation is 25% smaller and >2x faster. In absolute terms
  17 # performance is (quite impressive) ~6.5 cycles per processed byte.
  18 # Fully unrolled assembler would be ~5x larger and is likely to be
  19 # ~15% faster. It would be free from references to intermediate ring
  20 # buffer, but put more pressure on L1P [both because the code would be
  21 # larger and won't be using SPLOOP buffer]. There are no plans to
  22 # realize fully unrolled variant though...
  23 #
  24 # !!! Note that this module uses AMR, which means that all interrupt
  25 # service routines are expected to preserve it and for own well-being
  26 # zero it upon entry.
  27
  28 while (($output=shift) && ($output!~/\w[\w\-]*\.\w+$/)) {}
  29 open STDOUT,">$output";
  30
  31 ($CTX,$INP,$NUM) = ("A4","B4","A6");            # arguments
  32
  33 ($A,$B,$C,$D,$E, $Arot,$F,$F0,$T,$K) = map("A$_",(16..20, 21..25));
  34 ($X0,$X2,$X8,$X13) = ("A26","B26","A27","B27");
  35 ($TX0,$TX1,$TX2,$TX3) = map("B$_",(28..31));
  36 ($XPA,$XPB) = ("A5","B5");                      # X circular buffer
  37 ($Actx,$Bctx,$Cctx,$Dctx,$Ectx) = map("A$_",(3,6..9));  # zaps $NUM
  38
  39 $code=<<___;
  40         .text
  41
  42         .if     .ASSEMBLER_VERSION<7000000
  43         .asg    0,__TI_EABI__
  44         .endif
  45         .if     __TI_EABI__
  46         .asg    sha1_block_data_order,_sha1_block_data_order
  47         .endif
  48
  49         .asg    B3,RA
  50         .asg    A15,FP
  51         .asg    B15,SP
  52
  53         .if     .BIG_ENDIAN
  54         .asg    MV,SWAP2
  55         .asg    MV,SWAP4
  56         .endif
  57
  58         .global _sha1_block_data_order
  59 _sha1_block_data_order:
  60         .asmfunc stack_usage(64)
  61         MV      $NUM,A0                 ; reassign $NUM
  62 ||      MVK     -64,B0
  63   [!A0] BNOP    RA                      ; if ($NUM==0) return;
  64 || [A0] STW     FP,*SP--[16]            ; save frame pointer and alloca(64)
  65 || [A0] MV      SP,FP
  66    [A0] LDW     *${CTX}[0],$A           ; load A-E...
  67 || [A0] AND     B0,SP,SP                ; align stack at 64 bytes
  68    [A0] LDW     *${CTX}[1],$B
  69 || [A0] SUBAW   SP,2,SP                 ; reserve two words above buffer
  70    [A0] LDW     *${CTX}[2],$C
  71 || [A0] MVK     0x00404,B0
  72    [A0] LDW     *${CTX}[3],$D
  73 || [A0] MVKH    0x50000,B0              ; 0x050404, 64 bytes for $XP[AB]
  74    [A0] LDW     *${CTX}[4],$E
  75 || [A0] MVC     B0,AMR                  ; setup circular addressing
  76         LDNW    *${INP}++,$TX1          ; pre-fetch input
  77         NOP     1
  78
  79 loop?:
  80         MVK     0x00007999,$K
  81 ||      ADDAW   SP,2,$XPA
  82 ||      SUB     A0,1,A0
  83 ||      MVK     13,B0
  84         MVKH    0x5a820000,$K           ; K_00_19
  85 ||      ADDAW   SP,2,$XPB
  86 ||      MV      $A,$Actx
  87 ||      MV      $B,$Bctx
  88 ;;==================================================
  89         SPLOOPD 5                       ; BODY_00_13
  90 ||      MV      $C,$Cctx
  91 ||      MV      $D,$Dctx
  92 ||      MV      $E,$Ectx
  93 ||      MVC     B0,ILC
  94
  95         ROTL    $A,5,$Arot
  96 ||      AND     $C,$B,$F
  97 ||      ANDN    $D,$B,$F0
  98 ||      ADD     $K,$E,$T                ; T=E+K
  99
 100         XOR     $F0,$F,$F               ; F_00_19(B,C,D)
 101 ||      MV      $D,$E                   ; E=D
 102 ||      MV      $C,$D                   ; D=C
 103 ||      SWAP2   $TX1,$TX2
 104 ||      LDNW    *${INP}++,$TX1
 105
 106         ADD     $F,$T,$T                ; T+=F_00_19(B,C,D)
 107 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 108 ||      SWAP4   $TX2,$TX3               ; byte swap
 109
 110         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 111 ||      MV      $A,$B                   ; B=A
 112
 113         ADD     $TX3,$T,$A              ; A=T+Xi
 114 ||      STW     $TX3,*${XPB}++
 115         SPKERNEL
 116 ;;==================================================
 117         ROTL    $A,5,$Arot              ; BODY_14
 118 ||      AND     $C,$B,$F
 119 ||      ANDN    $D,$B,$F0
 120 ||      ADD     $K,$E,$T                ; T=E+K
 121
 122         XOR     $F0,$F,$F               ; F_00_19(B,C,D)
 123 ||      MV      $D,$E                   ; E=D
 124 ||      MV      $C,$D                   ; D=C
 125 ||      SWAP2   $TX1,$TX2
 126 ||      LDNW    *${INP}++,$TX1
 127
 128         ADD     $F,$T,$T                ; T+=F_00_19(B,C,D)
 129 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 130 ||      SWAP4   $TX2,$TX2               ; byte swap
 131 ||      LDW     *${XPA}++,$X0           ; fetches from X ring buffer are
 132 ||      LDW     *${XPB}[4],$X2          ; 2 iterations ahead
 133
 134         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 135 ||      MV      $A,$B                   ; B=A
 136 ||      LDW     *${XPA}[7],$X8
 137 ||      MV      $TX3,$X13               ; ||    LDW     *${XPB}[15],$X13
 138 ||      MV      $TX2,$TX3
 139
 140         ADD     $TX2,$T,$A              ; A=T+Xi
 141 ||      STW     $TX2,*${XPB}++
 142 ;;==================================================
 143         ROTL    $A,5,$Arot              ; BODY_15
 144 ||      AND     $C,$B,$F
 145 ||      ANDN    $D,$B,$F0
 146 ||      ADD     $K,$E,$T                ; T=E+K
 147
 148         XOR     $F0,$F,$F               ; F_00_19(B,C,D)
 149 ||      MV      $D,$E                   ; E=D
 150 ||      MV      $C,$D                   ; D=C
 151 ||      SWAP2   $TX1,$TX2
 152
 153         ADD     $F,$T,$T                ; T+=F_00_19(B,C,D)
 154 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 155 ||      SWAP4   $TX2,$TX2               ; byte swap
 156 ||      XOR     $X0,$X2,$TX0            ; Xupdate XORs are 1 iteration ahead
 157 ||      LDW     *${XPA}++,$X0
 158 ||      LDW     *${XPB}[4],$X2
 159
 160         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 161 ||      MV      $A,$B                   ; B=A
 162 ||      XOR     $X8,$X13,$TX1
 163 ||      LDW     *${XPA}[7],$X8
 164 ||      MV      $TX3,$X13               ; ||    LDW     *${XPB}[15],$X13
 165 ||      MV      $TX2,$TX3
 166
 167         ADD     $TX2,$T,$A              ; A=T+Xi
 168 ||      STW     $TX2,*${XPB}++
 169 ||      XOR     $TX0,$TX1,$TX1
 170 ||      MVK     3,B0
 171 ;;==================================================
 172         SPLOOPD 5                       ; BODY_16_19
 173 ||      MVC     B0,ILC
 174
 175         ROTL    $A,5,$Arot
 176 ||      AND     $C,$B,$F
 177 ||      ANDN    $D,$B,$F0
 178 ||      ADD     $K,$E,$T                ; T=E+K
 179 ||      ROTL    $TX1,1,$TX2             ; Xupdate output
 180
 181         XOR     $F0,$F,$F               ; F_00_19(B,C,D)
 182 ||      MV      $D,$E                   ; E=D
 183 ||      MV      $C,$D                   ; D=C
 184
 185         ADD     $F,$T,$T                ; T+=F_00_19(B,C,D)
 186 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 187 ||      XOR     $X0,$X2,$TX0
 188 ||      LDW     *${XPA}++,$X0
 189 ||      LDW     *${XPB}[4],$X2
 190
 191         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 192 ||      MV      $A,$B                   ; B=A
 193 ||      XOR     $X8,$X13,$TX1
 194 ||      LDW     *${XPA}[7],$X8
 195 ||      MV      $TX3,$X13               ; ||    LDW     *${XPB}[15],$X13
 196 ||      MV      $TX2,$TX3
 197
 198         ADD     $TX2,$T,$A              ; A=T+Xi
 199 ||      STW     $TX2,*${XPB}++
 200 ||      XOR     $TX0,$TX1,$TX1
 201         SPKERNEL
 202
 203         MVK     0xffffeba1,$K
 204 ||      MVK     19,B0
 205         MVKH    0x6ed90000,$K           ; K_20_39
 206 ___
 207 sub BODY_20_39 {
 208 $code.=<<___;
 209 ;;==================================================
 210         SPLOOPD 5                       ; BODY_20_39
 211 ||      MVC     B0,ILC
 212
 213         ROTL    $A,5,$Arot
 214 ||      XOR     $B,$C,$F
 215 ||      ADD     $K,$E,$T                ; T=E+K
 216 ||      ROTL    $TX1,1,$TX2             ; Xupdate output
 217
 218         XOR     $D,$F,$F                ; F_20_39(B,C,D)
 219 ||      MV      $D,$E                   ; E=D
 220 ||      MV      $C,$D                   ; D=C
 221
 222         ADD     $F,$T,$T                ; T+=F_20_39(B,C,D)
 223 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 224 ||      XOR     $X0,$X2,$TX0
 225 ||      LDW     *${XPA}++,$X0
 226 ||      LDW     *${XPB}[4],$X2
 227
 228         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 229 ||      MV      $A,$B                   ; B=A
 230 ||      XOR     $X8,$X13,$TX1
 231 ||      LDW     *${XPA}[7],$X8
 232 ||      MV      $TX3,$X13               ; ||    LDW     *${XPB}[15],$X13
 233 ||      MV      $TX2,$TX3
 234
 235         ADD     $TX2,$T,$A              ; A=T+Xi
 236 ||      STW     $TX2,*${XPB}++          ; last one is redundant
 237 ||      XOR     $TX0,$TX1,$TX1
 238         SPKERNEL
 239 ___
 240 $code.=<<___ if (!shift);
 241         MVK     0xffffbcdc,$K
 242         MVKH    0x8f1b0000,$K           ; K_40_59
 243 ___
 244 }       &BODY_20_39();
 245 $code.=<<___;
 246 ;;==================================================
 247         SPLOOPD 5                       ; BODY_40_59
 248 ||      MVC     B0,ILC
 249 ||      AND     $B,$C,$F
 250 ||      AND     $B,$D,$F0
 251
 252         ROTL    $A,5,$Arot
 253 ||      XOR     $F0,$F,$F
 254 ||      AND     $C,$D,$F0
 255 ||      ADD     $K,$E,$T                ; T=E+K
 256 ||      ROTL    $TX1,1,$TX2             ; Xupdate output
 257
 258         XOR     $F0,$F,$F               ; F_40_59(B,C,D)
 259 ||      MV      $D,$E                   ; E=D
 260 ||      MV      $C,$D                   ; D=C
 261
 262         ADD     $F,$T,$T                ; T+=F_40_59(B,C,D)
 263 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 264 ||      XOR     $X0,$X2,$TX0
 265 ||      LDW     *${XPA}++,$X0
 266 ||      LDW     *${XPB}[4],$X2
 267
 268         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 269 ||      MV      $A,$B                   ; B=A
 270 ||      XOR     $X8,$X13,$TX1
 271 ||      LDW     *${XPA}[7],$X8
 272 ||      MV      $TX3,$X13               ; ||    LDW     *${XPB}[15],$X13
 273 ||      MV      $TX2,$TX3
 274
 275         ADD     $TX2,$T,$A              ; A=T+Xi
 276 ||      STW     $TX2,*${XPB}++
 277 ||      XOR     $TX0,$TX1,$TX1
 278 ||      AND     $B,$C,$F
 279 ||      AND     $B,$D,$F0
 280         SPKERNEL
 281
 282         MVK     0xffffc1d6,$K
 283 ||      MVK     18,B0
 284         MVKH    0xca620000,$K           ; K_60_79
 285 ___
 286         &BODY_20_39(-1);                # BODY_60_78
 287 $code.=<<___;
 288 ;;==================================================
 289    [A0] B       loop?
 290 ||      ROTL    $A,5,$Arot              ; BODY_79
 291 ||      XOR     $B,$C,$F
 292 ||      ROTL    $TX1,1,$TX2             ; Xupdate output
 293
 294    [A0] LDNW    *${INP}++,$TX1          ; pre-fetch input
 295 ||      ADD     $K,$E,$T                ; T=E+K
 296 ||      XOR     $D,$F,$F                ; F_20_39(B,C,D)
 297
 298         ADD     $F,$T,$T                ; T+=F_20_39(B,C,D)
 299 ||      ADD     $Ectx,$D,$E             ; E=D,E+=Ectx
 300 ||      ADD     $Dctx,$C,$D             ; D=C,D+=Dctx
 301 ||      ROTL    $B,30,$C                ; C=ROL(B,30)
 302
 303         ADD     $Arot,$T,$T             ; T+=ROL(A,5)
 304 ||      ADD     $Bctx,$A,$B             ; B=A,B+=Bctx
 305
 306         ADD     $TX2,$T,$A              ; A=T+Xi
 307
 308         ADD     $Actx,$A,$A             ; A+=Actx
 309 ||      ADD     $Cctx,$C,$C             ; C+=Cctx
 310 ;; end of loop?
 311
 312         BNOP    RA                      ; return
 313 ||      MV      FP,SP                   ; restore stack pointer
 314 ||      LDW     *FP[0],FP               ; restore frame pointer
 315         STW     $A,*${CTX}[0]           ; emit A-E...
 316 ||      MVK     0,B0
 317         STW     $B,*${CTX}[1]
 318 ||      MVC     B0,AMR                  ; clear AMR
 319         STW     $C,*${CTX}[2]
 320         STW     $D,*${CTX}[3]
 321         STW     $E,*${CTX}[4]
 322         .endasmfunc
 323
 324         .sect   .const
 325         .cstring "SHA1 block transform for C64x+, CRYPTOGAMS by <appro\@openssl.org>"
 326         .align  4
 327 ___
 328
 329 print $code;
 330 close STDOUT;