mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
ac5d6faea8
Previously, YJIT incorrectly discarded the upper 32 bits of the object pointer when writing out VALUEs to setup default keyword arguments. In addition to incorrectly truncating, the output pointers were not properly tracked for handling GC compaction moving the referenced objects. YJIT previously attempted to encode a mov instruction with a memory destination and a 64 bit immediate when there is no such encoding possible in the ISA. Add an assert to mitigate not being able to catch this at build time.
1835 lines
53 KiB
C
1835 lines
53 KiB
C
// This file is a fragment of the yjit.o compilation unit. See yjit.c.
|
|
//
|
|
// Note that the definition for some of these functions don't specify
|
|
// static inline, but their declaration in yjit_asm.h do. The resulting
|
|
// linkage is the same as if they both specify. The relevant sections in
|
|
// N1256 is 6.2.2p4, 6.2.2p5, and 6.7.4p5.
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
|
|
// For mmapp(), sysconf()
|
|
#ifndef _WIN32
|
|
#include <unistd.h>
|
|
#include <sys/mman.h>
|
|
#endif
|
|
|
|
#include "yjit_asm.h"
|
|
|
|
// Compute the number of bits needed to encode a signed value
|
|
uint32_t sig_imm_size(int64_t imm)
|
|
{
|
|
// Compute the smallest size this immediate fits in
|
|
if (imm >= INT8_MIN && imm <= INT8_MAX)
|
|
return 8;
|
|
if (imm >= INT16_MIN && imm <= INT16_MAX)
|
|
return 16;
|
|
if (imm >= INT32_MIN && imm <= INT32_MAX)
|
|
return 32;
|
|
|
|
return 64;
|
|
}
|
|
|
|
// Compute the number of bits needed to encode an unsigned value
|
|
uint32_t unsig_imm_size(uint64_t imm)
|
|
{
|
|
// Compute the smallest size this immediate fits in
|
|
if (imm <= UINT8_MAX)
|
|
return 8;
|
|
else if (imm <= UINT16_MAX)
|
|
return 16;
|
|
else if (imm <= UINT32_MAX)
|
|
return 32;
|
|
|
|
return 64;
|
|
}
|
|
|
|
x86opnd_t mem_opnd(uint32_t num_bits, x86opnd_t base_reg, int32_t disp)
|
|
{
|
|
bool is_iprel = base_reg.as.reg.reg_type == REG_IP;
|
|
|
|
x86opnd_t opnd = {
|
|
OPND_MEM,
|
|
num_bits,
|
|
.as.mem = { base_reg.as.reg.reg_no, 0, 0, false, is_iprel, disp }
|
|
};
|
|
|
|
return opnd;
|
|
}
|
|
|
|
x86opnd_t mem_opnd_sib(uint32_t num_bits, x86opnd_t base_reg, x86opnd_t index_reg, int32_t scale, int32_t disp)
|
|
{
|
|
uint8_t scale_exp;
|
|
switch (scale) {
|
|
case 8:
|
|
scale_exp = 3;
|
|
break;
|
|
case 4:
|
|
scale_exp = 2;
|
|
break;
|
|
case 2:
|
|
scale_exp = 1;
|
|
break;
|
|
case 1:
|
|
scale_exp = 0;
|
|
break;
|
|
default:
|
|
rb_bug("yjit: scale not one of 1,2,4,8");
|
|
break;
|
|
}
|
|
|
|
bool is_iprel = base_reg.as.reg.reg_type == REG_IP;
|
|
|
|
x86opnd_t opnd = {
|
|
OPND_MEM,
|
|
num_bits,
|
|
.as.mem = {
|
|
.base_reg_no = base_reg.as.reg.reg_no,
|
|
.idx_reg_no = index_reg.as.reg.reg_no,
|
|
.has_idx = 1,
|
|
.scale_exp = scale_exp,
|
|
.is_iprel = is_iprel,
|
|
.disp = disp
|
|
}
|
|
};
|
|
|
|
return opnd;
|
|
}
|
|
|
|
static x86opnd_t resize_opnd(x86opnd_t opnd, uint32_t num_bits)
|
|
{
|
|
assert (num_bits % 8 == 0);
|
|
x86opnd_t sub = opnd;
|
|
sub.num_bits = num_bits;
|
|
return sub;
|
|
}
|
|
|
|
x86opnd_t imm_opnd(int64_t imm)
|
|
{
|
|
x86opnd_t opnd = {
|
|
OPND_IMM,
|
|
sig_imm_size(imm),
|
|
.as.imm = imm
|
|
};
|
|
|
|
return opnd;
|
|
}
|
|
|
|
x86opnd_t const_ptr_opnd(const void *ptr)
|
|
{
|
|
x86opnd_t opnd = {
|
|
OPND_IMM,
|
|
64,
|
|
.as.unsig_imm = (uint64_t)ptr
|
|
};
|
|
|
|
return opnd;
|
|
}
|
|
|
|
// Align the current write position to a multiple of bytes
|
|
static uint8_t *align_ptr(uint8_t *ptr, uint32_t multiple)
|
|
{
|
|
// Compute the pointer modulo the given alignment boundary
|
|
uint32_t rem = ((uint32_t)(uintptr_t)ptr) % multiple;
|
|
|
|
// If the pointer is already aligned, stop
|
|
if (rem == 0)
|
|
return ptr;
|
|
|
|
// Pad the pointer by the necessary amount to align it
|
|
uint32_t pad = multiple - rem;
|
|
|
|
return ptr + pad;
|
|
}
|
|
|
|
// Allocate a block of executable memory
|
|
static uint8_t *alloc_exec_mem(uint32_t mem_size)
|
|
{
|
|
#ifndef _WIN32
|
|
uint8_t *mem_block;
|
|
|
|
// On Linux
|
|
#if defined(MAP_FIXED_NOREPLACE) && defined(_SC_PAGESIZE)
|
|
// Align the requested address to page size
|
|
uint32_t page_size = (uint32_t)sysconf(_SC_PAGESIZE);
|
|
uint8_t *req_addr = align_ptr((uint8_t*)&alloc_exec_mem, page_size);
|
|
|
|
do {
|
|
// Try to map a chunk of memory as executable
|
|
mem_block = (uint8_t*)mmap(
|
|
(void*)req_addr,
|
|
mem_size,
|
|
PROT_READ | PROT_EXEC,
|
|
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE,
|
|
-1,
|
|
0
|
|
);
|
|
|
|
// If we succeeded, stop
|
|
if (mem_block != MAP_FAILED) {
|
|
break;
|
|
}
|
|
|
|
// +4MB
|
|
req_addr += 4 * 1024 * 1024;
|
|
} while (req_addr < (uint8_t*)&alloc_exec_mem + INT32_MAX);
|
|
|
|
// On MacOS and other platforms
|
|
#else
|
|
// Try to map a chunk of memory as executable
|
|
mem_block = (uint8_t*)mmap(
|
|
(void*)alloc_exec_mem,
|
|
mem_size,
|
|
PROT_READ | PROT_EXEC,
|
|
MAP_PRIVATE | MAP_ANONYMOUS,
|
|
-1,
|
|
0
|
|
);
|
|
#endif
|
|
|
|
// Fallback
|
|
if (mem_block == MAP_FAILED) {
|
|
// Try again without the address hint (e.g., valgrind)
|
|
mem_block = (uint8_t*)mmap(
|
|
NULL,
|
|
mem_size,
|
|
PROT_READ | PROT_EXEC,
|
|
MAP_PRIVATE | MAP_ANONYMOUS,
|
|
-1,
|
|
0
|
|
);
|
|
}
|
|
|
|
// Check that the memory mapping was successful
|
|
if (mem_block == MAP_FAILED) {
|
|
perror("mmap call failed");
|
|
exit(-1);
|
|
}
|
|
|
|
codeblock_t block;
|
|
codeblock_t *cb = █
|
|
|
|
cb_init(cb, mem_block, mem_size);
|
|
|
|
// Fill the executable memory with PUSH DS (0x1E) so that
|
|
// executing uninitialized memory will fault with #UD in
|
|
// 64-bit mode.
|
|
cb_mark_all_writeable(cb);
|
|
memset(mem_block, 0x1E, mem_size);
|
|
cb_mark_all_executable(cb);
|
|
|
|
return mem_block;
|
|
#else
|
|
// Windows not supported for now
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
// Initialize a code block object
|
|
void cb_init(codeblock_t *cb, uint8_t *mem_block, uint32_t mem_size)
|
|
{
|
|
assert (mem_block);
|
|
cb->mem_block_ = mem_block;
|
|
cb->mem_size = mem_size;
|
|
cb->write_pos = 0;
|
|
cb->num_labels = 0;
|
|
cb->num_refs = 0;
|
|
cb->current_aligned_write_pos = ALIGNED_WRITE_POSITION_NONE;
|
|
}
|
|
|
|
// Set the current write position
|
|
void cb_set_pos(codeblock_t *cb, uint32_t pos)
|
|
{
|
|
// Assert here since while assembler functions do bounds checking, there is
|
|
// nothing stopping users from taking out an out-of-bounds pointer and
|
|
// doing bad accesses with it.
|
|
assert (pos < cb->mem_size);
|
|
cb->write_pos = pos;
|
|
}
|
|
|
|
// Align the current write position to a multiple of bytes
|
|
void cb_align_pos(codeblock_t *cb, uint32_t multiple)
|
|
{
|
|
// Compute the pointer modulo the given alignment boundary
|
|
uint8_t *ptr = cb_get_write_ptr(cb);
|
|
uint8_t *aligned_ptr = align_ptr(ptr, multiple);
|
|
const uint32_t write_pos = cb->write_pos;
|
|
|
|
// Pad the pointer by the necessary amount to align it
|
|
ptrdiff_t pad = aligned_ptr - ptr;
|
|
cb_set_pos(cb, write_pos + (int32_t)pad);
|
|
}
|
|
|
|
// Set the current write position from a pointer
|
|
void cb_set_write_ptr(codeblock_t *cb, uint8_t *code_ptr)
|
|
{
|
|
intptr_t pos = code_ptr - cb->mem_block_;
|
|
assert (pos < cb->mem_size);
|
|
cb_set_pos(cb, (uint32_t)pos);
|
|
}
|
|
|
|
// Get a direct pointer into the executable memory block
|
|
uint8_t *cb_get_ptr(const codeblock_t *cb, uint32_t index)
|
|
{
|
|
if (index < cb->mem_size) {
|
|
return &cb->mem_block_[index];
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// Get a direct pointer to the current write position
|
|
uint8_t *cb_get_write_ptr(const codeblock_t *cb)
|
|
{
|
|
return cb_get_ptr(cb, cb->write_pos);
|
|
}
|
|
|
|
// Write a byte at the current position
|
|
void cb_write_byte(codeblock_t *cb, uint8_t byte)
|
|
{
|
|
assert (cb->mem_block_);
|
|
if (cb->write_pos < cb->mem_size) {
|
|
cb_mark_position_writeable(cb, cb->write_pos);
|
|
cb->mem_block_[cb->write_pos] = byte;
|
|
cb->write_pos++;
|
|
}
|
|
else {
|
|
cb->dropped_bytes = true;
|
|
}
|
|
}
|
|
|
|
// Write multiple bytes starting from the current position
|
|
void cb_write_bytes(codeblock_t *cb, uint32_t num_bytes, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, num_bytes);
|
|
|
|
for (uint32_t i = 0; i < num_bytes; ++i)
|
|
{
|
|
uint8_t byte = va_arg(va, int);
|
|
cb_write_byte(cb, byte);
|
|
}
|
|
|
|
va_end(va);
|
|
}
|
|
|
|
// Write a signed integer over a given number of bits at the current position
|
|
void cb_write_int(codeblock_t *cb, uint64_t val, uint32_t num_bits)
|
|
{
|
|
assert (num_bits > 0);
|
|
assert (num_bits % 8 == 0);
|
|
|
|
// Switch on the number of bits
|
|
switch (num_bits) {
|
|
case 8:
|
|
cb_write_byte(cb, (uint8_t)val);
|
|
break;
|
|
|
|
case 16:
|
|
cb_write_bytes(
|
|
cb,
|
|
2,
|
|
(uint8_t)((val >> 0) & 0xFF),
|
|
(uint8_t)((val >> 8) & 0xFF)
|
|
);
|
|
break;
|
|
|
|
case 32:
|
|
cb_write_bytes(
|
|
cb,
|
|
4,
|
|
(uint8_t)((val >> 0) & 0xFF),
|
|
(uint8_t)((val >> 8) & 0xFF),
|
|
(uint8_t)((val >> 16) & 0xFF),
|
|
(uint8_t)((val >> 24) & 0xFF)
|
|
);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
// Compute the size in bytes
|
|
uint32_t num_bytes = num_bits / 8;
|
|
|
|
// Write out the bytes
|
|
for (uint32_t i = 0; i < num_bytes; ++i)
|
|
{
|
|
uint8_t byte_val = (uint8_t)(val & 0xFF);
|
|
cb_write_byte(cb, byte_val);
|
|
val >>= 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allocate a new label with a given name
|
|
uint32_t cb_new_label(codeblock_t *cb, const char *name)
|
|
{
|
|
//if (hasASM)
|
|
// writeString(to!string(label) ~ ":");
|
|
|
|
assert (cb->num_labels < MAX_LABELS);
|
|
|
|
// Allocate the new label
|
|
uint32_t label_idx = cb->num_labels++;
|
|
|
|
// This label doesn't have an address yet
|
|
cb->label_addrs[label_idx] = 0;
|
|
cb->label_names[label_idx] = name;
|
|
|
|
return label_idx;
|
|
}
|
|
|
|
// Write a label at the current address
|
|
void cb_write_label(codeblock_t *cb, uint32_t label_idx)
|
|
{
|
|
assert (label_idx < MAX_LABELS);
|
|
cb->label_addrs[label_idx] = cb->write_pos;
|
|
}
|
|
|
|
// Add a label reference at the current write position
|
|
void cb_label_ref(codeblock_t *cb, uint32_t label_idx)
|
|
{
|
|
assert (label_idx < MAX_LABELS);
|
|
assert (cb->num_refs < MAX_LABEL_REFS);
|
|
|
|
// Keep track of the reference
|
|
cb->label_refs[cb->num_refs] = (labelref_t){ cb->write_pos, label_idx };
|
|
cb->num_refs++;
|
|
}
|
|
|
|
// Link internal label references
|
|
void cb_link_labels(codeblock_t *cb)
|
|
{
|
|
uint32_t orig_pos = cb->write_pos;
|
|
|
|
// For each label reference
|
|
for (uint32_t i = 0; i < cb->num_refs; ++i)
|
|
{
|
|
uint32_t ref_pos = cb->label_refs[i].pos;
|
|
uint32_t label_idx = cb->label_refs[i].label_idx;
|
|
assert (ref_pos < cb->mem_size);
|
|
assert (label_idx < MAX_LABELS);
|
|
|
|
uint32_t label_addr = cb->label_addrs[label_idx];
|
|
assert (label_addr < cb->mem_size);
|
|
|
|
// Compute the offset from the reference's end to the label
|
|
int64_t offset = (int64_t)label_addr - (int64_t)(ref_pos + 4);
|
|
|
|
cb_set_pos(cb, ref_pos);
|
|
cb_write_int(cb, offset, 32);
|
|
}
|
|
|
|
cb->write_pos = orig_pos;
|
|
|
|
// Clear the label positions and references
|
|
cb->num_labels = 0;
|
|
cb->num_refs = 0;
|
|
}
|
|
|
|
// Check if an operand needs a REX byte to be encoded
|
|
static bool rex_needed(x86opnd_t opnd)
|
|
{
|
|
if (opnd.type == OPND_NONE || opnd.type == OPND_IMM)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (opnd.type == OPND_REG)
|
|
{
|
|
return (
|
|
opnd.as.reg.reg_no > 7 ||
|
|
(opnd.num_bits == 8 && opnd.as.reg.reg_no >= 4 && opnd.as.reg.reg_no <= 7)
|
|
);
|
|
}
|
|
|
|
if (opnd.type == OPND_MEM)
|
|
{
|
|
return (opnd.as.mem.base_reg_no > 7) || (opnd.as.mem.has_idx && opnd.as.mem.idx_reg_no > 7);
|
|
}
|
|
|
|
rb_bug("unreachable");
|
|
}
|
|
|
|
// Check if an SIB byte is needed to encode this operand
|
|
static bool sib_needed(x86opnd_t opnd)
|
|
{
|
|
if (opnd.type != OPND_MEM)
|
|
return false;
|
|
|
|
return (
|
|
opnd.as.mem.has_idx ||
|
|
opnd.as.mem.base_reg_no == RSP.as.reg.reg_no ||
|
|
opnd.as.mem.base_reg_no == R12.as.reg.reg_no
|
|
);
|
|
}
|
|
|
|
// Compute the size of the displacement field needed for a memory operand
|
|
static uint32_t disp_size(x86opnd_t opnd)
|
|
{
|
|
assert (opnd.type == OPND_MEM);
|
|
|
|
// If using RIP as the base, use disp32
|
|
if (opnd.as.mem.is_iprel)
|
|
{
|
|
return 32;
|
|
}
|
|
|
|
// Compute the required displacement size
|
|
if (opnd.as.mem.disp != 0)
|
|
{
|
|
uint32_t num_bits = sig_imm_size(opnd.as.mem.disp);
|
|
assert (num_bits <= 32 && "displacement does not fit in 32 bits");
|
|
|
|
// x86 can only encode 8-bit and 32-bit displacements
|
|
if (num_bits == 16)
|
|
num_bits = 32;;
|
|
|
|
return num_bits;
|
|
}
|
|
|
|
// If EBP or RBP or R13 is used as the base, displacement must be encoded
|
|
if (opnd.as.mem.base_reg_no == RBP.as.reg.reg_no ||
|
|
opnd.as.mem.base_reg_no == R13.as.reg.reg_no)
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Write the REX byte
|
|
static void cb_write_rex(
|
|
codeblock_t *cb,
|
|
bool w_flag,
|
|
uint8_t reg_no,
|
|
uint8_t idx_reg_no,
|
|
uint8_t rm_reg_no
|
|
)
|
|
{
|
|
// 0 1 0 0 w r x b
|
|
// w - 64-bit operand size flag
|
|
// r - MODRM.reg extension
|
|
// x - SIB.index extension
|
|
// b - MODRM.rm or SIB.base extension
|
|
uint8_t w = w_flag? 1:0;
|
|
uint8_t r = (reg_no & 8)? 1:0;
|
|
uint8_t x = (idx_reg_no & 8)? 1:0;
|
|
uint8_t b = (rm_reg_no & 8)? 1:0;
|
|
|
|
// Encode and write the REX byte
|
|
uint8_t rexByte = 0x40 + (w << 3) + (r << 2) + (x << 1) + (b);
|
|
cb_write_byte(cb, rexByte);
|
|
}
|
|
|
|
// Write an opcode byte with an embedded register operand
|
|
static void cb_write_opcode(codeblock_t *cb, uint8_t opcode, x86opnd_t reg)
|
|
{
|
|
// Write the reg field into the opcode byte
|
|
uint8_t op_byte = opcode | (reg.as.reg.reg_no & 7);
|
|
cb_write_byte(cb, op_byte);
|
|
}
|
|
|
|
// Encode an RM instruction
|
|
static void cb_write_rm(
|
|
codeblock_t *cb,
|
|
bool szPref,
|
|
bool rexW,
|
|
x86opnd_t r_opnd,
|
|
x86opnd_t rm_opnd,
|
|
uint8_t opExt,
|
|
uint32_t op_len,
|
|
...)
|
|
{
|
|
assert (op_len > 0 && op_len <= 3);
|
|
assert (r_opnd.type == OPND_REG || r_opnd.type == OPND_NONE);
|
|
|
|
// Flag to indicate the REX prefix is needed
|
|
bool need_rex = rexW || rex_needed(r_opnd) || rex_needed(rm_opnd);
|
|
|
|
// Flag to indicate SIB byte is needed
|
|
bool need_sib = sib_needed(r_opnd) || sib_needed(rm_opnd);
|
|
|
|
// Add the operand-size prefix, if needed
|
|
if (szPref == true)
|
|
cb_write_byte(cb, 0x66);
|
|
|
|
// Add the REX prefix, if needed
|
|
if (need_rex)
|
|
{
|
|
// 0 1 0 0 w r x b
|
|
// w - 64-bit operand size flag
|
|
// r - MODRM.reg extension
|
|
// x - SIB.index extension
|
|
// b - MODRM.rm or SIB.base extension
|
|
|
|
uint8_t w = rexW? 1:0;
|
|
|
|
uint8_t r;
|
|
if (r_opnd.type != OPND_NONE)
|
|
r = (r_opnd.as.reg.reg_no & 8)? 1:0;
|
|
else
|
|
r = 0;
|
|
|
|
uint8_t x;
|
|
if (need_sib && rm_opnd.as.mem.has_idx)
|
|
x = (rm_opnd.as.mem.idx_reg_no & 8)? 1:0;
|
|
else
|
|
x = 0;
|
|
|
|
uint8_t b;
|
|
if (rm_opnd.type == OPND_REG)
|
|
b = (rm_opnd.as.reg.reg_no & 8)? 1:0;
|
|
else if (rm_opnd.type == OPND_MEM)
|
|
b = (rm_opnd.as.mem.base_reg_no & 8)? 1:0;
|
|
else
|
|
b = 0;
|
|
|
|
// Encode and write the REX byte
|
|
uint8_t rex_byte = 0x40 + (w << 3) + (r << 2) + (x << 1) + (b);
|
|
cb_write_byte(cb, rex_byte);
|
|
}
|
|
|
|
// Write the opcode bytes to the code block
|
|
va_list va;
|
|
va_start(va, op_len);
|
|
for (uint32_t i = 0; i < op_len; ++i)
|
|
{
|
|
uint8_t byte = va_arg(va, int);
|
|
cb_write_byte(cb, byte);
|
|
}
|
|
va_end(va);
|
|
|
|
// MODRM.mod (2 bits)
|
|
// MODRM.reg (3 bits)
|
|
// MODRM.rm (3 bits)
|
|
|
|
assert (
|
|
!(opExt != 0xFF && r_opnd.type != OPND_NONE) &&
|
|
"opcode extension and register operand present"
|
|
);
|
|
|
|
// Encode the mod field
|
|
uint8_t mod;
|
|
if (rm_opnd.type == OPND_REG)
|
|
{
|
|
mod = 3;
|
|
}
|
|
else
|
|
{
|
|
uint32_t dsize = disp_size(rm_opnd);
|
|
if (dsize == 0 || rm_opnd.as.mem.is_iprel)
|
|
mod = 0;
|
|
else if (dsize == 8)
|
|
mod = 1;
|
|
else if (dsize == 32)
|
|
mod = 2;
|
|
else
|
|
rb_bug("unreachable");
|
|
}
|
|
|
|
// Encode the reg field
|
|
uint8_t reg;
|
|
if (opExt != 0xFF)
|
|
reg = opExt;
|
|
else if (r_opnd.type == OPND_REG)
|
|
reg = r_opnd.as.reg.reg_no & 7;
|
|
else
|
|
reg = 0;
|
|
|
|
// Encode the rm field
|
|
uint8_t rm;
|
|
if (rm_opnd.type == OPND_REG)
|
|
{
|
|
rm = rm_opnd.as.reg.reg_no & 7;
|
|
}
|
|
else
|
|
{
|
|
if (need_sib)
|
|
rm = 4;
|
|
else
|
|
rm = rm_opnd.as.mem.base_reg_no & 7;
|
|
}
|
|
|
|
// Encode and write the ModR/M byte
|
|
uint8_t rm_byte = (mod << 6) + (reg << 3) + (rm);
|
|
cb_write_byte(cb, rm_byte);
|
|
|
|
// Add the SIB byte, if needed
|
|
if (need_sib)
|
|
{
|
|
// SIB.scale (2 bits)
|
|
// SIB.index (3 bits)
|
|
// SIB.base (3 bits)
|
|
|
|
assert (rm_opnd.type == OPND_MEM);
|
|
|
|
// Encode the scale value
|
|
uint8_t scale = rm_opnd.as.mem.scale_exp;
|
|
|
|
// Encode the index value
|
|
uint8_t index;
|
|
if (!rm_opnd.as.mem.has_idx)
|
|
index = 4;
|
|
else
|
|
index = rm_opnd.as.mem.idx_reg_no & 7;
|
|
|
|
// Encode the base register
|
|
uint8_t base = rm_opnd.as.mem.base_reg_no & 7;
|
|
|
|
// Encode and write the SIB byte
|
|
uint8_t sib_byte = (scale << 6) + (index << 3) + (base);
|
|
cb_write_byte(cb, sib_byte);
|
|
}
|
|
|
|
// Add the displacement
|
|
if (rm_opnd.type == OPND_MEM)
|
|
{
|
|
uint32_t dsize = disp_size(rm_opnd);
|
|
if (dsize > 0)
|
|
cb_write_int(cb, rm_opnd.as.mem.disp, dsize);
|
|
}
|
|
}
|
|
|
|
// Encode a mul-like single-operand RM instruction
|
|
static void write_rm_unary(
|
|
codeblock_t *cb,
|
|
const char *mnem,
|
|
uint8_t opMemReg8,
|
|
uint8_t opMemRegPref,
|
|
uint8_t opExt,
|
|
x86opnd_t opnd)
|
|
{
|
|
// Write a disassembly string
|
|
//cb.writeASM(mnem, opnd);
|
|
|
|
// Check the size of opnd0
|
|
uint32_t opndSize;
|
|
if (opnd.type == OPND_REG || opnd.type == OPND_MEM)
|
|
opndSize = opnd.num_bits;
|
|
else
|
|
rb_bug("yjit: invalid operand");
|
|
|
|
assert (opndSize == 8 || opndSize == 16 || opndSize == 32 || opndSize == 64);
|
|
bool szPref = opndSize == 16;
|
|
bool rexW = opndSize == 64;
|
|
|
|
if (opndSize == 8)
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd, opExt, 1, opMemReg8);
|
|
else
|
|
cb_write_rm(cb, szPref, rexW, NO_OPND, opnd, opExt, 1, opMemRegPref);
|
|
}
|
|
|
|
// Encode an add-like RM instruction with multiple possible encodings
|
|
static void cb_write_rm_multi(
|
|
codeblock_t *cb,
|
|
const char *mnem,
|
|
uint8_t opMemReg8,
|
|
uint8_t opMemRegPref,
|
|
uint8_t opRegMem8,
|
|
uint8_t opRegMemPref,
|
|
uint8_t opMemImm8,
|
|
uint8_t opMemImmSml,
|
|
uint8_t opMemImmLrg,
|
|
uint8_t opExtImm,
|
|
x86opnd_t opnd0,
|
|
x86opnd_t opnd1)
|
|
{
|
|
assert (opnd0.type == OPND_REG || opnd0.type == OPND_MEM);
|
|
|
|
/*
|
|
// Write disassembly string
|
|
if (!opnd1.isNone)
|
|
cb.writeASM(mnem, opnd0, opnd1);
|
|
else
|
|
cb.writeASM(mnem, opnd0);
|
|
*/
|
|
|
|
// Check the size of opnd0
|
|
uint32_t opndSize = opnd0.num_bits;
|
|
|
|
// Check the size of opnd1
|
|
if (opnd1.type == OPND_REG || opnd1.type == OPND_MEM)
|
|
{
|
|
assert (opnd1.num_bits == opndSize && "operand size mismatch");
|
|
}
|
|
else if (opnd1.type == OPND_IMM)
|
|
{
|
|
assert (opnd1.num_bits <= opndSize);
|
|
}
|
|
|
|
assert (opndSize == 8 || opndSize == 16 || opndSize == 32 || opndSize == 64);
|
|
bool szPref = opndSize == 16;
|
|
bool rexW = opndSize == 64;
|
|
|
|
// R/M + Reg
|
|
if ((opnd0.type == OPND_MEM && opnd1.type == OPND_REG) ||
|
|
(opnd0.type == OPND_REG && opnd1.type == OPND_REG))
|
|
{
|
|
// R/M is opnd0
|
|
if (opndSize == 8)
|
|
cb_write_rm(cb, false, false, opnd1, opnd0, 0xFF, 1, opMemReg8);
|
|
else
|
|
cb_write_rm(cb, szPref, rexW, opnd1, opnd0, 0xFF, 1, opMemRegPref);
|
|
}
|
|
|
|
// Reg + R/M
|
|
else if (opnd0.type == OPND_REG && opnd1.type == OPND_MEM)
|
|
{
|
|
// R/M is opnd1
|
|
if (opndSize == 8)
|
|
cb_write_rm(cb, false, false, opnd0, opnd1, 0xFF, 1, opRegMem8);
|
|
else
|
|
cb_write_rm(cb, szPref, rexW, opnd0, opnd1, 0xFF, 1, opRegMemPref);
|
|
}
|
|
|
|
// R/M + Imm
|
|
else if (opnd1.type == OPND_IMM)
|
|
{
|
|
// 8-bit immediate
|
|
if (opnd1.num_bits <= 8)
|
|
{
|
|
if (opndSize == 8)
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd0, opExtImm, 1, opMemImm8);
|
|
else
|
|
cb_write_rm(cb, szPref, rexW, NO_OPND, opnd0, opExtImm, 1, opMemImmSml);
|
|
|
|
cb_write_int(cb, opnd1.as.imm, 8);
|
|
}
|
|
|
|
// 32-bit immediate
|
|
else if (opnd1.num_bits <= 32)
|
|
{
|
|
assert (opnd1.num_bits <= opndSize && "immediate too large for dst");
|
|
cb_write_rm(cb, szPref, rexW, NO_OPND, opnd0, opExtImm, 1, opMemImmLrg);
|
|
cb_write_int(cb, opnd1.as.imm, (opndSize > 32)? 32:opndSize);
|
|
}
|
|
|
|
// Immediate too large
|
|
else
|
|
{
|
|
assert (false && "immediate value too large");
|
|
}
|
|
}
|
|
|
|
// Invalid operands
|
|
else
|
|
{
|
|
assert (false && "invalid operand combination");
|
|
}
|
|
}
|
|
|
|
// Encode a single-operand shift instruction
|
|
static void cb_write_shift(
|
|
codeblock_t *cb,
|
|
const char *mnem,
|
|
uint8_t opMemOnePref,
|
|
uint8_t opMemClPref,
|
|
uint8_t opMemImmPref,
|
|
uint8_t opExt,
|
|
x86opnd_t opnd0,
|
|
x86opnd_t opnd1)
|
|
{
|
|
// Write a disassembly string
|
|
//cb.writeASM(mnem, opnd0, opnd1);
|
|
|
|
// Check the size of opnd0
|
|
uint32_t opndSize;
|
|
if (opnd0.type == OPND_REG || opnd0.type == OPND_MEM)
|
|
opndSize = opnd0.num_bits;
|
|
else
|
|
rb_bug("yjit: shift: invalid first operand");
|
|
|
|
assert (opndSize == 16 || opndSize == 32 || opndSize == 64);
|
|
bool szPref = opndSize == 16;
|
|
bool rexW = opndSize == 64;
|
|
|
|
if (opnd1.type == OPND_IMM)
|
|
{
|
|
if (opnd1.as.imm == 1)
|
|
{
|
|
cb_write_rm(cb, szPref, rexW, NO_OPND, opnd0, opExt, 1, opMemOnePref);
|
|
}
|
|
else
|
|
{
|
|
assert (opnd1.num_bits <= 8);
|
|
cb_write_rm(cb, szPref, rexW, NO_OPND, opnd0, opExt, 1, opMemImmPref);
|
|
cb_write_byte(cb, (uint8_t)opnd1.as.imm);
|
|
}
|
|
}
|
|
/*
|
|
else if (opnd1.isReg && opnd1.reg == CL)
|
|
{
|
|
cb.writeRMInstr!('l', opExt, opMemClPref)(szPref, rexW, opnd0, X86Opnd.NONE);
|
|
}
|
|
*/
|
|
else
|
|
{
|
|
assert (false);
|
|
}
|
|
}
|
|
|
|
// Encode a relative jump to a label (direct or conditional)
|
|
// Note: this always encodes a 32-bit offset
|
|
static void cb_write_jcc(codeblock_t *cb, const char *mnem, uint8_t op0, uint8_t op1, uint32_t label_idx)
|
|
{
|
|
//cb.writeASM(mnem, label);
|
|
|
|
// Write the opcode
|
|
if (op0 != 0xFF)
|
|
cb_write_byte(cb, op0);
|
|
cb_write_byte(cb, op1);
|
|
|
|
// Add a reference to the label
|
|
cb_label_ref(cb, label_idx);
|
|
|
|
// Relative 32-bit offset to be patched
|
|
cb_write_int(cb, 0, 32);
|
|
}
|
|
|
|
// Encode a relative jump to a pointer at a 32-bit offset (direct or conditional)
|
|
static void cb_write_jcc_ptr(codeblock_t *cb, const char *mnem, uint8_t op0, uint8_t op1, uint8_t *dst_ptr)
|
|
{
|
|
//cb.writeASM(mnem, label);
|
|
|
|
// Write the opcode
|
|
if (op0 != 0xFF)
|
|
cb_write_byte(cb, op0);
|
|
cb_write_byte(cb, op1);
|
|
|
|
// Pointer to the end of this jump instruction
|
|
uint8_t *end_ptr = cb_get_ptr(cb, cb->write_pos + 4);
|
|
|
|
// Compute the jump offset
|
|
int64_t rel64 = (int64_t)(dst_ptr - end_ptr);
|
|
if (rel64 >= INT32_MIN && rel64 <= INT32_MAX) {
|
|
// Write the relative 32-bit jump offset
|
|
cb_write_int(cb, (int32_t)rel64, 32);
|
|
}
|
|
else {
|
|
// Offset doesn't fit in 4 bytes. Report error.
|
|
cb->dropped_bytes = true;
|
|
}
|
|
}
|
|
|
|
// Encode a conditional move instruction
|
|
static void cb_write_cmov(codeblock_t *cb, const char *mnem, uint8_t opcode1, x86opnd_t dst, x86opnd_t src)
|
|
{
|
|
//cb.writeASM(mnem, dst, src);
|
|
|
|
assert (dst.type == OPND_REG);
|
|
assert (src.type == OPND_REG || src.type == OPND_MEM);
|
|
assert (dst.num_bits >= 16 && "invalid dst reg size in cmov");
|
|
|
|
bool szPref = dst.num_bits == 16;
|
|
bool rexW = dst.num_bits == 64;
|
|
|
|
cb_write_rm(cb, szPref, rexW, dst, src, 0xFF, 2, 0x0F, opcode1);
|
|
}
|
|
|
|
// add - Integer addition
|
|
void add(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"add",
|
|
0x00, // opMemReg8
|
|
0x01, // opMemRegPref
|
|
0x02, // opRegMem8
|
|
0x03, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x00, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// and - Bitwise AND
|
|
void and(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"and",
|
|
0x20, // opMemReg8
|
|
0x21, // opMemRegPref
|
|
0x22, // opRegMem8
|
|
0x23, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x04, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
// call - Call to a pointer with a 32-bit displacement offset
|
|
static void call_rel32(codeblock_t *cb, int32_t rel32)
|
|
{
|
|
//cb.writeASM("call", rel32);
|
|
|
|
// Write the opcode
|
|
cb_write_byte(cb, 0xE8);
|
|
|
|
// Write the relative 32-bit jump offset
|
|
cb_write_int(cb, (int32_t)rel32, 32);
|
|
}
|
|
|
|
// call - Call a pointer, encode with a 32-bit offset if possible
|
|
void call_ptr(codeblock_t *cb, x86opnd_t scratch_reg, uint8_t *dst_ptr)
|
|
{
|
|
assert (scratch_reg.type == OPND_REG);
|
|
|
|
// Pointer to the end of this call instruction
|
|
uint8_t *end_ptr = cb_get_ptr(cb, cb->write_pos + 5);
|
|
|
|
// Compute the jump offset
|
|
int64_t rel64 = (int64_t)(dst_ptr - end_ptr);
|
|
|
|
// If the offset fits in 32-bit
|
|
if (rel64 >= INT32_MIN && rel64 <= INT32_MAX) {
|
|
call_rel32(cb, (int32_t)rel64);
|
|
return;
|
|
}
|
|
|
|
// Move the pointer into the scratch register and call
|
|
mov(cb, scratch_reg, const_ptr_opnd(dst_ptr));
|
|
call(cb, scratch_reg);
|
|
}
|
|
|
|
/// call - Call to label with 32-bit offset
|
|
void call_label(codeblock_t *cb, uint32_t label_idx)
|
|
{
|
|
//cb.writeASM("call", label);
|
|
|
|
// Write the opcode
|
|
cb_write_byte(cb, 0xE8);
|
|
|
|
// Add a reference to the label
|
|
cb_label_ref(cb, label_idx);
|
|
|
|
// Relative 32-bit offset to be patched
|
|
cb_write_int(cb, 0, 32);
|
|
}
|
|
|
|
/// call - Indirect call with an R/M operand
|
|
void call(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
//cb.writeASM("call", opnd);
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd, 2, 1, 0xFF);
|
|
}
|
|
|
|
/// cmovcc - Conditional move
|
|
void cmova(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmova", 0x47, dst, src); }
|
|
void cmovae(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovae", 0x43, dst, src); }
|
|
void cmovb(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovb", 0x42, dst, src); }
|
|
void cmovbe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovbe", 0x46, dst, src); }
|
|
void cmovc(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovc", 0x42, dst, src); }
|
|
void cmove(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmove", 0x44, dst, src); }
|
|
void cmovg(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovg", 0x4F, dst, src); }
|
|
void cmovge(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovge", 0x4D, dst, src); }
|
|
void cmovl(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovl", 0x4C, dst, src); }
|
|
void cmovle(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovle", 0x4E, dst, src); }
|
|
void cmovna(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovna", 0x46, dst, src); }
|
|
void cmovnae(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnae", 0x42, dst, src); }
|
|
void cmovnb(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnb", 0x43, dst, src); }
|
|
void cmovnbe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnbe", 0x47, dst, src); }
|
|
void cmovnc(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnc", 0x43, dst, src); }
|
|
void cmovne(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovne", 0x45, dst, src); }
|
|
void cmovng(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovng", 0x4E, dst, src); }
|
|
void cmovnge(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnge", 0x4C, dst, src); }
|
|
void cmovnl(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnl" , 0x4D, dst, src); }
|
|
void cmovnle(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnle", 0x4F, dst, src); }
|
|
void cmovno(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovno", 0x41, dst, src); }
|
|
void cmovnp(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnp", 0x4B, dst, src); }
|
|
void cmovns(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovns", 0x49, dst, src); }
|
|
void cmovnz(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnz", 0x45, dst, src); }
|
|
void cmovo(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovo", 0x40, dst, src); }
|
|
void cmovp(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovp", 0x4A, dst, src); }
|
|
void cmovpe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpe", 0x4A, dst, src); }
|
|
void cmovpo(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpo", 0x4B, dst, src); }
|
|
void cmovs(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovs", 0x48, dst, src); }
|
|
void cmovz(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovz", 0x44, dst, src); }
|
|
|
|
/// cmp - Compare and set flags
|
|
void cmp(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"cmp",
|
|
0x38, // opMemReg8
|
|
0x39, // opMemRegPref
|
|
0x3A, // opRegMem8
|
|
0x3B, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x07, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// cdq - Convert doubleword to quadword
|
|
void cdq(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("cdq");
|
|
cb_write_byte(cb, 0x99);
|
|
}
|
|
|
|
/// cqo - Convert quadword to octaword
|
|
void cqo(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("cqo");
|
|
cb_write_bytes(cb, 2, 0x48, 0x99);
|
|
}
|
|
|
|
/// Interrupt 3 - trap to debugger
|
|
void int3(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("INT 3");
|
|
cb_write_byte(cb, 0xCC);
|
|
}
|
|
|
|
/*
|
|
// div - Unsigned integer division
|
|
alias div = writeRMUnary!(
|
|
"div",
|
|
0xF6, // opMemReg8
|
|
0xF7, // opMemRegPref
|
|
0x06 // opExt
|
|
);
|
|
*/
|
|
|
|
/*
|
|
/// divsd - Divide scalar double
|
|
alias divsd = writeXMM64!(
|
|
"divsd",
|
|
0xF2, // prefix
|
|
0x0F, // opRegMem0
|
|
0x5E // opRegMem1
|
|
);
|
|
*/
|
|
|
|
/*
|
|
// idiv - Signed integer division
|
|
alias idiv = writeRMUnary!(
|
|
"idiv",
|
|
0xF6, // opMemReg8
|
|
0xF7, // opMemRegPref
|
|
0x07 // opExt
|
|
);
|
|
*/
|
|
|
|
/*
|
|
/// imul - Signed integer multiplication with two operands
|
|
void imul(CodeBlock cb, X86Opnd opnd0, X86Opnd opnd1)
|
|
{
|
|
cb.writeASM("imul", opnd0, opnd1);
|
|
|
|
assert (opnd0.isReg, "invalid first operand");
|
|
auto opndSize = opnd0.reg.size;
|
|
|
|
// Check the size of opnd1
|
|
if (opnd1.isReg)
|
|
assert (opnd1.reg.size is opndSize, "operand size mismatch");
|
|
else if (opnd1.isMem)
|
|
assert (opnd1.mem.size is opndSize, "operand size mismatch");
|
|
|
|
assert (opndSize is 16 || opndSize is 32 || opndSize is 64);
|
|
auto szPref = opndSize is 16;
|
|
auto rexW = opndSize is 64;
|
|
|
|
cb.writeRMInstr!('r', 0xFF, 0x0F, 0xAF)(szPref, rexW, opnd0, opnd1);
|
|
}
|
|
*/
|
|
|
|
/*
|
|
/// imul - Signed integer multiplication with three operands (one immediate)
|
|
void imul(CodeBlock cb, X86Opnd opnd0, X86Opnd opnd1, X86Opnd opnd2)
|
|
{
|
|
cb.writeASM("imul", opnd0, opnd1, opnd2);
|
|
|
|
assert (opnd0.isReg, "invalid first operand");
|
|
auto opndSize = opnd0.reg.size;
|
|
|
|
// Check the size of opnd1
|
|
if (opnd1.isReg)
|
|
assert (opnd1.reg.size is opndSize, "operand size mismatch");
|
|
else if (opnd1.isMem)
|
|
assert (opnd1.mem.size is opndSize, "operand size mismatch");
|
|
|
|
assert (opndSize is 16 || opndSize is 32 || opndSize is 64);
|
|
auto szPref = opndSize is 16;
|
|
auto rexW = opndSize is 64;
|
|
|
|
assert (opnd2.isImm, "invalid third operand");
|
|
auto imm = opnd2.imm;
|
|
|
|
// 8-bit immediate
|
|
if (imm.immSize <= 8)
|
|
{
|
|
cb.writeRMInstr!('r', 0xFF, 0x6B)(szPref, rexW, opnd0, opnd1);
|
|
cb.writeInt(imm.imm, 8);
|
|
}
|
|
|
|
// 32-bit immediate
|
|
else if (imm.immSize <= 32)
|
|
{
|
|
assert (imm.immSize <= opndSize, "immediate too large for dst");
|
|
cb.writeRMInstr!('r', 0xFF, 0x69)(szPref, rexW, opnd0, opnd1);
|
|
cb.writeInt(imm.imm, min(opndSize, 32));
|
|
}
|
|
|
|
// Immediate too large
|
|
else
|
|
{
|
|
assert (false, "immediate value too large");
|
|
}
|
|
}
|
|
*/
|
|
|
|
/// jcc - relative jumps to a label
|
|
void ja_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "ja" , 0x0F, 0x87, label_idx); }
|
|
void jae_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jae" , 0x0F, 0x83, label_idx); }
|
|
void jb_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jb" , 0x0F, 0x82, label_idx); }
|
|
void jbe_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jbe" , 0x0F, 0x86, label_idx); }
|
|
void jc_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jc" , 0x0F, 0x82, label_idx); }
|
|
void je_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "je" , 0x0F, 0x84, label_idx); }
|
|
void jg_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jg" , 0x0F, 0x8F, label_idx); }
|
|
void jge_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jge" , 0x0F, 0x8D, label_idx); }
|
|
void jl_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jl" , 0x0F, 0x8C, label_idx); }
|
|
void jle_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jle" , 0x0F, 0x8E, label_idx); }
|
|
void jna_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jna" , 0x0F, 0x86, label_idx); }
|
|
void jnae_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnae", 0x0F, 0x82, label_idx); }
|
|
void jnb_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnb" , 0x0F, 0x83, label_idx); }
|
|
void jnbe_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnbe", 0x0F, 0x87, label_idx); }
|
|
void jnc_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnc" , 0x0F, 0x83, label_idx); }
|
|
void jne_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jne" , 0x0F, 0x85, label_idx); }
|
|
void jng_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jng" , 0x0F, 0x8E, label_idx); }
|
|
void jnge_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnge", 0x0F, 0x8C, label_idx); }
|
|
void jnl_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnl" , 0x0F, 0x8D, label_idx); }
|
|
void jnle_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnle", 0x0F, 0x8F, label_idx); }
|
|
void jno_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jno" , 0x0F, 0x81, label_idx); }
|
|
void jnp_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnp" , 0x0F, 0x8b, label_idx); }
|
|
void jns_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jns" , 0x0F, 0x89, label_idx); }
|
|
void jnz_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnz" , 0x0F, 0x85, label_idx); }
|
|
void jo_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jo" , 0x0F, 0x80, label_idx); }
|
|
void jp_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jp" , 0x0F, 0x8A, label_idx); }
|
|
void jpe_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jpe" , 0x0F, 0x8A, label_idx); }
|
|
void jpo_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jpo" , 0x0F, 0x8B, label_idx); }
|
|
void js_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "js" , 0x0F, 0x88, label_idx); }
|
|
void jz_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jz" , 0x0F, 0x84, label_idx); }
|
|
void jmp_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jmp" , 0xFF, 0xE9, label_idx); }
|
|
|
|
/// jcc - relative jumps to a pointer (32-bit offset)
|
|
void ja_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "ja" , 0x0F, 0x87, ptr); }
|
|
void jae_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jae" , 0x0F, 0x83, ptr); }
|
|
void jb_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jb" , 0x0F, 0x82, ptr); }
|
|
void jbe_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jbe" , 0x0F, 0x86, ptr); }
|
|
void jc_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jc" , 0x0F, 0x82, ptr); }
|
|
void je_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "je" , 0x0F, 0x84, ptr); }
|
|
void jg_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jg" , 0x0F, 0x8F, ptr); }
|
|
void jge_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jge" , 0x0F, 0x8D, ptr); }
|
|
void jl_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jl" , 0x0F, 0x8C, ptr); }
|
|
void jle_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jle" , 0x0F, 0x8E, ptr); }
|
|
void jna_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jna" , 0x0F, 0x86, ptr); }
|
|
void jnae_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnae", 0x0F, 0x82, ptr); }
|
|
void jnb_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnb" , 0x0F, 0x83, ptr); }
|
|
void jnbe_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnbe", 0x0F, 0x87, ptr); }
|
|
void jnc_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnc" , 0x0F, 0x83, ptr); }
|
|
void jne_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jne" , 0x0F, 0x85, ptr); }
|
|
void jng_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jng" , 0x0F, 0x8E, ptr); }
|
|
void jnge_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnge", 0x0F, 0x8C, ptr); }
|
|
void jnl_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnl" , 0x0F, 0x8D, ptr); }
|
|
void jnle_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnle", 0x0F, 0x8F, ptr); }
|
|
void jno_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jno" , 0x0F, 0x81, ptr); }
|
|
void jnp_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnp" , 0x0F, 0x8b, ptr); }
|
|
void jns_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jns" , 0x0F, 0x89, ptr); }
|
|
void jnz_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnz" , 0x0F, 0x85, ptr); }
|
|
void jo_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jo" , 0x0F, 0x80, ptr); }
|
|
void jp_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jp" , 0x0F, 0x8A, ptr); }
|
|
void jpe_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jpe" , 0x0F, 0x8A, ptr); }
|
|
void jpo_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jpo" , 0x0F, 0x8B, ptr); }
|
|
void js_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "js" , 0x0F, 0x88, ptr); }
|
|
void jz_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jz" , 0x0F, 0x84, ptr); }
|
|
void jmp_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jmp" , 0xFF, 0xE9, ptr); }
|
|
|
|
/// jmp - Indirect jump near to an R/M operand
|
|
void jmp_rm(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
//cb.writeASM("jmp", opnd);
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd, 4, 1, 0xFF);
|
|
}
|
|
|
|
// jmp - Jump with relative 32-bit offset
|
|
void jmp32(codeblock_t *cb, int32_t offset)
|
|
{
|
|
//cb.writeASM("jmp", ((offset > 0)? "+":"-") ~ to!string(offset));
|
|
cb_write_byte(cb, 0xE9);
|
|
cb_write_int(cb, offset, 32);
|
|
}
|
|
|
|
/// lea - Load Effective Address
|
|
void lea(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
|
|
{
|
|
//cb.writeASM("lea", dst, src);
|
|
assert (dst.num_bits == 64);
|
|
cb_write_rm(cb, false, true, dst, src, 0xFF, 1, 0x8D);
|
|
}
|
|
|
|
// Does this number fit in 32 bits and stays the same if you zero extend it to 64 bit?
|
|
// If the sign bit is clear, sign extension and zero extension yield the same
|
|
// result.
|
|
static bool
|
|
zero_extendable_32bit(uint64_t number)
|
|
{
|
|
return number <= UINT32_MAX && (number & (1ull << 31ull)) == 0;
|
|
}
|
|
|
|
/// mov - Data move operation
|
|
void mov(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
|
|
{
|
|
// R/M + Imm
|
|
if (src.type == OPND_IMM)
|
|
{
|
|
//cb.writeASM("mov", dst, src);
|
|
|
|
// R + Imm
|
|
if (dst.type == OPND_REG)
|
|
{
|
|
assert (
|
|
src.num_bits <= dst.num_bits ||
|
|
unsig_imm_size(src.as.imm) <= dst.num_bits
|
|
);
|
|
|
|
// In case the source immediate could be zero extended to be 64
|
|
// bit, we can use the 32-bit operands version of the instruction.
|
|
// For example, we can turn mov(rax, 0x34) into the equivalent
|
|
// mov(eax, 0x34).
|
|
if (dst.num_bits == 64 && zero_extendable_32bit(src.as.unsig_imm)) {
|
|
if (rex_needed(dst))
|
|
cb_write_rex(cb, false, 0, 0, dst.as.reg.reg_no);
|
|
cb_write_opcode(cb, 0xB8, dst);
|
|
cb_write_int(cb, src.as.imm, 32);
|
|
}
|
|
else {
|
|
if (dst.num_bits == 16)
|
|
cb_write_byte(cb, 0x66);
|
|
|
|
if (rex_needed(dst) || dst.num_bits == 64)
|
|
cb_write_rex(cb, dst.num_bits == 64, 0, 0, dst.as.reg.reg_no);
|
|
|
|
cb_write_opcode(cb, (dst.num_bits == 8)? 0xB0:0xB8, dst);
|
|
|
|
cb_write_int(cb, src.as.imm, dst.num_bits);
|
|
}
|
|
}
|
|
|
|
// M + Imm
|
|
else if (dst.type == OPND_MEM)
|
|
{
|
|
assert (src.num_bits <= dst.num_bits);
|
|
|
|
if (dst.num_bits == 8)
|
|
cb_write_rm(cb, false, false, NO_OPND, dst, 0xFF, 1, 0xC6);
|
|
else
|
|
cb_write_rm(cb, dst.num_bits == 16, dst.num_bits == 64, NO_OPND, dst, 0, 1, 0xC7);
|
|
|
|
const uint32_t output_num_bits = (dst.num_bits > 32u) ? 32u : dst.num_bits;
|
|
// assert that we can write whole immediate without loss of infomation
|
|
assert (sig_imm_size(src.as.imm) <= output_num_bits);
|
|
cb_write_int(cb, src.as.imm, output_num_bits);
|
|
}
|
|
|
|
else
|
|
{
|
|
assert (false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"mov",
|
|
0x88, // opMemReg8
|
|
0x89, // opMemRegPref
|
|
0x8A, // opRegMem8
|
|
0x8B, // opRegMemPref
|
|
0xC6, // opMemImm8
|
|
0xFF, // opMemImmSml (not available)
|
|
0xFF, // opMemImmLrg
|
|
0xFF, // opExtImm
|
|
dst,
|
|
src
|
|
);
|
|
}
|
|
}
|
|
|
|
/// movsx - Move with sign extension (signed integers)
|
|
void movsx(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
|
|
{
|
|
assert (dst.type == OPND_REG);
|
|
assert (src.type == OPND_REG || src.type == OPND_MEM);
|
|
assert (src.num_bits < dst.num_bits);
|
|
|
|
//cb.writeASM("movsx", dst, src);
|
|
|
|
if (src.num_bits == 8)
|
|
{
|
|
cb_write_rm(cb, dst.num_bits == 16, dst.num_bits == 64, dst, src, 0xFF, 2, 0x0F, 0xBE);
|
|
}
|
|
else if (src.num_bits == 16)
|
|
{
|
|
cb_write_rm(cb, dst.num_bits == 16, dst.num_bits == 64, dst, src, 0xFF, 2, 0x0F, 0xBF);
|
|
}
|
|
else if (src.num_bits == 32)
|
|
{
|
|
cb_write_rm(cb, false, true, dst, src, 0xFF, 1, 0x63);
|
|
}
|
|
else
|
|
{
|
|
assert (false);
|
|
}
|
|
}
|
|
|
|
/*
|
|
/// movzx - Move with zero extension (unsigned values)
|
|
void movzx(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
|
|
{
|
|
cb.writeASM("movzx", dst, src);
|
|
|
|
uint32_t dstSize;
|
|
if (dst.isReg)
|
|
dstSize = dst.reg.size;
|
|
else
|
|
assert (false, "movzx dst must be a register");
|
|
|
|
uint32_t srcSize;
|
|
if (src.isReg)
|
|
srcSize = src.reg.size;
|
|
else if (src.isMem)
|
|
srcSize = src.mem.size;
|
|
else
|
|
assert (false);
|
|
|
|
assert (
|
|
srcSize < dstSize,
|
|
"movzx: srcSize >= dstSize"
|
|
);
|
|
|
|
if (srcSize is 8)
|
|
{
|
|
cb.writeRMInstr!('r', 0xFF, 0x0F, 0xB6)(dstSize is 16, dstSize is 64, dst, src);
|
|
}
|
|
else if (srcSize is 16)
|
|
{
|
|
cb.writeRMInstr!('r', 0xFF, 0x0F, 0xB7)(dstSize is 16, dstSize is 64, dst, src);
|
|
}
|
|
else
|
|
{
|
|
assert (false, "invalid src operand size for movxz");
|
|
}
|
|
}
|
|
*/
|
|
|
|
// neg - Integer negation (multiplication by -1)
|
|
void neg(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
write_rm_unary(
|
|
cb,
|
|
"neg",
|
|
0xF6, // opMemReg8
|
|
0xF7, // opMemRegPref
|
|
0x03, // opExt
|
|
opnd
|
|
);
|
|
}
|
|
|
|
// nop - Noop, one or multiple bytes long
|
|
void nop(codeblock_t *cb, uint32_t length)
|
|
{
|
|
switch (length) {
|
|
case 0:
|
|
break;
|
|
|
|
case 1:
|
|
//cb.writeASM("nop1");
|
|
cb_write_byte(cb, 0x90);
|
|
break;
|
|
|
|
case 2:
|
|
//cb.writeASM("nop2");
|
|
cb_write_bytes(cb, 2, 0x66,0x90);
|
|
break;
|
|
|
|
case 3:
|
|
//cb.writeASM("nop3");
|
|
cb_write_bytes(cb, 3, 0x0F,0x1F,0x00);
|
|
break;
|
|
|
|
case 4:
|
|
//cb.writeASM("nop4");
|
|
cb_write_bytes(cb, 4, 0x0F,0x1F,0x40,0x00);
|
|
break;
|
|
|
|
case 5:
|
|
//cb.writeASM("nop5");
|
|
cb_write_bytes(cb, 5, 0x0F,0x1F,0x44,0x00,0x00);
|
|
break;
|
|
|
|
case 6:
|
|
//cb.writeASM("nop6");
|
|
cb_write_bytes(cb, 6, 0x66,0x0F,0x1F,0x44,0x00,0x00);
|
|
break;
|
|
|
|
case 7:
|
|
//cb.writeASM("nop7");
|
|
cb_write_bytes(cb, 7, 0x0F,0x1F,0x80,0x00,0x00,0x00,0x00);
|
|
break;
|
|
|
|
case 8:
|
|
//cb.writeASM("nop8");
|
|
cb_write_bytes(cb, 8, 0x0F,0x1F,0x84,0x00,0x00,0x00,0x00,0x00);
|
|
break;
|
|
|
|
case 9:
|
|
//cb.writeASM("nop9");
|
|
cb_write_bytes(cb, 9, 0x66,0x0F,0x1F,0x84,0x00,0x00,0x00,0x00,0x00);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
uint32_t written = 0;
|
|
while (written + 9 <= length)
|
|
{
|
|
nop(cb, 9);
|
|
written += 9;
|
|
}
|
|
nop(cb, length - written);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// not - Bitwise NOT
|
|
void not(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
write_rm_unary(
|
|
cb,
|
|
"not",
|
|
0xF6, // opMemReg8
|
|
0xF7, // opMemRegPref
|
|
0x02, // opExt
|
|
opnd
|
|
);
|
|
}
|
|
|
|
/// or - Bitwise OR
|
|
void or(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"or",
|
|
0x08, // opMemReg8
|
|
0x09, // opMemRegPref
|
|
0x0A, // opRegMem8
|
|
0x0B, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x01, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// pop - Pop a register off the stack
|
|
void pop(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
assert (opnd.num_bits == 64);
|
|
|
|
//cb.writeASM("pop", opnd);
|
|
|
|
if (opnd.type == OPND_REG) {
|
|
if (rex_needed(opnd))
|
|
cb_write_rex(cb, false, 0, 0, opnd.as.reg.reg_no);
|
|
cb_write_opcode(cb, 0x58, opnd);
|
|
}
|
|
else if (opnd.type == OPND_MEM) {
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd, 0, 1, 0x8F);
|
|
}
|
|
else {
|
|
assert(false && "unexpected operand type");
|
|
}
|
|
}
|
|
|
|
/// popfq - Pop the flags register (64-bit)
|
|
void popfq(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("popfq");
|
|
|
|
// REX.W + 0x9D
|
|
cb_write_bytes(cb, 2, 0x48, 0x9D);
|
|
}
|
|
|
|
/// push - Push an operand on the stack
|
|
void push(codeblock_t *cb, x86opnd_t opnd)
|
|
{
|
|
assert (opnd.num_bits == 64);
|
|
|
|
//cb.writeASM("push", opnd);
|
|
|
|
if (opnd.type == OPND_REG) {
|
|
if (rex_needed(opnd))
|
|
cb_write_rex(cb, false, 0, 0, opnd.as.reg.reg_no);
|
|
cb_write_opcode(cb, 0x50, opnd);
|
|
}
|
|
else if (opnd.type == OPND_MEM) {
|
|
cb_write_rm(cb, false, false, NO_OPND, opnd, 6, 1, 0xFF);
|
|
}
|
|
else {
|
|
assert(false && "unexpected operand type");
|
|
}
|
|
}
|
|
|
|
/// pushfq - Push the flags register (64-bit)
|
|
void pushfq(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("pushfq");
|
|
cb_write_byte(cb, 0x9C);
|
|
}
|
|
|
|
/// ret - Return from call, popping only the return address
|
|
void ret(codeblock_t *cb)
|
|
{
|
|
//cb.writeASM("ret");
|
|
cb_write_byte(cb, 0xC3);
|
|
}
|
|
|
|
// sal - Shift arithmetic left
|
|
void sal(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_shift(
|
|
cb,
|
|
"sal",
|
|
0xD1, // opMemOnePref,
|
|
0xD3, // opMemClPref,
|
|
0xC1, // opMemImmPref,
|
|
0x04,
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// sar - Shift arithmetic right (signed)
|
|
void sar(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_shift(
|
|
cb,
|
|
"sar",
|
|
0xD1, // opMemOnePref,
|
|
0xD3, // opMemClPref,
|
|
0xC1, // opMemImmPref,
|
|
0x07,
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
// shl - Shift logical left
|
|
void shl(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_shift(
|
|
cb,
|
|
"shl",
|
|
0xD1, // opMemOnePref,
|
|
0xD3, // opMemClPref,
|
|
0xC1, // opMemImmPref,
|
|
0x04,
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// shr - Shift logical right (unsigned)
|
|
void shr(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_shift(
|
|
cb,
|
|
"shr",
|
|
0xD1, // opMemOnePref,
|
|
0xD3, // opMemClPref,
|
|
0xC1, // opMemImmPref,
|
|
0x05,
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// sub - Integer subtraction
|
|
void sub(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"sub",
|
|
0x28, // opMemReg8
|
|
0x29, // opMemRegPref
|
|
0x2A, // opRegMem8
|
|
0x2B, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x05, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
/// test - Logical Compare
|
|
void test(codeblock_t *cb, x86opnd_t rm_opnd, x86opnd_t test_opnd)
|
|
{
|
|
assert (rm_opnd.type == OPND_REG || rm_opnd.type == OPND_MEM);
|
|
assert (test_opnd.type == OPND_REG || test_opnd.type == OPND_IMM);
|
|
|
|
// If the second operand is an immediate
|
|
if (test_opnd.type == OPND_IMM)
|
|
{
|
|
x86opnd_t imm_opnd = test_opnd;
|
|
|
|
if (imm_opnd.as.imm >= 0)
|
|
{
|
|
assert (unsig_imm_size(imm_opnd.as.unsig_imm) <= 32);
|
|
assert (unsig_imm_size(imm_opnd.as.unsig_imm) <= rm_opnd.num_bits);
|
|
|
|
// Use the smallest operand size possible
|
|
rm_opnd = resize_opnd(rm_opnd, unsig_imm_size(imm_opnd.as.unsig_imm));
|
|
|
|
if (rm_opnd.num_bits == 8)
|
|
{
|
|
cb_write_rm(cb, false, false, NO_OPND, rm_opnd, 0x00, 1, 0xF6);
|
|
cb_write_int(cb, imm_opnd.as.imm, rm_opnd.num_bits);
|
|
}
|
|
else
|
|
{
|
|
cb_write_rm(cb, rm_opnd.num_bits == 16, false, NO_OPND, rm_opnd, 0x00, 1, 0xF7);
|
|
cb_write_int(cb, imm_opnd.as.imm, rm_opnd.num_bits);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This mode only applies to 64-bit R/M operands with 32-bit signed immediates
|
|
assert (imm_opnd.as.imm < 0);
|
|
assert (sig_imm_size(imm_opnd.as.imm) <= 32);
|
|
assert (rm_opnd.num_bits == 64);
|
|
cb_write_rm(cb, false, true, NO_OPND, rm_opnd, 0x00, 1, 0xF7);
|
|
cb_write_int(cb, imm_opnd.as.imm, 32);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert (test_opnd.num_bits == rm_opnd.num_bits);
|
|
|
|
if (rm_opnd.num_bits == 8)
|
|
{
|
|
cb_write_rm(cb, false, false, test_opnd, rm_opnd, 0xFF, 1, 0x84);
|
|
}
|
|
else
|
|
{
|
|
cb_write_rm(cb, rm_opnd.num_bits == 16, rm_opnd.num_bits == 64, test_opnd, rm_opnd, 0xFF, 1, 0x85);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Undefined opcode
|
|
void ud2(codeblock_t *cb)
|
|
{
|
|
cb_write_bytes(cb, 2, 0x0F, 0x0B);
|
|
}
|
|
|
|
/// xchg - Exchange Register/Memory with Register
|
|
void xchg(codeblock_t *cb, x86opnd_t rm_opnd, x86opnd_t r_opnd)
|
|
{
|
|
assert (rm_opnd.num_bits == 64);
|
|
assert (r_opnd.num_bits == 64);
|
|
assert (rm_opnd.type == OPND_REG);
|
|
assert (r_opnd.type == OPND_REG);
|
|
|
|
// If we're exchanging with RAX
|
|
if (rm_opnd.type == OPND_REG && rm_opnd.as.reg.reg_no == RAX.as.reg.reg_no)
|
|
{
|
|
// Write the REX byte
|
|
cb_write_rex(cb, rm_opnd.num_bits == 64, 0, 0, r_opnd.as.reg.reg_no);
|
|
|
|
// Write the opcode and register number
|
|
cb_write_byte(cb, 0x90 + (r_opnd.as.reg.reg_no & 7));
|
|
}
|
|
else
|
|
{
|
|
cb_write_rm(cb, rm_opnd.num_bits == 16, rm_opnd.num_bits == 64, r_opnd, rm_opnd, 0xFF, 1, 0x87);
|
|
}
|
|
}
|
|
|
|
/// xor - Exclusive bitwise OR
|
|
void xor(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
|
|
{
|
|
cb_write_rm_multi(
|
|
cb,
|
|
"xor",
|
|
0x30, // opMemReg8
|
|
0x31, // opMemRegPref
|
|
0x32, // opRegMem8
|
|
0x33, // opRegMemPref
|
|
0x80, // opMemImm8
|
|
0x83, // opMemImmSml
|
|
0x81, // opMemImmLrg
|
|
0x06, // opExtImm
|
|
opnd0,
|
|
opnd1
|
|
);
|
|
}
|
|
|
|
// LOCK - lock prefix for atomic shared memory operations
|
|
void cb_write_lock_prefix(codeblock_t *cb)
|
|
{
|
|
cb_write_byte(cb, 0xF0);
|
|
}
|
|
|
|
void cb_mark_all_writeable(codeblock_t * cb)
|
|
{
|
|
if (mprotect(cb->mem_block_, cb->mem_size, PROT_READ | PROT_WRITE)) {
|
|
fprintf(stderr, "Couldn't make JIT page (%p) writeable, errno: %s", (void *)cb->mem_block_, strerror(errno));
|
|
abort();
|
|
}
|
|
}
|
|
|
|
void cb_mark_position_writeable(codeblock_t * cb, uint32_t write_pos)
|
|
{
|
|
uint32_t pagesize = (uint32_t)sysconf(_SC_PAGESIZE);
|
|
uint32_t aligned_position = (write_pos / pagesize) * pagesize;
|
|
|
|
if (cb->current_aligned_write_pos != aligned_position) {
|
|
cb->current_aligned_write_pos = aligned_position;
|
|
void *const page_addr = cb_get_ptr(cb, aligned_position);
|
|
if (mprotect(page_addr, pagesize, PROT_READ | PROT_WRITE)) {
|
|
fprintf(stderr, "Couldn't make JIT page (%p) writeable, errno: %s", page_addr, strerror(errno));
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
void cb_mark_all_executable(codeblock_t * cb)
|
|
{
|
|
cb->current_aligned_write_pos = ALIGNED_WRITE_POSITION_NONE;
|
|
if (mprotect(cb->mem_block_, cb->mem_size, PROT_READ | PROT_EXEC)) {
|
|
fprintf(stderr, "Couldn't make JIT page (%p) executable, errno: %s", (void *)cb->mem_block_, strerror(errno));
|
|
abort();
|
|
}
|
|
}
|
|
|