| kesavand | c71914f | 2022-03-25 11:19:03 +0530 | [diff] [blame] | 1 | // +build !appengine |
| 2 | // +build gc |
| 3 | // +build !purego |
| 4 | // +build !noasm |
| 5 | |
| 6 | #include "textflag.h" |
| 7 | |
| 8 | // Register allocation: |
| 9 | // AX h |
| 10 | // SI pointer to advance through b |
| 11 | // DX n |
| 12 | // BX loop end |
| 13 | // R8 v1, k1 |
| 14 | // R9 v2 |
| 15 | // R10 v3 |
| 16 | // R11 v4 |
| 17 | // R12 tmp |
| 18 | // R13 prime1v |
| 19 | // R14 prime2v |
| 20 | // DI prime4v |
| 21 | |
| 22 | // round reads from and advances the buffer pointer in SI. |
| 23 | // It assumes that R13 has prime1v and R14 has prime2v. |
| 24 | #define round(r) \ |
| 25 | MOVQ (SI), R12 \ |
| 26 | ADDQ $8, SI \ |
| 27 | IMULQ R14, R12 \ |
| 28 | ADDQ R12, r \ |
| 29 | ROLQ $31, r \ |
| 30 | IMULQ R13, r |
| 31 | |
| 32 | // mergeRound applies a merge round on the two registers acc and val. |
| 33 | // It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v. |
| 34 | #define mergeRound(acc, val) \ |
| 35 | IMULQ R14, val \ |
| 36 | ROLQ $31, val \ |
| 37 | IMULQ R13, val \ |
| 38 | XORQ val, acc \ |
| 39 | IMULQ R13, acc \ |
| 40 | ADDQ DI, acc |
| 41 | |
| 42 | // func Sum64(b []byte) uint64 |
| 43 | TEXT ·Sum64(SB), NOSPLIT, $0-32 |
| 44 | // Load fixed primes. |
| 45 | MOVQ ·prime1v(SB), R13 |
| 46 | MOVQ ·prime2v(SB), R14 |
| 47 | MOVQ ·prime4v(SB), DI |
| 48 | |
| 49 | // Load slice. |
| 50 | MOVQ b_base+0(FP), SI |
| 51 | MOVQ b_len+8(FP), DX |
| 52 | LEAQ (SI)(DX*1), BX |
| 53 | |
| 54 | // The first loop limit will be len(b)-32. |
| 55 | SUBQ $32, BX |
| 56 | |
| 57 | // Check whether we have at least one block. |
| 58 | CMPQ DX, $32 |
| 59 | JLT noBlocks |
| 60 | |
| 61 | // Set up initial state (v1, v2, v3, v4). |
| 62 | MOVQ R13, R8 |
| 63 | ADDQ R14, R8 |
| 64 | MOVQ R14, R9 |
| 65 | XORQ R10, R10 |
| 66 | XORQ R11, R11 |
| 67 | SUBQ R13, R11 |
| 68 | |
| 69 | // Loop until SI > BX. |
| 70 | blockLoop: |
| 71 | round(R8) |
| 72 | round(R9) |
| 73 | round(R10) |
| 74 | round(R11) |
| 75 | |
| 76 | CMPQ SI, BX |
| 77 | JLE blockLoop |
| 78 | |
| 79 | MOVQ R8, AX |
| 80 | ROLQ $1, AX |
| 81 | MOVQ R9, R12 |
| 82 | ROLQ $7, R12 |
| 83 | ADDQ R12, AX |
| 84 | MOVQ R10, R12 |
| 85 | ROLQ $12, R12 |
| 86 | ADDQ R12, AX |
| 87 | MOVQ R11, R12 |
| 88 | ROLQ $18, R12 |
| 89 | ADDQ R12, AX |
| 90 | |
| 91 | mergeRound(AX, R8) |
| 92 | mergeRound(AX, R9) |
| 93 | mergeRound(AX, R10) |
| 94 | mergeRound(AX, R11) |
| 95 | |
| 96 | JMP afterBlocks |
| 97 | |
| 98 | noBlocks: |
| 99 | MOVQ ·prime5v(SB), AX |
| 100 | |
| 101 | afterBlocks: |
| 102 | ADDQ DX, AX |
| 103 | |
| 104 | // Right now BX has len(b)-32, and we want to loop until SI > len(b)-8. |
| 105 | ADDQ $24, BX |
| 106 | |
| 107 | CMPQ SI, BX |
| 108 | JG fourByte |
| 109 | |
| 110 | wordLoop: |
| 111 | // Calculate k1. |
| 112 | MOVQ (SI), R8 |
| 113 | ADDQ $8, SI |
| 114 | IMULQ R14, R8 |
| 115 | ROLQ $31, R8 |
| 116 | IMULQ R13, R8 |
| 117 | |
| 118 | XORQ R8, AX |
| 119 | ROLQ $27, AX |
| 120 | IMULQ R13, AX |
| 121 | ADDQ DI, AX |
| 122 | |
| 123 | CMPQ SI, BX |
| 124 | JLE wordLoop |
| 125 | |
| 126 | fourByte: |
| 127 | ADDQ $4, BX |
| 128 | CMPQ SI, BX |
| 129 | JG singles |
| 130 | |
| 131 | MOVL (SI), R8 |
| 132 | ADDQ $4, SI |
| 133 | IMULQ R13, R8 |
| 134 | XORQ R8, AX |
| 135 | |
| 136 | ROLQ $23, AX |
| 137 | IMULQ R14, AX |
| 138 | ADDQ ·prime3v(SB), AX |
| 139 | |
| 140 | singles: |
| 141 | ADDQ $4, BX |
| 142 | CMPQ SI, BX |
| 143 | JGE finalize |
| 144 | |
| 145 | singlesLoop: |
| 146 | MOVBQZX (SI), R12 |
| 147 | ADDQ $1, SI |
| 148 | IMULQ ·prime5v(SB), R12 |
| 149 | XORQ R12, AX |
| 150 | |
| 151 | ROLQ $11, AX |
| 152 | IMULQ R13, AX |
| 153 | |
| 154 | CMPQ SI, BX |
| 155 | JL singlesLoop |
| 156 | |
| 157 | finalize: |
| 158 | MOVQ AX, R12 |
| 159 | SHRQ $33, R12 |
| 160 | XORQ R12, AX |
| 161 | IMULQ R14, AX |
| 162 | MOVQ AX, R12 |
| 163 | SHRQ $29, R12 |
| 164 | XORQ R12, AX |
| 165 | IMULQ ·prime3v(SB), AX |
| 166 | MOVQ AX, R12 |
| 167 | SHRQ $32, R12 |
| 168 | XORQ R12, AX |
| 169 | |
| 170 | MOVQ AX, ret+24(FP) |
| 171 | RET |
| 172 | |
| 173 | // writeBlocks uses the same registers as above except that it uses AX to store |
| 174 | // the d pointer. |
| 175 | |
| 176 | // func writeBlocks(d *Digest, b []byte) int |
| 177 | TEXT ·writeBlocks(SB), NOSPLIT, $0-40 |
| 178 | // Load fixed primes needed for round. |
| 179 | MOVQ ·prime1v(SB), R13 |
| 180 | MOVQ ·prime2v(SB), R14 |
| 181 | |
| 182 | // Load slice. |
| 183 | MOVQ b_base+8(FP), SI |
| 184 | MOVQ b_len+16(FP), DX |
| 185 | LEAQ (SI)(DX*1), BX |
| 186 | SUBQ $32, BX |
| 187 | |
| 188 | // Load vN from d. |
| 189 | MOVQ d+0(FP), AX |
| 190 | MOVQ 0(AX), R8 // v1 |
| 191 | MOVQ 8(AX), R9 // v2 |
| 192 | MOVQ 16(AX), R10 // v3 |
| 193 | MOVQ 24(AX), R11 // v4 |
| 194 | |
| 195 | // We don't need to check the loop condition here; this function is |
| 196 | // always called with at least one block of data to process. |
| 197 | blockLoop: |
| 198 | round(R8) |
| 199 | round(R9) |
| 200 | round(R10) |
| 201 | round(R11) |
| 202 | |
| 203 | CMPQ SI, BX |
| 204 | JLE blockLoop |
| 205 | |
| 206 | // Copy vN back to d. |
| 207 | MOVQ R8, 0(AX) |
| 208 | MOVQ R9, 8(AX) |
| 209 | MOVQ R10, 16(AX) |
| 210 | MOVQ R11, 24(AX) |
| 211 | |
| 212 | // The number of bytes written is SI minus the old base pointer. |
| 213 | SUBQ b_base+8(FP), SI |
| 214 | MOVQ SI, ret+32(FP) |
| 215 | |
| 216 | RET |