fionera
/
transfer.sh
forkattu lähteestä kiska/transfer.sh
1
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
318 Commitit
9 Branchit
34 MiB
 
 
 
Haara: kiska
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'kiska'
${ noResults }
transfer.sh/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.s

282 rivejä
8.4 KiB
Raaka Pysyvä linkki Blame Historia 

  1. // Copyright 2016 The Go Authors. All rights reserved.

  2. // Use of this source code is governed by a BSD-style

  3. // license that can be found in the LICENSE file.

  4. 

  5. // +build amd64,!gccgo,!appengine

  6. 

  7. #include "textflag.h"

  8. 

  9. DATA ·iv0<>+0x00(SB)/8, $0x6a09e667f3bcc908

  10. DATA ·iv0<>+0x08(SB)/8, $0xbb67ae8584caa73b

  11. GLOBL ·iv0<>(SB), (NOPTR+RODATA), $16

  12. 

  13. DATA ·iv1<>+0x00(SB)/8, $0x3c6ef372fe94f82b

  14. DATA ·iv1<>+0x08(SB)/8, $0xa54ff53a5f1d36f1

  15. GLOBL ·iv1<>(SB), (NOPTR+RODATA), $16

  16. 

  17. DATA ·iv2<>+0x00(SB)/8, $0x510e527fade682d1

  18. DATA ·iv2<>+0x08(SB)/8, $0x9b05688c2b3e6c1f

  19. GLOBL ·iv2<>(SB), (NOPTR+RODATA), $16

  20. 

  21. DATA ·iv3<>+0x00(SB)/8, $0x1f83d9abfb41bd6b

  22. DATA ·iv3<>+0x08(SB)/8, $0x5be0cd19137e2179

  23. GLOBL ·iv3<>(SB), (NOPTR+RODATA), $16

  24. 

  25. DATA ·c40<>+0x00(SB)/8, $0x0201000706050403

  26. DATA ·c40<>+0x08(SB)/8, $0x0a09080f0e0d0c0b

  27. GLOBL ·c40<>(SB), (NOPTR+RODATA), $16

  28. 

  29. DATA ·c48<>+0x00(SB)/8, $0x0100070605040302

  30. DATA ·c48<>+0x08(SB)/8, $0x09080f0e0d0c0b0a

  31. GLOBL ·c48<>(SB), (NOPTR+RODATA), $16

  32. 

  33. #define SHUFFLE(v2, v3, v4, v5, v6, v7, t1, t2) \

  34. 	MOVO       v4, t1; \

  35. 	MOVO       v5, v4; \

  36. 	MOVO       t1, v5; \

  37. 	MOVO       v6, t1; \

  38. 	PUNPCKLQDQ v6, t2; \

  39. 	PUNPCKHQDQ v7, v6; \

  40. 	PUNPCKHQDQ t2, v6; \

  41. 	PUNPCKLQDQ v7, t2; \

  42. 	MOVO       t1, v7; \

  43. 	MOVO       v2, t1; \

  44. 	PUNPCKHQDQ t2, v7; \

  45. 	PUNPCKLQDQ v3, t2; \

  46. 	PUNPCKHQDQ t2, v2; \

  47. 	PUNPCKLQDQ t1, t2; \

  48. 	PUNPCKHQDQ t2, v3

  49. 

  50. #define SHUFFLE_INV(v2, v3, v4, v5, v6, v7, t1, t2) \

  51. 	MOVO       v4, t1; \

  52. 	MOVO       v5, v4; \

  53. 	MOVO       t1, v5; \

  54. 	MOVO       v2, t1; \

  55. 	PUNPCKLQDQ v2, t2; \

  56. 	PUNPCKHQDQ v3, v2; \

  57. 	PUNPCKHQDQ t2, v2; \

  58. 	PUNPCKLQDQ v3, t2; \

  59. 	MOVO       t1, v3; \

  60. 	MOVO       v6, t1; \

  61. 	PUNPCKHQDQ t2, v3; \

  62. 	PUNPCKLQDQ v7, t2; \

  63. 	PUNPCKHQDQ t2, v6; \

  64. 	PUNPCKLQDQ t1, t2; \

  65. 	PUNPCKHQDQ t2, v7

  66. 

  67. #define HALF_ROUND(v0, v1, v2, v3, v4, v5, v6, v7, m0, m1, m2, m3, t0, c40, c48) \

  68. 	PADDQ  m0, v0;        \

  69. 	PADDQ  m1, v1;        \

  70. 	PADDQ  v2, v0;        \

  71. 	PADDQ  v3, v1;        \

  72. 	PXOR   v0, v6;        \

  73. 	PXOR   v1, v7;        \

  74. 	PSHUFD $0xB1, v6, v6; \

  75. 	PSHUFD $0xB1, v7, v7; \

  76. 	PADDQ  v6, v4;        \

  77. 	PADDQ  v7, v5;        \

  78. 	PXOR   v4, v2;        \

  79. 	PXOR   v5, v3;        \

  80. 	PSHUFB c40, v2;       \

  81. 	PSHUFB c40, v3;       \

  82. 	PADDQ  m2, v0;        \

  83. 	PADDQ  m3, v1;        \

  84. 	PADDQ  v2, v0;        \

  85. 	PADDQ  v3, v1;        \

  86. 	PXOR   v0, v6;        \

  87. 	PXOR   v1, v7;        \

  88. 	PSHUFB c48, v6;       \

  89. 	PSHUFB c48, v7;       \

  90. 	PADDQ  v6, v4;        \

  91. 	PADDQ  v7, v5;        \

  92. 	PXOR   v4, v2;        \

  93. 	PXOR   v5, v3;        \

  94. 	MOVOU  v2, t0;        \

  95. 	PADDQ  v2, t0;        \

  96. 	PSRLQ  $63, v2;       \

  97. 	PXOR   t0, v2;        \

  98. 	MOVOU  v3, t0;        \

  99. 	PADDQ  v3, t0;        \

  100. 	PSRLQ  $63, v3;       \

  101. 	PXOR   t0, v3

  102. 

  103. #define LOAD_MSG(m0, m1, m2, m3, src, i0, i1, i2, i3, i4, i5, i6, i7) \

  104. 	MOVQ   i0*8(src), m0;     \

  105. 	PINSRQ $1, i1*8(src), m0; \

  106. 	MOVQ   i2*8(src), m1;     \

  107. 	PINSRQ $1, i3*8(src), m1; \

  108. 	MOVQ   i4*8(src), m2;     \

  109. 	PINSRQ $1, i5*8(src), m2; \

  110. 	MOVQ   i6*8(src), m3;     \

  111. 	PINSRQ $1, i7*8(src), m3

  112. 

  113. // func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)

  114. TEXT ·hashBlocksSSE4(SB), 4, $288-48 // frame size = 272 + 16 byte alignment

  115. 	MOVQ h+0(FP), AX

  116. 	MOVQ c+8(FP), BX

  117. 	MOVQ flag+16(FP), CX

  118. 	MOVQ blocks_base+24(FP), SI

  119. 	MOVQ blocks_len+32(FP), DI

  120. 

  121. 	MOVQ SP, BP

  122. 	MOVQ SP, R9

  123. 	ADDQ $15, R9

  124. 	ANDQ $~15, R9

  125. 	MOVQ R9, SP

  126. 

  127. 	MOVOU ·iv3<>(SB), X0

  128. 	MOVO  X0, 0(SP)

  129. 	XORQ  CX, 0(SP)     // 0(SP) = ·iv3 ^ (CX || 0)

  130. 

  131. 	MOVOU ·c40<>(SB), X13

  132. 	MOVOU ·c48<>(SB), X14

  133. 

  134. 	MOVOU 0(AX), X12

  135. 	MOVOU 16(AX), X15

  136. 

  137. 	MOVQ 0(BX), R8

  138. 	MOVQ 8(BX), R9

  139. 

  140. loop:

  141. 	ADDQ $128, R8

  142. 	CMPQ R8, $128

  143. 	JGE  noinc

  144. 	INCQ R9

  145. 

  146. noinc:

  147. 	MOVQ R8, X8

  148. 	PINSRQ $1, R9, X8

  149. 

  150. 	MOVO X12, X0

  151. 	MOVO X15, X1

  152. 	MOVOU 32(AX), X2

  153. 	MOVOU 48(AX), X3

  154. 	MOVOU ·iv0<>(SB), X4

  155. 	MOVOU ·iv1<>(SB), X5

  156. 	MOVOU ·iv2<>(SB), X6

  157. 

  158. 	PXOR X8, X6

  159. 	MOVO 0(SP), X7

  160. 

  161. 	LOAD_MSG(X8, X9, X10, X11, SI, 0, 2, 4, 6, 1, 3, 5, 7)

  162. 	MOVO X8, 16(SP)

  163. 	MOVO X9, 32(SP)

  164. 	MOVO X10, 48(SP)

  165. 	MOVO X11, 64(SP)

  166. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  167. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  168. 	LOAD_MSG(X8, X9, X10, X11, SI, 8, 10, 12, 14, 9, 11, 13, 15)

  169. 	MOVO X8, 80(SP)

  170. 	MOVO X9, 96(SP)

  171. 	MOVO X10, 112(SP)

  172. 	MOVO X11, 128(SP)

  173. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  174. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  175. 

  176. 	LOAD_MSG(X8, X9, X10, X11, SI, 14, 4, 9, 13, 10, 8, 15, 6)

  177. 	MOVO X8, 144(SP)

  178. 	MOVO X9, 160(SP)

  179. 	MOVO X10, 176(SP)

  180. 	MOVO X11, 192(SP)

  181. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  182. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  183. 	LOAD_MSG(X8, X9, X10, X11, SI, 1, 0, 11, 5, 12, 2, 7, 3)

  184. 	MOVO X8, 208(SP)

  185. 	MOVO X9, 224(SP)

  186. 	MOVO X10, 240(SP)

  187. 	MOVO X11, 256(SP)

  188. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  189. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  190. 

  191. 	LOAD_MSG(X8, X9, X10, X11, SI, 11, 12, 5, 15, 8, 0, 2, 13)

  192. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  193. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  194. 	LOAD_MSG(X8, X9, X10, X11, SI, 10, 3, 7, 9, 14, 6, 1, 4)

  195. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  196. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  197. 

  198. 	LOAD_MSG(X8, X9, X10, X11, SI, 7, 3, 13, 11, 9, 1, 12, 14)

  199. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  200. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  201. 	LOAD_MSG(X8, X9, X10, X11, SI, 2, 5, 4, 15, 6, 10, 0, 8)

  202. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  203. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  204. 

  205. 	LOAD_MSG(X8, X9, X10, X11, SI, 9, 5, 2, 10, 0, 7, 4, 15)

  206. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  207. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  208. 	LOAD_MSG(X8, X9, X10, X11, SI, 14, 11, 6, 3, 1, 12, 8, 13)

  209. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  210. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  211. 

  212. 	LOAD_MSG(X8, X9, X10, X11, SI, 2, 6, 0, 8, 12, 10, 11, 3)

  213. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  214. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  215. 	LOAD_MSG(X8, X9, X10, X11, SI, 4, 7, 15, 1, 13, 5, 14, 9)

  216. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  217. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  218. 

  219. 	LOAD_MSG(X8, X9, X10, X11, SI, 12, 1, 14, 4, 5, 15, 13, 10)

  220. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  221. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  222. 	LOAD_MSG(X8, X9, X10, X11, SI, 0, 6, 9, 8, 7, 3, 2, 11)

  223. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  224. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  225. 

  226. 	LOAD_MSG(X8, X9, X10, X11, SI, 13, 7, 12, 3, 11, 14, 1, 9)

  227. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  228. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  229. 	LOAD_MSG(X8, X9, X10, X11, SI, 5, 15, 8, 2, 0, 4, 6, 10)

  230. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  231. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  232. 

  233. 	LOAD_MSG(X8, X9, X10, X11, SI, 6, 14, 11, 0, 15, 9, 3, 8)

  234. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  235. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  236. 	LOAD_MSG(X8, X9, X10, X11, SI, 12, 13, 1, 10, 2, 7, 4, 5)

  237. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  238. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  239. 

  240. 	LOAD_MSG(X8, X9, X10, X11, SI, 10, 8, 7, 1, 2, 4, 6, 5)

  241. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  242. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  243. 	LOAD_MSG(X8, X9, X10, X11, SI, 15, 9, 3, 13, 11, 14, 12, 0)

  244. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X11, X13, X14)

  245. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  246. 

  247. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 16(SP), 32(SP), 48(SP), 64(SP), X11, X13, X14)

  248. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  249. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 80(SP), 96(SP), 112(SP), 128(SP), X11, X13, X14)

  250. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  251. 

  252. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 144(SP), 160(SP), 176(SP), 192(SP), X11, X13, X14)

  253. 	SHUFFLE(X2, X3, X4, X5, X6, X7, X8, X9)

  254. 	HALF_ROUND(X0, X1, X2, X3, X4, X5, X6, X7, 208(SP), 224(SP), 240(SP), 256(SP), X11, X13, X14)

  255. 	SHUFFLE_INV(X2, X3, X4, X5, X6, X7, X8, X9)

  256. 

  257. 	MOVOU 32(AX), X10

  258. 	MOVOU 48(AX), X11

  259. 	PXOR  X0, X12

  260. 	PXOR  X1, X15

  261. 	PXOR  X2, X10

  262. 	PXOR  X3, X11

  263. 	PXOR  X4, X12

  264. 	PXOR  X5, X15

  265. 	PXOR  X6, X10

  266. 	PXOR  X7, X11

  267. 	MOVOU X10, 32(AX)

  268. 	MOVOU X11, 48(AX)

  269. 

  270. 	LEAQ 128(SI), SI

  271. 	SUBQ $128, DI

  272. 	JNE  loop

  273. 

  274. 	MOVOU X12, 0(AX)

  275. 	MOVOU X15, 16(AX)

  276. 

  277. 	MOVQ R8, 0(BX)

  278. 	MOVQ R9, 8(BX)

  279. 

  280. 	MOVQ BP, SP

  281. 	RET