crypto/md5/asm/md5-ia64.S

   1 /* Copyright (c) 2005 Hewlett-Packard Development Company, L.P.
   2
   3 Permission is hereby granted, free of charge, to any person obtaining
   4 a copy of this software and associated documentation files (the
   5 "Software"), to deal in the Software without restriction, including
   6 without limitation the rights to use, copy, modify, merge, publish,
   7 distribute, sublicense, and/or sell copies of the Software, and to
   8 permit persons to whom the Software is furnished to do so, subject to
   9 the following conditions:
  10
  11 The above copyright notice and this permission notice shall be
  12 included in all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  18 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  19 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  20 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  21
  22 //      Common registers are assigned as follows:
  23 //
  24 //      COMMON
  25 //
  26 //      t0              Const Tbl Ptr   TPtr
  27 //      t1              Round Constant  TRound
  28 //      t4              Block residual  LenResid
  29 //      t5              Residual Data   DTmp
  30 //
  31 //      {in,out}0       Block 0 Cycle   RotateM0
  32 //      {in,out}1       Block Value 12  M12
  33 //      {in,out}2       Block Value 8   M8
  34 //      {in,out}3       Block Value 4   M4
  35 //      {in,out}4       Block Value 0   M0
  36 //      {in,out}5       Block 1 Cycle   RotateM1
  37 //      {in,out}6       Block Value 13  M13
  38 //      {in,out}7       Block Value 9   M9
  39 //      {in,out}8       Block Value 5   M5
  40 //      {in,out}9       Block Value 1   M1
  41 //      {in,out}10      Block 2 Cycle   RotateM2
  42 //      {in,out}11      Block Value 14  M14
  43 //      {in,out}12      Block Value 10  M10
  44 //      {in,out}13      Block Value 6   M6
  45 //      {in,out}14      Block Value 2   M2
  46 //      {in,out}15      Block 3 Cycle   RotateM3
  47 //      {in,out}16      Block Value 15  M15
  48 //      {in,out}17      Block Value 11  M11
  49 //      {in,out}18      Block Value 7   M7
  50 //      {in,out}19      Block Value 3   M3
  51 //      {in,out}20      Scratch                 Z
  52 //      {in,out}21      Scratch                 Y
  53 //      {in,out}22      Scratch                 X
  54 //      {in,out}23      Scratch                 W
  55 //      {in,out}24      Digest A                A
  56 //      {in,out}25      Digest B                B
  57 //      {in,out}26      Digest C                C
  58 //      {in,out}27      Digest D                D
  59 //      {in,out}28      Active Data Ptr DPtr
  60 //      in28            Dummy Value             -
  61 //      out28           Dummy Value             -
  62 //      bt0                     Coroutine Link  QUICK_RTN
  63 //
  64 ///     These predicates are used for computing the padding block(s) and
  65 ///     are shared between the driver and digest co-routines
  66 //
  67 //      pt0                     Extra Pad Block pExtra
  68 //      pt1                     Load next word  pLoad
  69 //      pt2                     Skip next word  pSkip
  70 //      pt3                     Search for Pad  pNoPad
  71 //      pt4                     Pad Word 0              pPad0
  72 //      pt5                     Pad Word 1              pPad1
  73 //      pt6                     Pad Word 2              pPad2
  74 //      pt7                     Pad Word 3              pPad3
  75
  76 #define DTmp            r19
  77 #define LenResid        r18
  78 #define QUICK_RTN       b6
  79 #define TPtr            r14
  80 #define TRound          r15
  81 #define pExtra          p6
  82 #define pLoad           p7
  83 #define pNoPad          p9
  84 #define pPad0           p10
  85 #define pPad1           p11
  86 #define pPad2           p12
  87 #define pPad3           p13
  88 #define pSkip           p8
  89
  90 #define A_              out24
  91 #define B_              out25
  92 #define C_              out26
  93 #define D_              out27
  94 #define DPtr_           out28
  95 #define M0_             out4
  96 #define M1_             out9
  97 #define M10_            out12
  98 #define M11_            out17
  99 #define M12_            out1
 100 #define M13_            out6
 101 #define M14_            out11
 102 #define M15_            out16
 103 #define M2_             out14
 104 #define M3_             out19
 105 #define M4_             out3
 106 #define M5_             out8
 107 #define M6_             out13
 108 #define M7_             out18
 109 #define M8_             out2
 110 #define M9_             out7
 111 #define RotateM0_       out0
 112 #define RotateM1_       out5
 113 #define RotateM2_       out10
 114 #define RotateM3_       out15
 115 #define W_              out23
 116 #define X_              out22
 117 #define Y_              out21
 118 #define Z_              out20
 119
 120 #define A               in24
 121 #define B               in25
 122 #define C               in26
 123 #define D               in27
 124 #define DPtr            in28
 125 #define M0              in4
 126 #define M1              in9
 127 #define M10             in12
 128 #define M11             in17
 129 #define M12             in1
 130 #define M13             in6
 131 #define M14             in11
 132 #define M15             in16
 133 #define M2              in14
 134 #define M3              in19
 135 #define M4              in3
 136 #define M5              in8
 137 #define M6              in13
 138 #define M7              in18
 139 #define M8              in2
 140 #define M9              in7
 141 #define RotateM0        in0
 142 #define RotateM1        in5
 143 #define RotateM2        in10
 144 #define RotateM3        in15
 145 #define W               in23
 146 #define X               in22
 147 #define Y               in21
 148 #define Z               in20
 149
 150 /* register stack configuration for md5_block_asm_data_order(): */
 151 #define MD5_NINP        3
 152 #define MD5_NLOC        0
 153 #define MD5_NOUT        29
 154 #define MD5_NROT        0
 155
 156 /* register stack configuration for helpers: */
 157 #define _NINPUTS        MD5_NOUT
 158 #define _NLOCALS        0
 159 #define _NOUTPUT        0
 160 #define _NROTATE        24      /* this must be <= _NINPUTS */
 161
 162 #if defined(_HPUX_SOURCE) && !defined(_LP64)
 163 #define ADDP    addp4
 164 #else
 165 #define ADDP    add
 166 #endif
 167
 168 #if defined(_HPUX_SOURCE) || defined(B_ENDIAN)
 169 #define HOST_IS_BIG_ENDIAN
 170 #endif
 171
 172 //      Macros for getting the left and right portions of little-endian words
 173
 174 #define GETLW(dst, src, align)  dep.z dst = src, 32 - 8 * align, 8 * align
 175 #define GETRW(dst, src, align)  extr.u dst = src, 8 * align, 32 - 8 * align
 176
 177 //      MD5 driver
 178 //
 179 //              Reads an input block, then calls the digest block
 180 //              subroutine and adds the results to the accumulated
 181 //              digest.  It allocates 32 outs which the subroutine
 182 //              uses as it's inputs and rotating
 183 //              registers. Initializes the round constant pointer and
 184 //              takes care of saving/restoring ar.lc
 185 //
 186 ///     INPUT
 187 //
 188 //      in0             Context Ptr             CtxPtr0
 189 //      in1             Input Data Ptr          DPtrIn
 190 //      in2             Integral Blocks         BlockCount
 191 //      rp              Return Address          -
 192 //
 193 ///     CODE
 194 //
 195 //      v2              Input Align             InAlign
 196 //      t0              Shared w/digest         -
 197 //      t1              Shared w/digest         -
 198 //      t2              Shared w/digest         -
 199 //      t3              Shared w/digest         -
 200 //      t4              Shared w/digest         -
 201 //      t5              Shared w/digest         -
 202 //      t6              PFS Save                PFSSave
 203 //      t7              ar.lc Save              LCSave
 204 //      t8              Saved PR                PRSave
 205 //      t9              2nd CtxPtr              CtxPtr1
 206 //      t10             Table Base              CTable
 207 //      t11             Table[0]                CTable0
 208 //      t13             Accumulator A           AccumA
 209 //      t14             Accumulator B           AccumB
 210 //      t15             Accumulator C           AccumC
 211 //      t16             Accumulator D           AccumD
 212 //      pt0             Shared w/digest         -
 213 //      pt1             Shared w/digest         -
 214 //      pt2             Shared w/digest         -
 215 //      pt3             Shared w/digest         -
 216 //      pt4             Shared w/digest         -
 217 //      pt5             Shared w/digest         -
 218 //      pt6             Shared w/digest         -
 219 //      pt7             Shared w/digest         -
 220 //      pt8             Not Aligned             pOff
 221 //      pt8             Blocks Left             pAgain
 222
 223 #define AccumA          r27
 224 #define AccumB          r28
 225 #define AccumC          r29
 226 #define AccumD          r30
 227 #define CTable          r24
 228 #define CTable0         r25
 229 #define CtxPtr0         in0
 230 #define CtxPtr1         r23
 231 #define DPtrIn          in1
 232 #define BlockCount      in2
 233 #define InAlign         r10
 234 #define LCSave          r21
 235 #define PFSSave         r20
 236 #define PRSave          r22
 237 #define pAgain          p63
 238 #define pOff            p63
 239
 240         .text
 241
 242 /* md5_block_asm_data_order(MD5_CTX *c, const void *data, size_t num)
 243
 244      where:
 245       c: a pointer to a structure of this type:
 246
 247            typedef struct MD5state_st
 248              {
 249                MD5_LONG A,B,C,D;
 250                MD5_LONG Nl,Nh;
 251                MD5_LONG data[MD5_LBLOCK];
 252                unsigned int num;
 253              }
 254            MD5_CTX;
 255
 256       data: a pointer to the input data (may be misaligned)
 257       num:  the number of 16-byte blocks to hash (i.e., the length
 258             of DATA is 16*NUM.
 259
 260    */
 261
 262         .type   md5_block_asm_data_order, @function
 263         .global md5_block_asm_data_order
 264         .align  32
 265         .proc   md5_block_asm_data_order
 266 md5_block_asm_data_order:
 267 .md5_block:
 268         .prologue
 269 {       .mmi
 270         .save   ar.pfs, PFSSave
 271         alloc   PFSSave = ar.pfs, MD5_NINP, MD5_NLOC, MD5_NOUT, MD5_NROT
 272         ADDP    CtxPtr1 = 8, CtxPtr0
 273         mov     CTable = ip
 274 }
 275 {       .mmi
 276         ADDP    DPtrIn = 0, DPtrIn
 277         ADDP    CtxPtr0 = 0, CtxPtr0
 278         .save   ar.lc, LCSave
 279         mov     LCSave = ar.lc
 280 }
 281 ;;
 282 {       .mmi
 283         add     CTable = .md5_tbl_data_order#-.md5_block#, CTable
 284         and     InAlign = 0x3, DPtrIn
 285 }
 286
 287 {       .mmi
 288         ld4     AccumA = [CtxPtr0], 4
 289         ld4     AccumC = [CtxPtr1], 4
 290         .save pr, PRSave
 291         mov     PRSave = pr
 292         .body
 293 }
 294 ;;
 295 {       .mmi
 296         ld4     AccumB = [CtxPtr0]
 297         ld4     AccumD = [CtxPtr1]
 298         dep     DPtr_ = 0, DPtrIn, 0, 2
 299 } ;;
 300 #ifdef HOST_IS_BIG_ENDIAN
 301         rum     psr.be;;        // switch to little-endian
 302 #endif
 303 {       .mmb
 304         ld4     CTable0 = [CTable], 4
 305         cmp.ne  pOff, p0 = 0, InAlign
 306 (pOff)  br.cond.spnt.many .md5_unaligned
 307 } ;;
 308
 309 //      The FF load/compute loop rotates values three times, so that
 310 //      loading into M12 here produces the M0 value, M13 -> M1, etc.
 311
 312 .md5_block_loop0:
 313 {       .mmi
 314         ld4     M12_ = [DPtr_], 4
 315         mov     TPtr = CTable
 316         mov     TRound = CTable0
 317 } ;;
 318 {       .mmi
 319         ld4     M13_ = [DPtr_], 4
 320         mov     A_ = AccumA
 321         mov     B_ = AccumB
 322 } ;;
 323 {       .mmi
 324         ld4     M14_ = [DPtr_], 4
 325         mov     C_ = AccumC
 326         mov     D_ = AccumD
 327 } ;;
 328 {       .mmb
 329         ld4     M15_ = [DPtr_], 4
 330         add     BlockCount = -1, BlockCount
 331         br.call.sptk.many QUICK_RTN = md5_digest_block0
 332 } ;;
 333
 334 //      Now, we add the new digest values and do some clean-up
 335 //      before checking if there's another full block to process
 336
 337 {       .mmi
 338         add     AccumA = AccumA, A_
 339         add     AccumB = AccumB, B_
 340         cmp.ne  pAgain, p0 = 0, BlockCount
 341 }
 342 {       .mib
 343         add     AccumC = AccumC, C_
 344         add     AccumD = AccumD, D_
 345 (pAgain) br.cond.dptk.many .md5_block_loop0
 346 } ;;
 347
 348 .md5_exit:
 349 #ifdef HOST_IS_BIG_ENDIAN
 350         sum     psr.be;;        // switch back to big-endian mode
 351 #endif
 352 {       .mmi
 353         st4     [CtxPtr0] = AccumB, -4
 354         st4     [CtxPtr1] = AccumD, -4
 355         mov     pr = PRSave, 0x1ffff ;;
 356 }
 357 {       .mmi
 358         st4     [CtxPtr0] = AccumA
 359         st4     [CtxPtr1] = AccumC
 360         mov     ar.lc = LCSave
 361 } ;;
 362 {       .mib
 363         mov     ar.pfs = PFSSave
 364         br.ret.sptk.few rp
 365 } ;;
 366
 367 #define MD5UNALIGNED(offset)                                            \
 368 .md5_process##offset:                                                   \
 369 {       .mib ;                                                          \
 370         nop     0x0     ;                                               \
 371         GETRW(DTmp, DTmp, offset) ;                                     \
 372 } ;;                                                                    \
 373 .md5_block_loop##offset:                                                \
 374 {       .mmi ;                                                          \
 375         ld4     Y_ = [DPtr_], 4 ;                                       \
 376         mov     TPtr = CTable ;                                         \
 377         mov     TRound = CTable0 ;                                      \
 378 } ;;                                                                    \
 379 {       .mmi ;                                                          \
 380         ld4     M13_ = [DPtr_], 4 ;                                     \
 381         mov     A_ = AccumA ;                                           \
 382         mov     B_ = AccumB ;                                           \
 383 } ;;                                                                    \
 384 {       .mii ;                                                          \
 385         ld4     M14_ = [DPtr_], 4 ;                                     \
 386         GETLW(W_, Y_, offset) ;                                         \
 387         mov     C_ = AccumC ;                                           \
 388 }                                                                       \
 389 {       .mmi ;                                                          \
 390         mov     D_ = AccumD ;;                                          \
 391         or      M12_ = W_, DTmp ;                                       \
 392         GETRW(DTmp, Y_, offset) ;                                       \
 393 }                                                                       \
 394 {       .mib ;                                                          \
 395         ld4     M15_ = [DPtr_], 4 ;                                     \
 396         add     BlockCount = -1, BlockCount ;                           \
 397         br.call.sptk.many QUICK_RTN = md5_digest_block##offset;         \
 398 } ;;                                                                    \
 399 {       .mmi ;                                                          \
 400         add     AccumA = AccumA, A_ ;                                   \
 401         add     AccumB = AccumB, B_ ;                                   \
 402         cmp.ne  pAgain, p0 = 0, BlockCount ;                            \
 403 }                                                                       \
 404 {       .mib ;                                                          \
 405         add     AccumC = AccumC, C_ ;                                   \
 406         add     AccumD = AccumD, D_ ;                                   \
 407 (pAgain) br.cond.dptk.many .md5_block_loop##offset ;                    \
 408 } ;;                                                                    \
 409 {       .mib ;                                                          \
 410         nop     0x0 ;                                                   \
 411         nop     0x0 ;                                                   \
 412         br.cond.sptk.many .md5_exit ;                                   \
 413 } ;;
 414
 415         .align  32
 416 .md5_unaligned:
 417 //
 418 //      Because variable shifts are expensive, we special case each of
 419 //      the four alignements. In practice, this won't hurt too much
 420 //      since only one working set of code will be loaded.
 421 //
 422 {       .mib
 423         ld4     DTmp = [DPtr_], 4
 424         cmp.eq  pOff, p0 = 1, InAlign
 425 (pOff)  br.cond.dpnt.many .md5_process1
 426 } ;;
 427 {       .mib
 428         cmp.eq  pOff, p0 = 2, InAlign
 429         nop     0x0
 430 (pOff)  br.cond.dpnt.many .md5_process2
 431 } ;;
 432         MD5UNALIGNED(3)
 433         MD5UNALIGNED(1)
 434         MD5UNALIGNED(2)
 435
 436         .endp md5_block_asm_data_order
 437
 438
 439 // MD5 Perform the F function and load
 440 //
 441 // Passed the first 4 words (M0 - M3) and initial (A, B, C, D) values,
 442 // computes the FF() round of functions, then branches to the common
 443 // digest code to finish up with GG(), HH, and II().
 444 //
 445 // INPUT
 446 //
 447 // rp Return Address -
 448 //
 449 // CODE
 450 //
 451 // v0 PFS bit bucket PFS
 452 // v1 Loop Trip Count LTrip
 453 // pt0 Load next word pMore
 454
 455 /* For F round: */
 456 #define LTrip   r9
 457 #define PFS     r8
 458 #define pMore   p6
 459
 460 /* For GHI rounds: */
 461 #define T       r9
 462 #define U       r10
 463 #define V       r11
 464
 465 #define COMPUTE(a, b, s, M, R)                  \
 466 {                                               \
 467         .mii ;                                  \
 468         ld4 TRound = [TPtr], 4 ;                \
 469         dep.z Y = Z, 32, 32 ;;                  \
 470         shrp Z = Z, Y, 64 - s ;                 \
 471 } ;;                                            \
 472 {                                               \
 473         .mmi ;                                  \
 474         add a = Z, b ;                          \
 475         mov R = M ;                             \
 476         nop 0x0 ;                               \
 477 } ;;
 478
 479 #define LOOP(a, b, s, M, R, label)              \
 480 {       .mii ;                                  \
 481         ld4 TRound = [TPtr], 4 ;                \
 482         dep.z Y = Z, 32, 32 ;;                  \
 483         shrp Z = Z, Y, 64 - s ;                 \
 484 } ;;                                            \
 485 {       .mib ;                                  \
 486         add a = Z, b ;                          \
 487         mov R = M ;                             \
 488         br.ctop.sptk.many label ;               \
 489 } ;;
 490
 491 // G(B, C, D) = (B & D) | (C & ~D)
 492
 493 #define G(a, b, c, d, M)                        \
 494 {       .mmi ;                                  \
 495         add Z = M, TRound ;                     \
 496         and Y = b, d ;                          \
 497         andcm X = c, d ;                        \
 498 } ;;                                            \
 499 {       .mii ;                                  \
 500         add Z = Z, a ;                          \
 501         or Y = Y, X ;;                          \
 502         add Z = Z, Y ;                          \
 503 } ;;
 504
 505 // H(B, C, D) = B ^ C ^ D
 506
 507 #define H(a, b, c, d, M)                        \
 508 {       .mmi ;                                  \
 509         add Z = M, TRound ;                     \
 510         xor Y = b, c ;                          \
 511         nop 0x0 ;                               \
 512 } ;;                                            \
 513 {       .mii ;                                  \
 514         add Z = Z, a ;                          \
 515         xor Y = Y, d ;;                         \
 516         add Z = Z, Y ;                          \
 517 } ;;
 518
 519 // I(B, C, D) = C ^ (B | ~D)
 520 //
 521 // However, since we have an andcm operator, we use the fact that
 522 //
 523 // Y ^ Z == ~Y ^ ~Z
 524 //
 525 // to rewrite the expression as
 526 //
 527 // I(B, C, D) = ~C ^ (~B & D)
 528
 529 #define I(a, b, c, d, M)                        \
 530 {       .mmi ;                                  \
 531         add Z = M, TRound ;                     \
 532         andcm Y = d, b ;                        \
 533         andcm X = -1, c ;                       \
 534 } ;;                                            \
 535 {       .mii ;                                  \
 536         add Z = Z, a ;                          \
 537         xor Y = Y, X ;;                         \
 538         add Z = Z, Y ;                          \
 539 } ;;
 540
 541 #define GG4(label)                              \
 542         G(A, B, C, D, M0)                       \
 543         COMPUTE(A, B, 5, M0, RotateM0)          \
 544         G(D, A, B, C, M1)                       \
 545         COMPUTE(D, A, 9, M1, RotateM1)          \
 546         G(C, D, A, B, M2)                       \
 547         COMPUTE(C, D, 14, M2, RotateM2)         \
 548         G(B, C, D, A, M3)                       \
 549         LOOP(B, C, 20, M3, RotateM3, label)
 550
 551 #define HH4(label)                              \
 552         H(A, B, C, D, M0)                       \
 553         COMPUTE(A, B, 4, M0, RotateM0)          \
 554         H(D, A, B, C, M1)                       \
 555         COMPUTE(D, A, 11, M1, RotateM1)         \
 556         H(C, D, A, B, M2)                       \
 557         COMPUTE(C, D, 16, M2, RotateM2)         \
 558         H(B, C, D, A, M3)                       \
 559         LOOP(B, C, 23, M3, RotateM3, label)
 560
 561 #define II4(label)                              \
 562         I(A, B, C, D, M0)                       \
 563         COMPUTE(A, B, 6, M0, RotateM0)          \
 564         I(D, A, B, C, M1)                       \
 565         COMPUTE(D, A, 10, M1, RotateM1)         \
 566         I(C, D, A, B, M2)                       \
 567         COMPUTE(C, D, 15, M2, RotateM2)         \
 568         I(B, C, D, A, M3)                       \
 569         LOOP(B, C, 21, M3, RotateM3, label)
 570
 571 #define FFLOAD(a, b, c, d, M, N, s)             \
 572 {       .mii ;                                  \
 573 (pMore) ld4 N = [DPtr], 4 ;                     \
 574         add Z = M, TRound ;                     \
 575         and Y = c, b ;                          \
 576 }                                               \
 577 {       .mmi ;                                  \
 578         andcm X = d, b ;;                       \
 579         add Z = Z, a ;                          \
 580         or Y = Y, X ;                           \
 581 } ;;                                            \
 582 {       .mii ;                                  \
 583         ld4 TRound = [TPtr], 4 ;                \
 584         add Z = Z, Y ;;                         \
 585         dep.z Y = Z, 32, 32 ;                   \
 586 } ;;                                            \
 587 {       .mii ;                                  \
 588         nop 0x0 ;                               \
 589         shrp Z = Z, Y, 64 - s ;;                \
 590         add a = Z, b ;                          \
 591 } ;;
 592
 593 #define FFLOOP(a, b, c, d, M, N, s, dest)       \
 594 {       .mii ;                                  \
 595 (pMore) ld4 N = [DPtr], 4 ;                     \
 596         add Z = M, TRound ;                     \
 597         and Y = c, b ;                          \
 598 }                                               \
 599 {       .mmi ;                                  \
 600         andcm X = d, b ;;                       \
 601         add Z = Z, a ;                          \
 602         or Y = Y, X ;                           \
 603 } ;;                                            \
 604 {       .mii ;                                  \
 605         ld4 TRound = [TPtr], 4 ;                \
 606         add Z = Z, Y ;;                         \
 607         dep.z Y = Z, 32, 32 ;                   \
 608 } ;;                                            \
 609 {       .mii ;                                  \
 610         nop 0x0 ;                               \
 611         shrp Z = Z, Y, 64 - s ;;                \
 612         add a = Z, b ;                          \
 613 }                                               \
 614 {       .mib ;                                  \
 615         cmp.ne pMore, p0 = 0, LTrip ;           \
 616         add LTrip = -1, LTrip ;                 \
 617         br.ctop.dptk.many dest ;                \
 618 } ;;
 619
 620         .type md5_digest_block0, @function
 621         .align 32
 622
 623         .proc md5_digest_block0
 624         .prologue
 625 md5_digest_block0:
 626         .altrp QUICK_RTN
 627         .body
 628 {       .mmi
 629         alloc PFS = ar.pfs, _NINPUTS, _NLOCALS, _NOUTPUT, _NROTATE
 630         mov LTrip = 2
 631         mov ar.lc = 3
 632 } ;;
 633 {       .mii
 634         cmp.eq pMore, p0 = r0, r0
 635         mov ar.ec = 0
 636         nop 0x0
 637 } ;;
 638
 639 .md5_FF_round0:
 640         FFLOAD(A, B, C, D, M12, RotateM0, 7)
 641         FFLOAD(D, A, B, C, M13, RotateM1, 12)
 642         FFLOAD(C, D, A, B, M14, RotateM2, 17)
 643         FFLOOP(B, C, D, A, M15, RotateM3, 22, .md5_FF_round0)
 644         //
 645         // !!! Fall through to md5_digest_GHI
 646         //
 647         .endp md5_digest_block0
 648
 649         .type md5_digest_GHI, @function
 650         .align 32
 651
 652         .proc md5_digest_GHI
 653         .prologue
 654         .regstk _NINPUTS, _NLOCALS, _NOUTPUT, _NROTATE
 655 md5_digest_GHI:
 656         .altrp QUICK_RTN
 657         .body
 658 //
 659 // The following sequence shuffles the block counstants round for the
 660 // next round:
 661 //
 662 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 663 // 1 6 11 0 5 10 14 4 9 14 3 8 13 2 7 12
 664 //
 665 {       .mmi
 666         mov Z = M0
 667         mov Y = M15
 668         mov ar.lc = 3
 669 }
 670 {       .mmi
 671         mov X = M2
 672         mov W = M9
 673         mov V = M4
 674 } ;;
 675
 676 {       .mmi
 677         mov M0 = M1
 678         mov M15 = M12
 679         mov ar.ec = 1
 680 }
 681 {       .mmi
 682         mov M2 = M11
 683         mov M9 = M14
 684         mov M4 = M5
 685 } ;;
 686
 687 {       .mmi
 688         mov M1 = M6
 689         mov M12 = M13
 690         mov U = M3
 691 }
 692 {       .mmi
 693         mov M11 = M8
 694         mov M14 = M7
 695         mov M5 = M10
 696 } ;;
 697
 698 {       .mmi
 699         mov M6 = Y
 700         mov M13 = X
 701         mov M3 = Z
 702 }
 703 {       .mmi
 704         mov M8 = W
 705         mov M7 = V
 706         mov M10 = U
 707 } ;;
 708
 709 .md5_GG_round:
 710         GG4(.md5_GG_round)
 711
 712 // The following sequence shuffles the block constants round for the
 713 // next round:
 714 //
 715 // 1 6 11 0 5 10 14 4 9 14 3 8 13 2 7 12
 716 // 5 8 11 14 1 4 7 10 13 0 3 6 9 12 15 2
 717
 718 {       .mmi
 719         mov Z = M0
 720         mov Y = M1
 721         mov ar.lc = 3
 722 }
 723 {       .mmi
 724         mov X = M3
 725         mov W = M5
 726         mov V = M6
 727 } ;;
 728
 729 {       .mmi
 730         mov M0 = M4
 731         mov M1 = M11
 732         mov ar.ec = 1
 733 }
 734 {       .mmi
 735         mov M3 = M9
 736         mov U = M8
 737         mov T = M13
 738 } ;;
 739
 740 {       .mmi
 741         mov M4 = Z
 742         mov M11 = Y
 743         mov M5 = M7
 744 }
 745 {       .mmi
 746         mov M6 = M14
 747         mov M8 = M12
 748         mov M13 = M15
 749 } ;;
 750
 751 {       .mmi
 752         mov M7 = W
 753         mov M14 = V
 754         nop 0x0
 755 }
 756 {       .mmi
 757         mov M9 = X
 758         mov M12 = U
 759         mov M15 = T
 760 } ;;
 761
 762 .md5_HH_round:
 763         HH4(.md5_HH_round)
 764
 765 // The following sequence shuffles the block constants round for the
 766 // next round:
 767 //
 768 // 5 8 11 14 1 4 7 10 13 0 3 6 9 12 15 2
 769 // 0 7 14 5 12 3 10 1 8 15 6 13 4 11 2 9
 770
 771 {       .mmi
 772         mov Z = M0
 773         mov Y = M15
 774         mov ar.lc = 3
 775 }
 776 {       .mmi
 777         mov X = M10
 778         mov W = M1
 779         mov V = M4
 780 } ;;
 781
 782 {       .mmi
 783         mov M0 = M9
 784         mov M15 = M12
 785         mov ar.ec = 1
 786 }
 787 {       .mmi
 788         mov M10 = M11
 789         mov M1 = M6
 790         mov M4 = M13
 791 } ;;
 792
 793 {       .mmi
 794         mov M9 = M14
 795         mov M12 = M5
 796         mov U = M3
 797 }
 798 {       .mmi
 799         mov M11 = M8
 800         mov M6 = M7
 801         mov M13 = M2
 802 } ;;
 803
 804 {       .mmi
 805         mov M14 = Y
 806         mov M5 = X
 807         mov M3 = Z
 808 }
 809 {       .mmi
 810         mov M8 = W
 811         mov M7 = V
 812         mov M2 = U
 813 } ;;
 814
 815 .md5_II_round:
 816         II4(.md5_II_round)
 817
 818 {       .mib
 819         nop 0x0
 820         nop 0x0
 821         br.ret.sptk.many QUICK_RTN
 822 } ;;
 823
 824         .endp md5_digest_GHI
 825
 826 #define FFLOADU(a, b, c, d, M, P, N, s, offset) \
 827 {       .mii ;                                  \
 828 (pMore) ld4 N = [DPtr], 4 ;                     \
 829         add Z = M, TRound ;                     \
 830         and Y = c, b ;                          \
 831 }                                               \
 832 {       .mmi ;                                  \
 833         andcm X = d, b ;;                       \
 834         add Z = Z, a ;                          \
 835         or Y = Y, X ;                           \
 836 } ;;                                            \
 837 {       .mii ;                                  \
 838         ld4 TRound = [TPtr], 4 ;                \
 839         GETLW(W, P, offset) ;                   \
 840         add Z = Z, Y ;                          \
 841 } ;;                                            \
 842 {       .mii ;                                  \
 843         or W = W, DTmp ;                        \
 844         dep.z Y = Z, 32, 32 ;;                  \
 845         shrp Z = Z, Y, 64 - s ;                 \
 846 } ;;                                            \
 847 {       .mii ;                                  \
 848         add a = Z, b ;                          \
 849         GETRW(DTmp, P, offset) ;                \
 850         mov P = W ;                             \
 851 } ;;
 852
 853 #define FFLOOPU(a, b, c, d, M, P, N, s, offset)         \
 854 {       .mii ;                                          \
 855 (pMore) ld4 N = [DPtr], 4 ;                             \
 856         add Z = M, TRound ;                             \
 857         and Y = c, b ;                                  \
 858 }                                                       \
 859 {       .mmi ;                                          \
 860         andcm X = d, b ;;                               \
 861         add Z = Z, a ;                                  \
 862         or Y = Y, X ;                                   \
 863 } ;;                                                    \
 864 {       .mii ;                                          \
 865         ld4 TRound = [TPtr], 4 ;                        \
 866 (pMore) GETLW(W, P, offset)     ;                       \
 867         add Z = Z, Y ;                                  \
 868 } ;;                                                    \
 869 {       .mii ;                                          \
 870 (pMore) or W = W, DTmp ;                                \
 871         dep.z Y = Z, 32, 32 ;;                          \
 872         shrp Z = Z, Y, 64 - s ;                         \
 873 } ;;                                                    \
 874 {       .mii ;                                          \
 875         add a = Z, b ;                                  \
 876 (pMore) GETRW(DTmp, P, offset)  ;                       \
 877 (pMore) mov P = W ;                                     \
 878 }                                                       \
 879 {       .mib ;                                          \
 880         cmp.ne pMore, p0 = 0, LTrip ;                   \
 881         add LTrip = -1, LTrip ;                         \
 882         br.ctop.sptk.many .md5_FF_round##offset ;       \
 883 } ;;
 884
 885 #define MD5FBLOCK(offset)                                               \
 886         .type md5_digest_block##offset, @function ;                     \
 887                                                                         \
 888         .align 32 ;                                                     \
 889         .proc md5_digest_block##offset ;                                \
 890         .prologue ;                                                     \
 891         .altrp QUICK_RTN ;                                              \
 892         .body ;                                                         \
 893 md5_digest_block##offset:                                               \
 894 {       .mmi ;                                                          \
 895         alloc PFS = ar.pfs, _NINPUTS, _NLOCALS, _NOUTPUT, _NROTATE ;    \
 896         mov LTrip = 2 ;                                                 \
 897         mov ar.lc = 3 ;                                                 \
 898 } ;;                                                                    \
 899 {       .mii ;                                                          \
 900         cmp.eq pMore, p0 = r0, r0 ;                                     \
 901         mov ar.ec = 0 ;                                                 \
 902         nop 0x0 ;                                                       \
 903 } ;;                                                                    \
 904                                                                         \
 905         .pred.rel "mutex", pLoad, pSkip ;                               \
 906 .md5_FF_round##offset:                                                  \
 907         FFLOADU(A, B, C, D, M12, M13, RotateM0, 7, offset)              \
 908         FFLOADU(D, A, B, C, M13, M14, RotateM1, 12, offset)             \
 909         FFLOADU(C, D, A, B, M14, M15, RotateM2, 17, offset)             \
 910         FFLOOPU(B, C, D, A, M15, RotateM0, RotateM3, 22, offset)        \
 911                                                                         \
 912 {       .mib ;                                                          \
 913         nop 0x0 ;                                                       \
 914         nop 0x0 ;                                                       \
 915         br.cond.sptk.many md5_digest_GHI ;                              \
 916 } ;;                                                                    \
 917         .endp md5digestBlock ## offset
 918
 919 MD5FBLOCK(1)
 920 MD5FBLOCK(2)
 921 MD5FBLOCK(3)
 922
 923         .align 64
 924         .type md5_constants, @object
 925 md5_constants:
 926 .md5_tbl_data_order:                    // To ensure little-endian data
 927                                         // order, code as bytes.
 928         data1 0x78, 0xa4, 0x6a, 0xd7    //     0
 929         data1 0x56, 0xb7, 0xc7, 0xe8    //     1
 930         data1 0xdb, 0x70, 0x20, 0x24    //     2
 931         data1 0xee, 0xce, 0xbd, 0xc1    //     3
 932         data1 0xaf, 0x0f, 0x7c, 0xf5    //     4
 933         data1 0x2a, 0xc6, 0x87, 0x47    //     5
 934         data1 0x13, 0x46, 0x30, 0xa8    //     6
 935         data1 0x01, 0x95, 0x46, 0xfd    //     7
 936         data1 0xd8, 0x98, 0x80, 0x69    //     8
 937         data1 0xaf, 0xf7, 0x44, 0x8b    //     9
 938         data1 0xb1, 0x5b, 0xff, 0xff    //    10
 939         data1 0xbe, 0xd7, 0x5c, 0x89    //    11
 940         data1 0x22, 0x11, 0x90, 0x6b    //    12
 941         data1 0x93, 0x71, 0x98, 0xfd    //    13
 942         data1 0x8e, 0x43, 0x79, 0xa6    //    14
 943         data1 0x21, 0x08, 0xb4, 0x49    //    15
 944         data1 0x62, 0x25, 0x1e, 0xf6    //    16
 945         data1 0x40, 0xb3, 0x40, 0xc0    //    17
 946         data1 0x51, 0x5a, 0x5e, 0x26    //    18
 947         data1 0xaa, 0xc7, 0xb6, 0xe9    //    19
 948         data1 0x5d, 0x10, 0x2f, 0xd6    //    20
 949         data1 0x53, 0x14, 0x44, 0x02    //    21
 950         data1 0x81, 0xe6, 0xa1, 0xd8    //    22
 951         data1 0xc8, 0xfb, 0xd3, 0xe7    //    23
 952         data1 0xe6, 0xcd, 0xe1, 0x21    //    24
 953         data1 0xd6, 0x07, 0x37, 0xc3    //    25
 954         data1 0x87, 0x0d, 0xd5, 0xf4    //    26
 955         data1 0xed, 0x14, 0x5a, 0x45    //    27
 956         data1 0x05, 0xe9, 0xe3, 0xa9    //    28
 957         data1 0xf8, 0xa3, 0xef, 0xfc    //    29
 958         data1 0xd9, 0x02, 0x6f, 0x67    //    30
 959         data1 0x8a, 0x4c, 0x2a, 0x8d    //    31
 960         data1 0x42, 0x39, 0xfa, 0xff    //    32
 961         data1 0x81, 0xf6, 0x71, 0x87    //    33
 962         data1 0x22, 0x61, 0x9d, 0x6d    //    34
 963         data1 0x0c, 0x38, 0xe5, 0xfd    //    35
 964         data1 0x44, 0xea, 0xbe, 0xa4    //    36
 965         data1 0xa9, 0xcf, 0xde, 0x4b    //    37
 966         data1 0x60, 0x4b, 0xbb, 0xf6    //    38
 967         data1 0x70, 0xbc, 0xbf, 0xbe    //    39
 968         data1 0xc6, 0x7e, 0x9b, 0x28    //    40
 969         data1 0xfa, 0x27, 0xa1, 0xea    //    41
 970         data1 0x85, 0x30, 0xef, 0xd4    //    42
 971         data1 0x05, 0x1d, 0x88, 0x04    //    43
 972         data1 0x39, 0xd0, 0xd4, 0xd9    //    44
 973         data1 0xe5, 0x99, 0xdb, 0xe6    //    45
 974         data1 0xf8, 0x7c, 0xa2, 0x1f    //    46
 975         data1 0x65, 0x56, 0xac, 0xc4    //    47
 976         data1 0x44, 0x22, 0x29, 0xf4    //    48
 977         data1 0x97, 0xff, 0x2a, 0x43    //    49
 978         data1 0xa7, 0x23, 0x94, 0xab    //    50
 979         data1 0x39, 0xa0, 0x93, 0xfc    //    51
 980         data1 0xc3, 0x59, 0x5b, 0x65    //    52
 981         data1 0x92, 0xcc, 0x0c, 0x8f    //    53
 982         data1 0x7d, 0xf4, 0xef, 0xff    //    54
 983         data1 0xd1, 0x5d, 0x84, 0x85    //    55
 984         data1 0x4f, 0x7e, 0xa8, 0x6f    //    56
 985         data1 0xe0, 0xe6, 0x2c, 0xfe    //    57
 986         data1 0x14, 0x43, 0x01, 0xa3    //    58
 987         data1 0xa1, 0x11, 0x08, 0x4e    //    59
 988         data1 0x82, 0x7e, 0x53, 0xf7    //    60
 989         data1 0x35, 0xf2, 0x3a, 0xbd    //    61
 990         data1 0xbb, 0xd2, 0xd7, 0x2a    //    62
 991         data1 0x91, 0xd3, 0x86, 0xeb    //    63
 992 .size   md5_constants#,64*4