crypto/aes/asm/aest4-sparcv9.pl

   1 #!/usr/bin/env perl
   2
   3 # ====================================================================
   4 # Written by David S. Miller <davem@devemloft.net> and Andy Polyakov
   5 # <appro@openssl.org>. The module is licensed under 2-clause BSD
   6 # license. October 2012. All rights reserved.
   7 # ====================================================================
   8
   9 ######################################################################
  10 # AES round instructions complete in 3 cycles and can be issued every
  11 # cycle. It means that round calculations should take 4*rounds cycles,
  12 # because any given round instruction depends on result of *both*
  13 # previous instructions:
  14 #
  15 #       |0 |1 |2 |3 |4
  16 #       |01|01|01|
  17 #          |23|23|23|
  18 #                   |01|01|...
  19 #                      |23|...
  20 #
  21 # Provided that fxor [with IV] takes 3 cycles to complete, critical
  22 # path length for CBC encrypt would be 3+4*rounds, or in other words
  23 # it should process one byte in at least (3+4*rounds)/16 cycles. This
  24 # estimate doesn't account for "collateral" instructions, such as
  25 # fetching input from memory, xor-ing it with zero-round key and
  26 # storing the result. Yet, *measured* performance [for data aligned
  27 # at 64-bit boundary!] deviates from this equation by less than 0.5%:
  28 #
  29 #               128-bit key     192-            256-
  30 # CBC encrypt   2.70/2.90(*)    3.20/3.40       3.70/3.90
  31 #                        (*) numbers after slash are for
  32 #                            misaligned data.
  33 #
  34 # Out-of-order execution logic managed to fully overlap "collateral"
  35 # instructions with those on critical path. Amazing!
  36 #
  37 # As with Intel AES-NI, question is if it's possible to improve
  38 # performance of parallelizeable modes by interleaving round
  39 # instructions. Provided round instruction latency and throughput
  40 # optimal interleave factor is 2. But can we expect 2x performance
  41 # improvement? Well, as round instructions can be issued one per
  42 # cycle, they don't saturate the 2-way issue pipeline and therefore
  43 # there is room for "collateral" calculations... Yet, 2x speed-up
  44 # over CBC encrypt remains unattaintable:
  45 #
  46 #               128-bit key     192-            256-
  47 # CBC decrypt   1.64/2.11       1.89/2.37       2.23/2.61
  48 # CTR           1.64/2.08(*)    1.89/2.33       2.23/2.61
  49 #                        (*) numbers after slash are for
  50 #                            misaligned data.
  51 #
  52 # Estimates based on amount of instructions under assumption that
  53 # round instructions are not pairable with any other instruction
  54 # suggest that latter is the actual case and pipeline runs
  55 # underutilized. It should be noted that T4 out-of-order execution
  56 # logic is so capable that performance gain from 2x interleave is
  57 # not even impressive, ~7-13% over non-interleaved code, largest
  58 # for 256-bit keys.
  59
  60 # To anchor to something else, software implementation processes
  61 # one byte in 29 cycles with 128-bit key on same processor. Intel
  62 # Sandy Bridge encrypts byte in 5.07 cycles in CBC mode and decrypts
  63 # in 0.93, naturally with AES-NI.
  64
  65 $bits=32;
  66 for (@ARGV)     { $bits=64 if (/\-m64/ || /\-xarch\=v9/); }
  67 if ($bits==64)  { $bias=2047; $frame=192; }
  68 else            { $bias=0;    $frame=112; }
  69
  70 $evp=1;         # if $evp is set to 0, script generates module with
  71 # AES_[en|de]crypt, AES_set_[en|de]crypt_key and AES_cbc_encrypt entry
  72 # points. These however are not fully compatible with openssl/aes.h,
  73 # because they expect AES_KEY to be aligned at 64-bit boundary. When
  74 # used through EVP, alignment is arranged at EVP layer. Second thing
  75 # that is arranged by EVP is at least 32-bit alignment of IV.
  76
  77 ######################################################################
  78 # single-round subroutines
  79 #
  80 {
  81 my ($inp,$out,$key,$rounds,$tmp,$mask)=map("%o$_",(0..5));
  82
  83 $code=<<___;
  84 .text
  85
  86 .globl  aes_t4_encrypt
  87 .align  32
  88 aes_t4_encrypt:
  89         andcc           $inp, 7, %g1            ! is input aligned?
  90         andn            $inp, 7, $inp
  91
  92         ldx             [$key + 0], %g4
  93         ldx             [$key + 8], %g5
  94
  95         ldx             [$inp + 0], %o4
  96         bz,pt           %icc, 1f
  97         ldx             [$inp + 8], %o5
  98         ldx             [$inp + 16], $inp
  99         sll             %g1, 3, %g1
 100         sub             %g0, %g1, %o3
 101         sllx            %o4, %g1, %o4
 102         sllx            %o5, %g1, %g1
 103         srlx            %o5, %o3, %o5
 104         srlx            $inp, %o3, %o3
 105         or              %o5, %o4, %o4
 106         or              %o3, %g1, %o5
 107 1:
 108         ld              [$key + 240], $rounds
 109         ldd             [$key + 16], %f12
 110         ldd             [$key + 24], %f14
 111         xor             %g4, %o4, %o4
 112         xor             %g5, %o5, %o5
 113         movxtod         %o4, %f0
 114         movxtod         %o5, %f2
 115         srl             $rounds, 1, $rounds
 116         ldd             [$key + 32], %f16
 117         sub             $rounds, 1, $rounds
 118         ldd             [$key + 40], %f18
 119         add             $key, 48, $key
 120
 121 .Lenc:
 122         aes_eround01    %f12, %f0, %f2, %f4
 123         aes_eround23    %f14, %f0, %f2, %f2
 124         ldd             [$key + 0], %f12
 125         ldd             [$key + 8], %f14
 126         sub             $rounds,1,$rounds
 127         aes_eround01    %f16, %f4, %f2, %f0
 128         aes_eround23    %f18, %f4, %f2, %f2
 129         ldd             [$key + 16], %f16
 130         ldd             [$key + 24], %f18
 131         brnz,pt         $rounds, .Lenc
 132         add             $key, 32, $key
 133
 134         andcc           $out, 7, $tmp           ! is output aligned?
 135         aes_eround01    %f12, %f0, %f2, %f4
 136         aes_eround23    %f14, %f0, %f2, %f2
 137         aes_eround01_l  %f16, %f4, %f2, %f0
 138         aes_eround23_l  %f18, %f4, %f2, %f2
 139
 140         bnz,pn          %icc, 2f
 141         nop
 142
 143         std             %f0, [$out + 0]
 144         retl
 145         std             %f2, [$out + 8]
 146
 147 2:      alignaddrl      $out, %g0, $out
 148         mov             0xff, $mask
 149         srl             $mask, $tmp, $mask
 150
 151         faligndata      %f0, %f0, %f4
 152         faligndata      %f0, %f2, %f6
 153         faligndata      %f2, %f2, %f8
 154
 155         stda            %f4, [$out + $mask]0xc0 ! partial store
 156         std             %f6, [$out + 8]
 157         add             $out, 16, $out
 158         orn             %g0, $mask, $mask
 159         retl
 160         stda            %f8, [$out + $mask]0xc0 ! partial store
 161 .type   aes_t4_encrypt,#function
 162 .size   aes_t4_encrypt,.-aes_t4_encrypt
 163
 164 .globl  aes_t4_decrypt
 165 .align  32
 166 aes_t4_decrypt:
 167         andcc           $inp, 7, %g1            ! is input aligned?
 168         andn            $inp, 7, $inp
 169
 170         ldx             [$key + 0], %g4
 171         ldx             [$key + 8], %g5
 172
 173         ldx             [$inp + 0], %o4
 174         bz,pt           %icc, 1f
 175         ldx             [$inp + 8], %o5
 176         ldx             [$inp + 16], $inp
 177         sll             %g1, 3, %g1
 178         sub             %g0, %g1, %o3
 179         sllx            %o4, %g1, %o4
 180         sllx            %o5, %g1, %g1
 181         srlx            %o5, %o3, %o5
 182         srlx            $inp, %o3, %o3
 183         or              %o5, %o4, %o4
 184         or              %o3, %g1, %o5
 185 1:
 186         ld              [$key + 240], $rounds
 187         ldd             [$key + 16], %f12
 188         ldd             [$key + 24], %f14
 189         xor             %g4, %o4, %o4
 190         xor             %g5, %o5, %o5
 191         movxtod         %o4, %f0
 192         movxtod         %o5, %f2
 193         srl             $rounds, 1, $rounds
 194         ldd             [$key + 32], %f16
 195         sub             $rounds, 1, $rounds
 196         ldd             [$key + 40], %f18
 197         add             $key, 48, $key
 198
 199 .Ldec:
 200         aes_dround01    %f12, %f0, %f2, %f4
 201         aes_dround23    %f14, %f0, %f2, %f2
 202         ldd             [$key + 0], %f12
 203         ldd             [$key + 8], %f14
 204         sub             $rounds,1,$rounds
 205         aes_dround01    %f16, %f4, %f2, %f0
 206         aes_dround23    %f18, %f4, %f2, %f2
 207         ldd             [$key + 16], %f16
 208         ldd             [$key + 24], %f18
 209         brnz,pt         $rounds, .Ldec
 210         add             $key, 32, $key
 211
 212         andcc           $out, 7, $tmp           ! is output aligned?
 213         aes_dround01    %f12, %f0, %f2, %f4
 214         aes_dround23    %f14, %f0, %f2, %f2
 215         aes_dround01_l  %f16, %f4, %f2, %f0
 216         aes_dround23_l  %f18, %f4, %f2, %f2
 217
 218         bnz,pn          %icc, 2f
 219         nop
 220
 221         std             %f0, [$out + 0]
 222         retl
 223         std             %f2, [$out + 8]
 224
 225 2:      alignaddrl      $out, %g0, $out
 226         mov             0xff, $mask
 227         srl             $mask, $tmp, $mask
 228
 229         faligndata      %f0, %f0, %f4
 230         faligndata      %f0, %f2, %f6
 231         faligndata      %f2, %f2, %f8
 232
 233         stda            %f4, [$out + $mask]0xc0 ! partial store
 234         std             %f6, [$out + 8]
 235         add             $out, 16, $out
 236         orn             %g0, $mask, $mask
 237         retl
 238         stda            %f8, [$out + $mask]0xc0 ! partial store
 239 .type   aes_t4_decrypt,#function
 240 .size   aes_t4_decrypt,.-aes_t4_decrypt
 241 ___
 242 }
 243
 244 ######################################################################
 245 # key setup subroutines
 246 #
 247 {
 248 my ($inp,$bits,$out,$tmp)=map("%o$_",(0..5));
 249 $code.=<<___;
 250 .globl  aes_t4_set_encrypt_key
 251 .align  32
 252 aes_t4_set_encrypt_key:
 253 .Lset_encrypt_key:
 254         and             $inp, 7, $tmp
 255         alignaddr       $inp, %g0, $inp
 256         cmp             $bits, 192
 257         ldd             [$inp + 0], %f0
 258         bl,pt           %icc,.L128
 259         ldd             [$inp + 8], %f2
 260
 261         be,pt           %icc,.L192
 262         ldd             [$inp + 16], %f4
 263         brz,pt          $tmp, .L256aligned
 264         ldd             [$inp + 24], %f6
 265
 266         ldd             [$inp + 32], %f8
 267         faligndata      %f0, %f2, %f0
 268         faligndata      %f2, %f4, %f2
 269         faligndata      %f4, %f6, %f4
 270         faligndata      %f6, %f8, %f6
 271 .L256aligned:
 272 ___
 273 for ($i=0; $i<6; $i++) {
 274     $code.=<<___;
 275         std             %f0, [$out + `32*$i+0`]
 276         aes_kexpand1    %f0, %f6, $i, %f0
 277         std             %f2, [$out + `32*$i+8`]
 278         aes_kexpand2    %f2, %f0, %f2
 279         std             %f4, [$out + `32*$i+16`]
 280         aes_kexpand0    %f4, %f2, %f4
 281         std             %f6, [$out + `32*$i+24`]
 282         aes_kexpand2    %f6, %f4, %f6
 283 ___
 284 }
 285 $code.=<<___;
 286         std             %f0, [$out + `32*$i+0`]
 287         aes_kexpand1    %f0, %f6, $i, %f0
 288         std             %f2, [$out + `32*$i+8`]
 289         aes_kexpand2    %f2, %f0, %f2
 290         std             %f4, [$out + `32*$i+16`]
 291         std             %f6, [$out + `32*$i+24`]
 292         std             %f0, [$out + `32*$i+32`]
 293         std             %f2, [$out + `32*$i+40`]
 294
 295         mov             14, $tmp
 296         st              $tmp, [$out + 240]
 297         retl
 298         xor             %o0, %o0, %o0
 299
 300 .align  16
 301 .L192:
 302         brz,pt          $tmp, .L192aligned
 303         nop
 304
 305         ldd             [$inp + 24], %f6
 306         faligndata      %f0, %f2, %f0
 307         faligndata      %f2, %f4, %f2
 308         faligndata      %f4, %f6, %f4
 309 .L192aligned:
 310 ___
 311 for ($i=0; $i<7; $i++) {
 312     $code.=<<___;
 313         std             %f0, [$out + `24*$i+0`]
 314         aes_kexpand1    %f0, %f4, $i, %f0
 315         std             %f2, [$out + `24*$i+8`]
 316         aes_kexpand2    %f2, %f0, %f2
 317         std             %f4, [$out + `24*$i+16`]
 318         aes_kexpand2    %f4, %f2, %f4
 319 ___
 320 }
 321 $code.=<<___;
 322         std             %f0, [$out + `24*$i+0`]
 323         aes_kexpand1    %f0, %f4, $i, %f0
 324         std             %f2, [$out + `24*$i+8`]
 325         aes_kexpand2    %f2, %f0, %f2
 326         std             %f4, [$out + `24*$i+16`]
 327         std             %f0, [$out + `24*$i+24`]
 328         std             %f2, [$out + `24*$i+32`]
 329
 330         mov             12, $tmp
 331         st              $tmp, [$out + 240]
 332         retl
 333         xor             %o0, %o0, %o0
 334
 335 .align  16
 336 .L128:
 337         brz,pt          $tmp, .L128aligned
 338         nop
 339
 340         ldd             [$inp + 16], %f4
 341         faligndata      %f0, %f2, %f0
 342         faligndata      %f2, %f4, %f2
 343 .L128aligned:
 344 ___
 345 for ($i=0; $i<10; $i++) {
 346     $code.=<<___;
 347         std             %f0, [$out + `16*$i+0`]
 348         aes_kexpand1    %f0, %f2, $i, %f0
 349         std             %f2, [$out + `16*$i+8`]
 350         aes_kexpand2    %f2, %f0, %f2
 351 ___
 352 }
 353 $code.=<<___;
 354         std             %f0, [$out + `16*$i+0`]
 355         std             %f2, [$out + `16*$i+8`]
 356
 357         mov             10, $tmp
 358         st              $tmp, [$out + 240]
 359         retl
 360         xor             %o0, %o0, %o0
 361 .type   aes_t4_set_encrypt_key,#function
 362 .size   aes_t4_set_encrypt_key,.-aes_t4_set_encrypt_key
 363
 364 .globl  aes_t4_set_decrypt_key
 365 .align  32
 366 aes_t4_set_decrypt_key:
 367         mov             %o7, %o5
 368         call            .Lset_encrypt_key
 369         nop
 370
 371         mov             %o5, %o7
 372         sll             $tmp, 4, $inp           ! $tmp is number of rounds
 373         add             $tmp, 2, $tmp
 374         add             $out, $inp, $inp        ! $inp=$out+16*rounds
 375         srl             $tmp, 2, $tmp           ! $tmp=(rounds+2)/4
 376
 377 .Lkey_flip:
 378         ldd             [$out + 0],  %f0
 379         ldd             [$out + 8],  %f2
 380         ldd             [$out + 16], %f4
 381         ldd             [$out + 24], %f6
 382         ldd             [$inp + 0],  %f8
 383         ldd             [$inp + 8],  %f10
 384         ldd             [$inp - 16], %f12
 385         ldd             [$inp - 8],  %f14
 386         sub             $tmp, 1, $tmp
 387         std             %f0, [$inp + 0]
 388         std             %f2, [$inp + 8]
 389         std             %f4, [$inp - 16]
 390         std             %f6, [$inp - 8]
 391         std             %f8, [$out + 0]
 392         std             %f10, [$out + 8]
 393         std             %f12, [$out + 16]
 394         std             %f14, [$out + 24]
 395         add             $out, 32, $out
 396         brnz            $tmp, .Lkey_flip
 397         sub             $inp, 32, $inp
 398
 399         retl
 400         xor             %o0, %o0, %o0
 401 .type   aes_t4_set_decrypt_key,#function
 402 .size   aes_t4_set_decrypt_key,.-aes_t4_set_decrypt_key
 403 ___
 404 }
 405
 406 {{{
 407 my ($inp,$out,$len,$key,$ivec,$enc)=map("%i$_",(0..5));
 408 my ($ileft,$iright,$ooff,$omask,$ivoff)=map("%l$_",(1..7));
 409
 410 $code.=<<___;
 411 .align  32
 412 _aes128_loadkey:
 413         ldx             [$key + 0], %g4
 414         ldx             [$key + 8], %g5
 415 ___
 416 for ($i=2; $i<22;$i++) {                        # load key schedule
 417     $code.=<<___;
 418         ldd             [$key + `8*$i`], %f`12+2*$i`
 419 ___
 420 }
 421 $code.=<<___;
 422         retl
 423         nop
 424 .type   _aes128_loadkey,#function
 425 .size   _aes128_loadkey,.-_aes128_loadkey
 426
 427 .align  32
 428 _aes128_encrypt_1x:
 429 ___
 430 for ($i=0; $i<4; $i++) {
 431     $code.=<<___;
 432         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f4
 433         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 434         aes_eround01    %f`16+8*$i+4`, %f4, %f2, %f0
 435         aes_eround23    %f`16+8*$i+6`, %f4, %f2, %f2
 436 ___
 437 }
 438 $code.=<<___;
 439         aes_eround01    %f48, %f0, %f2, %f4
 440         aes_eround23    %f50, %f0, %f2, %f2
 441         aes_eround01_l  %f52, %f4, %f2, %f0
 442         retl
 443         aes_eround23_l  %f54, %f4, %f2, %f2
 444 .type   _aes128_encrypt_1x,#function
 445 .size   _aes128_encrypt_1x,.-_aes128_encrypt_1x
 446
 447 .align  32
 448 _aes128_encrypt_2x:
 449 ___
 450 for ($i=0; $i<4; $i++) {
 451     $code.=<<___;
 452         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f8
 453         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 454         aes_eround01    %f`16+8*$i+0`, %f4, %f6, %f10
 455         aes_eround23    %f`16+8*$i+2`, %f4, %f6, %f6
 456         aes_eround01    %f`16+8*$i+4`, %f8, %f2, %f0
 457         aes_eround23    %f`16+8*$i+6`, %f8, %f2, %f2
 458         aes_eround01    %f`16+8*$i+4`, %f10, %f6, %f4
 459         aes_eround23    %f`16+8*$i+6`, %f10, %f6, %f6
 460 ___
 461 }
 462 $code.=<<___;
 463         aes_eround01    %f48, %f0, %f2, %f8
 464         aes_eround23    %f50, %f0, %f2, %f2
 465         aes_eround01    %f48, %f4, %f6, %f10
 466         aes_eround23    %f50, %f4, %f6, %f6
 467         aes_eround01_l  %f52, %f8, %f2, %f0
 468         aes_eround23_l  %f54, %f8, %f2, %f2
 469         aes_eround01_l  %f52, %f10, %f6, %f4
 470         retl
 471         aes_eround23_l  %f54, %f10, %f6, %f6
 472 .type   _aes128_encrypt_2x,#function
 473 .size   _aes128_encrypt_2x,.-_aes128_encrypt_2x
 474
 475 .align  32
 476 _aes128_decrypt_1x:
 477 ___
 478 for ($i=0; $i<4; $i++) {
 479     $code.=<<___;
 480         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f4
 481         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 482         aes_dround01    %f`16+8*$i+4`, %f4, %f2, %f0
 483         aes_dround23    %f`16+8*$i+6`, %f4, %f2, %f2
 484 ___
 485 }
 486 $code.=<<___;
 487         aes_dround01    %f48, %f0, %f2, %f4
 488         aes_dround23    %f50, %f0, %f2, %f2
 489         aes_dround01_l  %f52, %f4, %f2, %f0
 490         retl
 491         aes_dround23_l  %f54, %f4, %f2, %f2
 492 .type   _aes128_decrypt_1x,#function
 493 .size   _aes128_decrypt_1x,.-_aes128_decrypt_1x
 494
 495 .align  32
 496 _aes128_decrypt_2x:
 497 ___
 498 for ($i=0; $i<4; $i++) {
 499     $code.=<<___;
 500         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f8
 501         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 502         aes_dround01    %f`16+8*$i+0`, %f4, %f6, %f10
 503         aes_dround23    %f`16+8*$i+2`, %f4, %f6, %f6
 504         aes_dround01    %f`16+8*$i+4`, %f8, %f2, %f0
 505         aes_dround23    %f`16+8*$i+6`, %f8, %f2, %f2
 506         aes_dround01    %f`16+8*$i+4`, %f10, %f6, %f4
 507         aes_dround23    %f`16+8*$i+6`, %f10, %f6, %f6
 508 ___
 509 }
 510 $code.=<<___;
 511         aes_dround01    %f48, %f0, %f2, %f8
 512         aes_dround23    %f50, %f0, %f2, %f2
 513         aes_dround01    %f48, %f4, %f6, %f10
 514         aes_dround23    %f50, %f4, %f6, %f6
 515         aes_dround01_l  %f52, %f8, %f2, %f0
 516         aes_dround23_l  %f54, %f8, %f2, %f2
 517         aes_dround01_l  %f52, %f10, %f6, %f4
 518         retl
 519         aes_dround23_l  %f54, %f10, %f6, %f6
 520 .type   _aes128_decrypt_2x,#function
 521 .size   _aes128_decrypt_2x,.-_aes128_decrypt_2x
 522
 523 .align  32
 524 _aes192_loadkey:
 525 _aes256_loadkey:
 526         ldx             [$key + 0], %g4
 527         ldx             [$key + 8], %g5
 528 ___
 529 for ($i=2; $i<26;$i++) {                        # load key schedule
 530     $code.=<<___;
 531         ldd             [$key + `8*$i`], %f`12+2*$i`
 532 ___
 533 }
 534 $code.=<<___;
 535         retl
 536         nop
 537 .type   _aes192_loadkey,#function
 538 .size   _aes192_loadkey,.-_aes192_loadkey
 539
 540 .align  32
 541 _aes192_encrypt_1x:
 542 ___
 543 for ($i=0; $i<5; $i++) {
 544     $code.=<<___;
 545         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f4
 546         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 547         aes_eround01    %f`16+8*$i+4`, %f4, %f2, %f0
 548         aes_eround23    %f`16+8*$i+6`, %f4, %f2, %f2
 549 ___
 550 }
 551 $code.=<<___;
 552         aes_eround01    %f56, %f0, %f2, %f4
 553         aes_eround23    %f58, %f0, %f2, %f2
 554         aes_eround01_l  %f60, %f4, %f2, %f0
 555         retl
 556         aes_eround23_l  %f62, %f4, %f2, %f2
 557 .type   _aes192_encrypt_1x,#function
 558 .size   _aes192_encrypt_1x,.-_aes192_encrypt_1x
 559
 560 .align  32
 561 _aes192_encrypt_2x:
 562 ___
 563 for ($i=0; $i<5; $i++) {
 564     $code.=<<___;
 565         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f8
 566         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 567         aes_eround01    %f`16+8*$i+0`, %f4, %f6, %f10
 568         aes_eround23    %f`16+8*$i+2`, %f4, %f6, %f6
 569         aes_eround01    %f`16+8*$i+4`, %f8, %f2, %f0
 570         aes_eround23    %f`16+8*$i+6`, %f8, %f2, %f2
 571         aes_eround01    %f`16+8*$i+4`, %f10, %f6, %f4
 572         aes_eround23    %f`16+8*$i+6`, %f10, %f6, %f6
 573 ___
 574 }
 575 $code.=<<___;
 576         aes_eround01    %f56, %f0, %f2, %f8
 577         aes_eround23    %f58, %f0, %f2, %f2
 578         aes_eround01    %f56, %f4, %f6, %f10
 579         aes_eround23    %f58, %f4, %f6, %f6
 580         aes_eround01_l  %f60, %f8, %f2, %f0
 581         aes_eround23_l  %f62, %f8, %f2, %f2
 582         aes_eround01_l  %f60, %f10, %f6, %f4
 583         retl
 584         aes_eround23_l  %f62, %f10, %f6, %f6
 585 .type   _aes192_encrypt_2x,#function
 586 .size   _aes192_encrypt_2x,.-_aes192_encrypt_2x
 587
 588 .align  32
 589 _aes192_decrypt_1x:
 590 ___
 591 for ($i=0; $i<5; $i++) {
 592     $code.=<<___;
 593         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f4
 594         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 595         aes_dround01    %f`16+8*$i+4`, %f4, %f2, %f0
 596         aes_dround23    %f`16+8*$i+6`, %f4, %f2, %f2
 597 ___
 598 }
 599 $code.=<<___;
 600         aes_dround01    %f56, %f0, %f2, %f4
 601         aes_dround23    %f58, %f0, %f2, %f2
 602         aes_dround01_l  %f60, %f4, %f2, %f0
 603         retl
 604         aes_dround23_l  %f62, %f4, %f2, %f2
 605 .type   _aes192_decrypt_1x,#function
 606 .size   _aes192_decrypt_1x,.-_aes192_decrypt_1x
 607
 608 .align  32
 609 _aes192_decrypt_2x:
 610 ___
 611 for ($i=0; $i<5; $i++) {
 612     $code.=<<___;
 613         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f8
 614         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 615         aes_dround01    %f`16+8*$i+0`, %f4, %f6, %f10
 616         aes_dround23    %f`16+8*$i+2`, %f4, %f6, %f6
 617         aes_dround01    %f`16+8*$i+4`, %f8, %f2, %f0
 618         aes_dround23    %f`16+8*$i+6`, %f8, %f2, %f2
 619         aes_dround01    %f`16+8*$i+4`, %f10, %f6, %f4
 620         aes_dround23    %f`16+8*$i+6`, %f10, %f6, %f6
 621 ___
 622 }
 623 $code.=<<___;
 624         aes_dround01    %f56, %f0, %f2, %f8
 625         aes_dround23    %f58, %f0, %f2, %f2
 626         aes_dround01    %f56, %f4, %f6, %f10
 627         aes_dround23    %f58, %f4, %f6, %f6
 628         aes_dround01_l  %f60, %f8, %f2, %f0
 629         aes_dround23_l  %f62, %f8, %f2, %f2
 630         aes_dround01_l  %f60, %f10, %f6, %f4
 631         retl
 632         aes_dround23_l  %f62, %f10, %f6, %f6
 633 .type   _aes192_decrypt_2x,#function
 634 .size   _aes192_decrypt_2x,.-_aes192_decrypt_2x
 635
 636 .align  32
 637 _aes256_encrypt_1x:
 638         aes_eround01    %f16, %f0, %f2, %f4
 639         aes_eround23    %f18, %f0, %f2, %f2
 640         ldd             [$key + 208], %f16
 641         ldd             [$key + 216], %f18
 642         aes_eround01    %f20, %f4, %f2, %f0
 643         aes_eround23    %f22, %f4, %f2, %f2
 644         ldd             [$key + 224], %f20
 645         ldd             [$key + 232], %f22
 646 ___
 647 for ($i=1; $i<6; $i++) {
 648     $code.=<<___;
 649         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f4
 650         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 651         aes_eround01    %f`16+8*$i+4`, %f4, %f2, %f0
 652         aes_eround23    %f`16+8*$i+6`, %f4, %f2, %f2
 653 ___
 654 }
 655 $code.=<<___;
 656         aes_eround01    %f16, %f0, %f2, %f4
 657         aes_eround23    %f18, %f0, %f2, %f2
 658         ldd             [$key + 16], %f16
 659         ldd             [$key + 24], %f18
 660         aes_eround01_l  %f20, %f4, %f2, %f0
 661         aes_eround23_l  %f22, %f4, %f2, %f2
 662         ldd             [$key + 32], %f20
 663         retl
 664         ldd             [$key + 40], %f22
 665 .type   _aes256_encrypt_1x,#function
 666 .size   _aes256_encrypt_1x,.-_aes256_encrypt_1x
 667
 668 .align  32
 669 _aes256_encrypt_2x:
 670         aes_eround01    %f16, %f0, %f2, %f8
 671         aes_eround23    %f18, %f0, %f2, %f2
 672         aes_eround01    %f16, %f4, %f6, %f10
 673         aes_eround23    %f18, %f4, %f6, %f6
 674         ldd             [$key + 208], %f16
 675         ldd             [$key + 216], %f18
 676         aes_eround01    %f20, %f8, %f2, %f0
 677         aes_eround23    %f22, %f8, %f2, %f2
 678         aes_eround01    %f20, %f10, %f6, %f4
 679         aes_eround23    %f22, %f10, %f6, %f6
 680         ldd             [$key + 224], %f20
 681         ldd             [$key + 232], %f22
 682 ___
 683 for ($i=1; $i<6; $i++) {
 684     $code.=<<___;
 685         aes_eround01    %f`16+8*$i+0`, %f0, %f2, %f8
 686         aes_eround23    %f`16+8*$i+2`, %f0, %f2, %f2
 687         aes_eround01    %f`16+8*$i+0`, %f4, %f6, %f10
 688         aes_eround23    %f`16+8*$i+2`, %f4, %f6, %f6
 689         aes_eround01    %f`16+8*$i+4`, %f8, %f2, %f0
 690         aes_eround23    %f`16+8*$i+6`, %f8, %f2, %f2
 691         aes_eround01    %f`16+8*$i+4`, %f10, %f6, %f4
 692         aes_eround23    %f`16+8*$i+6`, %f10, %f6, %f6
 693 ___
 694 }
 695 $code.=<<___;
 696         aes_eround01    %f16, %f0, %f2, %f8
 697         aes_eround23    %f18, %f0, %f2, %f2
 698         aes_eround01    %f16, %f4, %f6, %f10
 699         aes_eround23    %f18, %f4, %f6, %f6
 700         ldd             [$key + 16], %f16
 701         ldd             [$key + 24], %f18
 702         aes_eround01_l  %f20, %f8, %f2, %f0
 703         aes_eround23_l  %f22, %f8, %f2, %f2
 704         aes_eround01_l  %f20, %f10, %f6, %f4
 705         aes_eround23_l  %f22, %f10, %f6, %f6
 706         ldd             [$key + 32], %f20
 707         retl
 708         ldd             [$key + 40], %f22
 709 .type   _aes256_encrypt_2x,#function
 710 .size   _aes256_encrypt_2x,.-_aes256_encrypt_2x
 711
 712 .align  32
 713 _aes256_decrypt_1x:
 714         aes_dround01    %f16, %f0, %f2, %f4
 715         aes_dround23    %f18, %f0, %f2, %f2
 716         ldd             [$key + 208], %f16
 717         ldd             [$key + 216], %f18
 718         aes_dround01    %f20, %f4, %f2, %f0
 719         aes_dround23    %f22, %f4, %f2, %f2
 720         ldd             [$key + 224], %f20
 721         ldd             [$key + 232], %f22
 722 ___
 723 for ($i=1; $i<6; $i++) {
 724     $code.=<<___;
 725         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f4
 726         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 727         aes_dround01    %f`16+8*$i+4`, %f4, %f2, %f0
 728         aes_dround23    %f`16+8*$i+6`, %f4, %f2, %f2
 729 ___
 730 }
 731 $code.=<<___;
 732         aes_dround01    %f16, %f0, %f2, %f4
 733         aes_dround23    %f18, %f0, %f2, %f2
 734         ldd             [$key + 16], %f16
 735         ldd             [$key + 24], %f18
 736         aes_dround01_l  %f20, %f4, %f2, %f0
 737         aes_dround23_l  %f22, %f4, %f2, %f2
 738         ldd             [$key + 32], %f20
 739         retl
 740         ldd             [$key + 40], %f22
 741 .type   _aes256_decrypt_1x,#function
 742 .size   _aes256_decrypt_1x,.-_aes256_decrypt_1x
 743
 744 .align  32
 745 _aes256_decrypt_2x:
 746         aes_dround01    %f16, %f0, %f2, %f8
 747         aes_dround23    %f18, %f0, %f2, %f2
 748         aes_dround01    %f16, %f4, %f6, %f10
 749         aes_dround23    %f18, %f4, %f6, %f6
 750         ldd             [$key + 208], %f16
 751         ldd             [$key + 216], %f18
 752         aes_dround01    %f20, %f8, %f2, %f0
 753         aes_dround23    %f22, %f8, %f2, %f2
 754         aes_dround01    %f20, %f10, %f6, %f4
 755         aes_dround23    %f22, %f10, %f6, %f6
 756         ldd             [$key + 224], %f20
 757         ldd             [$key + 232], %f22
 758 ___
 759 for ($i=1; $i<6; $i++) {
 760     $code.=<<___;
 761         aes_dround01    %f`16+8*$i+0`, %f0, %f2, %f8
 762         aes_dround23    %f`16+8*$i+2`, %f0, %f2, %f2
 763         aes_dround01    %f`16+8*$i+0`, %f4, %f6, %f10
 764         aes_dround23    %f`16+8*$i+2`, %f4, %f6, %f6
 765         aes_dround01    %f`16+8*$i+4`, %f8, %f2, %f0
 766         aes_dround23    %f`16+8*$i+6`, %f8, %f2, %f2
 767         aes_dround01    %f`16+8*$i+4`, %f10, %f6, %f4
 768         aes_dround23    %f`16+8*$i+6`, %f10, %f6, %f6
 769 ___
 770 }
 771 $code.=<<___;
 772         aes_dround01    %f16, %f0, %f2, %f8
 773         aes_dround23    %f18, %f0, %f2, %f2
 774         aes_dround01    %f16, %f4, %f6, %f10
 775         aes_dround23    %f18, %f4, %f6, %f6
 776         ldd             [$key + 16], %f16
 777         ldd             [$key + 24], %f18
 778         aes_dround01_l  %f20, %f8, %f2, %f0
 779         aes_dround23_l  %f22, %f8, %f2, %f2
 780         aes_dround01_l  %f20, %f10, %f6, %f4
 781         aes_dround23_l  %f22, %f10, %f6, %f6
 782         ldd             [$key + 32], %f20
 783         retl
 784         ldd             [$key + 40], %f22
 785 .type   _aes256_decrypt_2x,#function
 786 .size   _aes256_decrypt_2x,.-_aes256_decrypt_2x
 787 ___
 788
 789 sub aes_cbc_encrypt_implement {
 790 my $bits = shift;
 791
 792 $code.=<<___;
 793 .globl  aes${bits}_t4_cbc_encrypt
 794 .align  32
 795 aes${bits}_t4_cbc_encrypt:
 796         save            %sp, -$frame, %sp
 797 ___
 798 $code.=<<___ if (!$evp);
 799         andcc           $ivec, 7, $ivoff
 800         alignaddr       $ivec, %g0, $ivec
 801
 802         ldd             [$ivec + 0], %f0        ! load ivec
 803         bz,pt           %icc, 1f
 804         ldd             [$ivec + 8], %f2
 805         ldd             [$ivec + 16], %f4
 806         faligndata      %f0, %f2, %f0
 807         faligndata      %f2, %f4, %f2
 808 1:
 809 ___
 810 $code.=<<___ if ($evp);
 811         ld              [$ivec + 0], %f0
 812         ld              [$ivec + 4], %f1
 813         ld              [$ivec + 8], %f2
 814         ld              [$ivec + 12], %f3
 815 ___
 816 $code.=<<___;
 817         call            _aes${bits}_loadkey
 818         srlx            $len, 4, $len
 819         and             $inp, 7, $ileft
 820         andn            $inp, 7, $inp
 821         sll             $ileft, 3, $ileft
 822         mov             64, $iright
 823         mov             0xff, $omask
 824         sub             $iright, $ileft, $iright
 825         and             $out, 7, $ooff
 826         alignaddrl      $out, %g0, $out
 827         srl             $omask, $ooff, $omask
 828
 829 .L${bits}_cbc_enc_loop:
 830         ldx             [$inp + 0], %o0
 831         brz,pt          $ileft, 4f
 832         ldx             [$inp + 8], %o1
 833
 834         ldx             [$inp + 16], %o2
 835         sllx            %o0, $ileft, %o0
 836         srlx            %o1, $iright, %g1
 837         sllx            %o1, $ileft, %o1
 838         or              %g1, %o0, %o0
 839         srlx            %o2, $iright, %o2
 840         or              %o2, %o1, %o1
 841 4:
 842         xor             %g4, %o0, %o0           ! ^= rk[0]
 843         xor             %g5, %o1, %o1
 844         movxtod         %o0, %f12
 845         movxtod         %o1, %f14
 846
 847         fxor            %f12, %f0, %f0          ! ^= ivec
 848         fxor            %f14, %f2, %f2
 849         call            _aes${bits}_encrypt_1x
 850         add             $inp, 16, $inp
 851
 852         brnz,pn         $ooff, 2f
 853         sub             $len, 1, $len
 854
 855         std             %f0, [$out + 0]
 856         std             %f2, [$out + 8]
 857         brnz,pt         $len, .L${bits}_cbc_enc_loop
 858         add             $out, 16, $out
 859 ___
 860 $code.=<<___ if ($evp);
 861         st              %f0, [$ivec + 0]
 862         st              %f1, [$ivec + 4]
 863         st              %f2, [$ivec + 8]
 864         st              %f3, [$ivec + 12]
 865 ___
 866 $code.=<<___ if (!$evp);
 867         brnz,pn         $ivoff, 3f
 868         nop
 869
 870         std             %f0, [$ivec + 0]        ! write out ivec
 871         std             %f2, [$ivec + 8]
 872 ___
 873 $code.=<<___;
 874         ret
 875         restore
 876
 877 .align  16
 878 2:      ldxa            [$inp]0x82, %o0         ! avoid read-after-write hazard
 879                                                 ! and ~3x deterioration
 880                                                 ! in inp==out case
 881         faligndata      %f0, %f0, %f4           ! handle unaligned output
 882         faligndata      %f0, %f2, %f6
 883         faligndata      %f2, %f2, %f8
 884
 885         stda            %f4, [$out + $omask]0xc0        ! partial store
 886         std             %f6, [$out + 8]
 887         add             $out, 16, $out
 888         orn             %g0, $omask, $omask
 889         stda            %f8, [$out + $omask]0xc0        ! partial store
 890
 891         brnz,pt         $len, .L${bits}_cbc_enc_loop+4
 892         orn             %g0, $omask, $omask
 893 ___
 894 $code.=<<___ if ($evp);
 895         st              %f0, [$ivec + 0]
 896         st              %f1, [$ivec + 4]
 897         st              %f2, [$ivec + 8]
 898         st              %f3, [$ivec + 12]
 899 ___
 900 $code.=<<___ if (!$evp);
 901         brnz,pn         $ivoff, 3f
 902         nop
 903
 904         std             %f0, [$ivec + 0]        ! write out ivec
 905         std             %f2, [$ivec + 8]
 906         ret
 907         restore
 908
 909 .align  16
 910 3:      alignaddrl      $ivec, $ivoff, %g0      ! handle unaligned ivec
 911         mov             0xff, $omask
 912         srl             $omask, $ivoff, $omask
 913         faligndata      %f0, %f0, %f4
 914         faligndata      %f0, %f2, %f6
 915         faligndata      %f2, %f2, %f8
 916         stda            %f4, [$ivec + $omask]0xc0
 917         std             %f6, [$ivec + 8]
 918         add             $ivec, 16, $ivec
 919         orn             %g0, $omask, $omask
 920         stda            %f8, [$ivec + $omask]0xc0
 921 ___
 922 $code.=<<___;
 923         ret
 924         restore
 925 .type   aes${bits}_t4_cbc_encrypt,#function
 926 .size   aes${bits}_t4_cbc_encrypt,.-aes${bits}_t4_cbc_encrypt
 927 ___
 928 }
 929
 930 &aes_cbc_encrypt_implement(128);
 931 &aes_cbc_encrypt_implement(192);
 932 &aes_cbc_encrypt_implement(256);
 933
 934 sub aes_cbc_decrypt_implement {
 935 my $bits = shift;
 936
 937 $code.=<<___;
 938 .globl  aes${bits}_t4_cbc_decrypt
 939 .align  32
 940 aes${bits}_t4_cbc_decrypt:
 941         save            %sp, -$frame, %sp
 942 ___
 943 $code.=<<___ if (!$evp);
 944         andcc           $ivec, 7, $ivoff
 945         alignaddr       $ivec, %g0, $ivec
 946
 947         ldd             [$ivec + 0], %f12       ! load ivec
 948         bz,pt           %icc, 1f
 949         ldd             [$ivec + 8], %f14
 950         ldd             [$ivec + 16], %f0
 951         faligndata      %f12, %f14, %f12
 952         faligndata      %f14, %f0, %f14
 953 1:
 954 ___
 955 $code.=<<___ if ($evp);
 956         ld              [$ivec + 0], %f12       ! load ivec
 957         ld              [$ivec + 4], %f13
 958         ld              [$ivec + 8], %f14
 959         ld              [$ivec + 12], %f15
 960 ___
 961 $code.=<<___;
 962         call            _aes${bits}_loadkey
 963         srlx            $len, 4, $len
 964         andcc           $len, 1, %g0            ! is number of blocks even?
 965         and             $inp, 7, $ileft
 966         andn            $inp, 7, $inp
 967         sll             $ileft, 3, $ileft
 968         mov             64, $iright
 969         mov             0xff, $omask
 970         sub             $iright, $ileft, $iright
 971         and             $out, 7, $ooff
 972         alignaddrl      $out, %g0, $out
 973         bz              %icc, .L${bits}_cbc_dec_loop2x
 974         srl             $omask, $ooff, $omask
 975 .L${bits}_cbc_dec_loop:
 976         ldx             [$inp + 0], %o0
 977         brz,pt          $ileft, 4f
 978         ldx             [$inp + 8], %o1
 979
 980         ldx             [$inp + 16], %o2
 981         sllx            %o0, $ileft, %o0
 982         srlx            %o1, $iright, %g1
 983         sllx            %o1, $ileft, %o1
 984         or              %g1, %o0, %o0
 985         srlx            %o2, $iright, %o2
 986         or              %o2, %o1, %o1
 987 4:
 988         xor             %g4, %o0, %o2           ! ^= rk[0]
 989         xor             %g5, %o1, %o3
 990         movxtod         %o2, %f0
 991         movxtod         %o3, %f2
 992
 993         call            _aes${bits}_decrypt_1x
 994         add             $inp, 16, $inp
 995
 996         fxor            %f12, %f0, %f0          ! ^= ivec
 997         fxor            %f14, %f2, %f2
 998         movxtod         %o0, %f12
 999         movxtod         %o1, %f14
1000
1001         brnz,pn         $ooff, 2f
1002         sub             $len, 1, $len
1003
1004         std             %f0, [$out + 0]
1005         std             %f2, [$out + 8]
1006         brnz,pt         $len, .L${bits}_cbc_dec_loop2x
1007         add             $out, 16, $out
1008 ___
1009 $code.=<<___ if ($evp);
1010         st              %f12, [$ivec + 0]
1011         st              %f13, [$ivec + 4]
1012         st              %f14, [$ivec + 8]
1013         st              %f15, [$ivec + 12]
1014 ___
1015 $code.=<<___ if (!$evp);
1016         brnz,pn         $ivoff, .L${bits}_cbc_dec_unaligned_ivec
1017         nop
1018
1019         std             %f12, [$ivec + 0]       ! write out ivec
1020         std             %f14, [$ivec + 8]
1021 ___
1022 $code.=<<___;
1023         ret
1024         restore
1025
1026 .align  16
1027 2:      ldxa            [$inp]0x82, %o0         ! avoid read-after-write hazard
1028                                                 ! and ~3x deterioration
1029                                                 ! in inp==out case
1030         faligndata      %f0, %f0, %f4           ! handle unaligned output
1031         faligndata      %f0, %f2, %f6
1032         faligndata      %f2, %f2, %f8
1033
1034         stda            %f4, [$out + $omask]0xc0        ! partial store
1035         std             %f6, [$out + 8]
1036         add             $out, 16, $out
1037         orn             %g0, $omask, $omask
1038         stda            %f8, [$out + $omask]0xc0        ! partial store
1039
1040         brnz,pt         $len, .L${bits}_cbc_dec_loop2x+4
1041         orn             %g0, $omask, $omask
1042 ___
1043 $code.=<<___ if ($evp);
1044         st              %f12, [$ivec + 0]
1045         st              %f13, [$ivec + 4]
1046         st              %f14, [$ivec + 8]
1047         st              %f15, [$ivec + 12]
1048 ___
1049 $code.=<<___ if (!$evp);
1050         brnz,pn         $ivoff, .L${bits}_cbc_dec_unaligned_ivec
1051         nop
1052
1053         std             %f12, [$ivec + 0]       ! write out ivec
1054         std             %f14, [$ivec + 8]
1055 ___
1056 $code.=<<___;
1057         ret
1058         restore
1059
1060 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1061 .align  32
1062 .L${bits}_cbc_dec_loop2x:
1063         ldx             [$inp + 0], %o0
1064         ldx             [$inp + 8], %o1
1065         ldx             [$inp + 16], %o2
1066         brz,pt          $ileft, 4f
1067         ldx             [$inp + 24], %o3
1068
1069         ldx             [$inp + 32], %o4
1070         sllx            %o0, $ileft, %o0
1071         srlx            %o1, $iright, %g1
1072         or              %g1, %o0, %o0
1073         sllx            %o1, $ileft, %o1
1074         srlx            %o2, $iright, %g1
1075         or              %g1, %o1, %o1
1076         sllx            %o2, $ileft, %o2
1077         srlx            %o3, $iright, %g1
1078         or              %g1, %o2, %o2
1079         sllx            %o3, $ileft, %o3
1080         srlx            %o4, $iright, %o4
1081         or              %o4, %o3, %o3
1082 4:
1083         xor             %g4, %o0, %o4           ! ^= rk[0]
1084         xor             %g5, %o1, %o5
1085         movxtod         %o4, %f0
1086         movxtod         %o5, %f2
1087         xor             %g4, %o2, %o4
1088         xor             %g5, %o3, %o5
1089         movxtod         %o4, %f4
1090         movxtod         %o5, %f6
1091
1092         call            _aes${bits}_decrypt_2x
1093         add             $inp, 32, $inp
1094
1095         movxtod         %o0, %f8
1096         movxtod         %o1, %f10
1097         fxor            %f12, %f0, %f0          ! ^= ivec
1098         fxor            %f14, %f2, %f2
1099         movxtod         %o2, %f12
1100         movxtod         %o3, %f14
1101         fxor            %f8, %f4, %f4
1102         fxor            %f10, %f6, %f6
1103
1104         brnz,pn         $ooff, 2f
1105         sub             $len, 2, $len
1106
1107         std             %f0, [$out + 0]
1108         std             %f2, [$out + 8]
1109         std             %f4, [$out + 16]
1110         std             %f6, [$out + 24]
1111         brnz,pt         $len, .L${bits}_cbc_dec_loop2x
1112         add             $out, 32, $out
1113 ___
1114 $code.=<<___ if ($evp);
1115         st              %f12, [$ivec + 0]
1116         st              %f13, [$ivec + 4]
1117         st              %f14, [$ivec + 8]
1118         st              %f15, [$ivec + 12]
1119 ___
1120 $code.=<<___ if (!$evp);
1121         brnz,pn         $ivoff, .L${bits}_cbc_dec_unaligned_ivec
1122         nop
1123
1124         std             %f12, [$ivec + 0]       ! write out ivec
1125         std             %f14, [$ivec + 8]
1126 ___
1127 $code.=<<___;
1128         ret
1129         restore
1130
1131 .align  16
1132 2:      ldxa            [$inp]0x82, %o0         ! avoid read-after-write hazard
1133                                                 ! and ~3x deterioration
1134                                                 ! in inp==out case
1135         faligndata      %f0, %f0, %f8           ! handle unaligned output
1136         faligndata      %f0, %f2, %f0
1137         faligndata      %f2, %f4, %f2
1138         faligndata      %f4, %f6, %f4
1139         faligndata      %f6, %f6, %f6
1140         stda            %f8, [$out + $omask]0xc0        ! partial store
1141         std             %f0, [$out + 8]
1142         std             %f2, [$out + 16]
1143         std             %f4, [$out + 24]
1144         add             $out, 32, $out
1145         orn             %g0, $omask, $omask
1146         stda            %f6, [$out + $omask]0xc0        ! partial store
1147
1148         brnz,pt         $len, .L${bits}_cbc_dec_loop2x+4
1149         orn             %g0, $omask, $omask
1150 ___
1151 $code.=<<___ if ($evp);
1152         st              %f12, [$ivec + 0]
1153         st              %f13, [$ivec + 4]
1154         st              %f14, [$ivec + 8]
1155         st              %f15, [$ivec + 12]
1156 ___
1157 $code.=<<___ if (!$evp);
1158         brnz,pn         $ivoff, .L${bits}_cbc_dec_unaligned_ivec
1159         nop
1160
1161         std             %f12, [$ivec + 0]       ! write out ivec
1162         std             %f14, [$ivec + 8]
1163         ret
1164         restore
1165
1166 .align  16
1167 .L${bits}_cbc_dec_unaligned_ivec:
1168         alignaddrl      $ivec, $ivoff, %g0      ! handle unaligned ivec
1169         mov             0xff, $omask
1170         srl             $omask, $ivoff, $omask
1171         faligndata      %f12, %f12, %f0
1172         faligndata      %f12, %f14, %f2
1173         faligndata      %f14, %f14, %f4
1174         stda            %f0, [$ivec + $omask]0xc0
1175         std             %f2, [$ivec + 8]
1176         add             $ivec, 16, $ivec
1177         orn             %g0, $omask, $omask
1178         stda            %f4, [$ivec + $omask]0xc0
1179 ___
1180 $code.=<<___;
1181         ret
1182         restore
1183 .type   aes${bits}_t4_cbc_decrypt,#function
1184 .size   aes${bits}_t4_cbc_decrypt,.-aes${bits}_t4_cbc_decrypt
1185 ___
1186 }
1187
1188 &aes_cbc_decrypt_implement(128);
1189 &aes_cbc_decrypt_implement(192);
1190 &aes_cbc_decrypt_implement(256);
1191
1192 sub aes_ctr32_implement {
1193 my $bits = shift;
1194
1195 $code.=<<___;
1196 .globl  aes${bits}_t4_ctr32_encrypt
1197 .align  32
1198 aes${bits}_t4_ctr32_encrypt:
1199         save            %sp, -$frame, %sp
1200
1201         call            _aes${bits}_loadkey
1202         nop
1203
1204         ld              [$ivec + 0], %l4        ! counter
1205         ld              [$ivec + 4], %l5
1206         ld              [$ivec + 8], %l6
1207         ld              [$ivec + 12], %l7
1208
1209         sllx            %l4, 32, %o5
1210         or              %l5, %o5, %o5
1211         sllx            %l6, 32, %g1
1212         xor             %o5, %g4, %g4           ! ^= rk[0]
1213         xor             %g1, %g5, %g5
1214         movxtod         %g4, %f14               ! most significant 64 bits
1215
1216         andcc           $len, 1, %g0            ! is number of blocks even?
1217         and             $inp, 7, $ileft
1218         andn            $inp, 7, $inp
1219         sll             $ileft, 3, $ileft
1220         mov             64, $iright
1221         mov             0xff, $omask
1222         sub             $iright, $ileft, $iright
1223         and             $out, 7, $ooff
1224         alignaddrl      $out, %g0, $out
1225         bz              %icc, .L${bits}_ctr32_loop2x
1226         srl             $omask, $ooff, $omask
1227 .L${bits}_ctr32_loop:
1228         ldx             [$inp + 0], %o0
1229         brz,pt          $ileft, 4f
1230         ldx             [$inp + 8], %o1
1231
1232         ldx             [$inp + 16], %o2
1233         sllx            %o0, $ileft, %o0
1234         srlx            %o1, $iright, %g1
1235         sllx            %o1, $ileft, %o1
1236         or              %g1, %o0, %o0
1237         srlx            %o2, $iright, %o2
1238         or              %o2, %o1, %o1
1239 4:
1240         xor             %g5, %l7, %g1           ! ^= rk[0]
1241         add             %l7, 1, %l7
1242         movxtod         %g1, %f2
1243         srl             %l7, 0, %l7             ! clruw
1244
1245         aes_eround01    %f16, %f14, %f2, %f4
1246         aes_eround23    %f18, %f14, %f2, %f2
1247         call            _aes${bits}_encrypt_1x+8
1248         add             $inp, 16, $inp
1249
1250         movxtod         %o0, %f10
1251         movxtod         %o1, %f12
1252         fxor            %f10, %f0, %f0          ! ^= inp
1253         fxor            %f12, %f2, %f2
1254
1255         brnz,pn         $ooff, 2f
1256         sub             $len, 1, $len
1257
1258         std             %f0, [$out + 0]
1259         std             %f2, [$out + 8]
1260         brnz,pt         $len, .L${bits}_ctr32_loop2x
1261         add             $out, 16, $out
1262
1263         ret
1264         restore
1265
1266 .align  16
1267 2:      ldxa            [$inp]0x82, %o0         ! avoid read-after-write hazard
1268                                                 ! and ~3x deterioration
1269                                                 ! in inp==out case
1270         faligndata      %f0, %f0, %f4           ! handle unaligned output
1271         faligndata      %f0, %f2, %f6
1272         faligndata      %f2, %f2, %f8
1273         stda            %f4, [$out + $omask]0xc0        ! partial store
1274         std             %f6, [$out + 8]
1275         add             $out, 16, $out
1276         orn             %g0, $omask, $omask
1277         stda            %f8, [$out + $omask]0xc0        ! partial store
1278
1279         brnz,pt         $len, .L${bits}_ctr32_loop2x+4
1280         orn             %g0, $omask, $omask
1281
1282         ret
1283         restore
1284
1285 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1286 .align  32
1287 .L${bits}_ctr32_loop2x:
1288         ldx             [$inp + 0], %o0
1289         ldx             [$inp + 8], %o1
1290         ldx             [$inp + 16], %o2
1291         brz,pt          $ileft, 4f
1292         ldx             [$inp + 24], %o3
1293
1294         ldx             [$inp + 32], %o4
1295         sllx            %o0, $ileft, %o0
1296         srlx            %o1, $iright, %g1
1297         or              %g1, %o0, %o0
1298         sllx            %o1, $ileft, %o1
1299         srlx            %o2, $iright, %g1
1300         or              %g1, %o1, %o1
1301         sllx            %o2, $ileft, %o2
1302         srlx            %o3, $iright, %g1
1303         or              %g1, %o2, %o2
1304         sllx            %o3, $ileft, %o3
1305         srlx            %o4, $iright, %o4
1306         or              %o4, %o3, %o3
1307 4:
1308         xor             %g5, %l7, %g1           ! ^= rk[0]
1309         add             %l7, 1, %l7
1310         movxtod         %g1, %f2
1311         srl             %l7, 0, %l7             ! clruw
1312         xor             %g5, %l7, %g1
1313         add             %l7, 1, %l7
1314         movxtod         %g1, %f6
1315         srl             %l7, 0, %l7             ! clruw
1316
1317         aes_eround01    %f16, %f14, %f2, %f8
1318         aes_eround23    %f18, %f14, %f2, %f2
1319         aes_eround01    %f16, %f14, %f6, %f10
1320         aes_eround23    %f18, %f14, %f6, %f6
1321         call            _aes${bits}_encrypt_2x+16
1322         add             $inp, 32, $inp
1323
1324         movxtod         %o0, %f8
1325         movxtod         %o1, %f10
1326         movxtod         %o2, %f12
1327         fxor            %f8, %f0, %f0           ! ^= inp
1328         movxtod         %o3, %f8
1329         fxor            %f10, %f2, %f2
1330         fxor            %f12, %f4, %f4
1331         fxor            %f8, %f6, %f6
1332
1333         brnz,pn         $ooff, 2f
1334         sub             $len, 2, $len
1335
1336         std             %f0, [$out + 0]
1337         std             %f2, [$out + 8]
1338         std             %f4, [$out + 16]
1339         std             %f6, [$out + 24]
1340         brnz,pt         $len, .L${bits}_ctr32_loop2x
1341         add             $out, 32, $out
1342
1343         ret
1344         restore
1345
1346 .align  16
1347 2:      ldxa            [$inp]0x82, %o0         ! avoid read-after-write hazard
1348                                                 ! and ~3x deterioration
1349                                                 ! in inp==out case
1350         faligndata      %f0, %f0, %f8           ! handle unaligned output
1351         faligndata      %f0, %f2, %f0
1352         faligndata      %f2, %f4, %f2
1353         faligndata      %f4, %f6, %f4
1354         faligndata      %f6, %f6, %f6
1355
1356         stda            %f8, [$out + $omask]0xc0        ! partial store
1357         std             %f0, [$out + 8]
1358         std             %f2, [$out + 16]
1359         std             %f4, [$out + 24]
1360         add             $out, 32, $out
1361         orn             %g0, $omask, $omask
1362         stda            %f6, [$out + $omask]0xc0        ! partial store
1363
1364         brnz,pt         $len, .L${bits}_ctr32_loop2x+4
1365         orn             %g0, $omask, $omask
1366
1367         ret
1368         restore
1369 .type   aes${bits}_t4_ctr32_encrypt,#function
1370 .size   aes${bits}_t4_ctr32_encrypt,.-aes${bits}_t4_ctr32_encrypt
1371 ___
1372 }
1373
1374 if ($evp) {
1375     &aes_ctr32_implement(128);
1376     &aes_ctr32_implement(192);
1377     &aes_ctr32_implement(256);
1378 }
1379 }}}
1380
1381 if (!$evp) {
1382 $code.=<<___;
1383 .global AES_encrypt
1384 AES_encrypt=aes_t4_encrypt
1385 .global AES_decrypt
1386 AES_decrypt=aes_t4_decrypt
1387 .global AES_set_encrypt_key
1388 AES_set_encrypt_key=aes_t4_set_encrypt_key
1389 .global AES_set_decrypt_key
1390 AES_set_decrypt_key=aes_t4_set_decrypt_key
1391 ___
1392
1393 my ($inp,$out,$len,$key,$ivec,$enc)=map("%o$_",(0..5));
1394
1395 $code.=<<___;
1396 .globl  AES_cbc_encrypt
1397 .align  32
1398 AES_cbc_encrypt:
1399         ld              [$key + 240], %g1
1400         nop
1401         brz             $enc, .Lcbc_decrypt
1402         cmp             %g1, 12
1403
1404         bl,pt           %icc, aes128_t4_cbc_encrypt
1405         nop
1406         be,pn           %icc, aes192_t4_cbc_encrypt
1407         nop
1408         ba              aes256_t4_cbc_encrypt
1409         nop
1410
1411 .Lcbc_decrypt:
1412         bl,pt           %icc, aes128_t4_cbc_decrypt
1413         nop
1414         be,pn           %icc, aes192_t4_cbc_decrypt
1415         nop
1416         ba              aes256_t4_cbc_decrypt
1417         nop
1418 .type   AES_cbc_encrypt,#function
1419 .size   AES_cbc_encrypt,.-AES_cbc_encrypt
1420 ___
1421 }
1422 $code.=<<___;
1423 .asciz  "AES for SPARC T4, David S. Miller, Andy Polyakov"
1424 .align  4
1425 ___
1426 # Purpose of these subroutines is to explicitly encode VIS instructions,
1427 # so that one can compile the module without having to specify VIS
1428 # extentions on compiler command line, e.g. -xarch=v9 vs. -xarch=v9a.
1429 # Idea is to reserve for option to produce "universal" binary and let
1430 # programmer detect if current CPU is VIS capable at run-time.
1431 sub unvis {
1432 my ($mnemonic,$rs1,$rs2,$rd)=@_;
1433 my ($ref,$opf);
1434 my %visopf = (  "faligndata"    => 0x048,
1435                 "fxor"          => 0x06c        );
1436
1437     $ref = "$mnemonic\t$rs1,$rs2,$rd";
1438
1439     if ($opf=$visopf{$mnemonic}) {
1440         foreach ($rs1,$rs2,$rd) {
1441             return $ref if (!/%f([0-9]{1,2})/);
1442             $_=$1;
1443             if ($1>=32) {
1444                 return $ref if ($1&1);
1445                 # re-encode for upper double register addressing
1446                 $_=($1|$1>>5)&31;
1447             }
1448         }
1449
1450         return  sprintf ".word\t0x%08x !%s",
1451                         0x81b00000|$rd<<25|$rs1<<14|$opf<<5|$rs2,
1452                         $ref;
1453     } else {
1454         return $ref;
1455     }
1456 }
1457 sub unalignaddr {
1458 my ($mnemonic,$rs1,$rs2,$rd)=@_;
1459 my %bias = ( "g" => 0, "o" => 8, "l" => 16, "i" => 24 );
1460 my $ref = "$mnemonic\t$rs1,$rs2,$rd";
1461 my $opf = $mnemonic =~ /l$/ ? 0x01a :0x18;
1462
1463     foreach ($rs1,$rs2,$rd) {
1464         if (/%([goli])([0-7])/) { $_=$bias{$1}+$2; }
1465         else                    { return $ref; }
1466     }
1467     return  sprintf ".word\t0x%08x !%s",
1468                     0x81b00000|$rd<<25|$rs1<<14|$opf<<5|$rs2,
1469                     $ref;
1470 }
1471
1472 sub unaes_round {       # 4-argument instructions
1473 my ($mnemonic,$rs1,$rs2,$rs3,$rd)=@_;
1474 my ($ref,$opf);
1475 my %aesopf = (  "aes_eround01"  => 0,
1476                 "aes_eround23"  => 1,
1477                 "aes_dround01"  => 2,
1478                 "aes_dround23"  => 3,
1479                 "aes_eround01_l"=> 4,
1480                 "aes_eround23_l"=> 5,
1481                 "aes_dround01_l"=> 6,
1482                 "aes_dround23_l"=> 7,
1483                 "aes_kexpand1"  => 8    );
1484
1485     $ref = "$mnemonic\t$rs1,$rs2,$rs3,$rd";
1486
1487     if (defined($opf=$aesopf{$mnemonic})) {
1488         $rs3 = ($rs3 =~ /%f([0-6]*[02468])/) ? (($1|$1>>5)&31) : $rs3;
1489         foreach ($rs1,$rs2,$rd) {
1490             return $ref if (!/%f([0-9]{1,2})/);
1491             $_=$1;
1492             if ($1>=32) {
1493                 return $ref if ($1&1);
1494                 # re-encode for upper double register addressing
1495                 $_=($1|$1>>5)&31;
1496             }
1497         }
1498
1499         return  sprintf ".word\t0x%08x !%s",
1500                         2<<30|$rd<<25|0x19<<19|$rs1<<14|$rs3<<9|$opf<<5|$rs2,
1501                         $ref;
1502     } else {
1503         return $ref;
1504     }
1505 }
1506
1507 sub unaes_kexpand {     # 3-argument instructions
1508 my ($mnemonic,$rs1,$rs2,$rd)=@_;
1509 my ($ref,$opf);
1510 my %aesopf = (  "aes_kexpand0"  => 0x130,
1511                 "aes_kexpand2"  => 0x131        );
1512
1513     $ref = "$mnemonic\t$rs1,$rs2,$rd";
1514
1515     if (defined($opf=$aesopf{$mnemonic})) {
1516         foreach ($rs1,$rs2,$rd) {
1517             return $ref if (!/%f([0-9]{1,2})/);
1518             $_=$1;
1519             if ($1>=32) {
1520                 return $ref if ($1&1);
1521                 # re-encode for upper double register addressing
1522                 $_=($1|$1>>5)&31;
1523             }
1524         }
1525
1526         return  sprintf ".word\t0x%08x !%s",
1527                         2<<30|$rd<<25|0x36<<19|$rs1<<14|$opf<<5|$rs2,
1528                         $ref;
1529     } else {
1530         return $ref;
1531     }
1532 }
1533
1534 sub unmovxtox {         # 2-argument instructions
1535 my ($mnemonic,$rs,$rd)=@_;
1536 my %bias = ( "g" => 0, "o" => 8, "l" => 16, "i" => 24, "f" => 0 );
1537 my ($ref,$opf);
1538 my %movxopf = ( "movdtox"       => 0x110,
1539                 "movstouw"      => 0x111,
1540                 "movstosw"      => 0x113,
1541                 "movxtod"       => 0x118,
1542                 "movwtos"       => 0x119        );
1543
1544     $ref = "$mnemonic\t$rs,$rd";
1545
1546     if (defined($opf=$movxopf{$mnemonic})) {
1547         foreach ($rs,$rd) {
1548             return $ref if (!/%([fgoli])([0-9]{1,2})/);
1549             $_=$bias{$1}+$2;
1550             if ($2>=32) {
1551                 return $ref if ($2&1);
1552                 # re-encode for upper double register addressing
1553                 $_=($2|$2>>5)&31;
1554             }
1555         }
1556
1557         return  sprintf ".word\t0x%08x !%s",
1558                         2<<30|$rd<<25|0x36<<19|$opf<<5|$rs,
1559                         $ref;
1560     } else {
1561         return $ref;
1562     }
1563 }
1564
1565 foreach (split("\n",$code)) {
1566         s/\`([^\`]*)\`/eval $1/ge;
1567
1568         s/\b(aes_[edk][^\s]*)\s+(%f[0-9]{1,2}),\s*(%f[0-9]{1,2}),\s*([%fx0-9]+),\s*(%f[0-9]{1,2})/
1569                 &unaes_round($1,$2,$3,$4,$5)
1570          /ge or
1571         s/\b(aes_kexpand[02])\s+(%f[0-9]{1,2}),\s*(%f[0-9]{1,2}),\s*(%f[0-9]{1,2})/
1572                 &unaes_kexpand($1,$2,$3,$4)
1573          /ge or
1574         s/\b(mov[ds]to\w+)\s+(%f[0-9]{1,2}),\s*(%[goli][0-7])/
1575                 &unmovxtox($1,$2,$3)
1576          /ge or
1577         s/\b(mov[xw]to[ds])\s+(%[goli][0-7]),\s*(%f[0-9]{1,2})/
1578                 &unmovxtox($1,$2,$3)
1579          /ge or
1580         s/\b(f[^\s]*)\s+(%f[0-9]{1,2}),\s*(%f[0-9]{1,2}),\s*(%f[0-9]{1,2})/
1581                 &unvis($1,$2,$3,$4)
1582          /ge or
1583         s/\b(alignaddr[l]*)\s+(%[goli][0-7]),\s*(%[goli][0-7]),\s*(%[goli][0-7])/
1584                 &unalignaddr($1,$2,$3,$4)
1585          /ge;
1586
1587         print $_,"\n";
1588 }
1589
1590 close STDOUT;