# HG changeset patch
# User redestad
# Date 1583420837 -3600
#      Thu Mar 05 16:07:17 2020 +0100
# Node ID 1f64f9df14c9c99f0b14da57563cd0db6b4535a3
# Parent  0d7a66c273693937fd3cd206d8333847cadaf35e
8241042: x86_64: Improve Assembler generation
Reviewed-by: vlivanov

diff --git a/src/hotspot/cpu/x86/assembler_x86.cpp b/src/hotspot/cpu/x86/assembler_x86.cpp
--- a/src/hotspot/cpu/x86/assembler_x86.cpp
+++ b/src/hotspot/cpu/x86/assembler_x86.cpp
@@ -248,9 +248,7 @@
   assert(isByte(op1) && isByte(op2), "wrong opcode");
   assert(isByte(imm8), "not a byte");
   assert((op1 & 0x01) == 0, "should be 8bit operation");
-  emit_int8(op1);
-  emit_int8(op2 | encode(dst));
-  emit_int8(imm8);
+  emit_int24(op1, op2 | encode(dst), imm8);
 }
 
 
@@ -259,12 +257,10 @@
   assert((op1 & 0x01) == 1, "should be 32bit operation");
   assert((op1 & 0x02) == 0, "sign-extension bit should not be set");
   if (is8bit(imm32)) {
-    emit_int8(op1 | 0x02); // set sign bit
-    emit_int8(op2 | encode(dst));
-    emit_int8(imm32 & 0xFF);
+     // set sign bit
+    emit_int24(op1 | 0x02, op2 | encode(dst), imm32 & 0xFF);
   } else {
-    emit_int8(op1);
-    emit_int8(op2 | encode(dst));
+    emit_int16(op1, op2 | encode(dst));
     emit_int32(imm32);
   }
 }
@@ -274,8 +270,7 @@
   assert(isByte(op1) && isByte(op2), "wrong opcode");
   assert((op1 & 0x01) == 1, "should be 32bit operation");
   assert((op1 & 0x02) == 0, "sign-extension bit should not be set");
-  emit_int8(op1);
-  emit_int8(op2 | encode(dst));
+  emit_int16(op1, op2 | encode(dst));
   emit_int32(imm32);
 }
 
@@ -297,8 +292,7 @@
 
 void Assembler::emit_arith(int op1, int op2, Register dst, Register src) {
   assert(isByte(op1) && isByte(op2), "wrong opcode");
-  emit_int8(op1);
-  emit_int8(op2 | encode(dst) << 3 | encode(src));
+  emit_int16(op1, op2 | encode(dst) << 3 | encode(src));
 }
 
 
@@ -480,73 +474,62 @@
                              Address::ScaleFactor scale, int disp,
                              RelocationHolder const& rspec,
                              int rip_relative_correction) {
-  relocInfo::relocType rtype = rspec.type();
+  bool no_relocation = rspec.type() == relocInfo::none;
 
   // Encode the registers as needed in the fields they are used in
-
   int regenc = encode(reg) << 3;
-  int indexenc = index->is_valid() ? encode(index) << 3 : 0;
-  int baseenc = base->is_valid() ? encode(base) : 0;
-
   if (base->is_valid()) {
+    int baseenc = encode(base);
     if (index->is_valid()) {
       assert(scale != Address::no_scale, "inconsistent address");
       // [base + index*scale + disp]
-      if (disp == 0 && rtype == relocInfo::none  &&
+      int indexenc = encode(index) << 3;
+      if (disp == 0 && no_relocation &&
           base != rbp LP64_ONLY(&& base != r13)) {
         // [base + index*scale]
         // [00 reg 100][ss index base]
         assert(index != rsp, "illegal addressing mode");
-        emit_int8(0x04 | regenc);
-        emit_int8(scale << 6 | indexenc | baseenc);
-      } else if (emit_compressed_disp_byte(disp) && rtype == relocInfo::none) {
+        emit_int16(0x04 | regenc, scale << 6 | indexenc | baseenc);
+      } else if (emit_compressed_disp_byte(disp) && no_relocation) {
         // [base + index*scale + imm8]
         // [01 reg 100][ss index base] imm8
         assert(index != rsp, "illegal addressing mode");
-        emit_int8(0x44 | regenc);
-        emit_int8(scale << 6 | indexenc | baseenc);
-        emit_int8(disp & 0xFF);
+        emit_int24(0x44 | regenc, scale << 6 | indexenc | baseenc, disp & 0xFF);
       } else {
         // [base + index*scale + disp32]
         // [10 reg 100][ss index base] disp32
         assert(index != rsp, "illegal addressing mode");
-        emit_int8(0x84 | regenc);
-        emit_int8(scale << 6 | indexenc | baseenc);
+        emit_int16(0x84 | regenc, scale << 6 | indexenc | baseenc);
         emit_data(disp, rspec, disp32_operand);
       }
     } else if (base == rsp LP64_ONLY(|| base == r12)) {
       // [rsp + disp]
-      if (disp == 0 && rtype == relocInfo::none) {
+      if (disp == 0 && no_relocation) {
         // [rsp]
         // [00 reg 100][00 100 100]
-        emit_int8(0x04 | regenc);
-        emit_int8(0x24);
-      } else if (emit_compressed_disp_byte(disp) && rtype == relocInfo::none) {
+        emit_int16(0x04 | regenc, 0x24);
+      } else if (emit_compressed_disp_byte(disp) && no_relocation) {
         // [rsp + imm8]
         // [01 reg 100][00 100 100] disp8
-        emit_int8(0x44 | regenc);
-        emit_int8(0x24);
-        emit_int8(disp & 0xFF);
+        emit_int24(0x44 | regenc, 0x24, disp & 0xFF);
       } else {
         // [rsp + imm32]
         // [10 reg 100][00 100 100] disp32
-        emit_int8(0x84 | regenc);
-        emit_int8(0x24);
+        emit_int16(0x84 | regenc, 0x24);
         emit_data(disp, rspec, disp32_operand);
       }
     } else {
       // [base + disp]
       assert(base != rsp LP64_ONLY(&& base != r12), "illegal addressing mode");
-      if (disp == 0 && rtype == relocInfo::none &&
+      if (disp == 0 && no_relocation &&
           base != rbp LP64_ONLY(&& base != r13)) {
         // [base]
         // [00 reg base]
         emit_int8(0x00 | regenc | baseenc);
-      } else if (emit_compressed_disp_byte(disp) && rtype == relocInfo::none) {
+      } else if (emit_compressed_disp_byte(disp) && no_relocation) {
         // [base + disp8]
         // [01 reg base] disp8
-        emit_int8(0x40 | regenc | baseenc);
-        emit_int8(disp & 0xFF);
+        emit_int16(0x40 | regenc | baseenc, disp & 0xFF);
       } else {
         // [base + disp32]
         // [10 reg base] disp32
@@ -560,10 +543,9 @@
       // [index*scale + disp]
       // [00 reg 100][ss index 101] disp32
       assert(index != rsp, "illegal addressing mode");
-      emit_int8(0x04 | regenc);
-      emit_int8(scale << 6 | indexenc | 0x05);
+      emit_int16(0x04 | regenc, scale << 6 | (encode(index) << 3) | 0x05);
       emit_data(disp, rspec, disp32_operand);
-    } else if (rtype != relocInfo::none ) {
+    } else if (!no_relocation) {
       // [disp] (64bit) RIP-RELATIVE (32bit) abs
       // [00 000 101] disp32
 
@@ -587,8 +569,7 @@
       // 32bit never did this, did everything as the rip-rel/disp code above
       // [disp] ABSOLUTE
       // [00 reg 100][00 100 101] disp32
-      emit_int8(0x04 | regenc);
-      emit_int8(0x25);
+      emit_int16(0x04 | regenc, 0x25);
       emit_data(disp, rspec, disp32_operand);
     }
   }
@@ -1148,8 +1129,7 @@
 void Assembler::emit_farith(int b1, int b2, int i) {
   assert(isByte(b1) && isByte(b2), "wrong opcode");
   assert(0 <= i &&  i < 8, "illegal stack offset");
-  emit_int8(b1);
-  emit_int8(b2 + i);
+  emit_int16(b1, b2 + i);
 }
 
 
@@ -1235,28 +1215,28 @@
 void Assembler::addr_nop_4() {
   assert(UseAddressNop, "no CPU support");
   // 4 bytes: NOP DWORD PTR [EAX+0]
-  emit_int8(0x0F);
-  emit_int8(0x1F);
-  emit_int8(0x40); // emit_rm(cbuf, 0x1, EAX_enc, EAX_enc);
-  emit_int8(0);    // 8-bits offset (1 byte)
+  emit_int32(0x0F,
+             0x1F,
+             0x40, // emit_rm(cbuf, 0x1, EAX_enc, EAX_enc);
+             0);   // 8-bits offset (1 byte)
 }
 
 void Assembler::addr_nop_5() {
   assert(UseAddressNop, "no CPU support");
   // 5 bytes: NOP DWORD PTR [EAX+EAX*0+0] 8-bits offset
-  emit_int8(0x0F);
-  emit_int8(0x1F);
-  emit_int8(0x44); // emit_rm(cbuf, 0x1, EAX_enc, 0x4);
-  emit_int8(0x00); // emit_rm(cbuf, 0x0, EAX_enc, EAX_enc);
-  emit_int8(0);    // 8-bits offset (1 byte)
+  emit_int32(0x0F,
+             0x1F,
+             0x44,  // emit_rm(cbuf, 0x1, EAX_enc, 0x4);
+             0x00); // emit_rm(cbuf, 0x0, EAX_enc, EAX_enc);
+  emit_int8(0);     // 8-bits offset (1 byte)
 }
 
 void Assembler::addr_nop_7() {
   assert(UseAddressNop, "no CPU support");
   // 7 bytes: NOP DWORD PTR [EAX+0] 32-bits offset
-  emit_int8(0x0F);
-  emit_int8(0x1F);
-  emit_int8((unsigned char)0x80);
+  emit_int24(0x0F,
+             0x1F,
+             (unsigned char)0x80);
                    // emit_rm(cbuf, 0x2, EAX_enc, EAX_enc);
   emit_int32(0);   // 32-bits offset (4 bytes)
 }
@@ -1264,12 +1244,12 @@
 void Assembler::addr_nop_8() {
   assert(UseAddressNop, "no CPU support");
   // 8 bytes: NOP DWORD PTR [EAX+EAX*0+0] 32-bits offset
-  emit_int8(0x0F);
-  emit_int8(0x1F);
-  emit_int8((unsigned char)0x84);
-                   // emit_rm(cbuf, 0x2, EAX_enc, 0x4);
-  emit_int8(0x00); // emit_rm(cbuf, 0x0, EAX_enc, EAX_enc);
-  emit_int32(0);   // 32-bits offset (4 bytes)
+  emit_int32(0x0F,
+             0x1F,
+             (unsigned char)0x84,
+                    // emit_rm(cbuf, 0x2, EAX_enc, 0x4);
+             0x00); // emit_rm(cbuf, 0x0, EAX_enc, EAX_enc);
+  emit_int32(0);    // 32-bits offset (4 bytes)
 }
 
 void Assembler::addsd(XMMRegister dst, XMMRegister src) {
@@ -1277,8 +1257,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::addsd(XMMRegister dst, Address src) {
@@ -1296,8 +1275,7 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::addss(XMMRegister dst, Address src) {
@@ -1323,8 +1301,7 @@
   assert(VM_Version::supports_aes(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDE);
-  emit_int8(0xC0 | encode);
+  emit_int16((unsigned char)0xDE, 0xC0 | encode);
 }
 
 void Assembler::vaesdec(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -1332,8 +1309,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDE);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDE, (unsigned char)(0xC0 | encode));
 }
 
 
@@ -1350,8 +1326,7 @@
   assert(VM_Version::supports_aes(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaesdeclast(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -1359,8 +1334,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::aesenc(XMMRegister dst, Address src) {
@@ -1376,8 +1350,7 @@
   assert(VM_Version::supports_aes(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDC);
-  emit_int8(0xC0 | encode);
+  emit_int16((unsigned char)0xDC, 0xC0 | encode);
 }
 
 void Assembler::vaesenc(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -1385,8 +1358,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::aesenclast(XMMRegister dst, Address src) {
@@ -1402,8 +1374,7 @@
   assert(VM_Version::supports_aes(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaesenclast(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -1411,8 +1382,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xDD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andl(Address dst, int32_t imm32) {
@@ -1444,8 +1414,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andnl(Register dst, Register src1, Address src2) {
@@ -1459,30 +1428,24 @@
 
 void Assembler::bsfl(Register dst, Register src) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::bsrl(Register dst, Register src) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::bswapl(Register reg) { // bswap
   int encode = prefix_and_encode(reg->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)(0xC8 | encode));
+  emit_int16(0x0F, (unsigned char)(0xC8 | encode));
 }
 
 void Assembler::blsil(Register dst, Register src) {
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rbx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsil(Register dst, Address src) {
@@ -1498,8 +1461,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rdx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsmskl(Register dst, Address src) {
@@ -1515,8 +1477,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rcx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsrl(Register dst, Address src) {
@@ -1552,8 +1513,7 @@
 
 void Assembler::call(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8((unsigned char)(0xD0 | encode));
+  emit_int16((unsigned char)0xFF, (unsigned char)(0xD0 | encode));
 }
 
 
@@ -1588,17 +1548,14 @@
 void Assembler::cmovl(Condition cc, Register dst, Register src) {
   NOT_LP64(guarantee(VM_Version::supports_cmov(), "illegal instruction"));
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8(0x40 | cc);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, 0x40 | cc, (unsigned char)(0xC0 | encode));
 }
 
 
 void Assembler::cmovl(Condition cc, Register dst, Address src) {
   NOT_LP64(guarantee(VM_Version::supports_cmov(), "illegal instruction"));
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8(0x40 | cc);
+  emit_int16(0x0F, 0x40 | cc);
   emit_operand(dst, src);
 }
 
@@ -1638,8 +1595,7 @@
 void Assembler::cmpw(Address dst, int imm16) {
   InstructionMark im(this);
   assert(!dst.base_needs_rex() && !dst.index_needs_rex(), "no extended registers");
-  emit_int8(0x66);
-  emit_int8((unsigned char)0x81);
+  emit_int16(0x66, (unsigned char)0x81);
   emit_operand(rdi, dst, 2);
   emit_int16(imm16);
 }
@@ -1650,8 +1606,7 @@
 void Assembler::cmpxchgl(Register reg, Address adr) { // cmpxchg
   InstructionMark im(this);
   prefix(adr, reg);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB1);
+  emit_int16(0x0F, (unsigned char)0xB1);
   emit_operand(reg, adr);
 }
 
@@ -1661,8 +1616,7 @@
 void Assembler::cmpxchgb(Register reg, Address adr) { // cmpxchg
   InstructionMark im(this);
   prefix(adr, reg, true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB0);
+  emit_int16(0x0F, (unsigned char)0xB0);
   emit_operand(reg, adr);
 }
 
@@ -1684,8 +1638,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::comiss(XMMRegister dst, Address src) {
@@ -1702,13 +1655,11 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cpuid() {
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xA2);
+  emit_int16(0x0F, (unsigned char)0xA2);
 }
 
 // Opcode / Instruction                      Op /  En  64 - Bit Mode     Compat / Leg Mode Description                  Implemented
@@ -1755,10 +1706,10 @@
     break;
   }
   LP64_ONLY(prefix(crc, v, p);)
-  emit_int8((int8_t)0x0F);
-  emit_int8(0x38);
-  emit_int8((int8_t)(0xF0 | w));
-  emit_int8(0xC0 | ((crc->encoding() & 0x7) << 3) | (v->encoding() & 7));
+  emit_int32((int8_t)0x0F,
+             0x38,
+             (int8_t)(0xF0 | w),
+             0xC0 | ((crc->encoding() & 0x7) << 3) | (v->encoding() & 7));
 }
 
 void Assembler::crc32(Register crc, Address adr, int8_t sizeInBytes) {
@@ -1784,9 +1735,7 @@
     break;
   }
   LP64_ONLY(prefix(crc, adr, p);)
-  emit_int8((int8_t)0x0F);
-  emit_int8(0x38);
-  emit_int8((int8_t)(0xF0 | w));
+  emit_int24(0x0F, 0x38, (unsigned char)(0xF0 | w));
   emit_operand(crc, adr);
 }
 
@@ -1794,16 +1743,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE6);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE6, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtdq2ps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5B, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtsd2ss(XMMRegister dst, XMMRegister src) {
@@ -1811,8 +1758,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtsd2ss(XMMRegister dst, Address src) {
@@ -1830,8 +1776,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtsi2sdl(XMMRegister dst, Address src) {
@@ -1848,8 +1793,7 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtsi2ssl(XMMRegister dst, Address src) {
@@ -1866,16 +1810,14 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtss2sd(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtss2sd(XMMRegister dst, Address src) {
@@ -1893,16 +1835,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvttss2sil(Register dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvttpd2dq(XMMRegister dst, XMMRegister src) {
@@ -1910,32 +1850,28 @@
   int vector_len = VM_Version::supports_avx512novl() ? AVX_512bit : AVX_128bit;
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE6);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE6, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pabsb(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_ssse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x1C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pabsw(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_ssse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x1D);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1D, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pabsd(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_ssse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x1E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpabsb(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -1944,8 +1880,7 @@
   vector_len == AVX_512bit? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0x1C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpabsw(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -1954,8 +1889,7 @@
   vector_len == AVX_512bit? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0x1D);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1D, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpabsd(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -1964,8 +1898,7 @@
   vector_len == AVX_512bit? VM_Version::supports_evex() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0x1E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpabsq(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -1973,8 +1906,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0x1F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x1F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::decl(Address dst) {
@@ -2001,8 +1933,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::divss(XMMRegister dst, Address src) {
@@ -2019,14 +1950,12 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::emms() {
   NOT_LP64(assert(VM_Version::supports_mmx(), ""));
-  emit_int8(0x0F);
-  emit_int8(0x77);
+  emit_int16(0x0F, 0x77);
 }
 
 void Assembler::hlt() {
@@ -2035,39 +1964,31 @@
 
 void Assembler::idivl(Register src) {
   int encode = prefix_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xF8 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xF8 | encode));
 }
 
 void Assembler::divl(Register src) { // Unsigned
   int encode = prefix_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xF0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xF0 | encode));
 }
 
 void Assembler::imull(Register src) {
   int encode = prefix_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xE8 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xE8 | encode));
 }
 
 void Assembler::imull(Register dst, Register src) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xAF, (unsigned char)(0xC0 | encode));
 }
 
 
 void Assembler::imull(Register dst, Register src, int value) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
   if (is8bit(value)) {
-    emit_int8(0x6B);
-    emit_int8((unsigned char)(0xC0 | encode));
-    emit_int8(value & 0xFF);
+    emit_int24(0x6B, (unsigned char)(0xC0 | encode), value & 0xFF);
   } else {
-    emit_int8(0x69);
-    emit_int8((unsigned char)(0xC0 | encode));
+    emit_int16(0x69, (unsigned char)(0xC0 | encode));
     emit_int32(value);
   }
 }
@@ -2075,8 +1996,7 @@
 void Assembler::imull(Register dst, Address src) {
   InstructionMark im(this);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char) 0xAF);
+  emit_int16(0x0F, (unsigned char) 0xAF);
   emit_operand(dst, src);
 }
 
@@ -2101,14 +2021,12 @@
     intptr_t offs = (intptr_t)dst - (intptr_t)pc();
     if (maybe_short && is8bit(offs - short_size)) {
       // 0111 tttn #8-bit disp
-      emit_int8(0x70 | cc);
-      emit_int8((offs - short_size) & 0xFF);
+      emit_int16(0x70 | cc, (offs - short_size) & 0xFF);
     } else {
       // 0000 1111 1000 tttn #32-bit disp
       assert(is_simm32(offs - long_size),
              "must be 32bit offset (call4)");
-      emit_int8(0x0F);
-      emit_int8((unsigned char)(0x80 | cc));
+      emit_int16(0x0F, (unsigned char)(0x80 | cc));
       emit_int32(offs - long_size);
     }
   } else {
@@ -2117,8 +2035,7 @@
     // Note: use jccb() if label to be bound is very close to get
     //       an 8-bit displacement
     L.add_patch_at(code(), locator());
-    emit_int8(0x0F);
-    emit_int8((unsigned char)(0x80 | cc));
+    emit_int16(0x0F, (unsigned char)(0x80 | cc));
     emit_int32(0);
   }
 }
@@ -2137,13 +2054,11 @@
 #endif
     intptr_t offs = (intptr_t)entry - (intptr_t)pc();
     // 0111 tttn #8-bit disp
-    emit_int8(0x70 | cc);
-    emit_int8((offs - short_size) & 0xFF);
+    emit_int16(0x70 | cc, (offs - short_size) & 0xFF);
   } else {
     InstructionMark im(this);
     L.add_patch_at(code(), locator(), file, line);
-    emit_int8(0x70 | cc);
-    emit_int8(0);
+    emit_int16(0x70 | cc, 0);
   }
 }
 
@@ -2163,8 +2078,7 @@
     const int long_size = 5;
     intptr_t offs = entry - pc();
     if (maybe_short && is8bit(offs - short_size)) {
-      emit_int8((unsigned char)0xEB);
-      emit_int8((offs - short_size) & 0xFF);
+      emit_int16((unsigned char)0xEB, (offs - short_size) & 0xFF);
     } else {
       emit_int8((unsigned char)0xE9);
       emit_int32(offs - long_size);
@@ -2183,8 +2097,7 @@
 
 void Assembler::jmp(Register entry) {
   int encode = prefix_and_encode(entry->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8((unsigned char)(0xE0 | encode));
+  emit_int16((unsigned char)0xFF, (unsigned char)(0xE0 | encode));
 }
 
 void Assembler::jmp_literal(address dest, RelocationHolder const& rspec) {
@@ -2210,13 +2123,11 @@
     assert(is8bit(dist), "Dispacement too large for a short jmp at %s:%d", file, line);
 #endif
     intptr_t offs = entry - pc();
-    emit_int8((unsigned char)0xEB);
-    emit_int8((offs - short_size) & 0xFF);
+    emit_int16((unsigned char)0xEB, (offs - short_size) & 0xFF);
   } else {
     InstructionMark im(this);
     L.add_patch_at(code(), locator(), file, line);
-    emit_int8((unsigned char)0xEB);
-    emit_int8(0);
+    emit_int16((unsigned char)0xEB, 0);
   }
 }
 
@@ -2231,8 +2142,7 @@
     NOT_LP64(assert(VM_Version::supports_sse(), ""));
     InstructionMark im(this);
     prefix(src);
-    emit_int8(0x0F);
-    emit_int8((unsigned char)0xAE);
+    emit_int16(0x0F, (unsigned char)0xAE);
     emit_operand(as_Register(2), src);
   }
 }
@@ -2248,9 +2158,7 @@
 }
 
 void Assembler::lfence() {
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
-  emit_int8((unsigned char)0xE8);
+  emit_int24(0x0F, (unsigned char)0xAE, (unsigned char)0xE8);
 }
 
 void Assembler::lock() {
@@ -2261,25 +2169,19 @@
   assert(VM_Version::supports_lzcnt(), "encoding is treated as BSR");
   emit_int8((unsigned char)0xF3);
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBD, (unsigned char)(0xC0 | encode));
 }
 
 // Emit mfence instruction
 void Assembler::mfence() {
   NOT_LP64(assert(VM_Version::supports_sse2(), "unsupported");)
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
-  emit_int8((unsigned char)0xF0);
+  emit_int24(0x0F, (unsigned char)0xAE, (unsigned char)0xF0);
 }
 
 // Emit sfence instruction
 void Assembler::sfence() {
   NOT_LP64(assert(VM_Version::supports_sse2(), "unsupported");)
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
-  emit_int8((unsigned char)0xF8);
+  emit_int24(0x0F, (unsigned char)0xAE, (unsigned char)0xF8);
 }
 
 void Assembler::mov(Register dst, Register src) {
@@ -2292,8 +2194,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x28);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x28, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movaps(XMMRegister dst, XMMRegister src) {
@@ -2301,16 +2202,14 @@
   int vector_len = VM_Version::supports_avx512novl() ? AVX_512bit : AVX_128bit;
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x28);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x28, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movlhps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, src, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x16);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x16, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movb(Register dst, Address src) {
@@ -2327,40 +2226,35 @@
   InstructionAttr attributes(vector_len, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x12);
-  emit_int8(0xC0 | encode);
+  emit_int16(0x12, 0xC0 | encode);
 }
 
 void Assembler::kmovbl(KRegister dst, Register src) {
   assert(VM_Version::supports_avx512dq(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x92);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x92, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovbl(Register dst, KRegister src) {
   assert(VM_Version::supports_avx512dq(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x93);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x93, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovwl(KRegister dst, Register src) {
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x92);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x92, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovwl(Register dst, KRegister src) {
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x93);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x93, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovwl(KRegister dst, Address src) {
@@ -2376,24 +2270,21 @@
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x92);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x92, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovdl(Register dst, KRegister src) {
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x93);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x93, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovql(KRegister dst, KRegister src) {
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x90);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x90, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovql(KRegister dst, Address src) {
@@ -2418,24 +2309,21 @@
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x92);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x92, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::kmovql(Register dst, KRegister src) {
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x93);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x93, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::knotwl(KRegister dst, KRegister src) {
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x44);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x44, (unsigned char)(0xC0 | encode));
 }
 
 // This instruction produces ZF or CF flags
@@ -2443,8 +2331,7 @@
   assert(VM_Version::supports_avx512dq(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x98);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x98, (unsigned char)(0xC0 | encode));
 }
 
 // This instruction produces ZF or CF flags
@@ -2452,8 +2339,7 @@
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x98);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x98, (unsigned char)(0xC0 | encode));
 }
 
 // This instruction produces ZF or CF flags
@@ -2461,8 +2347,7 @@
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x98);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x98, (unsigned char)(0xC0 | encode));
 }
 
 // This instruction produces ZF or CF flags
@@ -2470,8 +2355,7 @@
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x98);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x98, (unsigned char)(0xC0 | encode));
 }
 
 // This instruction produces ZF or CF flags
@@ -2479,24 +2363,21 @@
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x99);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x99, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::ktestq(KRegister src1, KRegister src2) {
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x99);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x99, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::ktestd(KRegister src1, KRegister src2) {
   assert(VM_Version::supports_avx512bw(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(src1->encoding(), 0, src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x99);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x99, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movb(Address dst, int imm8) {
@@ -2520,8 +2401,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, as_XMMRegister(src->encoding()), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdl(Register dst, XMMRegister src) {
@@ -2529,8 +2409,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   // swap src/dst to get correct prefix
   int encode = simd_prefix_and_encode(src, xnoreg, as_XMMRegister(dst->encoding()), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x7E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdl(XMMRegister dst, Address src) {
@@ -2557,8 +2436,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdqa(XMMRegister dst, Address src) {
@@ -2585,8 +2463,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdqu(Address dst, XMMRegister src) {
@@ -2605,8 +2482,7 @@
   assert(UseAVX > 0, "");
   InstructionAttr attributes(AVX_256bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmovdqu(XMMRegister dst, Address src) {
@@ -2639,8 +2515,7 @@
   attributes.set_is_evex_instruction();
   int prefix = (_legacy_mode_bw) ? VEX_SIMD_F2 : VEX_SIMD_F3;
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), (Assembler::VexSimdPrefix)prefix, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evmovdqub(XMMRegister dst, Address src, int vector_len) {
@@ -2736,8 +2611,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evmovdqul(XMMRegister dst, Address src, int vector_len) {
@@ -2769,8 +2643,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evmovdquq(XMMRegister dst, Address src, int vector_len) {
@@ -2807,8 +2680,7 @@
 
 void Assembler::movl(Register dst, Register src) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x8B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x8B, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movl(Register dst, Address src) {
@@ -2849,15 +2721,13 @@
 
 void Assembler::movq( MMXRegister dst, Address src ) {
   assert( VM_Version::supports_mmx(), "" );
-  emit_int8(0x0F);
-  emit_int8(0x6F);
+  emit_int16(0x0F, 0x6F);
   emit_operand(dst, src);
 }
 
 void Assembler::movq( Address dst, MMXRegister src ) {
   assert( VM_Version::supports_mmx(), "" );
-  emit_int8(0x0F);
-  emit_int8(0x7F);
+  emit_int16(0x0F, 0x7F);
   // workaround gcc (3.2.1-7a) bug
   // In that version of gcc with only an emit_operand(MMX, Address)
   // gcc will tail jump and try and reverse the parameters completely
@@ -2892,17 +2762,14 @@
 void Assembler::movsbl(Register dst, Address src) { // movsxb
   InstructionMark im(this);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBE);
+  emit_int16(0x0F, (unsigned char)0xBE);
   emit_operand(dst, src);
 }
 
 void Assembler::movsbl(Register dst, Register src) { // movsxb
   NOT_LP64(assert(src->has_byte_register(), "must have byte register"));
   int encode = prefix_and_encode(dst->encoding(), false, src->encoding(), true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBE);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBE, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movsd(XMMRegister dst, XMMRegister src) {
@@ -2910,8 +2777,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x10);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x10, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movsd(XMMRegister dst, Address src) {
@@ -2941,8 +2807,7 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x10);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x10, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movss(XMMRegister dst, Address src) {
@@ -2969,16 +2834,13 @@
 void Assembler::movswl(Register dst, Address src) { // movsxw
   InstructionMark im(this);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBF);
+  emit_int16(0x0F, (unsigned char)0xBF);
   emit_operand(dst, src);
 }
 
 void Assembler::movswl(Register dst, Register src) { // movsxw
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movw(Address dst, int imm16) {
@@ -3010,32 +2872,26 @@
 void Assembler::movzbl(Register dst, Address src) { // movzxb
   InstructionMark im(this);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB6);
+  emit_int16(0x0F, (unsigned char)0xB6);
   emit_operand(dst, src);
 }
 
 void Assembler::movzbl(Register dst, Register src) { // movzxb
   NOT_LP64(assert(src->has_byte_register(), "must have byte register"));
   int encode = prefix_and_encode(dst->encoding(), false, src->encoding(), true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB6);
-  emit_int8(0xC0 | encode);
+  emit_int24(0x0F, (unsigned char)0xB6, 0xC0 | encode);
 }
 
 void Assembler::movzwl(Register dst, Address src) { // movzxw
   InstructionMark im(this);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB7);
+  emit_int16(0x0F, (unsigned char)0xB7);
   emit_operand(dst, src);
 }
 
 void Assembler::movzwl(Register dst, Register src) { // movzxw
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB7);
-  emit_int8(0xC0 | encode);
+  emit_int24(0x0F, (unsigned char)0xB7, 0xC0 | encode);
 }
 
 void Assembler::mull(Address src) {
@@ -3047,8 +2903,7 @@
 
 void Assembler::mull(Register src) {
   int encode = prefix_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xE0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xE0 | encode));
 }
 
 void Assembler::mulsd(XMMRegister dst, Address src) {
@@ -3067,8 +2922,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::mulss(XMMRegister dst, Address src) {
@@ -3085,14 +2939,12 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::negl(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xD8 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xD8 | encode));
 }
 
 void Assembler::nop(int i) {
@@ -3133,15 +2985,9 @@
     while(i >= 15) {
       // For Intel don't generate consecutive addess nops (mix with regular nops)
       i -= 15;
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
+      emit_int24(0x66, 0x66, 0x66);
       addr_nop_8();
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8((unsigned char)0x90);
-                         // nop
+      emit_int32(0x66, 0x66, 0x66, (unsigned char)0x90);
     }
     switch (i) {
       case 14:
@@ -3150,11 +2996,7 @@
         emit_int8(0x66); // size prefix
       case 12:
         addr_nop_8();
-        emit_int8(0x66); // size prefix
-        emit_int8(0x66); // size prefix
-        emit_int8(0x66); // size prefix
-        emit_int8((unsigned char)0x90);
-                         // nop
+        emit_int32(0x66, 0x66, 0x66, (unsigned char)0x90);
         break;
       case 11:
         emit_int8(0x66); // size prefix
@@ -3216,9 +3058,7 @@
 
     while(i >= 22) {
       i -= 11;
-      emit_int8(0x66); // size prefix
-      emit_int8(0x66); // size prefix
-      emit_int8(0x66); // size prefix
+      emit_int24(0x66, 0x66, 0x66);
       addr_nop_8();
     }
     // Generate first nop for size between 21-12
@@ -3315,15 +3155,9 @@
     while (i >= 15) {
       // For ZX don't generate consecutive addess nops (mix with regular nops)
       i -= 15;
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
+      emit_int24(0x66, 0x66, 0x66);
       addr_nop_8();
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8(0x66);   // size prefix
-      emit_int8((unsigned char)0x90);
-                         // nop
+      emit_int32(0x66, 0x66, 0x66, (unsigned char)0x90);
     }
     switch (i) {
       case 14:
@@ -3332,11 +3166,7 @@
         emit_int8(0x66); // size prefix
       case 12:
         addr_nop_8();
-        emit_int8(0x66); // size prefix
-        emit_int8(0x66); // size prefix
-        emit_int8(0x66); // size prefix
-        emit_int8((unsigned char)0x90);
-                         // nop
+        emit_int32(0x66, 0x66, 0x66, (unsigned char)0x90);
         break;
       case 11:
         emit_int8(0x66); // size prefix
@@ -3386,35 +3216,27 @@
   //  9: 0x66 0x66 0x90 0x66 0x66 0x90 0x66 0x66 0x90
   // 10: 0x66 0x66 0x66 0x90 0x66 0x66 0x90 0x66 0x66 0x90
   //
-  while(i > 12) {
+  while (i > 12) {
     i -= 4;
-    emit_int8(0x66); // size prefix
-    emit_int8(0x66);
-    emit_int8(0x66);
-    emit_int8((unsigned char)0x90);
-                     // nop
+    emit_int32(0x66, 0x66, 0x66, (unsigned char)0x90);
   }
   // 1 - 12 nops
-  if(i > 8) {
-    if(i > 9) {
+  if (i > 8) {
+    if (i > 9) {
       i -= 1;
       emit_int8(0x66);
     }
     i -= 3;
-    emit_int8(0x66);
-    emit_int8(0x66);
-    emit_int8((unsigned char)0x90);
+    emit_int24(0x66, 0x66, (unsigned char)0x90);
   }
   // 1 - 8 nops
-  if(i > 4) {
-    if(i > 6) {
+  if (i > 4) {
+    if (i > 6) {
       i -= 1;
       emit_int8(0x66);
     }
     i -= 3;
-    emit_int8(0x66);
-    emit_int8(0x66);
-    emit_int8((unsigned char)0x90);
+    emit_int24(0x66, 0x66, (unsigned char)0x90);
   }
   switch (i) {
     case 4:
@@ -3433,8 +3255,7 @@
 
 void Assembler::notl(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xD0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xD0 | encode));
 }
 
 void Assembler::orl(Address dst, int32_t imm32) {
@@ -3490,25 +3311,21 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x67);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x67, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpackuswb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "some form of AVX must be enabled");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x67);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x67, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpermq(XMMRegister dst, XMMRegister src, int imm8, int vector_len) {
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x00);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x00, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::vpermq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -3516,26 +3333,21 @@
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0x36);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x36, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vperm2i128(XMMRegister dst,  XMMRegister nds, XMMRegister src, int imm8) {
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(AVX_256bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x46);
-  emit_int8(0xC0 | encode);
-  emit_int8(imm8);
+  emit_int24(0x46, 0xC0 | encode, imm8);
 }
 
 void Assembler::vperm2f128(XMMRegister dst, XMMRegister nds, XMMRegister src, int imm8) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_256bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x06);
-  emit_int8(0xC0 | encode);
-  emit_int8(imm8);
+  emit_int24(0x06, 0xC0 | encode, imm8);
 }
 
 void Assembler::evpermi2q(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -3543,19 +3355,16 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x76);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x76, (unsigned char)(0xC0 | encode));
 }
 
 
 void Assembler::pause() {
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)0x90);
+  emit_int16((unsigned char)0xF3, (unsigned char)0x90);
 }
 
 void Assembler::ud2() {
-  emit_int8(0x0F);
-  emit_int8(0x0B);
+  emit_int16(0x0F, 0x0B);
 }
 
 void Assembler::pcmpestri(XMMRegister dst, Address src, int imm8) {
@@ -3572,9 +3381,7 @@
   assert(VM_Version::supports_sse4_2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x61);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x61, (unsigned char)(0xC0 | encode), imm8);
 }
 
 // In this context, the dst vector contains the components that are equal, non equal components are zeroed in dst
@@ -3582,8 +3389,7 @@
   assert(VM_Version::supports_sse2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x74);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x74, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, the dst vector contains the components that are equal, non equal components are zeroed in dst
@@ -3591,8 +3397,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x74);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x74, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, kdst is written the mask used to process the equal components
@@ -3601,8 +3406,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x74);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x74, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpcmpgtb(KRegister kdst, XMMRegister nds, Address src, int vector_len) {
@@ -3636,9 +3440,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x3E);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(vcc);
+  emit_int24(0x3E, (unsigned char)(0xC0 | encode), vcc);
 }
 
 void Assembler::evpcmpuw(KRegister kdst, KRegister mask, XMMRegister nds, XMMRegister src, ComparisonPredicate vcc, int vector_len) {
@@ -3648,9 +3450,7 @@
   attributes.set_embedded_opmask_register_specifier(mask);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x3E);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(vcc);
+  emit_int24(0x3E, (unsigned char)(0xC0 | encode), vcc);
 }
 
 void Assembler::evpcmpuw(KRegister kdst, XMMRegister nds, Address src, ComparisonPredicate vcc, int vector_len) {
@@ -3696,8 +3496,7 @@
   assert(VM_Version::supports_sse2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x75);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x75, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, the dst vector contains the components that are equal, non equal components are zeroed in dst
@@ -3705,8 +3504,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x75);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x75, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, kdst is written the mask used to process the equal components
@@ -3715,8 +3513,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x75);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x75, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpcmpeqw(KRegister kdst, XMMRegister nds, Address src, int vector_len) {
@@ -3745,8 +3542,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x76);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x76, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, kdst is written the mask used to process the equal components
@@ -3756,8 +3552,7 @@
   attributes.set_is_evex_instruction();
   attributes.reset_is_clear_context();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x76);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x76, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpcmpeqd(KRegister kdst, XMMRegister nds, Address src, int vector_len) {
@@ -3778,8 +3573,7 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x29);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x29, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, the dst vector contains the components that are equal, non equal components are zeroed in dst
@@ -3787,8 +3581,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x29);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x29, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, kdst is written the mask used to process the equal components
@@ -3798,8 +3591,7 @@
   attributes.reset_is_clear_context();
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(kdst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x29);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x29, (unsigned char)(0xC0 | encode));
 }
 
 // In this context, kdst is written the mask used to process the equal components
@@ -3820,25 +3612,21 @@
   assert(VM_Version::supports_sse2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD7);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD7, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmovmskb(Register dst, XMMRegister src) {
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(AVX_256bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD7);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD7, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pextrd(Register dst, XMMRegister src, int imm8) {
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(src, xnoreg, as_XMMRegister(dst->encoding()), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x16);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x16, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pextrd(Address dst, XMMRegister src, int imm8) {
@@ -3855,9 +3643,7 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(src, xnoreg, as_XMMRegister(dst->encoding()), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x16);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x16, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pextrq(Address dst, XMMRegister src, int imm8) {
@@ -3874,9 +3660,7 @@
   assert(VM_Version::supports_sse2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xC5);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xC5, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pextrw(Address dst, XMMRegister src, int imm8) {
@@ -3903,9 +3687,7 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x22);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x22, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pinsrd(XMMRegister dst, Address src, int imm8) {
@@ -3922,9 +3704,7 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x22);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x22, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pinsrq(XMMRegister dst, Address src, int imm8) {
@@ -3941,9 +3721,7 @@
   assert(VM_Version::supports_sse2(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xC4);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xC4, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pinsrw(XMMRegister dst, Address src, int imm8) {
@@ -3980,16 +3758,14 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x30);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x30, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pmovsxbw(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x20);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x20, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmovzxbw(XMMRegister dst, Address src, int vector_len) {
@@ -4009,8 +3785,7 @@
   vector_len == AVX_512bit? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x30);
-  emit_int8((unsigned char) (0xC0 | encode));
+  emit_int16(0x30, (unsigned char) (0xC0 | encode));
 }
 
 void Assembler::vpmovsxbw(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -4019,8 +3794,7 @@
   vector_len == AVX_512bit? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x20);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x20, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpmovzxbw(XMMRegister dst, KRegister mask, Address src, int vector_len) {
@@ -4079,16 +3853,14 @@
   vector_len == AVX_512bit? VM_Version::supports_evex() : 0, " ");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x33);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x33, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pmaddwd(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF5);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF5, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmaddwd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -4097,8 +3869,7 @@
     (vector_len == AVX_512bit ? VM_Version::supports_evex() : 0)), "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, nds, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF5);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF5, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpdpwssd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -4107,8 +3878,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x52);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x52, (unsigned char)(0xC0 | encode));
 }
 
 // generic
@@ -4122,8 +3892,7 @@
   InstructionMark im(this);
   emit_int8((unsigned char)0xF3);
   prefix(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB8);
+  emit_int16(0x0F, (unsigned char)0xB8);
   emit_operand(dst, src);
 }
 
@@ -4131,9 +3900,7 @@
   assert(VM_Version::supports_popcnt(), "must support");
   emit_int8((unsigned char)0xF3);
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xB8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpopcntd(XMMRegister dst, XMMRegister src, int vector_len) {
@@ -4141,8 +3908,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x55);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x55, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::popf() {
@@ -4159,56 +3925,51 @@
 }
 #endif
 
-void Assembler::prefetch_prefix(Address src) {
-  prefix(src);
-  emit_int8(0x0F);
-}
-
 void Assembler::prefetchnta(Address src) {
   NOT_LP64(assert(VM_Version::supports_sse(), "must support"));
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x18);
+  prefix(src);
+  emit_int16(0x0F, 0x18);
   emit_operand(rax, src); // 0, src
 }
 
 void Assembler::prefetchr(Address src) {
   assert(VM_Version::supports_3dnow_prefetch(), "must support");
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x0D);
+  prefix(src);
+  emit_int16(0x0F, 0x0D);
   emit_operand(rax, src); // 0, src
 }
 
 void Assembler::prefetcht0(Address src) {
   NOT_LP64(assert(VM_Version::supports_sse(), "must support"));
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x18);
+  prefix(src);
+  emit_int16(0x0F, 0x18);
   emit_operand(rcx, src); // 1, src
 }
 
 void Assembler::prefetcht1(Address src) {
   NOT_LP64(assert(VM_Version::supports_sse(), "must support"));
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x18);
+  prefix(src);
+  emit_int16(0x0F, 0x18);
   emit_operand(rdx, src); // 2, src
 }
 
 void Assembler::prefetcht2(Address src) {
   NOT_LP64(assert(VM_Version::supports_sse(), "must support"));
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x18);
+  prefix(src);
+  emit_int16(0x0F, 0x18);
   emit_operand(rbx, src); // 3, src
 }
 
 void Assembler::prefetchw(Address src) {
   assert(VM_Version::supports_3dnow_prefetch(), "must support");
   InstructionMark im(this);
-  prefetch_prefix(src);
-  emit_int8(0x0D);
+  prefix(src);
+  emit_int16(0x0F, 0x0D);
   emit_operand(rcx, src); // 1, src
 }
 
@@ -4220,8 +3981,7 @@
   assert(VM_Version::supports_ssse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x00);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x00, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpshufb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -4230,8 +3990,7 @@
          vector_len == AVX_512bit? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, nds, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x00);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x00, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pshufb(XMMRegister dst, Address src) {
@@ -4250,9 +4009,7 @@
   int vector_len = VM_Version::supports_avx512novl() ? AVX_512bit : AVX_128bit;
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x70);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(mode & 0xFF);
+  emit_int24(0x70, (unsigned char)(0xC0 | encode), mode & 0xFF);
 }
 
 void Assembler::vpshufd(XMMRegister dst, XMMRegister src, int mode, int vector_len) {
@@ -4262,9 +4019,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x70);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(mode & 0xFF);
+  emit_int24(0x70, (unsigned char)(0xC0 | encode), mode & 0xFF);
 }
 
 void Assembler::pshufd(XMMRegister dst, Address src, int mode) {
@@ -4285,9 +4040,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x70);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(mode & 0xFF);
+  emit_int24(0x70, (unsigned char)(0xC0 | encode), mode & 0xFF);
 }
 
 void Assembler::pshuflw(XMMRegister dst, Address src, int mode) {
@@ -4309,9 +4062,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x43);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8 & 0xFF);
+  emit_int24(0x43, (unsigned char)(0xC0 | encode), imm8 & 0xFF);
 }
 
 void Assembler::psrldq(XMMRegister dst, int shift) {
@@ -4319,9 +4070,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(xmm3, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift);
 }
 
 void Assembler::vpsrldq(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -4330,9 +4079,7 @@
          vector_len == AVX_512bit ? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /*vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(xmm3->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::pslldq(XMMRegister dst, int shift) {
@@ -4341,9 +4088,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM7 is for /7 encoding: 66 0F 73 /7 ib
   int encode = simd_prefix_and_encode(xmm7, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift);
 }
 
 void Assembler::vpslldq(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -4352,9 +4097,7 @@
          vector_len == AVX_512bit ? VM_Version::supports_avx512bw() : 0, "");
   InstructionAttr attributes(vector_len, /*vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(xmm7->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::ptest(XMMRegister dst, Address src) {
@@ -4390,8 +4133,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_256bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x17);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x17, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::punpcklbw(XMMRegister dst, Address src) {
@@ -4409,8 +4151,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_vlbw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x60);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x60, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::punpckldq(XMMRegister dst, Address src) {
@@ -4428,8 +4169,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x62);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x62, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::punpcklqdq(XMMRegister dst, XMMRegister src) {
@@ -4437,8 +4177,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::push(int32_t imm32) {
@@ -4450,7 +4189,6 @@
 
 void Assembler::push(Register src) {
   int encode = prefix_and_encode(src->encoding());
-
   emit_int8(0x50 | encode);
 }
 
@@ -4472,12 +4210,9 @@
   assert(isShiftCount(imm8), "illegal shift count");
   int encode = prefix_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xD0 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xD0 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)0xD0 | encode);
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)0xD0 | encode, imm8);
   }
 }
 
@@ -4485,63 +4220,60 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x53);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x53, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::rcpss(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x53);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x53, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::rdtsc() {
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0x31);
+  emit_int16((unsigned char)0x0F, (unsigned char)0x31);
 }
 
 // copies data from [esi] to [edi] using rcx pointer sized words
 // generic
 void Assembler::rep_mov() {
-  emit_int8((unsigned char)0xF3);
+  // REP
   // MOVSQ
-  LP64_ONLY(prefix(REX_W));
-  emit_int8((unsigned char)0xA5);
+  LP64_ONLY(emit_int24((unsigned char)0xF3, REX_W, (unsigned char)0xA5);)
+  NOT_LP64( emit_int16((unsigned char)0xF3,        (unsigned char)0xA5);)
 }
 
 // sets rcx bytes with rax, value at [edi]
 void Assembler::rep_stosb() {
-  emit_int8((unsigned char)0xF3); // REP
-  LP64_ONLY(prefix(REX_W));
-  emit_int8((unsigned char)0xAA); // STOSB
+  // REP
+  // STOSB
+  LP64_ONLY(emit_int24((unsigned char)0xF3, REX_W, (unsigned char)0xAA);)
+  NOT_LP64( emit_int16((unsigned char)0xF3,        (unsigned char)0xAA);)
 }
 
 // sets rcx pointer sized words with rax, value at [edi]
 // generic
 void Assembler::rep_stos() {
-  emit_int8((unsigned char)0xF3); // REP
-  LP64_ONLY(prefix(REX_W));       // LP64:STOSQ, LP32:STOSD
-  emit_int8((unsigned char)0xAB);
+  // REP
+  // LP64:STOSQ, LP32:STOSD
+  LP64_ONLY(emit_int24((unsigned char)0xF3, REX_W, (unsigned char)0xAB);)
+  NOT_LP64( emit_int16((unsigned char)0xF3,        (unsigned char)0xAB);)
 }
 
 // scans rcx pointer sized words at [edi] for occurance of rax,
 // generic
 void Assembler::repne_scan() { // repne_scan
-  emit_int8((unsigned char)0xF2);
   // SCASQ
-  LP64_ONLY(prefix(REX_W));
-  emit_int8((unsigned char)0xAF);
+  LP64_ONLY(emit_int24((unsigned char)0xF2, REX_W, (unsigned char)0xAF);)
+  NOT_LP64( emit_int16((unsigned char)0xF2,        (unsigned char)0xAF);)
 }
 
 #ifdef _LP64
 // scans rcx 4 byte words at [edi] for occurance of rax,
 // generic
 void Assembler::repne_scanl() { // repne_scan
-  emit_int8((unsigned char)0xF2);
   // SCASL
-  emit_int8((unsigned char)0xAF);
+  emit_int16((unsigned char)0xF2, (unsigned char)0xAF);
 }
 #endif
 
@@ -4566,19 +4298,15 @@
   int encode = prefix_and_encode(dst->encoding());
   assert(isShiftCount(imm8), "illegal shift count");
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xF8 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xF8 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xF8 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xF8 | encode), imm8);
   }
 }
 
 void Assembler::sarl(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xF8 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xF8 | encode));
 }
 
 void Assembler::sbbl(Address dst, int32_t imm32) {
@@ -4608,18 +4336,14 @@
 void Assembler::setb(Condition cc, Register dst) {
   assert(0 <= cc && cc < 16, "illegal cc");
   int encode = prefix_and_encode(dst->encoding(), true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0x90 | cc);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0x90 | cc, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::palignr(XMMRegister dst, XMMRegister src, int imm8) {
   assert(VM_Version::supports_ssse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0x0F, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::vpalignr(XMMRegister dst, XMMRegister nds, XMMRegister src, int imm8, int vector_len) {
@@ -4628,9 +4352,7 @@
          0, "");
   InstructionAttr attributes(vector_len, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, nds, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0x0F, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::evalignq(XMMRegister dst, XMMRegister nds, XMMRegister src, uint8_t imm8) {
@@ -4638,69 +4360,57 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x3);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24(0x3, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::pblendw(XMMRegister dst, XMMRegister src, int imm8) {
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x0E);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0x0E, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::sha1rnds4(XMMRegister dst, XMMRegister src, int imm8) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_3A, /* rex_w */ false);
-  emit_int8((unsigned char)0xCC);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)imm8);
+  emit_int24((unsigned char)0xCC, (unsigned char)(0xC0 | encode), (unsigned char)imm8);
 }
 
 void Assembler::sha1nexte(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xC8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xC8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::sha1msg1(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xC9);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xC9, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::sha1msg2(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xCA);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xCA, (unsigned char)(0xC0 | encode));
 }
 
 // xmm0 is implicit additional source to this instruction.
 void Assembler::sha256rnds2(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xCB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xCB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::sha256msg1(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xCC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xCC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::sha256msg2(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sha(), "");
   int encode = rex_prefix_and_encode(dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, /* rex_w */ false);
-  emit_int8((unsigned char)0xCD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xCD, (unsigned char)(0xC0 | encode));
 }
 
 
@@ -4708,63 +4418,46 @@
   assert(isShiftCount(imm8), "illegal shift count");
   int encode = prefix_and_encode(dst->encoding());
   if (imm8 == 1 ) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xE0 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xE0 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xE0 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xE0 | encode), imm8);
   }
 }
 
 void Assembler::shll(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xE0 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xE0 | encode));
 }
 
 void Assembler::shrl(Register dst, int imm8) {
   assert(isShiftCount(imm8), "illegal shift count");
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xC1);
-  emit_int8((unsigned char)(0xE8 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xC1, (unsigned char)(0xE8 | encode), imm8);
 }
 
 void Assembler::shrl(Register dst) {
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xE8 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xE8 | encode));
 }
 
 void Assembler::shldl(Register dst, Register src) {
   int encode = prefix_and_encode(src->encoding(), dst->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xA5);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xA5, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::shldl(Register dst, Register src, int8_t imm8) {
   int encode = prefix_and_encode(src->encoding(), dst->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xA4);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int32(0x0F, (unsigned char)0xA4, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::shrdl(Register dst, Register src) {
   int encode = prefix_and_encode(src->encoding(), dst->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xAD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::shrdl(Register dst, Register src, int8_t imm8) {
   int encode = prefix_and_encode(src->encoding(), dst->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAC);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int32(0x0F, (unsigned char)0xAC, (unsigned char)(0xC0 | encode), imm8);
 }
 
 // copies a single word from [esi] to [edi]
@@ -4776,9 +4469,7 @@
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x0B);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)rmode);
+  emit_int24(0x0B, (unsigned char)(0xC0 | encode), (unsigned char)rmode);
 }
 
 void Assembler::roundsd(XMMRegister dst, Address src, int32_t rmode) {
@@ -4796,8 +4487,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x51);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x51, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::sqrtsd(XMMRegister dst, Address src) {
@@ -4815,8 +4505,7 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x51);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x51, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::std() {
@@ -4845,8 +4534,7 @@
     NOT_LP64(assert(VM_Version::supports_sse(), ""));
     InstructionMark im(this);
     prefix(dst);
-    emit_int8(0x0F);
-    emit_int8((unsigned char)0xAE);
+    emit_int16(0x0F, (unsigned char)0xAE);
     emit_operand(as_Register(3), dst);
   }
 }
@@ -4892,8 +4580,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::subsd(XMMRegister dst, Address src) {
@@ -4911,8 +4598,7 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true , /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::subss(XMMRegister dst, Address src) {
@@ -4948,8 +4634,7 @@
     emit_int8((unsigned char)0xA9);
   } else {
     encode = prefix_and_encode(encode);
-    emit_int8((unsigned char)0xF7);
-    emit_int8((unsigned char)(0xC0 | encode));
+    emit_int16((unsigned char)0xF7, (unsigned char)(0xC0 | encode));
   }
   emit_int32(imm32);
 }
@@ -4970,18 +4655,14 @@
   assert(VM_Version::supports_bmi1(), "tzcnt instruction not supported");
   emit_int8((unsigned char)0xF3);
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBC);
-  emit_int8((unsigned char)0xC0 | encode);
+  emit_int24(0x0F, (unsigned char)0xBC, (unsigned char)0xC0 | encode);
 }
 
 void Assembler::tzcntq(Register dst, Register src) {
   assert(VM_Version::supports_bmi1(), "tzcnt instruction not supported");
   emit_int8((unsigned char)0xF3);
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::ucomisd(XMMRegister dst, Address src) {
@@ -5000,8 +4681,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::ucomiss(XMMRegister dst, Address src) {
@@ -5018,21 +4698,17 @@
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::xabort(int8_t imm8) {
-  emit_int8((unsigned char)0xC6);
-  emit_int8((unsigned char)0xF8);
-  emit_int8((unsigned char)(imm8 & 0xFF));
+  emit_int24((unsigned char)0xC6, (unsigned char)0xF8, (unsigned char)(imm8 & 0xFF));
 }
 
 void Assembler::xaddb(Address dst, Register src) {
   InstructionMark im(this);
   prefix(dst, src, true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xC0);
+  emit_int16(0x0F, (unsigned char)0xC0);
   emit_operand(src, dst);
 }
 
@@ -5040,16 +4716,14 @@
   InstructionMark im(this);
   emit_int8(0x66);
   prefix(dst, src);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xC1);
+  emit_int16(0x0F, (unsigned char)0xC1);
   emit_operand(src, dst);
 }
 
 void Assembler::xaddl(Address dst, Register src) {
   InstructionMark im(this);
   prefix(dst, src);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xC1);
+  emit_int16(0x0F, (unsigned char)0xC1);
   emit_operand(src, dst);
 }
 
@@ -5060,13 +4734,11 @@
     address entry = target(abort);
     assert(entry != NULL, "abort entry NULL");
     intptr_t offset = entry - pc();
-    emit_int8((unsigned char)0xC7);
-    emit_int8((unsigned char)0xF8);
+    emit_int16((unsigned char)0xC7, (unsigned char)0xF8);
     emit_int32(offset - 6); // 2 opcode + 4 address
   } else {
     abort.add_patch_at(code(), locator());
-    emit_int8((unsigned char)0xC7);
-    emit_int8((unsigned char)0xF8);
+    emit_int16((unsigned char)0xC7, (unsigned char)0xF8);
     emit_int32(0);
   }
 }
@@ -5095,20 +4767,15 @@
 
 void Assembler::xchgl(Register dst, Register src) {
   int encode = prefix_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x87);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x87, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::xend() {
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0x01);
-  emit_int8((unsigned char)0xD5);
+  emit_int24((unsigned char)0x0F, (unsigned char)0x01, (unsigned char)0xD5);
 }
 
 void Assembler::xgetbv() {
-  emit_int8(0x0F);
-  emit_int8(0x01);
-  emit_int8((unsigned char)0xD0);
+  emit_int24(0x0F, 0x01, (unsigned char)0xD0);
 }
 
 void Assembler::xorl(Register dst, int32_t imm32) {
@@ -5153,8 +4820,7 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaddss(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5171,8 +4837,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vdivsd(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5191,8 +4856,7 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vdivss(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5209,24 +4873,21 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vfmadd231sd(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
   assert(VM_Version::supports_fma(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xB9);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xB9, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vfmadd231ss(XMMRegister dst, XMMRegister src1, XMMRegister src2) {
   assert(VM_Version::supports_fma(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xB9);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xB9, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmulsd(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5245,8 +4906,7 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmulss(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5263,8 +4923,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsubsd(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5283,8 +4942,7 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsubss(XMMRegister dst, XMMRegister nds, Address src) {
@@ -5301,8 +4959,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 //====================VECTOR ARITHMETIC=====================================
@@ -5314,8 +4971,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::addpd(XMMRegister dst, Address src) {
@@ -5334,8 +4990,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaddpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5343,16 +4998,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaddps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vaddpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5381,16 +5034,14 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::subps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsubpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5398,16 +5049,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsubps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsubpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5436,8 +5085,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::mulpd(XMMRegister dst, Address src) {
@@ -5455,8 +5103,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmulpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5464,16 +5111,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmulps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmulpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5501,16 +5146,14 @@
   assert(VM_Version::supports_fma(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xB8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xB8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vfmadd231ps(XMMRegister dst, XMMRegister src1, XMMRegister src2, int vector_len) {
   assert(VM_Version::supports_fma(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xB8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xB8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vfmadd231pd(XMMRegister dst, XMMRegister src1, Address src2, int vector_len) {
@@ -5538,16 +5181,14 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::divps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vdivpd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5555,16 +5196,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vdivps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vdivpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5592,9 +5231,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x09);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)(rmode));
+  emit_int24(0x09, (unsigned char)(0xC0 | encode), (unsigned char)(rmode));
 }
 
 void Assembler::vroundpd(XMMRegister dst, Address src, int32_t rmode,  int vector_len) {
@@ -5612,9 +5249,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x09);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)(rmode));
+  emit_int24((unsigned char)0x09, (unsigned char)(0xC0 | encode), (unsigned char)(rmode));
 }
 
 void Assembler::vrndscalepd(XMMRegister dst, Address src, int32_t rmode, int vector_len) {
@@ -5636,8 +5271,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x51);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x51, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsqrtpd(XMMRegister dst, Address src, int vector_len) {
@@ -5655,8 +5289,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x51);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x51, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vsqrtps(XMMRegister dst, Address src, int vector_len) {
@@ -5674,16 +5307,14 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ !_legacy_mode_dq, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x54);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x54, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x54);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x54, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andps(XMMRegister dst, Address src) {
@@ -5712,16 +5343,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ !_legacy_mode_dq, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x54);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x54, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vandps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x54);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x54, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vandpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5759,8 +5388,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x14);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x14, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::xorpd(XMMRegister dst, XMMRegister src) {
@@ -5768,16 +5396,14 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ !_legacy_mode_dq, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x57);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x57, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::xorps(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x57);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x57, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::xorpd(XMMRegister dst, Address src) {
@@ -5806,16 +5432,14 @@
   InstructionAttr attributes(vector_len, /* vex_w */ !_legacy_mode_dq, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x57);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x57, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vxorps(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x57);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x57, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vxorpd(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5845,8 +5469,7 @@
          VM_Version::supports_avx2(), "256 bit integer vectors requires AVX2");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x01);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x01, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vphaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5854,32 +5477,28 @@
          VM_Version::supports_avx2(), "256 bit integer vectors requires AVX2");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x02);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x02, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::paddb(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::paddw(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::paddd(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFE);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFE, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::paddd(XMMRegister dst, Address src) {
@@ -5896,48 +5515,42 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD4);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD4, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::phaddw(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x01);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x01, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::phaddd(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sse3(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x02);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x02, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpaddb(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpaddw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpaddd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFE);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFE, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpaddq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -5945,8 +5558,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD4);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD4, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpaddb(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -5994,23 +5606,20 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psubw(XMMRegister dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF9);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF9, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psubd(XMMRegister dst, XMMRegister src) {
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFA);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFA, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psubq(XMMRegister dst, XMMRegister src) {
@@ -6026,24 +5635,21 @@
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsubw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF9);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF9, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsubd(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFA);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFA, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsubq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -6051,8 +5657,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xFB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsubb(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -6100,32 +5705,28 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD5);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD5, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pmulld(XMMRegister dst, XMMRegister src) {
   assert(VM_Version::supports_sse4_1(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x40);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x40, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmullw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD5);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD5, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmulld(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x40);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x40, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmullq(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -6133,8 +5734,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ _legacy_mode_dq, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x40);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x40, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpmullw(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -6174,9 +5774,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM6 is for /6 encoding: 66 0F 71 /6 ib
   int encode = simd_prefix_and_encode(xmm6, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::pslld(XMMRegister dst, int shift) {
@@ -6184,9 +5782,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM6 is for /6 encoding: 66 0F 72 /6 ib
   int encode = simd_prefix_and_encode(xmm6, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psllq(XMMRegister dst, int shift) {
@@ -6194,25 +5790,21 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM6 is for /6 encoding: 66 0F 73 /6 ib
   int encode = simd_prefix_and_encode(xmm6, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psllw(XMMRegister dst, XMMRegister shift) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pslld(XMMRegister dst, XMMRegister shift) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psllq(XMMRegister dst, XMMRegister shift) {
@@ -6220,8 +5812,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsllw(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6229,9 +5820,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM6 is for /6 encoding: 66 0F 71 /6 ib
   int encode = vex_prefix_and_encode(xmm6->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpslld(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6240,9 +5829,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM6 is for /6 encoding: 66 0F 72 /6 ib
   int encode = vex_prefix_and_encode(xmm6->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsllq(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6251,25 +5838,21 @@
   attributes.set_rex_vex_w_reverted();
   // XMM6 is for /6 encoding: 66 0F 73 /6 ib
   int encode = vex_prefix_and_encode(xmm6->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsllw(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpslld(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsllq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
@@ -6277,8 +5860,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 // Shift packed integers logically right by specified number of bits.
@@ -6287,9 +5869,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM2 is for /2 encoding: 66 0F 71 /2 ib
   int encode = simd_prefix_and_encode(xmm2, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psrld(XMMRegister dst, int shift) {
@@ -6297,9 +5877,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM2 is for /2 encoding: 66 0F 72 /2 ib
   int encode = simd_prefix_and_encode(xmm2, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psrlq(XMMRegister dst, int shift) {
@@ -6310,25 +5888,21 @@
   attributes.set_rex_vex_w_reverted();
   // XMM2 is for /2 encoding: 66 0F 73 /2 ib
   int encode = simd_prefix_and_encode(xmm2, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psrlw(XMMRegister dst, XMMRegister shift) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psrld(XMMRegister dst, XMMRegister shift) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psrlq(XMMRegister dst, XMMRegister shift) {
@@ -6336,8 +5910,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsrlw(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6345,9 +5918,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM2 is for /2 encoding: 66 0F 71 /2 ib
   int encode = vex_prefix_and_encode(xmm2->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsrld(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6355,9 +5926,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM2 is for /2 encoding: 66 0F 72 /2 ib
   int encode = vex_prefix_and_encode(xmm2->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsrlq(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6366,25 +5935,21 @@
   attributes.set_rex_vex_w_reverted();
   // XMM2 is for /2 encoding: 66 0F 73 /2 ib
   int encode = vex_prefix_and_encode(xmm2->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x73, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsrlw(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsrld(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsrlq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
@@ -6392,8 +5957,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpsrlvw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -6401,8 +5965,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x10);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x10, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpsllvw(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
@@ -6410,8 +5973,7 @@
   InstructionAttr attributes(vector_len, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x12);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x12, (unsigned char)(0xC0 | encode));
 }
 
 // Shift packed integers arithmetically right by specified number of bits.
@@ -6420,9 +5982,7 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM4 is for /4 encoding: 66 0F 71 /4 ib
   int encode = simd_prefix_and_encode(xmm4, dst, dst, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::psrad(XMMRegister dst, int shift) {
@@ -6439,16 +5999,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::psrad(XMMRegister dst, XMMRegister shift) {
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, shift, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsraw(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6456,9 +6014,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM4 is for /4 encoding: 66 0F 71 /4 ib
   int encode = vex_prefix_and_encode(xmm4->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x71);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x71, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsrad(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6466,25 +6022,21 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   // XMM4 is for /4 encoding: 66 0F 71 /4 ib
   int encode = vex_prefix_and_encode(xmm4->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24(0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::vpsraw(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE1);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE1, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpsrad(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evpsraq(XMMRegister dst, XMMRegister src, int shift, int vector_len) {
@@ -6493,9 +6045,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(xmm4->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0x72);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(shift & 0xFF);
+  emit_int24((unsigned char)0x72, (unsigned char)(0xC0 | encode), shift & 0xFF);
 }
 
 void Assembler::evpsraq(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
@@ -6504,8 +6054,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xE2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xE2, (unsigned char)(0xC0 | encode));
 }
 
 // logical operations packed integers
@@ -6513,16 +6062,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xDB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpand(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xDB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpand(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -6539,8 +6086,7 @@
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xDB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpshldvd(XMMRegister dst, XMMRegister src, XMMRegister shift, int vector_len) {
@@ -6557,8 +6103,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), src->encoding(), shift->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x73);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x73, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::pandn(XMMRegister dst, XMMRegister src) {
@@ -6566,16 +6111,14 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xDF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpandn(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xDF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xDF, (unsigned char)(0xC0 | encode));
 }
 
 
@@ -6583,16 +6126,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xEB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xEB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xEB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xEB, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpor(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -6609,8 +6150,7 @@
   assert(VM_Version::supports_evex(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xEB);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xEB, (unsigned char)(0xC0 | encode));
 }
 
 
@@ -6618,16 +6158,14 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xEF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xEF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpxor(XMMRegister dst, XMMRegister nds, XMMRegister src, int vector_len) {
   assert(UseAVX > 0, "requires some form of AVX");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xEF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xEF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpxor(XMMRegister dst, XMMRegister nds, Address src, int vector_len) {
@@ -6669,11 +6207,10 @@
   assert(imm8 <= 0x01, "imm8: %u", imm8);
   InstructionAttr attributes(AVX_256bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x38);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // last byte:
   // 0x00 - insert into lower 128 bits
   // 0x01 - insert into upper 128 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x38, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vinserti128(XMMRegister dst, XMMRegister nds, Address src, uint8_t imm8) {
@@ -6697,13 +6234,12 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x38);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - insert into q0 128 bits (0..127)
   // 0x01 - insert into q1 128 bits (128..255)
   // 0x02 - insert into q2 128 bits (256..383)
   // 0x03 - insert into q3 128 bits (384..511)
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x38, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vinserti32x4(XMMRegister dst, XMMRegister nds, Address src, uint8_t imm8) {
@@ -6730,11 +6266,10 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x3A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  //imm8:
   // 0x00 - insert into lower 256 bits
   // 0x01 - insert into upper 256 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x3A, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 
@@ -6745,11 +6280,10 @@
   assert(imm8 <= 0x01, "imm8: %u", imm8);
   InstructionAttr attributes(AVX_256bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x18);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - insert into lower 128 bits
   // 0x01 - insert into upper 128 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x18, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vinsertf128(XMMRegister dst, XMMRegister nds, Address src, uint8_t imm8) {
@@ -6772,13 +6306,12 @@
   assert(imm8 <= 0x03, "imm8: %u", imm8);
   InstructionAttr attributes(AVX_512bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x18);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - insert into q0 128 bits (0..127)
   // 0x01 - insert into q1 128 bits (128..255)
   // 0x02 - insert into q0 128 bits (256..383)
   // 0x03 - insert into q1 128 bits (384..512)
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x18, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vinsertf32x4(XMMRegister dst, XMMRegister nds, Address src, uint8_t imm8) {
@@ -6804,11 +6337,10 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x1A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - insert into lower 256 bits
   // 0x01 - insert into upper 256 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x1A, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vinsertf64x4(XMMRegister dst, XMMRegister nds, Address src, uint8_t imm8) {
@@ -6835,11 +6367,10 @@
   assert(imm8 <= 0x01, "imm8: %u", imm8);
   InstructionAttr attributes(AVX_256bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x39);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from lower 128 bits
   // 0x01 - extract from upper 128 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x39, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vextracti128(Address dst, XMMRegister src, uint8_t imm8) {
@@ -6864,13 +6395,12 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x39);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from bits 127:0
   // 0x01 - extract from bits 255:128
   // 0x02 - extract from bits 383:256
   // 0x03 - extract from bits 511:384
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x39, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vextracti32x4(Address dst, XMMRegister src, uint8_t imm8) {
@@ -6898,13 +6428,12 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x39);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from bits 127:0
   // 0x01 - extract from bits 255:128
   // 0x02 - extract from bits 383:256
   // 0x03 - extract from bits 511:384
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x39, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vextracti64x4(XMMRegister dst, XMMRegister src, uint8_t imm8) {
@@ -6913,11 +6442,10 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x3B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from lower 256 bits
   // 0x01 - extract from upper 256 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x3B, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vextracti64x4(Address dst, XMMRegister src, uint8_t imm8) {
@@ -6943,11 +6471,10 @@
   assert(imm8 <= 0x01, "imm8: %u", imm8);
   InstructionAttr attributes(AVX_256bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x19);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from lower 128 bits
   // 0x01 - extract from upper 128 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x19, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vextractf128(Address dst, XMMRegister src, uint8_t imm8) {
@@ -6972,13 +6499,12 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x19);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from bits 127:0
   // 0x01 - extract from bits 255:128
   // 0x02 - extract from bits 383:256
   // 0x03 - extract from bits 511:384
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x19, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vextractf32x4(Address dst, XMMRegister src, uint8_t imm8) {
@@ -7006,13 +6532,12 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x19);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from bits 127:0
   // 0x01 - extract from bits 255:128
   // 0x02 - extract from bits 383:256
   // 0x03 - extract from bits 511:384
-  emit_int8(imm8 & 0x03);
+  emit_int24(0x19, (unsigned char)(0xC0 | encode), imm8 & 0x03);
 }
 
 void Assembler::vextractf64x4(XMMRegister dst, XMMRegister src, uint8_t imm8) {
@@ -7021,11 +6546,10 @@
   InstructionAttr attributes(AVX_512bit, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(src->encoding(), 0, dst->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x1B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  // imm8:
   // 0x00 - extract from lower 256 bits
   // 0x01 - extract from upper 256 bits
-  emit_int8(imm8 & 0x01);
+  emit_int24(0x1B, (unsigned char)(0xC0 | encode), imm8 & 0x01);
 }
 
 void Assembler::vextractf64x4(Address dst, XMMRegister src, uint8_t imm8) {
@@ -7050,8 +6574,7 @@
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x78);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x78, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpbroadcastb(XMMRegister dst, Address src, int vector_len) {
@@ -7071,8 +6594,7 @@
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x79);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x79, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpbroadcastw(XMMRegister dst, Address src, int vector_len) {
@@ -7094,8 +6616,7 @@
   assert(UseAVX >= 2, "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x58);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x58, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpbroadcastd(XMMRegister dst, Address src, int vector_len) {
@@ -7116,8 +6637,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x59);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x59, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vpbroadcastq(XMMRegister dst, Address src, int vector_len) {
@@ -7138,8 +6658,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x5A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::evbroadcasti64x2(XMMRegister dst, Address src, int vector_len) {
@@ -7163,8 +6682,7 @@
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x18);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x18, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vbroadcastss(XMMRegister dst, Address src, int vector_len) {
@@ -7186,8 +6704,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x19);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x19, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vbroadcastsd(XMMRegister dst, Address src, int vector_len) {
@@ -7213,8 +6730,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x7A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7A, (unsigned char)(0xC0 | encode));
 }
 
 // duplicate 2-byte integer data from src into programmed locations in dest : requires AVX512BW and AVX512VL
@@ -7223,8 +6739,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ _legacy_mode_bw, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x7B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7B, (unsigned char)(0xC0 | encode));
 }
 
 // duplicate 4-byte integer data from src into programmed locations in dest : requires AVX512VL
@@ -7233,8 +6748,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x7C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7C, (unsigned char)(0xC0 | encode));
 }
 
 // duplicate 8-byte integer data from src into programmed locations in dest : requires AVX512VL
@@ -7243,8 +6757,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8(0x7C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7C, (unsigned char)(0xC0 | encode));
 }
 void Assembler::evpgatherdd(XMMRegister dst, KRegister mask, Address src, int vector_len) {
   assert(VM_Version::supports_evex(), "");
@@ -7265,9 +6778,7 @@
   assert(VM_Version::supports_clmul(), "");
   InstructionAttr attributes(AVX_128bit, /* rex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, dst, src, VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x44);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)mask);
+  emit_int24(0x44, (unsigned char)(0xC0 | encode), (unsigned char)mask);
 }
 
 // Carry-Less Multiplication Quadword
@@ -7275,9 +6786,7 @@
   assert(VM_Version::supports_avx() && VM_Version::supports_clmul(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x44);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)mask);
+  emit_int24(0x44, (unsigned char)(0xC0 | encode), (unsigned char)mask);
 }
 
 void Assembler::evpclmulqdq(XMMRegister dst, XMMRegister nds, XMMRegister src, int mask, int vector_len) {
@@ -7285,9 +6794,7 @@
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ true);
   attributes.set_is_evex_instruction();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8(0x44);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)mask);
+  emit_int24(0x44, (unsigned char)(0xC0 | encode), (unsigned char)mask);
 }
 
 void Assembler::vzeroupper_uncached() {
@@ -7308,8 +6815,7 @@
 void Assembler::cmp_literal32(Register src1, int32_t imm32, RelocationHolder const& rspec) {
   // NO PREFIX AS NEVER 64BIT
   InstructionMark im(this);
-  emit_int8((unsigned char)0x81);
-  emit_int8((unsigned char)(0xF8 | src1->encoding()));
+  emit_int8((unsigned char)0x81, (unsigned char)(0xF8 | src1->encoding()));
   emit_data(imm32, rspec, 0);
 }
 
@@ -7326,8 +6832,7 @@
 // into rdx:rax.  The ZF is set if the compared values were equal, and cleared otherwise.
 void Assembler::cmpxchg8(Address adr) {
   InstructionMark im(this);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xC7);
+  emit_int16(0x0F, (unsigned char)0xC7);
   emit_operand(rcx, adr);
 }
 
@@ -7339,8 +6844,7 @@
 // 64bit doesn't use the x87
 
 void Assembler::fabs() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xE1);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE1);
 }
 
 void Assembler::fadd(int i) {
@@ -7368,8 +6872,7 @@
 }
 
 void Assembler::fchs() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xE0);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE0);
 }
 
 void Assembler::fcom(int i) {
@@ -7393,18 +6896,15 @@
 }
 
 void Assembler::fcompp() {
-  emit_int8((unsigned char)0xDE);
-  emit_int8((unsigned char)0xD9);
+  emit_int16((unsigned char)0xDE, (unsigned char)0xD9);
 }
 
 void Assembler::fcos() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xFF);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFF);
 }
 
 void Assembler::fdecstp() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF6);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF6);
 }
 
 void Assembler::fdiv(int i) {
@@ -7475,14 +6975,11 @@
 }
 
 void Assembler::fincstp() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF7);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF7);
 }
 
 void Assembler::finit() {
-  emit_int8((unsigned char)0x9B);
-  emit_int8((unsigned char)0xDB);
-  emit_int8((unsigned char)0xE3);
+  emit_int24((unsigned char)0x9B, (unsigned char)0xDB, (unsigned char)0xE3);
 }
 
 void Assembler::fist_s(Address adr) {
@@ -7504,8 +7001,7 @@
 }
 
 void Assembler::fld1() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xE8);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE8);
 }
 
 void Assembler::fld_d(Address adr) {
@@ -7544,18 +7040,15 @@
 }
 
 void Assembler::fldlg2() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xEC);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEC);
 }
 
 void Assembler::fldln2() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xED);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xED);
 }
 
 void Assembler::fldz() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xEE);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEE);
 }
 
 void Assembler::flog() {
@@ -7602,24 +7095,20 @@
 
 void Assembler::fnstcw(Address src) {
   InstructionMark im(this);
-  emit_int8((unsigned char)0x9B);
-  emit_int8((unsigned char)0xD9);
+  emit_int16((unsigned char)0x9B, (unsigned char)0xD9);
   emit_operand32(rdi, src);
 }
 
 void Assembler::fnstsw_ax() {
-  emit_int8((unsigned char)0xDF);
-  emit_int8((unsigned char)0xE0);
+  emit_int16((unsigned char)0xDF, (unsigned char)0xE0);
 }
 
 void Assembler::fprem() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF8);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF8);
 }
 
 void Assembler::fprem1() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF5);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF5);
 }
 
 void Assembler::frstor(Address src) {
@@ -7629,13 +7118,11 @@
 }
 
 void Assembler::fsin() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xFE);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFE);
 }
 
 void Assembler::fsqrt() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xFA);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFA);
 }
 
 void Assembler::fst_d(Address adr) {
@@ -7721,15 +7208,11 @@
 }
 
 void Assembler::ftan() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF2);
-  emit_int8((unsigned char)0xDD);
-  emit_int8((unsigned char)0xD8);
+  emit_int32((unsigned char)0xD9, (unsigned char)0xF2, (unsigned char)0xDD, (unsigned char)0xD8);
 }
 
 void Assembler::ftst() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xE4);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xE4);
 }
 
 void Assembler::fucomi(int i) {
@@ -7753,23 +7236,19 @@
 }
 
 void Assembler::fyl2x() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF1);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF1);
 }
 
 void Assembler::frndint() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xFC);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xFC);
 }
 
 void Assembler::f2xm1() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xF0);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xF0);
 }
 
 void Assembler::fldl2e() {
-  emit_int8((unsigned char)0xD9);
-  emit_int8((unsigned char)0xEA);
+  emit_int16((unsigned char)0xD9, (unsigned char)0xEA);
 }
 #endif // !_LP64
 
@@ -7817,31 +7296,28 @@
   int vector_len = _attributes->get_vector_len();
   bool vex_w = _attributes->is_rex_vex_w();
   if (vex_b || vex_x || vex_w || (opc == VEX_OPCODE_0F_38) || (opc == VEX_OPCODE_0F_3A)) {
-    prefix(VEX_3bytes);
-
     int byte1 = (vex_r ? VEX_R : 0) | (vex_x ? VEX_X : 0) | (vex_b ? VEX_B : 0);
     byte1 = (~byte1) & 0xE0;
     byte1 |= opc;
-    emit_int8(byte1);
 
     int byte2 = ((~nds_enc) & 0xf) << 3;
     byte2 |= (vex_w ? VEX_W : 0) | ((vector_len > 0) ? 4 : 0) | pre;
-    emit_int8(byte2);
+
+    emit_int24((unsigned char)VEX_3bytes, byte1, byte2);
   } else {
-    prefix(VEX_2bytes);
-
     int byte1 = vex_r ? VEX_R : 0;
     byte1 = (~byte1) & 0x80;
     byte1 |= ((~nds_enc) & 0xf) << 3;
     byte1 |= ((vector_len > 0 ) ? 4 : 0) | pre;
-    emit_int8(byte1);
+    emit_int16((unsigned char)VEX_2bytes, byte1);
   }
 }
 
 // This is a 4 byte encoding
 void Assembler::evex_prefix(bool vex_r, bool vex_b, bool vex_x, bool evex_r, bool evex_v, int nds_enc, VexSimdPrefix pre, VexOpcode opc){
   // EVEX 0x62 prefix
-  prefix(EVEX_4bytes);
+  // byte1 = EVEX_4bytes;
+
   bool vex_w = _attributes->is_rex_vex_w();
   int evex_encoding = (vex_w ? VEX_W : 0);
   // EVEX.b is not currently used for broadcast of single element or data rounding modes
@@ -7854,7 +7330,6 @@
   // confine opc opcode extensions in mm bits to lower two bits
   // of form {0F, 0F_38, 0F_3A}
   byte2 |= opc;
-  emit_int8(byte2);
 
   // P1: byte 3 as Wvvvv1pp
   int byte3 = ((~nds_enc) & 0xf) << 3;
@@ -7864,7 +7339,6 @@
   // confine pre opcode extensions in pp bits to lower two bits
   // of form {66, F3, F2}
   byte3 |= pre;
-  emit_int8(byte3);
 
   // P2: byte 4 as zL'Lbv'aaa
   // kregs are implemented in the low 3 bits as aaa
@@ -7881,11 +7355,12 @@
   if (_attributes->is_no_reg_mask() == false) {
     byte4 |= (_attributes->is_clear_context() ? EVEX_Z : 0);
   }
-  emit_int8(byte4);
+
+  emit_int32(EVEX_4bytes, byte2, byte3, byte4);
 }
 
 void Assembler::vex_prefix(Address adr, int nds_enc, int xreg_enc, VexSimdPrefix pre, VexOpcode opc, InstructionAttr *attributes) {
-  bool vex_r = ((xreg_enc & 8) == 8) ? 1 : 0;
+  bool vex_r = (xreg_enc & 8) == 8;
   bool vex_b = adr.base_needs_rex();
   bool vex_x;
   if (adr.isxmmindex()) {
@@ -7900,7 +7375,7 @@
   // is allowed in legacy mode and has resources which will fit in it.
   // Pure EVEX instructions will have is_evex_instruction set in their definition.
   if (!attributes->is_legacy_mode()) {
-    if (UseAVX > 2 && !attributes->is_evex_instruction() && !_is_managed) {
+    if (UseAVX > 2 && !attributes->is_evex_instruction() && !is_managed()) {
       if ((attributes->get_vector_len() != AVX_512bit) && (nds_enc < 16) && (xreg_enc < 16)) {
           attributes->set_is_legacy_mode();
       }
@@ -7915,7 +7390,7 @@
     assert(((nds_enc < 16 && xreg_enc < 16) || (!attributes->is_legacy_mode())),"XMM register should be 0-15");
   }
 
-  _is_managed = false;
+  clear_managed();
   if (UseAVX > 2 && !attributes->is_legacy_mode())
   {
     bool evex_r = (xreg_enc >= 16);
@@ -7937,8 +7412,8 @@
 }
 
 int Assembler::vex_prefix_and_encode(int dst_enc, int nds_enc, int src_enc, VexSimdPrefix pre, VexOpcode opc, InstructionAttr *attributes) {
-  bool vex_r = ((dst_enc & 8) == 8) ? 1 : 0;
-  bool vex_b = ((src_enc & 8) == 8) ? 1 : 0;
+  bool vex_r = (dst_enc & 8) == 8;
+  bool vex_b = (src_enc & 8) == 8;
   bool vex_x = false;
   set_attributes(attributes);
   attributes->set_current_assembler(this);
@@ -7947,7 +7422,7 @@
   // is allowed in legacy mode and has resources which will fit in it.
   // Pure EVEX instructions will have is_evex_instruction set in their definition.
   if (!attributes->is_legacy_mode()) {
-    if (UseAVX > 2 && !attributes->is_evex_instruction() && !_is_managed) {
+    if (UseAVX > 2 && !attributes->is_evex_instruction() && !is_managed()) {
       if ((!attributes->uses_vl() || (attributes->get_vector_len() != AVX_512bit)) &&
           (dst_enc < 16) && (nds_enc < 16) && (src_enc < 16)) {
           attributes->set_is_legacy_mode();
@@ -7969,7 +7444,7 @@
     assert(((dst_enc < 16 && nds_enc < 16 && src_enc < 16) || (!attributes->is_legacy_mode())),"XMM register should be 0-15");
   }
 
-  _is_managed = false;
+  clear_managed();
   if (UseAVX > 2 && !attributes->is_legacy_mode())
   {
     bool evex_r = (dst_enc >= 16);
@@ -8019,8 +7494,7 @@
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vmaxsd(XMMRegister dst, XMMRegister nds, XMMRegister src) {
@@ -8028,16 +7502,14 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5F);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5F, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vminss(XMMRegister dst, XMMRegister nds, XMMRegister src) {
   assert(VM_Version::supports_avx(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5D);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5D, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::vminsd(XMMRegister dst, XMMRegister nds, XMMRegister src) {
@@ -8045,8 +7517,7 @@
   InstructionAttr attributes(AVX_128bit, /* vex_w */ VM_Version::supports_evex(), /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   attributes.set_rex_vex_w_reverted();
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x5D);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x5D, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cmppd(XMMRegister dst, XMMRegister nds, XMMRegister src, int cop, int vector_len) {
@@ -8054,9 +7525,7 @@
   assert(vector_len <= AVX_256bit, "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, nds, src, VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xC2);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)(0xF & cop));
+  emit_int24((unsigned char)0xC2, (unsigned char)(0xC0 | encode), (unsigned char)(0xF & cop));
 }
 
 void Assembler::blendvpd(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len) {
@@ -8064,10 +7533,8 @@
   assert(vector_len <= AVX_256bit, "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src1->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x4B);
-  emit_int8((unsigned char)(0xC0 | encode));
   int src2_enc = src2->encoding();
-  emit_int8((unsigned char)(0xF0 & src2_enc<<4));
+  emit_int24((unsigned char)0x4B, (unsigned char)(0xC0 | encode), (unsigned char)(0xF0 & src2_enc << 4));
 }
 
 void Assembler::cmpps(XMMRegister dst, XMMRegister nds, XMMRegister src, int cop, int vector_len) {
@@ -8075,9 +7542,7 @@
   assert(vector_len <= AVX_256bit, "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = simd_prefix_and_encode(dst, nds, src, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
-  emit_int8((unsigned char)0xC2);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)(0xF & cop));
+  emit_int24((unsigned char)0xC2, (unsigned char)(0xC0 | encode), (unsigned char)(0xF & cop));
 }
 
 void Assembler::blendvps(XMMRegister dst, XMMRegister nds, XMMRegister src1, XMMRegister src2, int vector_len) {
@@ -8085,35 +7550,29 @@
   assert(vector_len <= AVX_256bit, "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src1->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x4A);
-  emit_int8((unsigned char)(0xC0 | encode));
   int src2_enc = src2->encoding();
-  emit_int8((unsigned char)(0xF0 & src2_enc<<4));
+  emit_int24((unsigned char)0x4A, (unsigned char)(0xC0 | encode), (unsigned char)(0xF0 & src2_enc << 4));
 }
 
 void Assembler::vpblendd(XMMRegister dst, XMMRegister nds, XMMRegister src, int imm8, int vector_len) {
   assert(VM_Version::supports_avx2(), "");
   InstructionAttr attributes(vector_len, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), nds->encoding(), src->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0x02);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8((unsigned char)imm8);
+  emit_int24((unsigned char)0x02, (unsigned char)(0xC0 | encode), (unsigned char)imm8);
 }
 
 void Assembler::shlxl(Register dst, Register src1, Register src2) {
   assert(VM_Version::supports_bmi2(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src2->encoding(), src1->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::shlxq(Register dst, Register src1, Register src2) {
   assert(VM_Version::supports_bmi2(), "");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ true);
   int encode = vex_prefix_and_encode(dst->encoding(), src2->encoding(), src1->encoding(), VEX_SIMD_66, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xC0 | encode));
 }
 
 #ifndef _LP64
@@ -8156,18 +7615,14 @@
 }
 
 void Assembler::set_byte_if_not_zero(Register dst) {
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0x95);
-  emit_int8((unsigned char)(0xE0 | dst->encoding()));
+  emit_int8(0x0F, (unsigned char)0x95, (unsigned char)(0xE0 | dst->encoding()));
 }
 
 #else // LP64
 
 void Assembler::set_byte_if_not_zero(Register dst) {
   int enc = prefix_and_encode(dst->encoding(), true);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0x95);
-  emit_int8((unsigned char)(0xE0 | enc));
+  emit_int24(0x0F, (unsigned char)0x95, (unsigned char)(0xE0 | enc));
 }
 
 // 64bit only pieces of the assembler
@@ -8317,22 +7772,22 @@
 }
 
 int Assembler::prefixq_and_encode(int dst_enc, int src_enc) {
-  if (dst_enc < 8) {
-    if (src_enc < 8) {
-      prefix(REX_W);
-    } else {
-      prefix(REX_WB);
-      src_enc -= 8;
-    }
-  } else {
-    if (src_enc < 8) {
-      prefix(REX_WR);
-    } else {
-      prefix(REX_WRB);
-      src_enc -= 8;
-    }
+  static const int8_t prefixes[] = {
+      REX_W,
+      REX_WB,
+      REX_WR,
+      REX_WRB
+  };
+  int idx = 0;
+  if (dst_enc >= 8) {
+    idx |= 2;
     dst_enc -= 8;
   }
+  if (src_enc >= 8) {
+    src_enc -= 8;
+    idx |= 1;
+  }
+  emit_int8(prefixes[idx]);
   return dst_enc << 3 | src_enc;
 }
 
@@ -8390,22 +7845,36 @@
   }
 }
 
-void Assembler::prefixq(Address adr) {
+int8_t Assembler::get_prefixq(Address adr) {
+  static const Assembler::Prefix prefixes[] = {
+      REX_W,
+      REX_WX,
+      REX_WB,
+      REX_WXB
+  };
+  int idx = (int)adr.index_needs_rex() | ((int)adr.base_needs_rex() << 1);
+  Assembler::Prefix prfx = prefixes[idx];
+#ifdef ASSERT
   if (adr.base_needs_rex()) {
     if (adr.index_needs_rex()) {
-      prefix(REX_WXB);
+      assert(prfx == REX_WXB, "must be");
     } else {
-      prefix(REX_WB);
+      assert(prfx == REX_WB, "must be");
     }
   } else {
     if (adr.index_needs_rex()) {
-      prefix(REX_WX);
+      assert(prfx == REX_WX, "must be");
     } else {
-      prefix(REX_W);
+      assert(prfx == REX_W, "must be");
     }
   }
-}
-
+#endif
+  return (int8_t)prfx;
+}
+
+void Assembler::prefixq(Address adr) {
+  emit_int8(get_prefixq(adr));
+}
 
 void Assembler::prefix(Address adr, Register reg, bool byteinst) {
   if (reg->encoding() < 8) {
@@ -8439,36 +7908,23 @@
   }
 }
 
+int8_t Assembler::get_prefixq(Address adr, Register src) {
+  static const int8_t prefixes[] = {
+      REX_WR,
+      REX_WRX,
+      REX_WRB,
+      REX_WRXB,
+      REX_W,
+      REX_WX,
+      REX_WB,
+      REX_WXB,
+  };
+  int idx = (int)adr.index_needs_rex() | ((int)adr.base_needs_rex() << 1) | ((int)(src->encoding() < 8) << 2);
+  return prefixes[idx];
+}
+
 void Assembler::prefixq(Address adr, Register src) {
-  if (src->encoding() < 8) {
-    if (adr.base_needs_rex()) {
-      if (adr.index_needs_rex()) {
-        prefix(REX_WXB);
-      } else {
-        prefix(REX_WB);
-      }
-    } else {
-      if (adr.index_needs_rex()) {
-        prefix(REX_WX);
-      } else {
-        prefix(REX_W);
-      }
-    }
-  } else {
-    if (adr.base_needs_rex()) {
-      if (adr.index_needs_rex()) {
-        prefix(REX_WRXB);
-      } else {
-        prefix(REX_WRB);
-      }
-    } else {
-      if (adr.index_needs_rex()) {
-        prefix(REX_WRX);
-      } else {
-        prefix(REX_WR);
-      }
-    }
-  }
+  emit_int8(get_prefixq(adr, src));
 }
 
 void Assembler::prefix(Address adr, XMMRegister reg) {
@@ -8540,8 +7996,8 @@
 
 void Assembler::adcq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x13);
+  emit_int16(get_prefixq(src, dst),
+             0x13);
   emit_operand(dst, src);
 }
 
@@ -8558,8 +8014,8 @@
 
 void Assembler::addq(Address dst, Register src) {
   InstructionMark im(this);
-  prefixq(dst, src);
-  emit_int8(0x01);
+  emit_int16(get_prefixq(dst, src),
+             0x01);
   emit_operand(src, dst);
 }
 
@@ -8570,8 +8026,7 @@
 
 void Assembler::addq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x03);
+  emit_int16(get_prefixq(src, dst), 0x03);
   emit_operand(dst, src);
 }
 
@@ -8584,26 +8039,26 @@
   //assert(VM_Version::supports_adx(), "adx instructions not supported");
   emit_int8((unsigned char)0x66);
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8(0x38);
-  emit_int8((unsigned char)0xF6);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int32(0x0F,
+             0x38,
+             (unsigned char)0xF6,
+             (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::adoxq(Register dst, Register src) {
   //assert(VM_Version::supports_adx(), "adx instructions not supported");
   emit_int8((unsigned char)0xF3);
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8(0x38);
-  emit_int8((unsigned char)0xF6);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int32(0x0F,
+             0x38,
+             (unsigned char)0xF6,
+             (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andq(Address dst, int32_t imm32) {
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x81);
+  emit_int16(get_prefixq(dst),
+             (unsigned char)0x81);
   emit_operand(rsp, dst, 4);
   emit_int32(imm32);
 }
@@ -8615,8 +8070,7 @@
 
 void Assembler::andq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x23);
+  emit_int16(get_prefixq(src, dst), 0x23);
   emit_operand(dst, src);
 }
 
@@ -8629,8 +8083,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), src1->encoding(), src2->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF2);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF2, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::andnq(Register dst, Register src1, Address src2) {
@@ -8644,30 +8097,24 @@
 
 void Assembler::bsfq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBC);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBC, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::bsrq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::bswapq(Register reg) {
   int encode = prefixq_and_encode(reg->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)(0xC8 | encode));
+  emit_int16(0x0F, (unsigned char)(0xC8 | encode));
 }
 
 void Assembler::blsiq(Register dst, Register src) {
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rbx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsiq(Register dst, Address src) {
@@ -8683,8 +8130,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rdx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsmskq(Register dst, Address src) {
@@ -8700,8 +8146,7 @@
   assert(VM_Version::supports_bmi1(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(rcx->encoding(), dst->encoding(), src->encoding(), VEX_SIMD_NONE, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF3);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF3, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::blsrq(Register dst, Address src) {
@@ -8714,15 +8159,13 @@
 }
 
 void Assembler::cdqq() {
-  prefix(REX_W);
-  emit_int8((unsigned char)0x99);
+  emit_int16(REX_W, (unsigned char)0x99);
 }
 
 void Assembler::clflush(Address adr) {
   assert(VM_Version::supports_clflush(), "should do");
   prefix(adr);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int16(0x0F, (unsigned char)0xAE);
   emit_operand(rdi, adr);
 }
 
@@ -8735,9 +8178,8 @@
   // instruction prefix is 0x66
   emit_int8(0x66);
   prefix(adr);
-  // opcode family is 0x0f 0xAE
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  // opcode family is 0x0F 0xAE
+  emit_int16(0x0F, (unsigned char)0xAE);
   // extended opcode byte is 7 == rdi
   emit_operand(rdi, adr);
 }
@@ -8752,31 +8194,25 @@
   emit_int8(0x66);
   prefix(adr);
   // opcode family is 0x0f 0xAE
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int16(0x0F, (unsigned char)0xAE);
   // extended opcode byte is 6 == rsi
   emit_operand(rsi, adr);
 }
 
 void Assembler::cmovq(Condition cc, Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8(0x40 | cc);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, 0x40 | cc, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cmovq(Condition cc, Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x0F);
-  emit_int8(0x40 | cc);
+  emit_int24(get_prefixq(src, dst), 0x0F, 0x40 | cc);
   emit_operand(dst, src);
 }
 
 void Assembler::cmpq(Address dst, int32_t imm32) {
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x81);
+  emit_int16(get_prefixq(dst), (unsigned char)0x81);
   emit_operand(rdi, dst, 4);
   emit_int32(imm32);
 }
@@ -8788,8 +8224,7 @@
 
 void Assembler::cmpq(Address dst, Register src) {
   InstructionMark im(this);
-  prefixq(dst, src);
-  emit_int8(0x3B);
+  emit_int16(get_prefixq(dst, src), 0x3B);
   emit_operand(src, dst);
 }
 
@@ -8800,16 +8235,13 @@
 
 void Assembler::cmpq(Register dst, Address  src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x3B);
+  emit_int16(get_prefixq(src, dst), 0x3B);
   emit_operand(dst, src);
 }
 
 void Assembler::cmpxchgq(Register reg, Address adr) {
   InstructionMark im(this);
-  prefixq(adr, reg);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB1);
+  emit_int24(get_prefixq(adr, reg), 0x0F, (unsigned char)0xB1);
   emit_operand(reg, adr);
 }
 
@@ -8817,8 +8249,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, dst, as_XMMRegister(src->encoding()), VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2A);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2A, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvtsi2sdq(XMMRegister dst, Address src) {
@@ -8846,10 +8277,7 @@
   // F2 REX.W 0F 2C /r
   // CVTTSD2SI r64, xmm1/m64
   InstructionMark im(this);
-  emit_int8((unsigned char)0xF2);
-  prefix(REX_W);
-  emit_int8(0x0F);
-  emit_int8(0x2C);
+  emit_int32((unsigned char)0xF2, REX_W, 0x0F, 0x2C);
   emit_operand(dst, src);
 }
 
@@ -8857,101 +8285,80 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_F2, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::cvttss2siq(Register dst, XMMRegister src) {
   NOT_LP64(assert(VM_Version::supports_sse(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(as_XMMRegister(dst->encoding()), xnoreg, src, VEX_SIMD_F3, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x2C);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x2C, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::decl(Register dst) {
   // Don't use it directly. Use MacroAssembler::decrementl() instead.
   // Use two-byte form (one-byte form is a REX prefix in 64-bit mode)
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8((unsigned char)(0xC8 | encode));
+  emit_int16((unsigned char)0xFF, (unsigned char)(0xC8 | encode));
 }
 
 void Assembler::decq(Register dst) {
   // Don't use it directly. Use MacroAssembler::decrementq() instead.
   // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8(0xC8 | encode);
+  emit_int16((unsigned char)0xFF, 0xC8 | encode);
 }
 
 void Assembler::decq(Address dst) {
   // Don't use it directly. Use MacroAssembler::decrementq() instead.
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0xFF);
+  emit_int16(get_prefixq(dst), (unsigned char)0xFF);
   emit_operand(rcx, dst);
 }
 
 void Assembler::fxrstor(Address src) {
-  prefixq(src);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int24(get_prefixq(src), 0x0F, (unsigned char)0xAE);
   emit_operand(as_Register(1), src);
 }
 
 void Assembler::xrstor(Address src) {
-  prefixq(src);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int24(get_prefixq(src), 0x0F, (unsigned char)0xAE);
   emit_operand(as_Register(5), src);
 }
 
 void Assembler::fxsave(Address dst) {
-  prefixq(dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int24(get_prefixq(dst), 0x0F, (unsigned char)0xAE);
   emit_operand(as_Register(0), dst);
 }
 
 void Assembler::xsave(Address dst) {
-  prefixq(dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAE);
+  emit_int24(get_prefixq(dst), 0x0F, (unsigned char)0xAE);
   emit_operand(as_Register(4), dst);
 }
 
 void Assembler::idivq(Register src) {
   int encode = prefixq_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xF8 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xF8 | encode));
 }
 
 void Assembler::imulq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xAF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xAF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::imulq(Register dst, Register src, int value) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
   if (is8bit(value)) {
-    emit_int8(0x6B);
-    emit_int8((unsigned char)(0xC0 | encode));
-    emit_int8(value & 0xFF);
+    emit_int24(0x6B, (unsigned char)(0xC0 | encode), value & 0xFF);
   } else {
-    emit_int8(0x69);
-    emit_int8((unsigned char)(0xC0 | encode));
+    emit_int16(0x69, (unsigned char)(0xC0 | encode));
     emit_int32(value);
   }
 }
 
 void Assembler::imulq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char) 0xAF);
+  emit_int24(get_prefixq(src, dst), 0x0F, (unsigned char)0xAF);
   emit_operand(dst, src);
 }
 
@@ -8959,23 +8366,20 @@
   // Don't use it directly. Use MacroAssembler::incrementl() instead.
   // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
   int encode = prefix_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::incq(Register dst) {
   // Don't use it directly. Use MacroAssembler::incrementq() instead.
   // Use two-byte form (one-byte from is a REX prefix in 64-bit mode)
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xFF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xFF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::incq(Address dst) {
   // Don't use it directly. Use MacroAssembler::incrementq() instead.
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0xFF);
+  emit_int16(get_prefixq(dst), (unsigned char)0xFF);
   emit_operand(rax, dst);
 }
 
@@ -8985,8 +8389,7 @@
 
 void Assembler::leaq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x8D);
+  emit_int16(get_prefixq(src, dst), (unsigned char)0x8D);
   emit_operand(dst, src);
 }
 
@@ -9022,8 +8425,7 @@
 void Assembler::cmp_narrow_oop(Register src1, int32_t imm32, RelocationHolder const& rspec) {
   InstructionMark im(this);
   int encode = prefix_and_encode(src1->encoding());
-  emit_int8((unsigned char)0x81);
-  emit_int8((unsigned char)(0xF8 | encode));
+  emit_int16((unsigned char)0x81, (unsigned char)(0xF8 | encode));
   emit_data((int)imm32, rspec, narrow_oop_operand);
 }
 
@@ -9039,9 +8441,7 @@
   assert(VM_Version::supports_lzcnt(), "encoding is treated as BSR");
   emit_int8((unsigned char)0xF3);
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBD);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBD, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdq(XMMRegister dst, Register src) {
@@ -9049,8 +8449,7 @@
   NOT_LP64(assert(VM_Version::supports_sse2(), ""));
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = simd_prefix_and_encode(dst, xnoreg, as_XMMRegister(src->encoding()), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x6E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x6E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movdq(Register dst, XMMRegister src) {
@@ -9059,43 +8458,35 @@
   InstructionAttr attributes(AVX_128bit, /* rex_w */ true, /* legacy_mode */ false, /* no_mask_reg */ true, /* uses_vl */ false);
   // swap src/dst to get correct prefix
   int encode = simd_prefix_and_encode(src, xnoreg, as_XMMRegister(dst->encoding()), VEX_SIMD_66, VEX_OPCODE_0F, &attributes);
-  emit_int8(0x7E);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x7E, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x8B);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0x8B, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x8B);
+  emit_int16(get_prefixq(src, dst), (unsigned char)0x8B);
   emit_operand(dst, src);
 }
 
 void Assembler::movq(Address dst, Register src) {
   InstructionMark im(this);
-  prefixq(dst, src);
-  emit_int8((unsigned char)0x89);
+  emit_int16(get_prefixq(dst, src), (unsigned char)0x89);
   emit_operand(src, dst);
 }
 
 void Assembler::movsbq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBE);
+  emit_int24(get_prefixq(src, dst), 0x0F, (unsigned char)0xBE);
   emit_operand(dst, src);
 }
 
 void Assembler::movsbq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBE);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24(0x0F, (unsigned char)0xBE, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movslq(Register dst, int32_t imm32) {
@@ -9112,109 +8503,87 @@
 void Assembler::movslq(Address dst, int32_t imm32) {
   assert(is_simm32(imm32), "lost bits");
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0xC7);
+  emit_int16(get_prefixq(dst), (unsigned char)0xC7);
   emit_operand(rax, dst, 4);
   emit_int32(imm32);
 }
 
 void Assembler::movslq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x63);
+  emit_int16(get_prefixq(src, dst), 0x63);
   emit_operand(dst, src);
 }
 
 void Assembler::movslq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x63);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16(0x63, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movswq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xBF);
+  emit_int24(get_prefixq(src, dst), 0x0F, (unsigned char)0xBF);
   emit_operand(dst, src);
 }
 
 void Assembler::movswq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xBF);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24((unsigned char)0x0F, (unsigned char)0xBF, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::movzbq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xB6);
+  emit_int24(get_prefixq(src, dst), (unsigned char)0x0F, (unsigned char)0xB6);
   emit_operand(dst, src);
 }
 
 void Assembler::movzbq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xB6);
-  emit_int8(0xC0 | encode);
+  emit_int24(0x0F, (unsigned char)0xB6, 0xC0 | encode);
 }
 
 void Assembler::movzwq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xB7);
+  emit_int24(get_prefixq(src, dst), (unsigned char)0x0F, (unsigned char)0xB7);
   emit_operand(dst, src);
 }
 
 void Assembler::movzwq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xB7);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24((unsigned char)0x0F, (unsigned char)0xB7, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::mulq(Address src) {
   InstructionMark im(this);
-  prefixq(src);
-  emit_int8((unsigned char)0xF7);
+  emit_int16(get_prefixq(src), (unsigned char)0xF7);
   emit_operand(rsp, src);
 }
 
 void Assembler::mulq(Register src) {
   int encode = prefixq_and_encode(src->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xE0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xE0 | encode));
 }
 
 void Assembler::mulxq(Register dst1, Register dst2, Register src) {
   assert(VM_Version::supports_bmi2(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst1->encoding(), dst2->encoding(), src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F_38, &attributes);
-  emit_int8((unsigned char)0xF6);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int16((unsigned char)0xF6, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::negq(Register dst) {
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xD8 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xD8 | encode));
 }
 
 void Assembler::notq(Register dst) {
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xF7);
-  emit_int8((unsigned char)(0xD0 | encode));
+  emit_int16((unsigned char)0xF7, (unsigned char)(0xD0 | encode));
 }
 
 void Assembler::btsq(Address dst, int imm8) {
   assert(isByte(imm8), "not a byte");
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xBA);
+  emit_int24(get_prefixq(dst), (unsigned char)0x0F, (unsigned char)0xBA);
   emit_operand(rbp /* 5 */, dst, 1);
   emit_int8(imm8);
 }
@@ -9222,17 +8591,14 @@
 void Assembler::btrq(Address dst, int imm8) {
   assert(isByte(imm8), "not a byte");
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xBA);
+  emit_int24(get_prefixq(dst), (unsigned char)0x0F, (unsigned char)0xBA);
   emit_operand(rsi /* 6 */, dst, 1);
   emit_int8(imm8);
 }
 
 void Assembler::orq(Address dst, int32_t imm32) {
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x81);
+  emit_int16(get_prefixq(dst), (unsigned char)0x81);
   emit_operand(rcx, dst, 4);
   emit_int32(imm32);
 }
@@ -9244,8 +8610,7 @@
 
 void Assembler::orq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x0B);
+  emit_int16(get_prefixq(src, dst), 0x0B);
   emit_operand(dst, src);
 }
 
@@ -9257,10 +8622,7 @@
 void Assembler::popcntq(Register dst, Address src) {
   assert(VM_Version::supports_popcnt(), "must support");
   InstructionMark im(this);
-  emit_int8((unsigned char)0xF3);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xB8);
+  emit_int32((unsigned char)0xF3, get_prefixq(src, dst), (unsigned char)0x0F, (unsigned char)0xB8);
   emit_operand(dst, src);
 }
 
@@ -9268,15 +8630,12 @@
   assert(VM_Version::supports_popcnt(), "must support");
   emit_int8((unsigned char)0xF3);
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x0F);
-  emit_int8((unsigned char)0xB8);
-  emit_int8((unsigned char)(0xC0 | encode));
+  emit_int24((unsigned char)0x0F, (unsigned char)0xB8, (unsigned char)(0xC0 | encode));
 }
 
 void Assembler::popq(Address dst) {
   InstructionMark im(this);
-  prefixq(dst);
-  emit_int8((unsigned char)0x8F);
+  emit_int16(get_prefixq(dst), (unsigned char)0x8F);
   emit_operand(rax, dst);
 }
 
@@ -9347,6 +8706,7 @@
   code_section->set_end(end + src_len);
 }
 
+
 void Assembler::popa() { // 64bit
   emit_copy(code_section(), popa_code, popa_len);
 }
@@ -9407,8 +8767,7 @@
 
 void Assembler::pushq(Address src) {
   InstructionMark im(this);
-  prefixq(src);
-  emit_int8((unsigned char)0xFF);
+  emit_int16(get_prefixq(src), (unsigned char)0xFF);
   emit_operand(rsi, src);
 }
 
@@ -9416,12 +8775,9 @@
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xD0 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xD0 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xD0 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xD0 | encode), imm8);
   }
 }
 
@@ -9429,12 +8785,9 @@
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xD8 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xD8 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xD8 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xD8 | encode), imm8);
   }
 }
 
@@ -9442,12 +8795,9 @@
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xC8 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xC8 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xc8 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xc8 | encode), imm8);
   }
 }
 
@@ -9455,37 +8805,29 @@
   assert(VM_Version::supports_bmi2(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ true, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0xF0);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xF0, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::rorxd(Register dst, Register src, int imm8) {
   assert(VM_Version::supports_bmi2(), "bit manipulation instructions not supported");
   InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
   int encode = vex_prefix_and_encode(dst->encoding(), 0, src->encoding(), VEX_SIMD_F2, VEX_OPCODE_0F_3A, &attributes);
-  emit_int8((unsigned char)0xF0);
-  emit_int8((unsigned char)(0xC0 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xF0, (unsigned char)(0xC0 | encode), imm8);
 }
 
 void Assembler::sarq(Register dst, int imm8) {
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xF8 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xF8 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xF8 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xF8 | encode), imm8);
   }
 }
 
 void Assembler::sarq(Register dst) {
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xF8 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xF8 | encode));
 }
 
 void Assembler::sbbq(Address dst, int32_t imm32) {
@@ -9501,8 +8843,7 @@
 
 void Assembler::sbbq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x1B);
+  emit_int16(get_prefixq(src, dst), 0x1B);
   emit_operand(dst, src);
 }
 
@@ -9515,33 +8856,26 @@
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
   if (imm8 == 1) {
-    emit_int8((unsigned char)0xD1);
-    emit_int8((unsigned char)(0xE0 | encode));
+    emit_int16((unsigned char)0xD1, (unsigned char)(0xE0 | encode));
   } else {
-    emit_int8((unsigned char)0xC1);
-    emit_int8((unsigned char)(0xE0 | encode));
-    emit_int8(imm8);
+    emit_int24((unsigned char)0xC1, (unsigned char)(0xE0 | encode), imm8);
   }
 }
 
 void Assembler::shlq(Register dst) {
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8((unsigned char)(0xE0 | encode));
+  emit_int16((unsigned char)0xD3, (unsigned char)(0xE0 | encode));
 }
 
 void Assembler::shrq(Register dst, int imm8) {
   assert(isShiftCount(imm8 >> 1), "illegal shift count");
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xC1);
-  emit_int8((unsigned char)(0xE8 | encode));
-  emit_int8(imm8);
+  emit_int24((unsigned char)0xC1, (unsigned char)(0xE8 | encode), imm8);
 }
 
 void Assembler::shrq(Register dst) {
   int encode = prefixq_and_encode(dst->encoding());
-  emit_int8((unsigned char)0xD3);
-  emit_int8(0xE8 | encode);
+  emit_int16((unsigned char)0xD3, 0xE8 | encode);
 }
 
 void Assembler::subq(Address dst, int32_t imm32) {
@@ -9552,8 +8886,7 @@
 
 void Assembler::subq(Address dst, Register src) {
   InstructionMark im(this);
-  prefixq(dst, src);
-  emit_int8(0x29);
+  emit_int16(get_prefixq(dst, src), 0x29);
   emit_operand(src, dst);
 }
 
@@ -9570,8 +8903,7 @@
 
 void Assembler::subq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x2B);
+  emit_int16(get_prefixq(src, dst), 0x2B);
   emit_operand(dst, src);
 }
 
@@ -9586,12 +8918,10 @@
   // 8bit operands
   int encode = dst->encoding();
   if (encode == 0) {
-    prefix(REX_W);
-    emit_int8((unsigned char)0xA9);
+    emit_int16(REX_W, (unsigned char)0xA9);
   } else {
     encode = prefixq_and_encode(encode);
-    emit_int8((unsigned char)0xF7);
-    emit_int8((unsigned char)(0xC0 | encode));
+    emit_int16((unsigned char)0xF7, (unsigned char)(0xC0 | encode));
   }
   emit_int32(imm32);
 }
@@ -9603,30 +8933,25 @@
 
 void Assembler::testq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x85);
+  emit_int16(get_prefixq(src, dst), (unsigned char)0x85);
   emit_operand(dst, src);
 }
 
 void Assembler::xaddq(Address dst, Register src) {
   InstructionMark im(this);
-  prefixq(dst, src);
-  emit_int8(0x0F);
-  emit_int8((unsigned char)0xC1);
+  emit_int24(get_prefixq(dst, src), 0x0F, (unsigned char)0xC1);
   emit_operand(src, dst);
 }
 
 void Assembler::xchgq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8((unsigned char)0x87);
+  emit_int16(get_prefixq(src, dst), (unsigned char)0x87);
   emit_operand(dst, src);
 }
 
 void Assembler::xchgq(Register dst, Register src) {
   int encode = prefixq_and_encode(dst->encoding(), src->encoding());
-  emit_int8((unsigned char)0x87);
-  emit_int8((unsigned char)(0xc0 | encode));
+  emit_int16((unsigned char)0x87, (unsigned char)(0xc0 | encode));
 }
 
 void Assembler::xorq(Register dst, Register src) {
@@ -9636,8 +8961,7 @@
 
 void Assembler::xorq(Register dst, Address src) {
   InstructionMark im(this);
-  prefixq(src, dst);
-  emit_int8(0x33);
+  emit_int16(get_prefixq(src, dst), 0x33);
   emit_operand(dst, src);
 }
 
diff --git a/src/hotspot/cpu/x86/assembler_x86.hpp b/src/hotspot/cpu/x86/assembler_x86.hpp
--- a/src/hotspot/cpu/x86/assembler_x86.hpp
+++ b/src/hotspot/cpu/x86/assembler_x86.hpp
@@ -339,15 +339,15 @@
 
  private:
   bool base_needs_rex() const {
-    return _base != noreg && _base->encoding() >= 8;
+    return _base->is_valid() && _base->encoding() >= 8;
   }
 
   bool index_needs_rex() const {
-    return _index != noreg &&_index->encoding() >= 8;
+    return _index->is_valid() &&_index->encoding() >= 8;
   }
 
   bool xmmindex_needs_rex() const {
-    return _xmmindex != xnoreg && _xmmindex->encoding() >= 8;
+    return _xmmindex->is_valid() && _xmmindex->encoding() >= 8;
   }
 
   relocInfo::relocType reloc() const { return _rspec.type(); }
@@ -659,7 +659,7 @@
   bool _legacy_mode_dq;
   bool _legacy_mode_vl;
   bool _legacy_mode_vlbw;
-  bool _is_managed;
+  NOT_LP64(bool _is_managed;)
 
   class InstructionAttr *_attributes;
 
@@ -673,18 +673,25 @@
   int prefix_and_encode(int dst_enc, bool dst_is_byte, int src_enc, bool src_is_byte);
   int prefixq_and_encode(int dst_enc, int src_enc);
 
+
   void prefix(Register reg);
   void prefix(Register dst, Register src, Prefix p);
   void prefix(Register dst, Address adr, Prefix p);
   void prefix(Address adr);
   void prefixq(Address adr);
 
+
   void prefix(Address adr, Register reg,  bool byteinst = false);
   void prefix(Address adr, XMMRegister reg);
   void prefixq(Address adr, Register reg);
   void prefixq(Address adr, XMMRegister reg);
 
-  void prefetch_prefix(Address src);
+  // Some prefix variant have a total mapping - they always exactly one prefix
+  // byte per input), so beside a prefix-emitting method we provide a method
+  // to get the prefix byte to emit. This byte can then be folded into a byte
+  // stream. This can generate faster, more compact code.
+  int8_t get_prefixq(Address adr);
+  int8_t get_prefixq(Address adr, Register reg);
 
   void rex_prefix(Address adr, XMMRegister xreg,
                   VexSimdPrefix pre, VexOpcode opc, bool rex_w);
@@ -870,16 +877,18 @@
     _legacy_mode_dq = (VM_Version::supports_avx512dq() == false);
     _legacy_mode_vl = (VM_Version::supports_avx512vl() == false);
     _legacy_mode_vlbw = (VM_Version::supports_avx512vlbw() == false);
-    _is_managed = false;
+    NOT_LP64(_is_managed = false;)
     _attributes = NULL;
   }
 
   void set_attributes(InstructionAttr *attributes) { _attributes = attributes; }
   void clear_attributes(void) { _attributes = NULL; }
 
-  void set_managed(void) { _is_managed = true; }
-  void clear_managed(void) { _is_managed = false; }
-  bool is_managed(void) { return _is_managed; }
+  void set_managed(void) { NOT_LP64(_is_managed = true;) }
+  void clear_managed(void) { NOT_LP64(_is_managed = false;) }
+  bool is_managed(void) {
+    NOT_LP64(return _is_managed;)
+    LP64_ONLY(return false;) }
 
   void lea(Register dst, Address src);
 
@@ -2280,22 +2289,20 @@
     bool no_reg_mask,   // when true, k0 is used when EVEX encoding is chosen, else embedded_opmask_register_specifier is used
     bool uses_vl)       // This instruction may have legacy constraints based on vector length for EVEX
     :
-      _avx_vector_len(vector_len),
       _rex_vex_w(rex_vex_w),
-      _rex_vex_w_reverted(false),
-      _legacy_mode(legacy_mode),
+      _legacy_mode(legacy_mode || UseAVX < 3),
       _no_reg_mask(no_reg_mask),
       _uses_vl(uses_vl),
+      _rex_vex_w_reverted(false),
+      _is_evex_instruction(false),
+      _is_clear_context(true),
+      _is_extended_context(false),
+      _avx_vector_len(vector_len),
       _tuple_type(Assembler::EVEX_ETUP),
       _input_size_in_bits(Assembler::EVEX_NObit),
-      _is_evex_instruction(false),
       _evex_encoding(0),
-      _is_clear_context(true),
-      _is_extended_context(false),
       _embedded_opmask_register_specifier(0), // hard code k0
-      _current_assembler(NULL) {
-    if (UseAVX < 3) _legacy_mode = true;
-  }
+      _current_assembler(NULL) { }
 
   ~InstructionAttr() {
     if (_current_assembler != NULL) {
@@ -2305,37 +2312,37 @@
   }
 
 private:
-  int  _avx_vector_len;
   bool _rex_vex_w;
-  bool _rex_vex_w_reverted;
   bool _legacy_mode;
   bool _no_reg_mask;
   bool _uses_vl;
+  bool _rex_vex_w_reverted;
+  bool _is_evex_instruction;
+  bool _is_clear_context;
+  bool _is_extended_context;
+  int  _avx_vector_len;
   int  _tuple_type;
   int  _input_size_in_bits;
-  bool _is_evex_instruction;
   int  _evex_encoding;
-  bool _is_clear_context;
-  bool _is_extended_context;
   int _embedded_opmask_register_specifier;
 
   Assembler *_current_assembler;
 
 public:
   // query functions for field accessors
-  int  get_vector_len(void) const { return _avx_vector_len; }
   bool is_rex_vex_w(void) const { return _rex_vex_w; }
-  bool is_rex_vex_w_reverted(void) { return _rex_vex_w_reverted; }
   bool is_legacy_mode(void) const { return _legacy_mode; }
   bool is_no_reg_mask(void) const { return _no_reg_mask; }
   bool uses_vl(void) const { return _uses_vl; }
+  bool is_rex_vex_w_reverted(void) { return _rex_vex_w_reverted; }
+  bool is_evex_instruction(void) const { return _is_evex_instruction; }
+  bool is_clear_context(void) const { return _is_clear_context; }
+  bool is_extended_context(void) const { return _is_extended_context; }
+  int  get_vector_len(void) const { return _avx_vector_len; }
   int  get_tuple_type(void) const { return _tuple_type; }
   int  get_input_size(void) const { return _input_size_in_bits; }
-  int  is_evex_instruction(void) const { return _is_evex_instruction; }
   int  get_evex_encoding(void) const { return _evex_encoding; }
-  bool is_clear_context(void) const { return _is_clear_context; }
-  bool is_extended_context(void) const { return _is_extended_context; }
-  int get_embedded_opmask_register_specifier(void) const { return _embedded_opmask_register_specifier; }
+  int  get_embedded_opmask_register_specifier(void) const { return _embedded_opmask_register_specifier; }
 
   // Set the vector len manually
   void set_vector_len(int vector_len) { _avx_vector_len = vector_len; }
diff --git a/src/hotspot/share/asm/assembler.hpp b/src/hotspot/share/asm/assembler.hpp
--- a/src/hotspot/share/asm/assembler.hpp
+++ b/src/hotspot/share/asm/assembler.hpp
@@ -283,14 +283,21 @@
   // ensure buf contains all code (call this before using/copying the code)
   void flush();
 
-  void emit_int8(   int8_t  x) { code_section()->emit_int8(   x); }
-  void emit_int16(  int16_t x) { code_section()->emit_int16(  x); }
-  void emit_int32(  int32_t x) { code_section()->emit_int32(  x); }
-  void emit_int64(  int64_t x) { code_section()->emit_int64(  x); }
+  void emit_int8(   int8_t x1)                                  { code_section()->emit_int8(x1); }
 
-  void emit_float(  jfloat  x) { code_section()->emit_float(  x); }
-  void emit_double( jdouble x) { code_section()->emit_double( x); }
-  void emit_address(address x) { code_section()->emit_address(x); }
+  void emit_int16(  int16_t x)                                  { code_section()->emit_int16(x); }
+  void emit_int16(  int8_t x1, int8_t x2)                       { code_section()->emit_int16(x1, x2); }
+
+  void emit_int24(  int8_t x1, int8_t x2, int8_t x3)            { code_section()->emit_int24(x1, x2, x3); }
+
+  void emit_int32(  int32_t x)                                  { code_section()->emit_int32(x); }
+  void emit_int32(  int8_t x1, int8_t x2, int8_t x3, int8_t x4) { code_section()->emit_int32(x1, x2, x3, x4); }
+
+  void emit_int64(  int64_t x)                                  { code_section()->emit_int64(x); }
+
+  void emit_float(  jfloat  x)                                  { code_section()->emit_float(x); }
+  void emit_double( jdouble x)                                  { code_section()->emit_double(x); }
+  void emit_address(address x)                                  { code_section()->emit_address(x); }
 
   // min and max values for signed immediate ranges
   static int min_simm(int nbits) { return -(intptr_t(1) << (nbits - 1))    ; }
diff --git a/src/hotspot/share/asm/codeBuffer.hpp b/src/hotspot/share/asm/codeBuffer.hpp
--- a/src/hotspot/share/asm/codeBuffer.hpp
+++ b/src/hotspot/share/asm/codeBuffer.hpp
@@ -200,9 +200,38 @@
   }
 
   // Code emission
-  void emit_int8 ( int8_t  x)  { *((int8_t*)  end()) = x; set_end(end() + sizeof(int8_t)); }
-  void emit_int16( int16_t x)  { *((int16_t*) end()) = x; set_end(end() + sizeof(int16_t)); }
-  void emit_int32( int32_t x)  { *((int32_t*) end()) = x; set_end(end() + sizeof(int32_t)); }
+  void emit_int8(int8_t x1) {
+    address curr = end();
+    *((int8_t*)  curr++) = x1;
+    set_end(curr);
+  }
+
+  void emit_int16(int16_t x) { *((int16_t*) end()) = x; set_end(end() + sizeof(int16_t)); }
+  void emit_int16(int8_t x1, int8_t x2) {
+    address curr = end();
+    *((int8_t*)  curr++) = x1;
+    *((int8_t*)  curr++) = x2;
+    set_end(curr);
+  }
+
+  void emit_int24(int8_t x1, int8_t x2, int8_t x3)  {
+    address curr = end();
+    *((int8_t*)  curr++) = x1;
+    *((int8_t*)  curr++) = x2;
+    *((int8_t*)  curr++) = x3;
+    set_end(curr);
+  }
+
+  void emit_int32(int32_t x) { *((int32_t*) end()) = x; set_end(end() + sizeof(int32_t)); }
+  void emit_int32(int8_t x1, int8_t x2, int8_t x3, int8_t x4)  {
+    address curr = end();
+    *((int8_t*)  curr++) = x1;
+    *((int8_t*)  curr++) = x2;
+    *((int8_t*)  curr++) = x3;
+    *((int8_t*)  curr++) = x4;
+    set_end(curr);
+  }
+
   void emit_int64( int64_t x)  { *((int64_t*) end()) = x; set_end(end() + sizeof(int64_t)); }
 
   void emit_float( jfloat  x)  { *((jfloat*)  end()) = x; set_end(end() + sizeof(jfloat)); }