integer_8cpp-source.html

Crypto++是一个非常强大的密码学库,主要是功能全

00265 
00266 <span class="keyword">inline</span> <span class="keywordtype">void</span> Portable::Multiply2Bottom(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
00267 {
00268 <span class="preprocessor">#ifdef IS_LITTLE_ENDIAN</span>
00269 <span class="preprocessor"></span>        <span class="keywordflow">if</span> (<span class="keyword">sizeof</span>(dword) == <span class="keyword">sizeof</span>(size_t))
00270         {
00271                 dword a = *(<span class="keyword">const</span> dword *)A, b = *(<span class="keyword">const</span> dword *)B;
00272                 ((dword *)C)[0] = a*b;
00273         }
00274         <span class="keywordflow">else</span>
00275 <span class="preprocessor">#endif</span>
00276 <span class="preprocessor"></span>        {
00277                 dword t = (dword)A[0]*B[0];
00278                 C[0] = LOW_WORD(t);
00279                 C[1] = HIGH_WORD(t) + A[0]*B[1] + A[1]*B[0];
00280         }
00281 }
00282 
00283 word Portable::Multiply2Add(word *C, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
00284 {
00285         word D[4] = {A[1]-A[0], A[0]-A[1], B[0]-B[1], B[1]-B[0]};
00286         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> ai = A[1] &lt; A[0];
00287         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> bi = B[0] &lt; B[1];
00288         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> di = ai &amp; bi;
00289         dword d = (dword)D[di]*D[di+2];
00290         D[1] = D[3] = 0;
00291         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> si = ai + !bi;
00292         word s = D[si];
00293 
00294         dword A0B0 = (dword)A[0]*B[0];
00295         dword t = A0B0 + C[0];
00296         C[0] = LOW_WORD(t);
00297 
00298         dword A1B1 = (dword)A[1]*B[1];
00299         t = (dword) HIGH_WORD(t) + LOW_WORD(A0B0) + LOW_WORD(d) + LOW_WORD(A1B1) + C[1];
00300         C[1] = LOW_WORD(t);
00301 
00302         t = (dword) HIGH_WORD(t) + LOW_WORD(A1B1) + HIGH_WORD(A0B0) + HIGH_WORD(d) + HIGH_WORD(A1B1) - s + C[2];
00303         C[2] = LOW_WORD(t);
00304 
00305         t = (dword) HIGH_WORD(t) + HIGH_WORD(A1B1) + C[3];
00306         C[3] = LOW_WORD(t);
00307         <span class="keywordflow">return</span> HIGH_WORD(t);
00308 }
00309 
00310 <span class="preprocessor">#define MulAcc(x, y)                                                            \</span>
00311 <span class="preprocessor">        p = (dword)A[x] * B[y] + c;                                     \</span>
00312 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00313 <span class="preprocessor">        p = (dword)d + HIGH_WORD(p);                                    \</span>
00314 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00315 <span class="preprocessor">        e += HIGH_WORD(p);</span>
00316 <span class="preprocessor"></span>
00317 <span class="preprocessor">#define SaveMulAcc(s, x, y)                                             \</span>
00318 <span class="preprocessor">        R[s] = c;                                                                               \</span>
00319 <span class="preprocessor">        p = (dword)A[x] * B[y] + d;                                     \</span>
00320 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00321 <span class="preprocessor">        p = (dword)e + HIGH_WORD(p);                                    \</span>
00322 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00323 <span class="preprocessor">        e = HIGH_WORD(p);</span>
00324 <span class="preprocessor"></span>
00325 <span class="preprocessor">#define SquAcc(x, y)                                                            \</span>
00326 <span class="preprocessor">        q = (dword)A[x] * A[y]; \</span>
00327 <span class="preprocessor">        p = q + c;                                      \</span>
00328 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00329 <span class="preprocessor">        p = (dword)d + HIGH_WORD(p);                                    \</span>
00330 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00331 <span class="preprocessor">        e += HIGH_WORD(p);                      \</span>
00332 <span class="preprocessor">        p = q + c;                                      \</span>
00333 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00334 <span class="preprocessor">        p = (dword)d + HIGH_WORD(p);                                    \</span>
00335 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00336 <span class="preprocessor">        e += HIGH_WORD(p);</span>
00337 <span class="preprocessor"></span>
00338 <span class="preprocessor">#define SaveSquAcc(s, x, y)                                             \</span>
00339 <span class="preprocessor">        R[s] = c;                                                                               \</span>
00340 <span class="preprocessor">        q = (dword)A[x] * A[y]; \</span>
00341 <span class="preprocessor">        p = q + d;                                      \</span>
00342 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00343 <span class="preprocessor">        p = (dword)e + HIGH_WORD(p);                                    \</span>
00344 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00345 <span class="preprocessor">        e = HIGH_WORD(p);                       \</span>
00346 <span class="preprocessor">        p = q + c;                                      \</span>
00347 <span class="preprocessor">        c = LOW_WORD(p);                                                                \</span>
00348 <span class="preprocessor">        p = (dword)d + HIGH_WORD(p);                                    \</span>
00349 <span class="preprocessor">        d = LOW_WORD(p);                                                                \</span>
00350 <span class="preprocessor">        e += HIGH_WORD(p);</span>
00351 <span class="preprocessor"></span>
00352 <span class="keywordtype">void</span> Portable::Multiply4(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
00353 {
00354         dword p;
00355         word c, d, e;
00356 
00357         p = (dword)A[0] * B[0];
00358         R[0] = LOW_WORD(p);
00359         c = HIGH_WORD(p);
00360         d = e = 0;
00361 
00362         MulAcc(0, 1);
00363         MulAcc(1, 0);
00364 
00365         SaveMulAcc(1, 2, 0);
00366         MulAcc(1, 1);
00367         MulAcc(0, 2);
00368 
00369         SaveMulAcc(2, 0, 3);
00370         MulAcc(1, 2);
00371         MulAcc(2, 1);
00372         MulAcc(3, 0);
00373 
00374         SaveMulAcc(3, 3, 1);
00375         MulAcc(2, 2);
00376         MulAcc(1, 3);
00377 
00378         SaveMulAcc(4, 2, 3);
00379         MulAcc(3, 2);
00380 
00381         R[5] = c;
00382         p = (dword)A[3] * B[3] + d;
00383         R[6] = LOW_WORD(p);
00384         R[7] = e + HIGH_WORD(p);
00385 }
00386 
00387 <span class="keywordtype">void</span> Portable::Square2(word *R, <span class="keyword">const</span> word *A)
00388 {
00389         dword p, q;
00390         word c, d, e;
00391 
00392         p = (dword)A[0] * A[0];
00393         R[0] = LOW_WORD(p);
00394         c = HIGH_WORD(p);
00395         d = e = 0;
00396 
00397         SquAcc(0, 1);
00398 
00399         R[1] = c;
00400         p = (dword)A[1] * A[1] + d;
00401         R[2] = LOW_WORD(p);
00402         R[3] = e + HIGH_WORD(p);
00403 }
00404 
00405 <span class="keywordtype">void</span> Portable::Square4(word *R, <span class="keyword">const</span> word *A)
00406 {
00407         <span class="keyword">const</span> word *B = A;
00408         dword p, q;
00409         word c, d, e;
00410 
00411         p = (dword)A[0] * A[0];
00412         R[0] = LOW_WORD(p);
00413         c = HIGH_WORD(p);
00414         d = e = 0;
00415 
00416         SquAcc(0, 1);
00417 
00418         SaveSquAcc(1, 2, 0);
00419         MulAcc(1, 1);
00420 
00421         SaveSquAcc(2, 0, 3);
00422         SquAcc(1, 2);
00423 
00424         SaveSquAcc(3, 3, 1);
00425         MulAcc(2, 2);
00426 
00427         SaveSquAcc(4, 2, 3);
00428 
00429         R[5] = c;
00430         p = (dword)A[3] * A[3] + d;
00431         R[6] = LOW_WORD(p);
00432         R[7] = e + HIGH_WORD(p);
00433 }
00434 
00435 <span class="keywordtype">void</span> Portable::Multiply8(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
00436 {
00437         dword p;
00438         word c, d, e;
00439 
00440         p = (dword)A[0] * B[0];
00441         R[0] = LOW_WORD(p);
00442         c = HIGH_WORD(p);
00443         d = e = 0;
00444 
00445         MulAcc(0, 1);
00446         MulAcc(1, 0);
00447 
00448         SaveMulAcc(1, 2, 0);
00449         MulAcc(1, 1);
00450         MulAcc(0, 2);
00451 
00452         SaveMulAcc(2, 0, 3);
00453         MulAcc(1, 2);
00454         MulAcc(2, 1);
00455         MulAcc(3, 0);
00456 
00457         SaveMulAcc(3, 0, 4);
00458         MulAcc(1, 3);
00459         MulAcc(2, 2);
00460         MulAcc(3, 1);
00461         MulAcc(4, 0);
00462 
00463         SaveMulAcc(4, 0, 5);
00464         MulAcc(1, 4);
00465         MulAcc(2, 3);
00466         MulAcc(3, 2);
00467         MulAcc(4, 1);
00468         MulAcc(5, 0);
00469 
00470         SaveMulAcc(5, 0, 6);
00471         MulAcc(1, 5);
00472         MulAcc(2, 4);
00473         MulAcc(3, 3);
00474         MulAcc(4, 2);
00475         MulAcc(5, 1);
00476         MulAcc(6, 0);
00477 
00478         SaveMulAcc(6, 0, 7);
00479         MulAcc(1, 6);
00480         MulAcc(2, 5);
00481         MulAcc(3, 4);
00482         MulAcc(4, 3);
00483         MulAcc(5, 2);
00484         MulAcc(6, 1);
00485         MulAcc(7, 0);
00486 
00487         SaveMulAcc(7, 1, 7);
00488         MulAcc(2, 6);
00489         MulAcc(3, 5);
00490         MulAcc(4, 4);
00491         MulAcc(5, 3);
00492         MulAcc(6, 2);
00493         MulAcc(7, 1);
00494 
00495         SaveMulAcc(8, 2, 7);
00496         MulAcc(3, 6);
00497         MulAcc(4, 5);
00498         MulAcc(5, 4);
00499         MulAcc(6, 3);
00500         MulAcc(7, 2);
00501 
00502         SaveMulAcc(9, 3, 7);
00503         MulAcc(4, 6);
00504         MulAcc(5, 5);
00505         MulAcc(6, 4);
00506         MulAcc(7, 3);
00507 
00508         SaveMulAcc(10, 4, 7);
00509         MulAcc(5, 6);
00510         MulAcc(6, 5);
00511         MulAcc(7, 4);
00512 
00513         SaveMulAcc(11, 5, 7);
00514         MulAcc(6, 6);
00515         MulAcc(7, 5);
00516 
00517         SaveMulAcc(12, 6, 7);
00518         MulAcc(7, 6);
00519 
00520         R[13] = c;
00521         p = (dword)A[7] * B[7] + d;
00522         R[14] = LOW_WORD(p);
00523         R[15] = e + HIGH_WORD(p);
00524 }
00525 
00526 <span class="keywordtype">void</span> Portable::Multiply4Bottom(word *R, <span class="keyword">const</span> word *A, <span class="keyword">const</span> word *B)
00527 {
00528         dword p;
00529         word c, d, e;
00530 
00531         p = (dword)A[0] * B[0];
00532         R[0] = LOW_WORD(p);
00533         c = HIGH_WORD(p);
00534         d = e = 0;
00535