1388 int encode = prefix_and_encode(dst->encoding(), src->encoding());
1389 emit_int8(0x0F);
1390 emit_int8((unsigned char)0xAF);
1391 emit_int8((unsigned char)(0xC0 | encode));
1392 }
1393
1394
1395 void Assembler::imull(Register dst, Register src, int value) {
1396 int encode = prefix_and_encode(dst->encoding(), src->encoding());
1397 if (is8bit(value)) {
1398 emit_int8(0x6B);
1399 emit_int8((unsigned char)(0xC0 | encode));
1400 emit_int8(value & 0xFF);
1401 } else {
1402 emit_int8(0x69);
1403 emit_int8((unsigned char)(0xC0 | encode));
1404 emit_int32(value);
1405 }
1406 }
1407
1408 void Assembler::incl(Address dst) {
1409 // Don't use it directly. Use MacroAssembler::increment() instead.
1410 InstructionMark im(this);
1411 prefix(dst);
1412 emit_int8((unsigned char)0xFF);
1413 emit_operand(rax, dst);
1414 }
1415
1416 void Assembler::jcc(Condition cc, Label& L, bool maybe_short) {
1417 InstructionMark im(this);
1418 assert((0 <= cc) && (cc < 16), "illegal cc");
1419 if (L.is_bound()) {
1420 address dst = target(L);
1421 assert(dst != NULL, "jcc most probably wrong");
1422
1423 const int short_size = 2;
1424 const int long_size = 6;
1425 intptr_t offs = (intptr_t)dst - (intptr_t)pc();
1426 if (maybe_short && is8bit(offs - short_size)) {
1427 // 0111 tttn #8-bit disp
5005 }
5006
5007 void Assembler::imulq(Register dst, Register src) {
5008 int encode = prefixq_and_encode(dst->encoding(), src->encoding());
5009 emit_int8(0x0F);
5010 emit_int8((unsigned char)0xAF);
5011 emit_int8((unsigned char)(0xC0 | encode));
5012 }
5013
5014 void Assembler::imulq(Register dst, Register src, int value) {
5015 int encode = prefixq_and_encode(dst->encoding(), src->encoding());
5016 if (is8bit(value)) {
5017 emit_int8(0x6B);
5018 emit_int8((unsigned char)(0xC0 | encode));
5019 emit_int8(value & 0xFF);
5020 } else {
5021 emit_int8(0x69);
5022 emit_int8((unsigned char)(0xC0 | encode));
5023 emit_int32(value);
5024 }
5025 }
5026
5027 void Assembler::incl(Register dst) {
5028 // Don't use it directly. Use MacroAssembler::incrementl() instead.
5029 // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
5030 int encode = prefix_and_encode(dst->encoding());
5031 emit_int8((unsigned char)0xFF);
5032 emit_int8((unsigned char)(0xC0 | encode));
5033 }
5034
5035 void Assembler::incq(Register dst) {
5036 // Don't use it directly. Use MacroAssembler::incrementq() instead.
5037 // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
5038 int encode = prefixq_and_encode(dst->encoding());
5039 emit_int8((unsigned char)0xFF);
5040 emit_int8((unsigned char)(0xC0 | encode));
5041 }
5042
5043 void Assembler::incq(Address dst) {
5044 // Don't use it directly. Use MacroAssembler::incrementq() instead.
|
1388 int encode = prefix_and_encode(dst->encoding(), src->encoding());
1389 emit_int8(0x0F);
1390 emit_int8((unsigned char)0xAF);
1391 emit_int8((unsigned char)(0xC0 | encode));
1392 }
1393
1394
1395 void Assembler::imull(Register dst, Register src, int value) {
1396 int encode = prefix_and_encode(dst->encoding(), src->encoding());
1397 if (is8bit(value)) {
1398 emit_int8(0x6B);
1399 emit_int8((unsigned char)(0xC0 | encode));
1400 emit_int8(value & 0xFF);
1401 } else {
1402 emit_int8(0x69);
1403 emit_int8((unsigned char)(0xC0 | encode));
1404 emit_int32(value);
1405 }
1406 }
1407
1408 void Assembler::imull(Register dst, Address src) {
1409 InstructionMark im(this);
1410 prefix(src, dst);
1411 emit_int8(0x0F);
1412 emit_int8((unsigned char) 0xAF);
1413 emit_operand(dst, src);
1414 }
1415
1416
1417 void Assembler::incl(Address dst) {
1418 // Don't use it directly. Use MacroAssembler::increment() instead.
1419 InstructionMark im(this);
1420 prefix(dst);
1421 emit_int8((unsigned char)0xFF);
1422 emit_operand(rax, dst);
1423 }
1424
1425 void Assembler::jcc(Condition cc, Label& L, bool maybe_short) {
1426 InstructionMark im(this);
1427 assert((0 <= cc) && (cc < 16), "illegal cc");
1428 if (L.is_bound()) {
1429 address dst = target(L);
1430 assert(dst != NULL, "jcc most probably wrong");
1431
1432 const int short_size = 2;
1433 const int long_size = 6;
1434 intptr_t offs = (intptr_t)dst - (intptr_t)pc();
1435 if (maybe_short && is8bit(offs - short_size)) {
1436 // 0111 tttn #8-bit disp
5014 }
5015
5016 void Assembler::imulq(Register dst, Register src) {
5017 int encode = prefixq_and_encode(dst->encoding(), src->encoding());
5018 emit_int8(0x0F);
5019 emit_int8((unsigned char)0xAF);
5020 emit_int8((unsigned char)(0xC0 | encode));
5021 }
5022
5023 void Assembler::imulq(Register dst, Register src, int value) {
5024 int encode = prefixq_and_encode(dst->encoding(), src->encoding());
5025 if (is8bit(value)) {
5026 emit_int8(0x6B);
5027 emit_int8((unsigned char)(0xC0 | encode));
5028 emit_int8(value & 0xFF);
5029 } else {
5030 emit_int8(0x69);
5031 emit_int8((unsigned char)(0xC0 | encode));
5032 emit_int32(value);
5033 }
5034 }
5035
5036 void Assembler::imulq(Register dst, Address src) {
5037 InstructionMark im(this);
5038 prefixq(src, dst);
5039 emit_int8(0x0F);
5040 emit_int8((unsigned char) 0xAF);
5041 emit_operand(dst, src);
5042 }
5043
5044 void Assembler::incl(Register dst) {
5045 // Don't use it directly. Use MacroAssembler::incrementl() instead.
5046 // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
5047 int encode = prefix_and_encode(dst->encoding());
5048 emit_int8((unsigned char)0xFF);
5049 emit_int8((unsigned char)(0xC0 | encode));
5050 }
5051
5052 void Assembler::incq(Register dst) {
5053 // Don't use it directly. Use MacroAssembler::incrementq() instead.
5054 // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
5055 int encode = prefixq_and_encode(dst->encoding());
5056 emit_int8((unsigned char)0xFF);
5057 emit_int8((unsigned char)(0xC0 | encode));
5058 }
5059
5060 void Assembler::incq(Address dst) {
5061 // Don't use it directly. Use MacroAssembler::incrementq() instead.
|