Cross Reference: /external/v8/src/x64/assembler-x64.h

Lines Matching refs:dst
673   void pop(Register dst);
674   void pop(const Operand& dst);
680   void movb(Register dst, const Operand& src);
681   void movb(Register dst, Immediate imm);
682   void movb(const Operand& dst, Register src);
686   void movw(const Operand& dst, Register src);
688   void movl(Register dst, Register src);
689   void movl(Register dst, const Operand& src);
690   void movl(const Operand& dst, Register src);
691   void movl(const Operand& dst, Immediate imm);
693   void movl(Register dst, Immediate imm32);
696   void movq(const Operand& dst, Register src);
698   void movq(Register dst, const Operand& src);
699   void movq(Register dst, Register src);
701   void movq(Register dst, Immediate x);
704   void movl(const Operand& dst, Label* src);
707   void movq(const Operand& dst, Immediate value);
710   void movq(Register dst, void* ptr, RelocInfo::Mode rmode);
711   void movq(Register dst, int64_t value, RelocInfo::Mode rmode);
712   void movq(Register dst, const char* s, RelocInfo::Mode rmode);
714   void movq(Register dst, ExternalReference ext);
715   void movq(Register dst, Handle<Object> handle, RelocInfo::Mode rmode);
717   void movsxbq(Register dst, const Operand& src);
718   void movsxwq(Register dst, const Operand& src);
719   void movsxlq(Register dst, Register src);
720   void movsxlq(Register dst, const Operand& src);
721   void movzxbq(Register dst, const Operand& src);
722   void movzxbl(Register dst, const Operand& src);
723   void movzxwq(Register dst, const Operand& src);
724   void movzxwl(Register dst, const Operand& src);
738   void cmovq(Condition cc, Register dst, Register src);
739   void cmovq(Condition cc, Register dst, const Operand& src);
740   void cmovl(Condition cc, Register dst, Register src);
741   void cmovl(Condition cc, Register dst, const Operand& src);
744   void xchg(Register dst, Register src);
747   void addl(Register dst, Register src) {
748     arithmetic_op_32(0x03, dst, src);
751   void addl(Register dst, Immediate src) {
752     immediate_arithmetic_op_32(0x0, dst, src);
755   void addl(Register dst, const Operand& src) {
756     arithmetic_op_32(0x03, dst, src);
759   void addl(const Operand& dst, Immediate src) {
760     immediate_arithmetic_op_32(0x0, dst, src);
763   void addl(const Operand& dst, Register src) {
764     arithmetic_op_32(0x01, src, dst);
767   void addq(Register dst, Register src) {
768     arithmetic_op(0x03, dst, src);
771   void addq(Register dst, const Operand& src) {
772     arithmetic_op(0x03, dst, src);
775   void addq(const Operand& dst, Register src) {
776     arithmetic_op(0x01, src, dst);
779   void addq(Register dst, Immediate src) {
780     immediate_arithmetic_op(0x0, dst, src);
783   void addq(const Operand& dst, Immediate src) {
784     immediate_arithmetic_op(0x0, dst, src);
787   void sbbl(Register dst, Register src) {
788     arithmetic_op_32(0x1b, dst, src);
791   void sbbq(Register dst, Register src) {
792     arithmetic_op(0x1b, dst, src);
795   void cmpb(Register dst, Immediate src) {
796     immediate_arithmetic_op_8(0x7, dst, src);
801   void cmpb(Register dst, Register src) {
802     arithmetic_op(0x3A, dst, src);
805   void cmpb(Register dst, const Operand& src) {
806     arithmetic_op(0x3A, dst, src);
809   void cmpb(const Operand& dst, Register src) {
810     arithmetic_op(0x38, src, dst);
813   void cmpb(const Operand& dst, Immediate src) {
814     immediate_arithmetic_op_8(0x7, dst, src);
817   void cmpw(const Operand& dst, Immediate src) {
818     immediate_arithmetic_op_16(0x7, dst, src);
821   void cmpw(Register dst, Immediate src) {
822     immediate_arithmetic_op_16(0x7, dst, src);
825   void cmpw(Register dst, const Operand& src) {
826     arithmetic_op_16(0x3B, dst, src);
829   void cmpw(Register dst, Register src) {
830     arithmetic_op_16(0x3B, dst, src);
833   void cmpw(const Operand& dst, Register src) {
834     arithmetic_op_16(0x39, src, dst);
837   void cmpl(Register dst, Register src) {
838     arithmetic_op_32(0x3B, dst, src);
841   void cmpl(Register dst, const Operand& src) {
842     arithmetic_op_32(0x3B, dst, src);
845   void cmpl(const Operand& dst, Register src) {
846     arithmetic_op_32(0x39, src, dst);
849   void cmpl(Register dst, Immediate src) {
850     immediate_arithmetic_op_32(0x7, dst, src);
853   void cmpl(const Operand& dst, Immediate src) {
854     immediate_arithmetic_op_32(0x7, dst, src);
857   void cmpq(Register dst, Register src) {
858     arithmetic_op(0x3B, dst, src);
861   void cmpq(Register dst, const Operand& src) {
862     arithmetic_op(0x3B, dst, src);
865   void cmpq(const Operand& dst, Register src) {
866     arithmetic_op(0x39, src, dst);
869   void cmpq(Register dst, Immediate src) {
870     immediate_arithmetic_op(0x7, dst, src);
873   void cmpq(const Operand& dst, Immediate src) {
874     immediate_arithmetic_op(0x7, dst, src);
877   void and_(Register dst, Register src) {
878     arithmetic_op(0x23, dst, src);
881   void and_(Register dst, const Operand& src) {
882     arithmetic_op(0x23, dst, src);
885   void and_(const Operand& dst, Register src) {
886     arithmetic_op(0x21, src, dst);
889   void and_(Register dst, Immediate src) {
890     immediate_arithmetic_op(0x4, dst, src);
893   void and_(const Operand& dst, Immediate src) {
894     immediate_arithmetic_op(0x4, dst, src);
897   void andl(Register dst, Immediate src) {
898     immediate_arithmetic_op_32(0x4, dst, src);
901   void andl(Register dst, Register src) {
902     arithmetic_op_32(0x23, dst, src);
905   void andl(Register dst, const Operand& src) {
906     arithmetic_op_32(0x23, dst, src);
909   void andb(Register dst, Immediate src) {
910     immediate_arithmetic_op_8(0x4, dst, src);
913   void decq(Register dst);
914   void decq(const Operand& dst);
915   void decl(Register dst);
916   void decl(const Operand& dst);
917   void decb(Register dst);
918   void decb(const Operand& dst);
932   void imul(Register dst, Register src);                 // dst = dst * src.
933   void imul(Register dst, const Operand& src);           // dst = dst * src.
934   void imul(Register dst, Register src, Immediate imm);  // dst = src * imm.
936   void imull(Register dst, Register src);                 // dst = dst * src.
937   void imull(Register dst, const Operand& src);           // dst = dst * src.
938   void imull(Register dst, Register src, Immediate imm);  // dst = src * imm.
940   void incq(Register dst);
941   void incq(const Operand& dst);
942   void incl(Register dst);
943   void incl(const Operand& dst);
945   void lea(Register dst, const Operand& src);
946   void leal(Register dst, const Operand& src);
951   void neg(Register dst);
952   void neg(const Operand& dst);
953   void negl(Register dst);
955   void not_(Register dst);
956   void not_(const Operand& dst);
957   void notl(Register dst);
959   void or_(Register dst, Register src) {
960     arithmetic_op(0x0B, dst, src);
963   void orl(Register dst, Register src) {
964     arithmetic_op_32(0x0B, dst, src);
967   void or_(Register dst, const Operand& src) {
968     arithmetic_op(0x0B, dst, src);
971   void orl(Register dst, const Operand& src) {
972     arithmetic_op_32(0x0B, dst, src);
975   void or_(const Operand& dst, Register src) {
976     arithmetic_op(0x09, src, dst);
979   void or_(Register dst, Immediate src) {
980     immediate_arithmetic_op(0x1, dst, src);
983   void orl(Register dst, Immediate src) {
984     immediate_arithmetic_op_32(0x1, dst, src);
987   void or_(const Operand& dst, Immediate src) {
988     immediate_arithmetic_op(0x1, dst, src);
991   void orl(const Operand& dst, Immediate src) {
992     immediate_arithmetic_op_32(0x1, dst, src);
996   void rcl(Register dst, Immediate imm8) {
997     shift(dst, imm8, 0x2);
1000   void rol(Register dst, Immediate imm8) {
1001     shift(dst, imm8, 0x0);
1004   void rcr(Register dst, Immediate imm8) {
1005     shift(dst, imm8, 0x3);
1008   void ror(Register dst, Immediate imm8) {
1009     shift(dst, imm8, 0x1);
1012   // Shifts dst:src left by cl bits, affecting only dst.
1013   void shld(Register dst, Register src);
1015   // Shifts src:dst right by cl bits, affecting only dst.
1016   void shrd(Register dst, Register src);
1018   // Shifts dst right, duplicating sign bit, by shift_amount bits.
1020   void sar(Register dst, Immediate shift_amount) {
1021     shift(dst, shift_amount, 0x7);
1024   // Shifts dst right, duplicating sign bit, by shift_amount bits.
1026   void sarl(Register dst, Immediate shift_amount) {
1027     shift_32(dst, shift_amount, 0x7);
1030   // Shifts dst right, duplicating sign bit, by cl % 64 bits.
1031   void sar_cl(Register dst) {
1032     shift(dst, 0x7);
1035   // Shifts dst right, duplicating sign bit, by cl % 64 bits.
1036   void sarl_cl(Register dst) {
1037     shift_32(dst, 0x7);
1040   void shl(Register dst, Immediate shift_amount) {
1041     shift(dst, shift_amount, 0x4);
1044   void shl_cl(Register dst) {
1045     shift(dst, 0x4);
1048   void shll_cl(Register dst) {
1049     shift_32(dst, 0x4);
1052   void shll(Register dst, Immediate shift_amount) {
1053     shift_32(dst, shift_amount, 0x4);
1056   void shr(Register dst, Immediate shift_amount) {
1057     shift(dst, shift_amount, 0x5);
1060   void shr_cl(Register dst) {
1061     shift(dst, 0x5);
1064   void shrl_cl(Register dst) {
1065     shift_32(dst, 0x5);
1068   void shrl(Register dst, Immediate shift_amount) {
1069     shift_32(dst, shift_amount, 0x5);
1072   void store_rax(void* dst, RelocInfo::Mode mode);
1075   void subq(Register dst, Register src) {
1076     arithmetic_op(0x2B, dst, src);
1079   void subq(Register dst, const Operand& src) {
1080     arithmetic_op(0x2B, dst, src);
1083   void subq(const Operand& dst, Register src) {
1084     arithmetic_op(0x29, src, dst);
1087   void subq(Register dst, Immediate src) {
1088     immediate_arithmetic_op(0x5, dst, src);
1091   void subq(const Operand& dst, Immediate src) {
1092     immediate_arithmetic_op(0x5, dst, src);
1095   void subl(Register dst, Register src) {
1096     arithmetic_op_32(0x2B, dst, src);
1099   void subl(Register dst, const Operand& src) {
1100     arithmetic_op_32(0x2B, dst, src);
1103   void subl(const Operand& dst, Immediate src) {
1104     immediate_arithmetic_op_32(0x5, dst, src);
1107   void subl(Register dst, Immediate src) {
1108     immediate_arithmetic_op_32(0x5, dst, src);
1111   void subb(Register dst, Immediate src) {
1112     immediate_arithmetic_op_8(0x5, dst, src);
1115   void testb(Register dst, Register src);
1119   void testl(Register dst, Register src);
1123   void testq(Register dst, Register src);
1124   void testq(Register dst, Immediate mask);
1126   void xor_(Register dst, Register src) {
1127     if (dst.code() == src.code()) {
1128       arithmetic_op_32(0x33, dst, src);
1130       arithmetic_op(0x33, dst, src);
1134   void xorl(Register dst, Register src) {
1135     arithmetic_op_32(0x33, dst, src);
1138   void xorl(Register dst, const Operand& src) {
1139     arithmetic_op_32(0x33, dst, src);
1142   void xorl(Register dst, Immediate src) {
1143     immediate_arithmetic_op_32(0x6, dst, src);
1146   void xorl(const Operand& dst, Immediate src) {
1147     immediate_arithmetic_op_32(0x6, dst, src);
1150   void xor_(Register dst, const Operand& src) {
1151     arithmetic_op(0x33, dst, src);
1154   void xor_(const Operand& dst, Register src) {
1155     arithmetic_op(0x31, src, dst);
1158   void xor_(Register dst, Immediate src) {
1159     immediate_arithmetic_op(0x6, dst, src);
1162   void xor_(const Operand& dst, Immediate src) {
1163     immediate_arithmetic_op(0x6, dst, src);
1167   void bt(const Operand& dst, Register src);
1168   void bts(const Operand& dst, Register src);
1308   void movd(XMMRegister dst, Register src);
1309   void movd(Register dst, XMMRegister src);
1310   void movq(XMMRegister dst, Register src);
1311   void movq(Register dst, XMMRegister src);
1312   void movq(XMMRegister dst, XMMRegister src);
1313   void extractps(Register dst, XMMRegister src, byte imm8);
1319   void movsd(XMMRegister dst, XMMRegister src);
1321   void movsd(const Operand& dst, XMMRegister src);
1322   void movsd(XMMRegister dst, const Operand& src);
1324   void movdqa(const Operand& dst, XMMRegister src);
1325   void movdqa(XMMRegister dst, const Operand& src);
1327   void movapd(XMMRegister dst, XMMRegister src);
1328   void movaps(XMMRegister dst, XMMRegister src);
1330   void movss(XMMRegister dst, const Operand& src);
1331   void movss(const Operand& dst, XMMRegister src);
1333   void cvttss2si(Register dst, const Operand& src);
1334   void cvttss2si(Register dst, XMMRegister src);
1335   void cvttsd2si(Register dst, const Operand& src);
1336   void cvttsd2si(Register dst, XMMRegister src);
1337   void cvttsd2siq(Register dst, XMMRegister src);
1339   void cvtlsi2sd(XMMRegister dst, const Operand& src);
1340   void cvtlsi2sd(XMMRegister dst, Register src);
1341   void cvtqsi2sd(XMMRegister dst, const Operand& src);
1342   void cvtqsi2sd(XMMRegister dst, Register src);
1344   void cvtlsi2ss(XMMRegister dst, Register src);
1346   void cvtss2sd(XMMRegister dst, XMMRegister src);
1347   void cvtss2sd(XMMRegister dst, const Operand& src);
1348   void cvtsd2ss(XMMRegister dst, XMMRegister src);
1350   void cvtsd2si(Register dst, XMMRegister src);
1351   void cvtsd2siq(Register dst, XMMRegister src);
1353   void addsd(XMMRegister dst, XMMRegister src);
1354   void subsd(XMMRegister dst, XMMRegister src);
1355   void mulsd(XMMRegister dst, XMMRegister src);
1356   void divsd(XMMRegister dst, XMMRegister src);
1358   void andpd(XMMRegister dst, XMMRegister src);
1359   void orpd(XMMRegister dst, XMMRegister src);
1360   void xorpd(XMMRegister dst, XMMRegister src);
1361   void xorps(XMMRegister dst, XMMRegister src);
1362   void sqrtsd(XMMRegister dst, XMMRegister src);
1364   void ucomisd(XMMRegister dst, XMMRegister src);
1365   void ucomisd(XMMRegister dst, const Operand& src);
1374   void roundsd(XMMRegister dst, XMMRegister src, RoundingMode mode);
1376   void movmskpd(Register dst, XMMRegister src);
1379   void emit_sse_operand(XMMRegister dst, XMMRegister src);
1381   void emit_sse_operand(XMMRegister dst, Register src);
1382   void emit_sse_operand(Register dst, XMMRegister src);
1578   void immediate_arithmetic_op(byte subcode, Register dst, Immediate src);
1579   void immediate_arithmetic_op(byte subcode, const Operand& dst, Immediate src);
1582                                  Register dst,
1585                                  const Operand& dst,
1589                                   Register dst,
1592                                   const Operand& dst,
1596                                   Register dst,
1599                                   const Operand& dst,
1603   void shift(Register dst, Immediate shift_amount, int subcode);
1604   void shift_32(Register dst, Immediate shift_amount, int subcode);
1605   // Shift dst by cl % 64 bits.
1606   void shift(Register dst, int subcode);
1607   void shift_32(Register dst, int subcode);