< prev index next >

src/hotspot/cpu/x86/assembler_x86.hpp

Print this page

1445     LoadLoad   = 1 << 0
1446   };
1447 
1448   // Serializes memory and blows flags
1449   void membar(Membar_mask_bits order_constraint);
1450 
1451   void mfence();
1452   void sfence();
1453 
1454   // Moves
1455 
1456   void mov64(Register dst, int64_t imm64);
1457   void mov64(Register dst, int64_t imm64, relocInfo::relocType rtype, int format);
1458 
1459   void movb(Address dst, Register src);
1460   void movb(Address dst, int imm8);
1461   void movb(Register dst, Address src);
1462 
1463   void movddup(XMMRegister dst, XMMRegister src);
1464 














1465   void kmovbl(KRegister dst, Register src);
1466   void kmovbl(Register dst, KRegister src);

1467   void kmovwl(KRegister dst, Register src);
1468   void kmovwl(KRegister dst, Address src);
1469   void kmovwl(Register dst, KRegister src);
1470   void kmovwl(Address dst, KRegister src);
1471   void kmovwl(KRegister dst, KRegister src);
1472   void kmovdl(KRegister dst, Register src);
1473   void kmovdl(Register dst, KRegister src);
1474   void kmovql(KRegister dst, KRegister src);
1475   void kmovql(Address dst, KRegister src);
1476   void kmovql(KRegister dst, Address src);
1477   void kmovql(KRegister dst, Register src);
1478   void kmovql(Register dst, KRegister src);
1479 

1480   void knotwl(KRegister dst, KRegister src);

1481   void knotql(KRegister dst, KRegister src);
1482 
1483   void kortestbl(KRegister dst, KRegister src);
1484   void kortestwl(KRegister dst, KRegister src);
1485   void kortestdl(KRegister dst, KRegister src);
1486   void kortestql(KRegister dst, KRegister src);
1487 






1488   void ktestq(KRegister src1, KRegister src2);
1489   void ktestd(KRegister src1, KRegister src2);
1490 
1491   void ktestql(KRegister dst, KRegister src);



1492 
1493   void movdl(XMMRegister dst, Register src);
1494   void movdl(Register dst, XMMRegister src);
1495   void movdl(XMMRegister dst, Address src);
1496   void movdl(Address dst, XMMRegister src);
1497 
1498   // Move Double Quadword
1499   void movdq(XMMRegister dst, Register src);
1500   void movdq(Register dst, XMMRegister src);
1501 
1502   // Move Aligned Double Quadword
1503   void movdqa(XMMRegister dst, XMMRegister src);
1504   void movdqa(XMMRegister dst, Address src);
1505 
1506   // Move Unaligned Double Quadword
1507   void movdqu(Address     dst, XMMRegister src);
1508   void movdqu(XMMRegister dst, Address src);
1509   void movdqu(XMMRegister dst, XMMRegister src);
1510 
1511   // Move Unaligned 256bit Vector

2135   void vmulss(XMMRegister dst, XMMRegister nds, Address src);
2136   void vmulss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2137   void vsubsd(XMMRegister dst, XMMRegister nds, Address src);
2138   void vsubsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2139   void vsubss(XMMRegister dst, XMMRegister nds, Address src);
2140   void vsubss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2141 
2142   void vmaxss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2143   void vmaxsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2144   void vminss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2145   void vminsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2146 
2147   void shlxl(Register dst, Register src1, Register src2);
2148   void shlxq(Register dst, Register src1, Register src2);
2149   void shrxl(Register dst, Register src1, Register src2);
2150   void shrxq(Register dst, Register src1, Register src2);
2151 
2152   void bzhiq(Register dst, Register src1, Register src2);
2153 
2154   //====================VECTOR ARITHMETIC=====================================
2155   void evpmovd2m(KRegister kdst, XMMRegister src, int vector_len);
2156   void evpmovq2m(KRegister kdst, XMMRegister src, int vector_len);
2157 
2158   // Add Packed Floating-Point Values
2159   void addpd(XMMRegister dst, XMMRegister src);
2160   void addpd(XMMRegister dst, Address src);
2161   void addps(XMMRegister dst, XMMRegister src);
2162   void vaddpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2163   void vaddps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2164   void vaddpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2165   void vaddps(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2166 
2167   // Subtract Packed Floating-Point Values
2168   void subpd(XMMRegister dst, XMMRegister src);
2169   void subps(XMMRegister dst, XMMRegister src);
2170   void vsubpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2171   void vsubps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2172   void vsubpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2173   void vsubps(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2174 
2175   // Multiply Packed Floating-Point Values
2176   void mulpd(XMMRegister dst, XMMRegister src);
2177   void mulpd(XMMRegister dst, Address src);

2229   void vphaddw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2230   void vphaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2231   void phaddw(XMMRegister dst, XMMRegister src);
2232   void phaddd(XMMRegister dst, XMMRegister src);
2233 
2234   // Add packed integers
2235   void paddb(XMMRegister dst, XMMRegister src);
2236   void paddw(XMMRegister dst, XMMRegister src);
2237   void paddd(XMMRegister dst, XMMRegister src);
2238   void paddd(XMMRegister dst, Address src);
2239   void paddq(XMMRegister dst, XMMRegister src);
2240   void vpaddb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2241   void vpaddw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2242   void vpaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2243   void vpaddq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2244   void vpaddb(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2245   void vpaddw(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2246   void vpaddd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2247   void vpaddq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2248 


































































































































2249   // Sub packed integers
2250   void psubb(XMMRegister dst, XMMRegister src);
2251   void psubw(XMMRegister dst, XMMRegister src);
2252   void psubd(XMMRegister dst, XMMRegister src);
2253   void psubq(XMMRegister dst, XMMRegister src);
2254   void vpsubusb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2255   void vpsubb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2256   void vpsubw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2257   void vpsubd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2258   void vpsubq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2259   void vpsubb(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2260   void vpsubw(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2261   void vpsubd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2262   void vpsubq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2263 
2264   // Multiply packed integers (only shorts and ints)
2265   void pmullw(XMMRegister dst, XMMRegister src);
2266   void pmulld(XMMRegister dst, XMMRegister src);
2267   void pmuludq(XMMRegister dst, XMMRegister src);
2268   void vpmullw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);

2347 
2348   // Variable shift left packed integers
2349   void vpsllvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2350   void vpsllvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2351 
2352   // Variable shift right packed integers
2353   void vpsrlvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2354   void vpsrlvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2355 
2356   // Variable shift right arithmetic packed integers
2357   void vpsravd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2358   void evpsravq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2359 
2360   void vpshldvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2361   void vpshrdvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2362 
2363   // And packed integers
2364   void pand(XMMRegister dst, XMMRegister src);
2365   void vpand(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2366   void vpand(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2367   void evpandd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2368   void vpandq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2369 
2370   // Andn packed integers
2371   void pandn(XMMRegister dst, XMMRegister src);
2372   void vpandn(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2373 
2374   // Or packed integers
2375   void por(XMMRegister dst, XMMRegister src);
2376   void vpor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2377   void vpor(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2378   void vporq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2379 
2380   void evpord(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2381   void evpord(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2382 
2383   // Xor packed integers
2384   void pxor(XMMRegister dst, XMMRegister src);
2385   void vpxor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2386   void vpxor(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2387   void vpxorq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2388   void evpxord(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2389   void evpxorq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2390   void evpxorq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2391 
2392   // Ternary logic instruction.
2393   void vpternlogd(XMMRegister dst, int imm8, XMMRegister src2, XMMRegister src3, int vector_len);
2394   void vpternlogd(XMMRegister dst, int imm8, XMMRegister src2, Address     src3, int vector_len);
2395   void vpternlogq(XMMRegister dst, int imm8, XMMRegister src2, XMMRegister src3, int vector_len);
2396 
2397   // Vector Rotate Left/Right instruction.
2398   void evprolvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2399   void evprolvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2400   void evprorvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2401   void evprorvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2402   void evprold(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2403   void evprolq(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2404   void evprord(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2405   void evprorq(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2406 
2407   // vinserti forms
2408   void vinserti128(XMMRegister dst, XMMRegister nds, XMMRegister src, uint8_t imm8);

2510 
2511   // Vector long compares
2512   void evpcmpq(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2513                int comparison, bool is_signed, int vector_len);
2514   void evpcmpq(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2515                int comparison, bool is_signed, int vector_len);
2516 
2517   // Vector byte compares
2518   void evpcmpb(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2519                int comparison, bool is_signed, int vector_len);
2520   void evpcmpb(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2521                int comparison, bool is_signed, int vector_len);
2522 
2523   // Vector short compares
2524   void evpcmpw(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2525                int comparison, bool is_signed, int vector_len);
2526   void evpcmpw(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2527                int comparison, bool is_signed, int vector_len);
2528 
2529   void evpmovb2m(KRegister dst, XMMRegister src, int vector_len);







2530 
2531   // Vector blends
2532   void blendvps(XMMRegister dst, XMMRegister src);
2533   void blendvpd(XMMRegister dst, XMMRegister src);
2534   void pblendvb(XMMRegister dst, XMMRegister src);
2535   void blendvpb(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len);
2536   void vblendvps(XMMRegister dst, XMMRegister nds, XMMRegister src, XMMRegister mask, int vector_len);
2537   void vblendvpd(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len);
2538   void vpblendvb(XMMRegister dst, XMMRegister nds, XMMRegister src, XMMRegister mask, int vector_len);
2539   void vpblendd(XMMRegister dst, XMMRegister nds, XMMRegister src, int imm8, int vector_len);
2540   void evblendmpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2541   void evblendmps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2542   void evpblendmb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2543   void evpblendmw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2544   void evpblendmd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2545   void evpblendmq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2546  protected:
2547   // Next instructions require address alignment 16 bytes SSE mode.
2548   // They should be called only from corresponding MacroAssembler instructions.
2549   void andpd(XMMRegister dst, Address src);

1445     LoadLoad   = 1 << 0
1446   };
1447 
1448   // Serializes memory and blows flags
1449   void membar(Membar_mask_bits order_constraint);
1450 
1451   void mfence();
1452   void sfence();
1453 
1454   // Moves
1455 
1456   void mov64(Register dst, int64_t imm64);
1457   void mov64(Register dst, int64_t imm64, relocInfo::relocType rtype, int format);
1458 
1459   void movb(Address dst, Register src);
1460   void movb(Address dst, int imm8);
1461   void movb(Register dst, Address src);
1462 
1463   void movddup(XMMRegister dst, XMMRegister src);
1464 
1465   void kandbl(KRegister dst, KRegister src1, KRegister src2);
1466   void kandwl(KRegister dst, KRegister src1, KRegister src2);
1467   void kanddl(KRegister dst, KRegister src1, KRegister src2);
1468   void kandql(KRegister dst, KRegister src1, KRegister src2);
1469 
1470   void korbl(KRegister dst, KRegister src1, KRegister src2);
1471   void korwl(KRegister dst, KRegister src1, KRegister src2);
1472   void kordl(KRegister dst, KRegister src1, KRegister src2);
1473   void korql(KRegister dst, KRegister src1, KRegister src2);
1474 
1475   void kxorbl(KRegister dst, KRegister src1, KRegister src2);
1476   void kxorwl(KRegister dst, KRegister src1, KRegister src2);
1477   void kxordl(KRegister dst, KRegister src1, KRegister src2);
1478   void kxorql(KRegister dst, KRegister src1, KRegister src2);
1479   void kmovbl(KRegister dst, Register src);
1480   void kmovbl(Register dst, KRegister src);
1481   void kmovbl(KRegister dst, KRegister src);
1482   void kmovwl(KRegister dst, Register src);
1483   void kmovwl(KRegister dst, Address src);
1484   void kmovwl(Register dst, KRegister src);
1485   void kmovwl(Address dst, KRegister src);
1486   void kmovwl(KRegister dst, KRegister src);
1487   void kmovdl(KRegister dst, Register src);
1488   void kmovdl(Register dst, KRegister src);
1489   void kmovql(KRegister dst, KRegister src);
1490   void kmovql(Address dst, KRegister src);
1491   void kmovql(KRegister dst, Address src);
1492   void kmovql(KRegister dst, Register src);
1493   void kmovql(Register dst, KRegister src);
1494 
1495   void knotbl(KRegister dst, KRegister src);
1496   void knotwl(KRegister dst, KRegister src);
1497   void knotdl(KRegister dst, KRegister src);
1498   void knotql(KRegister dst, KRegister src);
1499 
1500   void kortestbl(KRegister dst, KRegister src);
1501   void kortestwl(KRegister dst, KRegister src);
1502   void kortestdl(KRegister dst, KRegister src);
1503   void kortestql(KRegister dst, KRegister src);
1504 
1505   void kxnorbl(KRegister dst, KRegister src1, KRegister src2);
1506   void kshiftlbl(KRegister dst, KRegister src, int imm8);
1507   void kshiftrbl(KRegister dst, KRegister src, int imm8);
1508   void kshiftrwl(KRegister dst, KRegister src, int imm8);
1509   void kshiftrdl(KRegister dst, KRegister src, int imm8);
1510   void kshiftrql(KRegister dst, KRegister src, int imm8);
1511   void ktestq(KRegister src1, KRegister src2);
1512   void ktestd(KRegister src1, KRegister src2);
1513 
1514   void ktestql(KRegister dst, KRegister src);
1515   void ktestdl(KRegister dst, KRegister src);
1516   void ktestwl(KRegister dst, KRegister src);
1517   void ktestbl(KRegister dst, KRegister src);
1518 
1519   void movdl(XMMRegister dst, Register src);
1520   void movdl(Register dst, XMMRegister src);
1521   void movdl(XMMRegister dst, Address src);
1522   void movdl(Address dst, XMMRegister src);
1523 
1524   // Move Double Quadword
1525   void movdq(XMMRegister dst, Register src);
1526   void movdq(Register dst, XMMRegister src);
1527 
1528   // Move Aligned Double Quadword
1529   void movdqa(XMMRegister dst, XMMRegister src);
1530   void movdqa(XMMRegister dst, Address src);
1531 
1532   // Move Unaligned Double Quadword
1533   void movdqu(Address     dst, XMMRegister src);
1534   void movdqu(XMMRegister dst, Address src);
1535   void movdqu(XMMRegister dst, XMMRegister src);
1536 
1537   // Move Unaligned 256bit Vector

2161   void vmulss(XMMRegister dst, XMMRegister nds, Address src);
2162   void vmulss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2163   void vsubsd(XMMRegister dst, XMMRegister nds, Address src);
2164   void vsubsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2165   void vsubss(XMMRegister dst, XMMRegister nds, Address src);
2166   void vsubss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2167 
2168   void vmaxss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2169   void vmaxsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2170   void vminss(XMMRegister dst, XMMRegister nds, XMMRegister src);
2171   void vminsd(XMMRegister dst, XMMRegister nds, XMMRegister src);
2172 
2173   void shlxl(Register dst, Register src1, Register src2);
2174   void shlxq(Register dst, Register src1, Register src2);
2175   void shrxl(Register dst, Register src1, Register src2);
2176   void shrxq(Register dst, Register src1, Register src2);
2177 
2178   void bzhiq(Register dst, Register src1, Register src2);
2179 
2180   //====================VECTOR ARITHMETIC=====================================



2181   // Add Packed Floating-Point Values
2182   void addpd(XMMRegister dst, XMMRegister src);
2183   void addpd(XMMRegister dst, Address src);
2184   void addps(XMMRegister dst, XMMRegister src);
2185   void vaddpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2186   void vaddps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2187   void vaddpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2188   void vaddps(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2189 
2190   // Subtract Packed Floating-Point Values
2191   void subpd(XMMRegister dst, XMMRegister src);
2192   void subps(XMMRegister dst, XMMRegister src);
2193   void vsubpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2194   void vsubps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2195   void vsubpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2196   void vsubps(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2197 
2198   // Multiply Packed Floating-Point Values
2199   void mulpd(XMMRegister dst, XMMRegister src);
2200   void mulpd(XMMRegister dst, Address src);

2252   void vphaddw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2253   void vphaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2254   void phaddw(XMMRegister dst, XMMRegister src);
2255   void phaddd(XMMRegister dst, XMMRegister src);
2256 
2257   // Add packed integers
2258   void paddb(XMMRegister dst, XMMRegister src);
2259   void paddw(XMMRegister dst, XMMRegister src);
2260   void paddd(XMMRegister dst, XMMRegister src);
2261   void paddd(XMMRegister dst, Address src);
2262   void paddq(XMMRegister dst, XMMRegister src);
2263   void vpaddb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2264   void vpaddw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2265   void vpaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2266   void vpaddq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2267   void vpaddb(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2268   void vpaddw(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2269   void vpaddd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2270   void vpaddq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2271 
2272   // Leaf level assembler routines for masked operations.
2273   void evpaddb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2274   void evpaddb(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2275   void evpaddw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2276   void evpaddw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2277   void evpaddd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2278   void evpaddd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2279   void evpaddq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2280   void evpaddq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2281   void evaddps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2282   void evaddps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2283   void evaddpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2284   void evaddpd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2285   void evpsubb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2286   void evpsubb(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2287   void evpsubw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2288   void evpsubw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2289   void evpsubd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2290   void evpsubd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2291   void evpsubq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2292   void evpsubq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2293   void evsubps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2294   void evsubps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2295   void evsubpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2296   void evsubpd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2297   void evpmullw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2298   void evpmullw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2299   void evpmulld(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2300   void evpmulld(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2301   void evpmullq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2302   void evpmullq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2303   void evmulps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2304   void evmulps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2305   void evmulpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2306   void evmulpd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2307   void evdivps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2308   void evdivps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2309   void evdivpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2310   void evdivpd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2311   void evpabsb(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len);
2312   void evpabsb(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len);
2313   void evpabsw(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len);
2314   void evpabsw(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len);
2315   void evpabsd(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len);
2316   void evpabsd(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len);
2317   void evpabsq(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len);
2318   void evpabsq(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len);
2319   void evpfma213ps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2320   void evpfma213ps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2321   void evpfma213pd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2322   void evpfma213pd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2323   void evpermb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2324   void evpermb(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2325   void evpermw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2326   void evpermw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2327   void evpermd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2328   void evpermd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2329   void evpermq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2330   void evpermq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2331   void evpsllw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2332   void evpslld(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2333   void evpsllq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2334   void evpsrlw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2335   void evpsrld(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2336   void evpsrlq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2337   void evpsraw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2338   void evpsrad(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2339   void evpsraq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2340   void evsqrtps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2341   void evsqrtps(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2342   void evsqrtpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2343   void evsqrtpd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2344 
2345   void evpsllw(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2346   void evpslld(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2347   void evpsllq(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2348   void evpsrlw(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2349   void evpsrld(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2350   void evpsrlq(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2351   void evpsraw(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2352   void evpsrad(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2353   void evpsraq(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2354 
2355   void evpsllvw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2356   void evpsllvd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2357   void evpsllvq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2358   void evpsrlvw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2359   void evpsrlvd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2360   void evpsrlvq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2361   void evpsravw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2362   void evpsravd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2363   void evpsravq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2364   void evpmaxsb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2365   void evpmaxsw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2366   void evpmaxsd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2367   void evpmaxsq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2368   void evpminsb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2369   void evpminsw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2370   void evpminsd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2371   void evpminsq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2372   void evpmaxsb(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2373   void evpmaxsw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2374   void evpmaxsd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2375   void evpmaxsq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2376   void evpminsb(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2377   void evpminsw(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2378   void evpminsd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2379   void evpminsq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2380   void evpord(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2381   void evpord(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2382   void evporq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2383   void evporq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2384   void evpandd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2385   void evpandd(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2386   void evpandq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2387   void evpandq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2388   void evpxord(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2389   void evpxord(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2390   void evpxorq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2391   void evpxorq(XMMRegister dst, KRegister mask, XMMRegister nds, Address src, bool merge, int vector_len);
2392 
2393   void evprold(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2394   void evprolq(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2395   void evprolvd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2396   void evprolvq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2397   void evprord(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2398   void evprorq(XMMRegister dst, KRegister mask, XMMRegister src, int shift, bool merge, int vector_len);
2399   void evprorvd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2400   void evprorvq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2401 
2402   // Sub packed integers
2403   void psubb(XMMRegister dst, XMMRegister src);
2404   void psubw(XMMRegister dst, XMMRegister src);
2405   void psubd(XMMRegister dst, XMMRegister src);
2406   void psubq(XMMRegister dst, XMMRegister src);
2407   void vpsubusb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2408   void vpsubb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2409   void vpsubw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2410   void vpsubd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2411   void vpsubq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2412   void vpsubb(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2413   void vpsubw(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2414   void vpsubd(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2415   void vpsubq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2416 
2417   // Multiply packed integers (only shorts and ints)
2418   void pmullw(XMMRegister dst, XMMRegister src);
2419   void pmulld(XMMRegister dst, XMMRegister src);
2420   void pmuludq(XMMRegister dst, XMMRegister src);
2421   void vpmullw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);

2500 
2501   // Variable shift left packed integers
2502   void vpsllvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2503   void vpsllvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2504 
2505   // Variable shift right packed integers
2506   void vpsrlvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2507   void vpsrlvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2508 
2509   // Variable shift right arithmetic packed integers
2510   void vpsravd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2511   void evpsravq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2512 
2513   void vpshldvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2514   void vpshrdvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2515 
2516   // And packed integers
2517   void pand(XMMRegister dst, XMMRegister src);
2518   void vpand(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2519   void vpand(XMMRegister dst, XMMRegister nds, Address src, int vector_len);

2520   void vpandq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2521 
2522   // Andn packed integers
2523   void pandn(XMMRegister dst, XMMRegister src);
2524   void vpandn(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2525 
2526   // Or packed integers
2527   void por(XMMRegister dst, XMMRegister src);
2528   void vpor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2529   void vpor(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2530   void vporq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2531 



2532   // Xor packed integers
2533   void pxor(XMMRegister dst, XMMRegister src);
2534   void vpxor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2535   void vpxor(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2536   void vpxorq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);

2537   void evpxorq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len);
2538   void evpxorq(XMMRegister dst, XMMRegister nds, Address src, int vector_len);
2539 
2540   // Ternary logic instruction.
2541   void vpternlogd(XMMRegister dst, int imm8, XMMRegister src2, XMMRegister src3, int vector_len);
2542   void vpternlogd(XMMRegister dst, int imm8, XMMRegister src2, Address     src3, int vector_len);
2543   void vpternlogq(XMMRegister dst, int imm8, XMMRegister src2, XMMRegister src3, int vector_len);
2544 
2545   // Vector Rotate Left/Right instruction.
2546   void evprolvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2547   void evprolvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2548   void evprorvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2549   void evprorvq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len);
2550   void evprold(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2551   void evprolq(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2552   void evprord(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2553   void evprorq(XMMRegister dst, XMMRegister src, int shift, int vector_len);
2554 
2555   // vinserti forms
2556   void vinserti128(XMMRegister dst, XMMRegister nds, XMMRegister src, uint8_t imm8);

2658 
2659   // Vector long compares
2660   void evpcmpq(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2661                int comparison, bool is_signed, int vector_len);
2662   void evpcmpq(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2663                int comparison, bool is_signed, int vector_len);
2664 
2665   // Vector byte compares
2666   void evpcmpb(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2667                int comparison, bool is_signed, int vector_len);
2668   void evpcmpb(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2669                int comparison, bool is_signed, int vector_len);
2670 
2671   // Vector short compares
2672   void evpcmpw(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src,
2673                int comparison, bool is_signed, int vector_len);
2674   void evpcmpw(KRegister kdst, KRegister mask, XMMRegister nds, Address src,
2675                int comparison, bool is_signed, int vector_len);
2676 
2677   void evpmovb2m(KRegister dst, XMMRegister src, int vector_len);
2678   void evpmovw2m(KRegister dst, XMMRegister src, int vector_len);
2679   void evpmovd2m(KRegister dst, XMMRegister src, int vector_len);
2680   void evpmovq2m(KRegister dst, XMMRegister src, int vector_len);
2681   void evpmovm2b(XMMRegister dst, KRegister src, int vector_len);
2682   void evpmovm2w(XMMRegister dst, KRegister src, int vector_len);
2683   void evpmovm2d(XMMRegister dst, KRegister src, int vector_len);
2684   void evpmovm2q(XMMRegister dst, KRegister src, int vector_len);
2685 
2686   // Vector blends
2687   void blendvps(XMMRegister dst, XMMRegister src);
2688   void blendvpd(XMMRegister dst, XMMRegister src);
2689   void pblendvb(XMMRegister dst, XMMRegister src);
2690   void blendvpb(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len);
2691   void vblendvps(XMMRegister dst, XMMRegister nds, XMMRegister src, XMMRegister mask, int vector_len);
2692   void vblendvpd(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len);
2693   void vpblendvb(XMMRegister dst, XMMRegister nds, XMMRegister src, XMMRegister mask, int vector_len);
2694   void vpblendd(XMMRegister dst, XMMRegister nds, XMMRegister src, int imm8, int vector_len);
2695   void evblendmpd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2696   void evblendmps(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2697   void evpblendmb(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2698   void evpblendmw(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2699   void evpblendmd(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2700   void evpblendmq(XMMRegister dst, KRegister mask, XMMRegister nds, XMMRegister src, bool merge, int vector_len);
2701  protected:
2702   // Next instructions require address alignment 16 bytes SSE mode.
2703   // They should be called only from corresponding MacroAssembler instructions.
2704   void andpd(XMMRegister dst, Address src);
< prev index next >