|
|
<%//////////////////////// montgomeryTemplate//////////////////////// This function creates functions with the montgomery transformation// applied// the round hook allows to add diferent code in the iteration//// All the montgomery functions modifies:// r8, r9, 10, r11, rax, rcx//////////////////////function montgomeryTemplate(fnName, round) { let r0, r1, r2; function setR(step) { if ((step % 3) == 0) { r0 = "r8"; r1 = "r9"; r2 = "r10"; } else if ((step % 3) == 1) { r0 = "r9"; r1 = "r10"; r2 = "r8"; } else { r0 = "r10"; r1 = "r8"; r2 = "r9"; } }
const base = bigInt.one.shiftLeft(64); const np64 = base.minus(q.modInv(base));%><%=fnName%>: sub rsp, <%= n64*8 %> ; Reserve space for ms mov rcx, rdx ; rdx is needed for multiplications so keep it in cx mov r11, 0x<%= np64.toString(16) %> ; np xor r8,r8 xor r9,r9 xor r10,r10<% // Main loop for (let i=0; i<n64*2; i++) { setR(i); round(i, r0, r1, r2);%>
<% for (let j=i-1; j>=0; j--) { // All ms if (((i-j)<n64)&&(j<n64)) {%> mov rax, [rsp + <%= j*8 %>] mul qword [q + <%= (i-j)*8 %>] add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } } // ms%>
<% if (i<n64) {%> mov rax, <%= r0 %> mul r11 mov [rsp + <%= i*8 %>], rax mul qword [q] add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } else {%> mov [rdi + <%= (i-n64)*8 %> ], <%= r0 %> xor <%= r0 %>,<%= r0 %><% }%>
<% } // Main Loop%> test <%= r1 %>, <%= r1 %> jnz <%=fnName%>_mulM_sq ; Compare with q<% for (let i=0; i<n64; i++) {%> mov rax, [rdi + <%= (n64-i-1)*8 %>] cmp rax, [q + <%= (n64-i-1)*8 %>] jc <%=fnName%>_mulM_done ; q is bigget so done. jnz <%=fnName%>_mulM_sq ; q is lower<% }%> ; If equal substract q
<%=fnName%>_mulM_sq:<% for (let i=0; i<n64; i++) {%> mov rax, [q + <%= i*8 %>] <%= i==0 ? "sub" : "sbb" %> [rdi + <%= i*8 %>], rax<% }%>
<%=fnName%>_mulM_done: mov rdx, rcx ; recover rdx to its original place. add rsp, <%= n64*8 %> ; recover rsp ret
<%} // Template%>
;;;;;;;;;;;;;;;;;;;;;;; rawMontgomeryMul;;;;;;;;;;;;;;;;;;;;;;; Multiply two elements in montgomery form; Params:; rsi <= Pointer to the long data of element 1; rdx <= Pointer to the long data of element 2; rdi <= Pointer to the long data of result; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;;;<%montgomeryTemplate("rawMontgomeryMul", function(i, r0, r1, r2) { // Same Digit for (let o1=Math.max(0, i-n64+1); (o1<=i)&&(o1<n64); o1++) { const o2= i-o1;%> mov rax, [rsi + <%= 8*o1 %>] mul qword [rcx + <%= 8*o2 %>] add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } // Same digit})%>
;;;;;;;;;;;;;;;;;;;;;;; rawMontgomerySquare;;;;;;;;;;;;;;;;;;;;;;; Square an element; Params:; rsi <= Pointer to the long data of element 1; rdi <= Pointer to the long data of result; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;;;<%montgomeryTemplate("rawMontgomerySquare", function(i, r0, r1, r2) { // Same Digit for (let o1=Math.max(0, i-n64+1); (o1<((i+1)>>1) )&&(o1<n64); o1++) { const o2= i-o1;%> mov rax, [rsi + <%= 8*o1 %>] mul qword [rsi + <%= 8*o2 %>] add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0 add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } // Same digit%>
<% if (i%2 == 0) { %> mov rax, [rsi + <%= 8*(i/2) %>] mul rax add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } %>
<%})%>
;;;;;;;;;;;;;;;;;;;;;;; rawMontgomeryMul1;;;;;;;;;;;;;;;;;;;;;;; Multiply two elements in montgomery form; Params:; rsi <= Pointer to the long data of element 1; rdx <= second operand; rdi <= Pointer to the long data of result; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;;;<%montgomeryTemplate("rawMontgomeryMul1", function(i, r0, r1, r2) { // Same Digit if (i<n64) {%> mov rax, [rsi + <%= 8*i %>] mul rcx add <%= r0 %>, rax adc <%= r1 %>, rdx adc <%= r2 %>, 0x0<% } // Same digit})%>
;;;;;;;;;;;;;;;;;;;;;;; rawFromMontgomery;;;;;;;;;;;;;;;;;;;;;;; Multiply two elements in montgomery form; Params:; rsi <= Pointer to the long data of element 1; rdi <= Pointer to the long data of result; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;;;<%montgomeryTemplate("rawFromMontgomery", function(i, r0, r1, r2) { // Same Digit if (i<n64) {%> add <%= r0 %>, [rdi + <%= 8*i %>] adc <%= r1 %>, 0x0 adc <%= r2 %>, 0x0<% } // Same digit})%>
;;;;;;;;;;;;;;;;;;;;;;; toMontgomery;;;;;;;;;;;;;;;;;;;;;;; Convert a number to Montgomery; rdi <= Pointer element to convert; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;<%=name%>_toMontgomery: mov rax, [rdi] bts rax, 62 ; check if montgomery jc toMontgomery_doNothing bts rax, 63 jc toMontgomeryLong
toMontgomeryShort: mov [rdi], rax add rdi, 8 push rsi lea rsi, [R2] movsx rdx, eax cmp rdx, 0 js negMontgomeryShortposMontgomeryShort: call rawMontgomeryMul1 pop rsi sub rdi, 8 ret
negMontgomeryShort: neg rdx ; Do the multiplication positive and then negate the result. call rawMontgomeryMul1 mov rsi, rdi call rawNegL pop rsi sub rdi, 8 ret
toMontgomeryLong: mov [rdi], rax add rdi, 8 push rsi mov rdx, rdi lea rsi, [R2] call rawMontgomeryMul pop rsi sub rdi, 8
toMontgomery_doNothing: ret
;;;;;;;;;;;;;;;;;;;;;;; toNormal;;;;;;;;;;;;;;;;;;;;;;; Convert a number from Montgomery; rdi <= Pointer element to convert; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;<%=name%>_toNormal: mov rax, [rdi] btc rax, 62 ; check if montgomery jnc toNormal_doNothing bt rax, 63 ; if short, it means it's converted jnc toNormal_doNothing
toNormalLong: mov [rdi], rax add rdi, 8 call rawFromMontgomery sub rdi, 8
toNormal_doNothing: ret
;;;;;;;;;;;;;;;;;;;;;;; toLongNormal;;;;;;;;;;;;;;;;;;;;;;; Convert a number to long normal; rdi <= Pointer element to convert; Modified registers:; r8, r9, 10, r11, rax, rcx;;;;;;;;;;;;;;;;;;;;<%=name%>_toLongNormal: mov rax, [rdi] bt rax, 62 ; check if montgomery jc toLongNormal_fromMontgomery bt rax, 63 ; check if long jnc toLongNormal_fromShort ret ; It is already long
toLongNormal_fromMontgomery: add rdi, 8 call rawFromMontgomery sub rdi, 8 ret
toLongNormal_fromShort: mov r8, rsi ; save rsi movsx rsi, eax call rawCopyS2L mov rsi, r8 ; recover rsi ret
|
