| blob | e7de08d46a2bc6a4025897d4fafb8a91793f4ed5 |
1 /* Copyright (c) 2005 Hewlett-Packard Development Company, L.P.
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:
11 The above copyright notice and this permission notice shall be
12 included in all copies or substantial portions of the Software.
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. */
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
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
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
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
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
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 */
162 #if defined(_HPUX_SOURCE) && !defined(_LP64)
163 #define ADDP addp4
164 #else
165 #define ADDP add
166 #endif
168 #if defined(_HPUX_SOURCE) || defined(B_ENDIAN)
169 #define HOST_IS_BIG_ENDIAN
170 #endif
172 // Macros for getting the left and right portions of little-endian words
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
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
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
240 .text
242 /* md5_block_asm_data_order(MD5_CTX *c, const void *data, size_t num)
244 where:
245 c: a pointer to a structure of this type:
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;
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.
260 */
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 }
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 } ;;
309 // The FF load/compute loop rotates values three times, so that
310 // loading into M12 here produces the M0 value, M13 -> M1, etc.
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 } ;;
334 // Now, we add the new digest values and do some clean-up
335 // before checking if there's another full block to process
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 } ;;
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 } ;;
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 } ;;
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)
436 .endp md5_block_asm_data_order
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
455 /* For F round: */
456 #define LTrip r9
457 #define PFS r8
458 #define pMore p6
460 /* For GHI rounds: */
461 #define T r9
462 #define U r10
463 #define V r11
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 } ;;
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 } ;;
491 // G(B, C, D) = (B & D) | (C & ~D)
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 } ;;
505 // H(B, C, D) = B ^ C ^ D
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 } ;;
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)
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 } ;;
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)
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)
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)
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 } ;;
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 } ;;
620 .type md5_digest_block0, @function
621 .align 32
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 } ;;
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
649 .type md5_digest_GHI, @function
650 .align 32
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 } ;;
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 } ;;
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 } ;;
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 } ;;
709 .md5_GG_round:
710 GG4(.md5_GG_round)
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
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 } ;;
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 } ;;
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 } ;;
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 } ;;
762 .md5_HH_round:
763 HH4(.md5_HH_round)
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
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 } ;;
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 } ;;
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 } ;;
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 } ;;
815 .md5_II_round:
816 II4(.md5_II_round)
818 { .mib
819 nop 0x0
820 nop 0x0
821 br.ret.sptk.many QUICK_RTN
822 } ;;
824 .endp md5_digest_GHI
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 } ;;
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 } ;;
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 md5_digest_block##offset
919 MD5FBLOCK(1)
920 MD5FBLOCK(2)
921 MD5FBLOCK(3)
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