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