Lines Matching refs:mov
248 &mov ($v0,$s[3]); # copy s3
249 &mov (&DWP(4,"esp"),$s[2]); # save s2
250 &mov ($v1,$s[0]); # copy s0
251 &mov (&DWP(8,"esp"),$s[1]); # save s1
255 &mov ($s[0],&DWP(0,$te,$s[0],8)); # s0>>0
257 &mov ($s[3],&DWP(3,$te,$s[2],8)); # s0>>8
260 &mov ($s[2],&DWP(2,$te,$v1,8)); # s0>>16
261 &mov ($v1,$v0);
262 &mov ($s[1],&DWP(1,$te,$s[1],8)); # s0>>24
272 &mov ($v1,&DWP(4,"esp")); # restore s2
275 &mov ($v0,$v1);
284 &mov ($v0,&DWP(8,"esp")); # restore s1
287 &mov ($v1,$v0);
296 &mov ($key,$__key); # reincarnate v1 as key
307 &mov ($v1,&DWP(0,$te,$v0,8)); # 0
316 &mov ($__s0,$v1); # t[0] saved
320 &mov ($v1,&DWP(0,$te,$v0,8)); # 4
329 &mov ($s1,$v1); # s[1]=t[1]
333 &mov ($v1,&DWP(2,$te,$v0,8)); # 2
338 &mov ($v0,$s3);
344 &mov ($s2,&DWP(1,$te,$v0,8)); # 11
346 &mov ($s0,$__s0); # s[0]=t[0]
350 &mov ($key,$__key); # reincarnate v0 as key
352 &mov ($s3,&DWP(0,$te,$s3,8)); # 12
354 &mov ($s2,$v1); # s[2]=t[2]
362 &mov ("ecx",&DWP(0,$tbl,$acc,8)); # 0
365 &mov ("edx",&DWP(3,$tbl,"edx",8)); # 1
383 &mov ("ecx",&DWP(0,$tbl,$acc,8)); # 4
396 &mov ("ecx",&DWP(2,$tbl,$acc,8)); # 2
417 &mov ("ebx",&DWP(28,$key)); # t[3]
431 { my $Fn = \&mov;
441 else { &mov ($out,$s[0]); }
453 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$__s0); }##%ebx
454 else { &mov ($tmp,$s[2]);
462 if ($i==3) { $tmp=$s[3]; &mov ($s[2],$__s1); }##%ecx
464 else { &mov ($tmp,$s[3]);
469 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
470 if ($i==3) { &mov ($s[3],$acc); }
482 &mov ($acc,$tmp);
486 &mov ($tmp,$s[$i]);
490 &mov ($r2,$s[$i]);
497 &mov ($tmp,0x80808080) if ($i!=1);
503 &mov ($__key,$key); # save key
510 &mov ($acc,&DWP(240,$key)); # load key->rounds
513 &mov ($__end,$acc); # end of key schedule
516 &mov ($key,&DWP(0-128,$tbl));
517 &mov ($acc,&DWP(32-128,$tbl));
518 &mov ($key,&DWP(64-128,$tbl));
519 &mov ($acc,&DWP(96-128,$tbl));
520 &mov ($key,&DWP(128-128,$tbl));
521 &mov ($acc,&DWP(160-128,$tbl));
522 &mov ($key,&DWP(192-128,$tbl));
523 &mov ($acc,&DWP(224-128,$tbl));
531 &mov ($tbl,0x80808080);
536 &mov ($key,$__key);
537 &mov ($tbl,$__tbl);
545 &mov ($__key,$key);
613 &mov ($__key,$key);
689 &mov ($key,$__key);
702 &mov ($acc,&DWP(240,$key)); # load key->rounds
705 &mov ($__end,$acc); # end of key schedule
707 &mov ($s0,0x1b1b1b1b); # magic constant
708 &mov (&DWP(8,"esp"),$s0);
709 &mov (&DWP(12,"esp"),$s0);
712 &mov ($s0,&DWP(0-128,$tbl));
713 &mov ($s1,&DWP(32-128,$tbl));
714 &mov ($s2,&DWP(64-128,$tbl));
715 &mov ($s3,&DWP(96-128,$tbl));
716 &mov ($s0,&DWP(128-128,$tbl));
717 &mov ($s1,&DWP(160-128,$tbl));
718 &mov ($s2,&DWP(192-128,$tbl));
719 &mov ($s3,&DWP(224-128,$tbl));
748 &mov ($s0,&DWP(0-128,$tbl));
750 &mov ($s1,&DWP(64-128,$tbl));
752 &mov ($s2,&DWP(128-128,$tbl));
754 &mov ($s3,&DWP(192-128,$tbl));
777 if ($i==3) { &mov ($key,$__key); }##%edx
778 else { &mov ($out,$s[0]);
782 &mov ($out,&DWP(0,$te,$out,8));
788 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$__s0); }##%ebx
789 else { &mov ($tmp,$s[2]);
795 if ($i==3) { $tmp=$s[3]; &mov ($s[2],$__s1); }##%ecx
797 else { &mov ($tmp,$s[3]);
800 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
801 if ($i==3) { &mov ($s[3],$acc); }
810 if ($i==3) { &mov ($key,$__key); }##%edx
811 else { &mov ($out,$s[0]); }
815 &mov ($out,&DWP(2,$te,$out,8));
820 &mov ($tmp,&DWP(0,$te,$tmp,8));
824 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$__s0); }##%ebx
825 else { &mov ($tmp,$s[2]);
829 &mov ($tmp,&DWP(0,$te,$tmp,8));
833 if ($i==3) { $tmp=$s[3]; &mov ($s[2],$__s1); }##%ecx
835 else { &mov ($tmp,$s[3]);
837 &mov ($tmp,&DWP(2,$te,$tmp,8));
840 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
841 if ($i==3) { &mov ($s[3],$acc); }
848 &mov ($s2="esi",$acc="ecx");
852 &mov ($__key,$key); # save key
859 &mov ($acc,&DWP(240,$key)); # load key->rounds
864 &mov ($__end,$acc); # end of key schedule
881 &mov ($__key,$key);
906 &mov ($__key,$key); # advance rd_key
923 &mov ($__key,$key); # advance rd_key
943 &mov ($s1="ebx",$key="edi");
944 &mov ($s2="ecx",$acc="esi");
1166 &mov ($acc,&wparam(0)); # load inp
1167 &mov ($key,&wparam(2)); # load key
1169 &mov ($s0,"esp");
1180 &mov ($_esp,$s0); # save stack pointer
1201 &mov ("esp",$_esp); # restore stack pointer
1202 &mov ($acc,&wparam(1)); # load out
1209 &mov ($_tbl,$tbl);
1210 &mov ($s0,&DWP(0,$acc)); # load input data
1211 &mov ($s1,&DWP(4,$acc));
1212 &mov ($s2,&DWP(8,$acc));
1213 &mov ($s3,&DWP(12,$acc));
1215 &mov ("esp",$_esp); # restore stack pointer
1216 &mov ($acc,&wparam(1)); # load out
1217 &mov (&DWP(0,$acc),$s0); # write output data
1218 &mov (&DWP(4,$acc),$s1);
1219 &mov (&DWP(8,$acc),$s2);
1220 &mov (&DWP(12,$acc),$s3);
1230 { my $Fn = \&mov;
1241 else { &mov ($out,$s[0]); }
1251 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$acc); }
1252 else { mov ($tmp,$s[2]); }
1260 else { &mov ($tmp,$s[3]); }
1265 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
1278 &mov ($tmp,0x80808080);
1280 &mov ($acc,$tmp);
1287 &mov ($tmp,0x80808080);
1290 &mov ($acc,$tmp);
1298 &mov ($tmp,0x80808080);
1301 &mov ($acc,$tmp);
1321 &mov ($s[0],$__s0) if($i==2); #prefetch $s0
1322 &mov ($s[1],$__s1) if($i==3); #prefetch $s1
1323 &mov ($s[2],$__s2) if($i==1);
1326 &mov ($s[3],$__s3) if($i==1);
1327 &mov (&DWP(4+4*$i,"esp"),$s[$i]) if($i>=2);
1332 &mov ($__key,$key); # save key
1339 &mov ($acc,&DWP(240,$key)); # load key->rounds
1343 &mov ($__end,$acc); # end of key schedule
1346 &mov ($key,&DWP(0-128,$tbl));
1347 &mov ($acc,&DWP(32-128,$tbl));
1348 &mov ($key,&DWP(64-128,$tbl));
1349 &mov ($acc,&DWP(96-128,$tbl));
1350 &mov ($key,&DWP(128-128,$tbl));
1351 &mov ($acc,&DWP(160-128,$tbl));
1352 &mov ($key,&DWP(192-128,$tbl));
1353 &mov ($acc,&DWP(224-128,$tbl));
1365 &mov ($key,$__key);
1366 &mov ($tbl,$__tbl);
1374 &mov ($__key,$key);
1400 &mov ($__key,$key);
1476 &mov ($key,$__key);
1489 &mov ($acc,&DWP(240,$key)); # load key->rounds
1492 &mov ($__end,$acc); # end of key schedule
1494 &mov ($s0,0x1b1b1b1b); # magic constant
1495 &mov (&DWP(8,"esp"),$s0);
1496 &mov (&DWP(12,"esp"),$s0);
1499 &mov ($s0,&DWP(0-128,$tbl));
1500 &mov ($s1,&DWP(32-128,$tbl));
1501 &mov ($s2,&DWP(64-128,$tbl));
1502 &mov ($s3,&DWP(96-128,$tbl));
1503 &mov ($s0,&DWP(128-128,$tbl));
1504 &mov ($s1,&DWP(160-128,$tbl));
1505 &mov ($s2,&DWP(192-128,$tbl));
1506 &mov ($s3,&DWP(224-128,$tbl));
1566 &mov ($s0,&DWP(0-128,$tbl));
1568 &mov ($s1,&DWP(64-128,$tbl));
1570 &mov ($s2,&DWP(128-128,$tbl));
1572 &mov ($s3,&DWP(192-128,$tbl));
1599 if($i==3) { &mov ($key,$__key); }
1600 else { &mov ($out,$s[0]); }
1602 &mov ($out,&DWP(0,$td,$out,8));
1608 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$acc); }
1609 else { &mov ($tmp,$s[2]); }
1614 if ($i==3) { $tmp=$s[3]; &mov ($s[2],$__s1); }
1615 else { &mov ($tmp,$s[3]); }
1618 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
1619 if ($i==3) { &mov ($s[3],$__s0); }
1629 &mov ($tmp,&DWP(0-128,$td));
1630 &mov ($acc,&DWP(32-128,$td));
1631 &mov ($tmp,&DWP(64-128,$td));
1632 &mov ($acc,&DWP(96-128,$td));
1633 &mov ($tmp,&DWP(128-128,$td));
1634 &mov ($acc,&DWP(160-128,$td));
1635 &mov ($tmp,&DWP(192-128,$td));
1636 &mov ($acc,&DWP(224-128,$td));
1638 if($i==3) { &mov ($key,$__key); }
1639 else { &mov ($out,$s[0]); }
1649 if ($i==3) { $tmp=$s[2]; &mov ($s[1],$acc); }
1650 else { mov ($tmp,$s[2]); }
1657 if ($i==3) { $tmp=$s[3]; &mov ($s[2],$__s1); }
1658 else { &mov ($tmp,$s[3]); }
1663 if ($i<2) { &mov (&DWP(4+4*$i,"esp"),$out); }
1664 if ($i==3) { &mov ($s[3],$__s0);
1670 &mov ($__key,$key); # save key
1677 &mov ($acc,&DWP(240,$key)); # load key->rounds
1682 &mov ($__end,$acc); # end of key schedule
1694 &mov ($__key,$key);
1715 &mov ($__key,$key); # advance rd_key
1728 &mov ($__key,$key); # advance rd_key
1957 &mov ($acc,&wparam(0)); # load inp
1958 &mov ($key,&wparam(2)); # load key
1960 &mov ($s0,"esp");
1971 &mov ($_esp,$s0); # save stack pointer
1992 &mov ("esp",$_esp); # restore stack pointer
1993 &mov ($acc,&wparam(1)); # load out
2000 &mov ($_tbl,$tbl);
2001 &mov ($s0,&DWP(0,$acc)); # load input data
2002 &mov ($s1,&DWP(4,$acc));
2003 &mov ($s2,&DWP(8,$acc));
2004 &mov ($s3,&DWP(12,$acc));
2006 &mov ("esp",$_esp); # restore stack pointer
2007 &mov ($acc,&wparam(1)); # load out
2008 &mov (&DWP(0,$acc),$s0); # write output data
2009 &mov (&DWP(4,$acc),$s1);
2010 &mov (&DWP(8,$acc),$s2);
2011 &mov (&DWP(12,$acc),$s3);
2040 &mov ($s2 eq "ecx"? $s2 : "",&wparam(2)); # load len
2072 &mov ($s0,$tbl);
2074 &mov ($s3,$acc);
2094 &mov ($_tbl,$tbl); # save %ebp
2095 &mov ($_esp,$acc); # save %esp
2097 &mov ($s0,&DWP(0,$s3)); # load inp
2098 &mov ($s1,&DWP(4,$s3)); # load out
2099 #&mov ($s2,&DWP(8,$s3)); # load len
2100 &mov ($key,&DWP(12,$s3)); # load key
2101 &mov ($acc,&DWP(16,$s3)); # load ivp
2102 &mov ($s3,&DWP(20,$s3)); # load enc flag
2104 &mov ($_inp,$s0); # save copy of inp
2105 &mov ($_out,$s1); # save copy of out
2106 &mov ($_len,$s2); # save copy of len
2107 &mov ($_key,$key); # save copy of key
2108 &mov ($_ivp,$acc); # save copy of ivp
2110 &mov ($mark,0); # copy of aes_key->rounds = 0;
2112 &mov ($s1 eq "ebx" ? $s1 : "",$key);
2113 &mov ($s2 eq "ecx" ? $s2 : "",244/4);
2115 &mov ("esi",$key);
2123 &mov ($_key,"edi");
2127 &mov ($key,16);
2129 &mov ($s0,&DWP(0,$tbl));
2130 &mov ($s1,&DWP(32,$tbl));
2131 &mov ($s2,&DWP(64,$tbl));
2132 &mov ($acc,&DWP(96,$tbl));
2138 &mov ($acc,$_inp);
2139 &mov ($key,$_ivp);
2145 &mov ($s0,&DWP(0,$key)); # load iv
2146 &mov ($s1,&DWP(4,$key));
2149 &mov ($s2,&DWP(8,$key));
2150 &mov ($s3,&DWP(12,$key));
2157 &mov ($key,$_key); # load key
2160 &mov ($acc,$_inp); # load inp
2161 &mov ($key,$_out); # load out
2163 &mov (&DWP(0,$key),$s0); # save output data
2164 &mov (&DWP(4,$key),$s1);
2165 &mov (&DWP(8,$key),$s2);
2166 &mov (&DWP(12,$key),$s3);
2169 &mov ($s2,$_len); # load len
2170 &mov ($_inp,$acc); # save inp
2172 &mov ($_out,$s3); # save out
2174 &mov ($_len,$s2); # save len
2176 &mov ($acc,$_ivp); # load ivp
2177 &mov ($s2,&DWP(8,$key)); # restore last 2 dwords
2178 &mov ($s3,&DWP(12,$key));
2179 &mov (&DWP(0,$acc),$s0); # save ivec
2180 &mov (&DWP(4,$acc),$s1);
2181 &mov (&DWP(8,$acc),$s2);
2182 &mov (&DWP(12,$acc),$s3);
2185 &mov ("edi",$_key);
2188 &mov ("ecx",240/4);
2193 &mov ("esp",$_esp);
2205 &mov ($_tmp,$key);
2209 &mov ($s0,&DWP(0,$acc)); # read input
2210 &mov ($s1,&DWP(4,$acc));
2211 &mov ($s2,&DWP(8,$acc));
2212 &mov ($s3,&DWP(12,$acc));
2214 &mov ($key,$_key); # load key
2217 &mov ($key,$_tmp); # load ivp
2218 &mov ($acc,$_len); # load len
2224 &mov ($key,$_out); # load out
2225 &mov ($acc,$_inp); # load inp
2227 &mov (&DWP(0,$key),$s0); # write output
2228 &mov (&DWP(4,$key),$s1);
2229 &mov (&DWP(8,$key),$s2);
2230 &mov (&DWP(12,$key),$s3);
2232 &mov ($s2,$_len); # load len
2233 &mov ($_tmp,$acc); # save ivp
2235 &mov ($_inp,$acc); # save inp
2237 &mov ($_out,$key); # save out
2239 &mov ($_len,$s2); # save len
2241 &mov ($key,$_tmp); # load temp ivp
2242 &mov ($acc,$_ivp); # load user ivp
2243 &mov ($s0,&DWP(0,$key)); # load iv
2244 &mov ($s1,&DWP(4,$key));
2245 &mov ($s2,&DWP(8,$key));
2246 &mov ($s3,&DWP(12,$key));
2247 &mov (&DWP(0,$acc),$s0); # copy back to user
2248 &mov (&DWP(4,$acc),$s1);
2249 &mov (&DWP(8,$acc),$s2);
2250 &mov (&DWP(12,$acc),$s3);
2255 &mov ($s0,&DWP(0,$acc)); # read input
2256 &mov ($s1,&DWP(4,$acc));
2257 &mov ($s2,&DWP(8,$acc));
2258 &mov ($s3,&DWP(12,$acc));
2261 &mov (&DWP(0,$key),$s0); # copy to temp
2262 &mov (&DWP(4,$key),$s1);
2263 &mov (&DWP(8,$key),$s2);
2264 &mov (&DWP(12,$key),$s3);
2266 &mov ($key,$_key); # load key
2269 &mov ($key,$_ivp); # load ivp
2270 &mov ($acc,$_out); # load out
2276 &mov (&DWP(0,$acc),$s0); # write output
2277 &mov (&DWP(4,$acc),$s1);
2278 &mov (&DWP(8,$acc),$s2);
2279 &mov (&DWP(12,$acc),$s3);
2282 &mov ($_out,$acc); # save out
2285 &mov ($s0,&DWP(0,$acc)); # read temp
2286 &mov ($s1,&DWP(4,$acc));
2287 &mov ($s2,&DWP(8,$acc));
2288 &mov ($s3,&DWP(12,$acc));
2290 &mov (&DWP(0,$key),$s0); # copy iv
2291 &mov (&DWP(4,$key),$s1);
2292 &mov (&DWP(8,$key),$s2);
2293 &mov (&DWP(12,$key),$s3);
2295 &mov ($acc,$_inp); # load inp
2296 &mov ($s2,$_len); # load len
2298 &mov ($_inp,$acc); # save inp
2300 &mov ($_len,$s2); # save len
2305 &mov ("edi",$_key);
2308 &mov ("ecx",240/4);
2313 &mov ("esp",$_esp);
2321 &mov ($s0,&DWP(0,$s0)) if (!$x86only);# load OPENSSL_ia32cap
2322 &mov ($key,&wparam(3)); # load key
2345 &mov ($_tbl,$tbl); # save %ebp
2346 &mov ($_esp,$acc); # save %esp
2347 &mov ($_tmp,$s0); # save OPENSSL_ia32cap
2349 &mov ($s0,&DWP(0,$s3)); # load inp
2350 &mov ($s1,&DWP(4,$s3)); # load out
2351 #&mov ($s2,&DWP(8,$s3)); # load len
2352 #&mov ($key,&DWP(12,$s3)); # load key
2353 &mov ($acc,&DWP(16,$s3)); # load ivp
2354 &mov ($s3,&DWP(20,$s3)); # load enc flag
2356 &mov ($_inp,$s0); # save copy of inp
2357 &mov ($_out,$s1); # save copy of out
2358 &mov ($_len,$s2); # save copy of len
2359 &mov ($_key,$key); # save copy of key
2360 &mov ($_ivp,$acc); # save copy of ivp
2362 &mov ($key,$acc);
2363 &mov ($acc,$s0);
2370 &mov ($s3,$s1);
2384 &mov ($key,$_key);
2387 &mov ($acc,$_inp); # load inp
2388 &mov ($key,$_out); # load out
2389 &mov ($s2,$_len); # load len
2395 &mov ($_inp,$acc); # save inp
2397 &mov ($_out,$s3); # save out
2400 &mov ($_len,$s2); # save len
2404 &mov ($acc,$_ivp); # load ivp
2408 &mov ("esp",$_esp);
2414 &mov ($s0,&DWP(0,$key)); # load iv
2415 &mov ($s1,&DWP(4,$key));
2418 &mov ($s2,&DWP(8,$key));
2419 &mov ($s3,&DWP(12,$key));
2426 &mov ($key,$_key); # load key
2429 &mov ($acc,$_inp); # load inp
2430 &mov ($key,$_out); # load out
2432 &mov (&DWP(0,$key),$s0); # save output data
2433 &mov (&DWP(4,$key),$s1);
2434 &mov (&DWP(8,$key),$s2);
2435 &mov (&DWP(12,$key),$s3);
2437 &mov ($s2,$_len); # load len
2439 &mov ($_inp,$acc); # save inp
2441 &mov ($_out,$s3); # save out
2444 &mov ($_len,$s2); # save len
2448 &mov ($acc,$_ivp); # load ivp
2449 &mov ($s2,&DWP(8,$key)); # restore last dwords
2450 &mov ($s3,&DWP(12,$key));
2451 &mov (&DWP(0,$acc),$s0); # save ivec
2452 &mov (&DWP(4,$acc),$s1);
2453 &mov (&DWP(8,$acc),$s2);
2454 &mov (&DWP(12,$acc),$s3);
2456 &mov ("esp",$_esp);
2463 &mov ($key eq "edi"? $key:"",$s3); # load out to edi
2464 &mov ($s1,16);
2474 &mov ($s2,$s1);
2479 &mov ($key,$_ivp); # restore ivp
2480 &mov ($acc,$s3); # output as input
2481 &mov ($s0,&DWP(0,$key));
2482 &mov ($s1,&DWP(4,$key));
2483 &mov ($_len,16); # len=16
2496 &mov ($key,$_key);
2499 &mov ($acc,$_inp); # load inp
2501 &mov ($s1,$_out); # load out
2502 &mov ($s2,$_len); # load len
2503 &mov ($key,$_ivp); # load ivp
2521 &mov ($_out,$s1); # save out
2523 &mov ($_inp,$acc); # save inp
2524 &mov ($_len,$s2); # save len
2527 &mov ("esp",$_esp);
2538 &mov ("edi",$s1); # out
2539 &mov ("esi",$s0); # temp
2543 &mov ("esp",$_esp);
2549 &mov ($s0,&DWP(0,$acc)); # read input
2550 &mov ($s1,&DWP(4,$acc));
2551 &mov ($s2,&DWP(8,$acc));
2552 &mov ($s3,&DWP(12,$acc));
2555 &mov (&DWP(0,$key),$s0); # copy to temp
2556 &mov (&DWP(4,$key),$s1);
2557 &mov (&DWP(8,$key),$s2);
2558 &mov (&DWP(12,$key),$s3);
2560 &mov ($key,$_key); # load key
2563 &mov ($key,$_ivp); # load ivp
2564 &mov ($acc,$_len); # load len
2573 &mov ($_len,$acc); # save len
2574 &mov ($acc,$_out); # load out
2576 &mov (&DWP(0,$acc),$s0); # write output
2577 &mov (&DWP(4,$acc),$s1);
2578 &mov (&DWP(8,$acc),$s2);
2579 &mov (&DWP(12,$acc),$s3);
2582 &mov ($_out,$acc); # save out
2585 &mov ($s0,&DWP(0,$acc)); # read temp
2586 &mov ($s1,&DWP(4,$acc));
2587 &mov ($s2,&DWP(8,$acc));
2588 &mov ($s3,&DWP(12,$acc));
2590 &mov (&DWP(0,$key),$s0); # copy it to iv
2591 &mov (&DWP(4,$key),$s1);
2592 &mov (&DWP(8,$key),$s2);
2593 &mov (&DWP(12,$key),$s3);
2595 &mov ($acc,$_inp); # load inp
2597 &mov ($_inp,$acc); # save inp
2599 &mov ("esp",$_esp);
2606 &mov (&DWP(0,$acc),$s0); # save output to temp
2607 &mov (&DWP(4,$acc),$s1);
2608 &mov (&DWP(8,$acc),$s2);
2609 &mov (&DWP(12,$acc),$s3);
2611 &mov ($acc,$_inp);
2612 &mov ($s0,&DWP(0,$acc)); # re-read input
2613 &mov ($s1,&DWP(4,$acc));
2614 &mov ($s2,&DWP(8,$acc));
2615 &mov ($s3,&DWP(12,$acc));
2617 &mov (&DWP(0,$key),$s0); # copy it to iv
2618 &mov (&DWP(4,$key),$s1);
2619 &mov (&DWP(8,$key),$s2);
2620 &mov (&DWP(12,$key),$s3);
2622 &mov ("ecx",$_len);
2623 &mov ("edi",$_out);
2628 &mov ("esp",$_esp);
2661 &mov ("esi",&wparam(1)); # user supplied key
2662 &mov ("edi",&wparam(3)); # private key schedule
2676 &mov ("eax",&DWP(0-128,$tbl));
2677 &mov ("ebx",&DWP(32-128,$tbl));
2678 &mov ("ecx",&DWP(64-128,$tbl));
2679 &mov ("edx",&DWP(96-128,$tbl));
2680 &mov ("eax",&DWP(128-128,$tbl));
2681 &mov ("ebx",&DWP(160-128,$tbl));
2682 &mov ("ecx",&DWP(192-128,$tbl));
2683 &mov ("edx",&DWP(224-128,$tbl));
2685 &mov ("ecx",&wparam(2)); # number of bits in key
2692 &mov ("eax",-2); # invalid number of bits
2696 &mov ("eax",&DWP(0,"esi")); # copy first 4 dwords
2697 &mov ("ebx",&DWP(4,"esi"));
2698 &mov ("ecx",&DWP(8,"esi"));
2699 &mov ("edx",&DWP(12,"esi"));
2700 &mov (&DWP(0,"edi"),"eax");
2701 &mov (&DWP(4,"edi"),"ebx");
2702 &mov (&DWP(8,"edi"),"ecx");
2703 &mov (&DWP(12,"edi"),"edx");
2710 &mov ("eax",&DWP(0,"edi")); # rk[0]
2711 &mov ("edx",&DWP(12,"edi")); # rk[3]
2715 &mov (&DWP(16,"edi"),"eax"); # rk[4]
2717 &mov (&DWP(20,"edi"),"eax"); # rk[5]
2719 &mov (&DWP(24,"edi"),"eax"); # rk[6]
2721 &mov (&DWP(28,"edi"),"eax"); # rk[7]
2727 &mov (&DWP(80,"edi"),10); # setup number of rounds
2732 &mov ("eax",&DWP(0,"esi")); # copy first 6 dwords
2733 &mov ("ebx",&DWP(4,"esi"));
2734 &mov ("ecx",&DWP(8,"esi"));
2735 &mov ("edx",&DWP(12,"esi"));
2736 &mov (&DWP(0,"edi"),"eax");
2737 &mov (&DWP(4,"edi"),"ebx");
2738 &mov (&DWP(8,"edi"),"ecx");
2739 &mov (&DWP(12,"edi"),"edx");
2740 &mov ("ecx",&DWP(16,"esi"));
2741 &mov ("edx",&DWP(20,"esi"));
2742 &mov (&DWP(16,"edi"),"ecx");
2743 &mov (&DWP(20,"edi"),"edx");
2750 &mov ("eax",&DWP(0,"edi")); # rk[0]
2751 &mov ("edx",&DWP(20,"edi")); # rk[5]
2755 &mov (&DWP(24,"edi"),"eax"); # rk[6]
2757 &mov (&DWP(28,"edi"),"eax"); # rk[7]
2759 &mov (&DWP(32,"edi"),"eax"); # rk[8]
2761 &mov (&DWP(36,"edi"),"eax"); # rk[9]
2768 &mov (&DWP(40,"edi"),"eax"); # rk[10]
2770 &mov (&DWP(44,"edi"),"eax"); # rk[11]
2776 &mov (&DWP(72,"edi"),12); # setup number of rounds
2781 &mov ("eax",&DWP(0,"esi")); # copy first 8 dwords
2782 &mov ("ebx",&DWP(4,"esi"));
2783 &mov ("ecx",&DWP(8,"esi"));
2784 &mov ("edx",&DWP(12,"esi"));
2785 &mov (&DWP(0,"edi"),"eax");
2786 &mov (&DWP(4,"edi"),"ebx");
2787 &mov (&DWP(8,"edi"),"ecx");
2788 &mov (&DWP(12,"edi"),"edx");
2789 &mov ("eax",&DWP(16,"esi"));
2790 &mov ("ebx",&DWP(20,"esi"));
2791 &mov ("ecx",&DWP(24,"esi"));
2792 &mov ("edx",&DWP(28,"esi"));
2793 &mov (&DWP(16,"edi"),"eax");
2794 &mov (&DWP(20,"edi"),"ebx");
2795 &mov (&DWP(24,"edi"),"ecx");
2796 &mov (&DWP(28,"edi"),"edx");
2803 &mov ("edx",&DWP(28,"edi")); # rk[7]
2805 &mov ("eax",&DWP(0,"edi")); # rk[0]
2809 &mov (&DWP(32,"edi"),"eax"); # rk[8]
2811 &mov (&DWP(36,"edi"),"eax"); # rk[9]
2813 &mov (&DWP(40,"edi"),"eax"); # rk[10]
2815 &mov (&DWP(44,"edi"),"eax"); # rk[11]
2821 &mov ("edx","eax");
2822 &mov ("eax",&DWP(16,"edi")); # rk[4]
2843 &mov (&DWP(48,"edi"),"eax"); # rk[12]
2845 &mov (&DWP(52,"edi"),"eax"); # rk[13]
2847 &mov (&DWP(56,"edi"),"eax"); # rk[14]
2849 &mov (&DWP(60,"edi"),"eax"); # rk[15]
2855 &mov (&DWP(48,"edi"),14); # setup number of rounds
2860 &mov ("eax",-1);
2875 &mov ($tmp,0x80808080);
2878 &mov ($acc,$tmp);
2884 &mov ($tmp,0x80808080);
2888 &mov ($acc,$tmp);
2895 &mov ($tmp,0x80808080);
2899 &mov ($acc,$tmp);
2908 &mov ($tmp,&DWP(4*($i+1),$key)); # modulo-scheduled load
2920 &mov ($tp2,$tmp);
2923 &mov (&DWP(4*$i,$key),$tp1);
2940 &mov ("esi",&wparam(2));
2941 &mov ("ecx",&DWP(240,"esi")); # pull number of rounds
2946 &mov ("eax",&DWP(0,"esi"));
2947 &mov ("ebx",&DWP(4,"esi"));
2948 &mov ("ecx",&DWP(0,"edi"));
2949 &mov ("edx",&DWP(4,"edi"));
2950 &mov (&DWP(0,"edi"),"eax");
2951 &mov (&DWP(4,"edi"),"ebx");
2952 &mov (&DWP(0,"esi"),"ecx");
2953 &mov (&DWP(4,"esi"),"edx");
2954 &mov ("eax",&DWP(8,"esi"));
2955 &mov ("ebx",&DWP(12,"esi"));
2956 &mov ("ecx",&DWP(8,"edi"));
2957 &mov ("edx",&DWP(12,"edi"));
2958 &mov (&DWP(8,"edi"),"eax");
2959 &mov (&DWP(12,"edi"),"ebx");
2960 &mov (&DWP(8,"esi"),"ecx");
2961 &mov (&DWP(12,"esi"),"edx");
2967 &mov ($key,&wparam(2));
2968 &mov ($acc,&DWP(240,$key)); # pull number of rounds
2971 &mov (&wparam(2),$acc);
2973 &mov ($s0,&DWP(16,$key)); # modulo-scheduled load