2020-09-10 17:20:46 -04:00
|
|
|
#include <assert.h>
|
|
|
|
#include "insns.inc"
|
|
|
|
#include "internal.h"
|
|
|
|
#include "vm_core.h"
|
2020-10-15 09:06:42 -04:00
|
|
|
#include "vm_sync.h"
|
2020-09-10 17:20:46 -04:00
|
|
|
#include "vm_callinfo.h"
|
|
|
|
#include "builtin.h"
|
2020-10-13 11:15:22 -04:00
|
|
|
#include "internal/compile.h"
|
2020-09-10 17:20:46 -04:00
|
|
|
#include "insns_info.inc"
|
|
|
|
#include "ujit_compile.h"
|
|
|
|
#include "ujit_asm.h"
|
2020-09-17 17:09:42 -04:00
|
|
|
#include "ujit_utils.h"
|
2020-09-10 17:20:46 -04:00
|
|
|
|
2020-09-23 03:02:01 -04:00
|
|
|
// TODO: give ujit_examples.inc some more meaningful file name
|
2020-09-17 17:09:42 -04:00
|
|
|
// eg ujit_hook.h
|
2020-09-23 03:02:01 -04:00
|
|
|
#include "ujit_examples.inc"
|
2020-09-14 13:31:34 -04:00
|
|
|
|
2020-10-05 07:41:46 -04:00
|
|
|
#ifdef _WIN32
|
|
|
|
#define PLATFORM_SUPPORTED_P 0
|
|
|
|
#else
|
|
|
|
#define PLATFORM_SUPPORTED_P 1
|
|
|
|
#endif
|
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
bool rb_ujit_enabled;
|
|
|
|
|
2020-09-24 15:57:53 -04:00
|
|
|
// Hash table of encoded instructions
|
|
|
|
extern st_table *rb_encoded_insn_data;
|
|
|
|
|
2020-09-15 17:04:33 -04:00
|
|
|
// Code generation context
|
|
|
|
typedef struct ctx_struct
|
|
|
|
{
|
2020-09-16 10:33:34 -04:00
|
|
|
// Current PC
|
2020-10-13 11:15:22 -04:00
|
|
|
VALUE *pc;
|
2020-09-16 10:33:34 -04:00
|
|
|
|
2020-09-17 13:40:50 -04:00
|
|
|
// Difference between the current stack pointer and actual stack top
|
|
|
|
int32_t stack_diff;
|
2020-09-15 17:04:33 -04:00
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
const rb_iseq_t *iseq;
|
|
|
|
|
2020-09-15 17:04:33 -04:00
|
|
|
} ctx_t;
|
|
|
|
|
2020-09-24 15:57:53 -04:00
|
|
|
// MicroJIT code generation function signature
|
2020-10-15 11:46:37 -04:00
|
|
|
typedef bool (*codegen_fn)(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx);
|
2020-09-15 17:04:33 -04:00
|
|
|
|
|
|
|
// Map from YARV opcodes to code generation functions
|
|
|
|
static st_table *gen_fns;
|
|
|
|
|
|
|
|
// Code block into which we write machine code
|
2020-09-10 17:20:46 -04:00
|
|
|
static codeblock_t block;
|
|
|
|
static codeblock_t* cb = NULL;
|
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
// Code block into which we write out-of-line machine code
|
|
|
|
static codeblock_t outline_block;
|
|
|
|
static codeblock_t* ocb = NULL;
|
2020-09-14 13:31:34 -04:00
|
|
|
|
|
|
|
// Keep track of mapping from instructions to generated code
|
2020-09-11 15:36:40 -04:00
|
|
|
// See comment for rb_encoded_insn_data in iseq.c
|
2020-09-11 14:58:32 -04:00
|
|
|
static void
|
|
|
|
addr2insn_bookkeeping(void *code_ptr, int insn)
|
|
|
|
{
|
|
|
|
const void * const *table = rb_vm_get_insns_address_table();
|
|
|
|
const void * const translated_address = table[insn];
|
|
|
|
st_data_t encoded_insn_data;
|
|
|
|
if (st_lookup(rb_encoded_insn_data, (st_data_t)translated_address, &encoded_insn_data)) {
|
2020-09-22 18:25:29 -04:00
|
|
|
st_insert(rb_encoded_insn_data, (st_data_t)code_ptr, encoded_insn_data);
|
2020-09-11 14:58:32 -04:00
|
|
|
}
|
|
|
|
else {
|
2020-09-11 15:36:40 -04:00
|
|
|
rb_bug("ujit: failed to find info for original instruction while dealing with addr2insn");
|
2020-09-11 14:58:32 -04:00
|
|
|
}
|
|
|
|
}
|
2020-09-10 17:20:46 -04:00
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
static int
|
|
|
|
opcode_at_pc(const rb_iseq_t *iseq, const VALUE *pc)
|
|
|
|
{
|
|
|
|
const VALUE at_pc = *pc;
|
|
|
|
if (FL_TEST_RAW((VALUE)iseq, ISEQ_TRANSLATED)) {
|
|
|
|
return rb_vm_insn_addr2insn((const void *)at_pc);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return (int)at_pc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Get the current instruction opcode from the context object
|
2020-10-13 11:15:22 -04:00
|
|
|
int ctx_get_opcode(ctx_t *ctx)
|
2020-09-16 10:33:34 -04:00
|
|
|
{
|
2020-10-13 11:15:22 -04:00
|
|
|
return opcode_at_pc(ctx->iseq, ctx->pc);
|
2020-09-16 10:33:34 -04:00
|
|
|
}
|
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Get an instruction argument from the context object
|
|
|
|
VALUE ctx_get_arg(ctx_t* ctx, size_t arg_idx)
|
|
|
|
{
|
|
|
|
assert (arg_idx + 1 < insn_len(ctx_get_opcode(ctx)));
|
|
|
|
return *(ctx->pc + arg_idx + 1);
|
|
|
|
}
|
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
/*
|
|
|
|
Get an operand for the adjusted stack pointer address
|
|
|
|
*/
|
|
|
|
x86opnd_t ctx_sp_opnd(ctx_t* ctx, size_t n)
|
|
|
|
{
|
|
|
|
int32_t offset = (ctx->stack_diff) * 8;
|
|
|
|
return mem_opnd(64, RSI, offset);
|
|
|
|
}
|
|
|
|
|
2020-09-17 13:40:50 -04:00
|
|
|
/*
|
|
|
|
Make space on the stack for N values
|
|
|
|
Return a pointer to the new stack top
|
|
|
|
*/
|
|
|
|
x86opnd_t ctx_stack_push(ctx_t* ctx, size_t n)
|
|
|
|
{
|
|
|
|
ctx->stack_diff += n;
|
|
|
|
|
|
|
|
// SP points just above the topmost value
|
|
|
|
int32_t offset = (ctx->stack_diff - 1) * 8;
|
|
|
|
return mem_opnd(64, RSI, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
Pop N values off the stack
|
|
|
|
Return a pointer to the stack top before the pop operation
|
|
|
|
*/
|
|
|
|
x86opnd_t ctx_stack_pop(ctx_t* ctx, size_t n)
|
|
|
|
{
|
|
|
|
// SP points just above the topmost value
|
|
|
|
int32_t offset = (ctx->stack_diff - 1) * 8;
|
2020-09-18 12:40:05 -04:00
|
|
|
x86opnd_t top = mem_opnd(64, RSI, offset);
|
|
|
|
|
|
|
|
ctx->stack_diff -= n;
|
|
|
|
|
|
|
|
return top;
|
2020-09-17 13:40:50 -04:00
|
|
|
}
|
|
|
|
|
2020-09-30 15:17:13 -04:00
|
|
|
x86opnd_t ctx_stack_opnd(ctx_t* ctx, int32_t idx)
|
|
|
|
{
|
|
|
|
// SP points just above the topmost value
|
|
|
|
int32_t offset = (ctx->stack_diff - 1 - idx) * 8;
|
|
|
|
x86opnd_t opnd = mem_opnd(64, RSI, offset);
|
|
|
|
|
|
|
|
return opnd;
|
|
|
|
}
|
2020-09-28 15:50:41 -04:00
|
|
|
|
|
|
|
// Ruby instruction entry
|
|
|
|
static void
|
|
|
|
ujit_gen_entry(codeblock_t* cb)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < sizeof(ujit_pre_call_bytes); ++i)
|
|
|
|
cb_write_byte(cb, ujit_pre_call_bytes[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Generate an inline exit to return to the interpreter
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ujit_gen_exit(codeblock_t* cb, ctx_t* ctx, VALUE* exit_pc)
|
|
|
|
{
|
|
|
|
// Write the adjusted SP back into the CFP
|
|
|
|
if (ctx->stack_diff != 0)
|
|
|
|
{
|
|
|
|
x86opnd_t stack_pointer = ctx_sp_opnd(ctx, 1);
|
|
|
|
lea(cb, RSI, stack_pointer);
|
|
|
|
mov(cb, mem_opnd(64, RDI, 8), RSI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Directly return the next PC, which is a constant
|
|
|
|
mov(cb, RAX, const_ptr_opnd(exit_pc));
|
|
|
|
|
|
|
|
// Write PC back into the CFP
|
|
|
|
mov(cb, mem_opnd(64, RDI, 0), RAX);
|
|
|
|
|
|
|
|
// Write the post call bytes
|
|
|
|
for (size_t i = 0; i < sizeof(ujit_post_call_bytes); ++i)
|
|
|
|
cb_write_byte(cb, ujit_post_call_bytes[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Generate an out-of-line exit to return to the interpreter
|
|
|
|
*/
|
|
|
|
uint8_t*
|
|
|
|
ujit_side_exit(codeblock_t* cb, ctx_t* ctx, VALUE* exit_pc)
|
|
|
|
{
|
|
|
|
uint8_t* code_ptr = cb_get_ptr(cb, cb->write_pos);
|
|
|
|
|
|
|
|
// Write back the old instruction at the exit PC
|
|
|
|
// Otherwise the interpreter may jump right back to the
|
|
|
|
// JITted code we're trying to exit
|
|
|
|
const void * const *table = rb_vm_get_insns_address_table();
|
2020-10-13 11:15:22 -04:00
|
|
|
int opcode = opcode_at_pc(ctx->iseq, exit_pc);
|
2020-09-28 15:50:41 -04:00
|
|
|
void* old_instr = (void*)table[opcode];
|
|
|
|
mov(cb, RAX, const_ptr_opnd(exit_pc));
|
|
|
|
mov(cb, RCX, const_ptr_opnd(old_instr));
|
|
|
|
mov(cb, mem_opnd(64, RAX, 0), RCX);
|
|
|
|
|
|
|
|
// Generate the code to exit to the interpreters
|
|
|
|
ujit_gen_exit(cb, ctx, exit_pc);
|
|
|
|
|
|
|
|
return code_ptr;
|
|
|
|
}
|
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
/*
|
|
|
|
Generate a chunk of machine code for one individual bytecode instruction
|
|
|
|
Eventually, this will handle multiple instructions in a sequence
|
|
|
|
|
2020-09-16 12:37:59 -04:00
|
|
|
MicroJIT code gets a pointer to the cfp as the first argument in RDI
|
2020-09-16 10:33:34 -04:00
|
|
|
See rb_ujit_empty_func(rb_control_frame_t *cfp) in iseq.c
|
2020-09-16 12:37:59 -04:00
|
|
|
|
2020-09-17 13:40:50 -04:00
|
|
|
Throughout the generated code, we store the current stack pointer in RSI
|
|
|
|
|
2020-09-16 12:37:59 -04:00
|
|
|
System V ABI reference:
|
|
|
|
https://wiki.osdev.org/System_V_ABI#x86-64
|
2020-09-16 10:33:34 -04:00
|
|
|
*/
|
2020-09-11 14:58:32 -04:00
|
|
|
uint8_t *
|
2020-10-13 11:15:22 -04:00
|
|
|
ujit_compile_insn(const rb_iseq_t *iseq, unsigned int insn_idx, unsigned int* next_ujit_idx)
|
2020-09-10 17:20:46 -04:00
|
|
|
{
|
2020-09-28 07:03:28 -04:00
|
|
|
if (!cb) {
|
|
|
|
return NULL;
|
2020-09-10 17:20:46 -04:00
|
|
|
}
|
2020-10-13 11:15:22 -04:00
|
|
|
VALUE *encoded = iseq->body->iseq_encoded;
|
2020-09-10 17:20:46 -04:00
|
|
|
|
2020-09-17 11:49:53 -04:00
|
|
|
// NOTE: if we are ever deployed in production, we
|
|
|
|
// should probably just log an error and return NULL here,
|
|
|
|
// so we can fail more gracefully
|
2020-09-14 16:59:39 -04:00
|
|
|
if (cb->write_pos + 1024 >= cb->mem_size)
|
|
|
|
{
|
|
|
|
rb_bug("out of executable memory");
|
|
|
|
}
|
2020-09-28 17:01:26 -04:00
|
|
|
if (ocb->write_pos + 1024 >= ocb->mem_size)
|
|
|
|
{
|
|
|
|
rb_bug("out of executable memory (outlined block)");
|
|
|
|
}
|
2020-09-14 16:59:39 -04:00
|
|
|
|
2020-09-20 14:23:14 -04:00
|
|
|
// Align the current write positon to cache line boundaries
|
|
|
|
cb_align_pos(cb, 64);
|
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Get a pointer to the current write position in the code block
|
|
|
|
uint8_t *code_ptr = &cb->mem_block[cb->write_pos];
|
|
|
|
//printf("write pos: %ld\n", cb->write_pos);
|
|
|
|
|
2020-09-16 13:52:35 -04:00
|
|
|
// Get the first opcode in the sequence
|
2020-10-13 11:15:22 -04:00
|
|
|
int first_opcode = opcode_at_pc(iseq, &encoded[insn_idx]);
|
2020-09-14 16:59:39 -04:00
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Create codegen context
|
|
|
|
ctx_t ctx;
|
2020-09-17 13:40:50 -04:00
|
|
|
ctx.pc = NULL;
|
|
|
|
ctx.stack_diff = 0;
|
2020-10-13 11:15:22 -04:00
|
|
|
ctx.iseq = iseq;
|
2020-09-16 10:33:34 -04:00
|
|
|
|
2020-09-16 13:52:35 -04:00
|
|
|
// For each instruction to compile
|
|
|
|
size_t num_instrs;
|
|
|
|
for (num_instrs = 0;; ++num_instrs)
|
|
|
|
{
|
|
|
|
// Set the current PC
|
2020-10-13 11:15:22 -04:00
|
|
|
ctx.pc = &encoded[insn_idx];
|
2020-09-16 13:52:35 -04:00
|
|
|
|
|
|
|
// Get the current opcode
|
|
|
|
int opcode = ctx_get_opcode(&ctx);
|
|
|
|
|
|
|
|
// Lookup the codegen function for this instruction
|
|
|
|
st_data_t st_gen_fn;
|
2020-09-17 13:40:50 -04:00
|
|
|
if (!rb_st_lookup(gen_fns, opcode, &st_gen_fn))
|
2020-09-16 13:52:35 -04:00
|
|
|
{
|
2020-09-21 16:46:57 -04:00
|
|
|
//print_int(cb, imm_opnd(num_instrs));
|
2020-09-18 12:20:43 -04:00
|
|
|
//print_str(cb, insn_name(opcode));
|
2020-09-16 13:52:35 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the pre call bytes before the first instruction
|
|
|
|
if (num_instrs == 0)
|
|
|
|
{
|
2020-09-28 15:50:41 -04:00
|
|
|
ujit_gen_entry(cb);
|
2020-09-17 13:40:50 -04:00
|
|
|
|
|
|
|
// Load the current SP from the CFP into RSI
|
|
|
|
mov(cb, RSI, mem_opnd(64, RDI, 8));
|
2020-09-16 13:52:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Call the code generation function
|
|
|
|
codegen_fn gen_fn = (codegen_fn)st_gen_fn;
|
2020-10-15 11:46:37 -04:00
|
|
|
if (!gen_fn(cb, ocb, &ctx))
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2020-09-16 13:52:35 -04:00
|
|
|
|
|
|
|
// Move to the next instruction
|
|
|
|
insn_idx += insn_len(opcode);
|
|
|
|
}
|
2020-09-11 15:36:40 -04:00
|
|
|
|
2020-09-17 11:49:53 -04:00
|
|
|
// Let the caller know how many instructions ujit compiled
|
|
|
|
*next_ujit_idx = insn_idx;
|
|
|
|
|
2020-09-16 13:52:35 -04:00
|
|
|
// If no instructions were compiled
|
|
|
|
if (num_instrs == 0)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2020-09-14 14:36:39 -04:00
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
// Generate code to exit to the interpreter
|
|
|
|
ujit_gen_exit(cb, &ctx, ctx.pc);
|
2020-09-21 16:46:57 -04:00
|
|
|
|
2020-09-16 13:52:35 -04:00
|
|
|
addr2insn_bookkeeping(code_ptr, first_opcode);
|
2020-09-15 17:04:33 -04:00
|
|
|
|
|
|
|
return code_ptr;
|
2020-09-16 10:33:34 -04:00
|
|
|
}
|
2020-09-14 11:54:25 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_dup(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-18 12:40:05 -04:00
|
|
|
{
|
|
|
|
x86opnd_t dup_val = ctx_stack_pop(ctx, 1);
|
|
|
|
x86opnd_t loc0 = ctx_stack_push(ctx, 1);
|
|
|
|
x86opnd_t loc1 = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, RAX, dup_val);
|
|
|
|
mov(cb, loc0, RAX);
|
|
|
|
mov(cb, loc1, RAX);
|
2020-10-15 11:46:37 -04:00
|
|
|
return true;
|
2020-09-18 12:40:05 -04:00
|
|
|
}
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_nop(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-16 10:33:34 -04:00
|
|
|
{
|
2020-09-18 12:20:43 -04:00
|
|
|
// Do nothing
|
2020-10-15 11:46:37 -04:00
|
|
|
return true;
|
2020-09-16 10:33:34 -04:00
|
|
|
}
|
2020-09-14 11:54:25 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_pop(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-16 10:33:34 -04:00
|
|
|
{
|
|
|
|
// Decrement SP
|
2020-09-17 13:40:50 -04:00
|
|
|
ctx_stack_pop(ctx, 1);
|
2020-10-15 11:46:37 -04:00
|
|
|
return true;
|
2020-09-16 10:33:34 -04:00
|
|
|
}
|
2020-09-14 16:59:39 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_putnil(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-16 10:33:34 -04:00
|
|
|
{
|
|
|
|
// Write constant at SP
|
2020-09-17 13:40:50 -04:00
|
|
|
x86opnd_t stack_top = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, stack_top, imm_opnd(Qnil));
|
2020-10-15 11:46:37 -04:00
|
|
|
return true;
|
2020-09-16 10:33:34 -04:00
|
|
|
}
|
2020-09-14 16:59:39 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_putobject(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-16 15:30:23 -04:00
|
|
|
{
|
2020-10-05 11:31:24 -04:00
|
|
|
// Load the argument from the bytecode sequence.
|
|
|
|
// We need to do this as the argument can chanage due to GC compaction.
|
|
|
|
x86opnd_t pc_imm = const_ptr_opnd((void*)ctx->pc);
|
|
|
|
mov(cb, RAX, pc_imm);
|
|
|
|
mov(cb, RAX, mem_opnd(64, RAX, 8)); // One after the opcode
|
2020-09-16 15:30:23 -04:00
|
|
|
|
2020-10-05 11:31:24 -04:00
|
|
|
// Write argument at SP
|
2020-09-17 13:40:50 -04:00
|
|
|
x86opnd_t stack_top = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, stack_top, RAX);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-09-17 13:40:50 -04:00
|
|
|
}
|
2020-09-16 15:30:23 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_putobject_int2fix(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-17 13:40:50 -04:00
|
|
|
{
|
|
|
|
int opcode = ctx_get_opcode(ctx);
|
|
|
|
int cst_val = (opcode == BIN(putobject_INT2FIX_0_))? 0:1;
|
2020-09-16 15:30:23 -04:00
|
|
|
|
2020-09-17 13:40:50 -04:00
|
|
|
// Write constant at SP
|
|
|
|
x86opnd_t stack_top = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, stack_top, imm_opnd(INT2FIX(cst_val)));
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-09-16 15:30:23 -04:00
|
|
|
}
|
2020-09-15 15:12:31 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_putself(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-18 12:20:43 -04:00
|
|
|
{
|
|
|
|
// Load self from CFP
|
|
|
|
mov(cb, RAX, mem_opnd(64, RDI, 24));
|
|
|
|
|
|
|
|
// Write it on the stack
|
|
|
|
x86opnd_t stack_top = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, stack_top, RAX);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-09-18 12:20:43 -04:00
|
|
|
}
|
2020-09-15 15:12:31 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_getlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-16 10:33:34 -04:00
|
|
|
{
|
2020-09-24 15:57:53 -04:00
|
|
|
// Load environment pointer EP from CFP
|
2020-09-30 16:57:54 -04:00
|
|
|
mov(cb, RDX, member_opnd(RDI, rb_control_frame_t, ep));
|
2020-09-15 15:12:31 -04:00
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Compute the offset from BP to the local
|
|
|
|
int32_t local_idx = (int32_t)ctx_get_arg(ctx, 0);
|
|
|
|
const int32_t offs = -8 * local_idx;
|
2020-09-15 15:12:31 -04:00
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Load the local from the block
|
|
|
|
mov(cb, RCX, mem_opnd(64, RDX, offs));
|
2020-09-15 15:12:31 -04:00
|
|
|
|
2020-09-16 10:33:34 -04:00
|
|
|
// Write the local at SP
|
2020-09-17 13:40:50 -04:00
|
|
|
x86opnd_t stack_top = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, stack_top, RCX);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-09-10 17:20:46 -04:00
|
|
|
}
|
2020-09-14 13:31:34 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_setlocal_wc0(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-24 15:57:53 -04:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
vm_env_write(const VALUE *ep, int index, VALUE v)
|
|
|
|
{
|
|
|
|
VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
|
|
|
|
if (LIKELY((flags & VM_ENV_FLAG_WB_REQUIRED) == 0)) {
|
|
|
|
VM_STACK_ENV_WRITE(ep, index, v);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
vm_env_write_slowpath(ep, index, v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Load environment pointer EP from CFP
|
2020-09-30 16:57:54 -04:00
|
|
|
mov(cb, RDX, member_opnd(RDI, rb_control_frame_t, ep));
|
2020-09-24 15:57:53 -04:00
|
|
|
|
|
|
|
// flags & VM_ENV_FLAG_WB_REQUIRED
|
2020-09-28 15:50:41 -04:00
|
|
|
x86opnd_t flags_opnd = mem_opnd(64, RDX, 8 * VM_ENV_DATA_INDEX_FLAGS);
|
|
|
|
test(cb, flags_opnd, imm_opnd(VM_ENV_FLAG_WB_REQUIRED));
|
2020-09-24 15:57:53 -04:00
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
// Create a size-exit to fall back to the interpreter
|
|
|
|
uint8_t* side_exit = ujit_side_exit(ocb, ctx, ctx->pc);
|
2020-09-24 15:57:53 -04:00
|
|
|
|
|
|
|
// if (flags & VM_ENV_FLAG_WB_REQUIRED) != 0
|
2020-09-28 15:50:41 -04:00
|
|
|
jnz_ptr(cb, side_exit);
|
2020-09-24 15:57:53 -04:00
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
// Pop the value to write from the stack
|
2020-09-24 15:57:53 -04:00
|
|
|
x86opnd_t stack_top = ctx_stack_pop(ctx, 1);
|
|
|
|
mov(cb, RCX, stack_top);
|
|
|
|
|
2020-09-28 15:50:41 -04:00
|
|
|
// Write the value at the environment pointer
|
2020-09-24 15:57:53 -04:00
|
|
|
int32_t local_idx = (int32_t)ctx_get_arg(ctx, 0);
|
|
|
|
const int32_t offs = -8 * local_idx;
|
|
|
|
mov(cb, mem_opnd(64, RDX, offs), RCX);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-09-24 15:57:53 -04:00
|
|
|
}
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_opt_minus(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-10-02 12:12:28 -04:00
|
|
|
{
|
|
|
|
// Create a size-exit to fall back to the interpreter
|
|
|
|
// Note: we generate the side-exit before popping operands from the stack
|
|
|
|
uint8_t* side_exit = ujit_side_exit(ocb, ctx, ctx->pc);
|
|
|
|
|
|
|
|
// TODO: make a helper function for this
|
|
|
|
// Make sure that minus isn't redefined for integers
|
|
|
|
mov(cb, RAX, const_ptr_opnd(ruby_current_vm_ptr));
|
|
|
|
test(
|
|
|
|
cb,
|
|
|
|
member_opnd_idx(RAX, rb_vm_t, redefined_flag, BOP_MINUS),
|
|
|
|
imm_opnd(INTEGER_REDEFINED_OP_FLAG)
|
|
|
|
);
|
|
|
|
jnz_ptr(cb, side_exit);
|
|
|
|
|
|
|
|
// Get the operands and destination from the stack
|
|
|
|
x86opnd_t arg1 = ctx_stack_pop(ctx, 1);
|
|
|
|
x86opnd_t arg0 = ctx_stack_pop(ctx, 1);
|
|
|
|
|
|
|
|
// If not fixnums, fall back
|
|
|
|
test(cb, arg0, imm_opnd(RUBY_FIXNUM_FLAG));
|
|
|
|
jz_ptr(cb, side_exit);
|
|
|
|
test(cb, arg1, imm_opnd(RUBY_FIXNUM_FLAG));
|
|
|
|
jz_ptr(cb, side_exit);
|
|
|
|
|
|
|
|
// Subtract arg0 - arg1 and test for overflow
|
|
|
|
mov(cb, RAX, arg0);
|
|
|
|
sub(cb, RAX, arg1);
|
|
|
|
jo_ptr(cb, side_exit);
|
|
|
|
add(cb, RAX, imm_opnd(1));
|
|
|
|
|
|
|
|
// Push the output on the stack
|
|
|
|
x86opnd_t dst = ctx_stack_push(ctx, 1);
|
|
|
|
mov(cb, dst, RAX);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
return true;
|
2020-10-02 12:12:28 -04:00
|
|
|
}
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
bool
|
|
|
|
gen_opt_send_without_block(codeblock_t* cb, codeblock_t* ocb, ctx_t* ctx)
|
2020-09-30 15:17:13 -04:00
|
|
|
{
|
2020-10-15 15:15:31 -04:00
|
|
|
// Definitions relevant to the call cache are in vm_callinfo.h
|
|
|
|
|
2020-09-30 15:17:13 -04:00
|
|
|
struct rb_call_data * cd = (struct rb_call_data *)ctx_get_arg(ctx, 0);
|
|
|
|
int32_t argc = (int32_t)vm_ci_argc(cd->ci);
|
|
|
|
const struct rb_callcache *cc = cd->cc;
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
// Callee method ID
|
2020-09-30 15:17:13 -04:00
|
|
|
ID mid = vm_ci_mid(cd->ci);
|
2020-10-15 15:15:31 -04:00
|
|
|
|
|
|
|
//printf("jitting call to \"%s\", argc: %lu\n", rb_id2name(mid), argc);
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
// Don't JIT calls with keyword splat
|
|
|
|
if (vm_ci_flag(cd->ci) & VM_CALL_KW_SPLAT)
|
2020-09-30 16:57:54 -04:00
|
|
|
{
|
2020-10-15 11:46:37 -04:00
|
|
|
return false;
|
2020-09-30 15:17:13 -04:00
|
|
|
}
|
|
|
|
|
2020-10-15 15:15:31 -04:00
|
|
|
// Don't JIT calls that aren't simple
|
2020-10-15 11:46:37 -04:00
|
|
|
if (!(vm_ci_flag(cd->ci) & VM_CALL_ARGS_SIMPLE))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-10-15 15:15:31 -04:00
|
|
|
// Don't JIT if the inline cache is not set
|
|
|
|
if (cd->cc == vm_cc_empty())
|
|
|
|
{
|
|
|
|
//printf("call cache is empty\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't JIT if this is not a C call
|
2020-10-16 13:42:14 -04:00
|
|
|
if (vm_cc_cme(cd->cc)->def->type != VM_METHOD_TYPE_CFUNC)
|
2020-10-15 15:15:31 -04:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2020-10-15 11:46:37 -04:00
|
|
|
|
2020-10-16 14:46:46 -04:00
|
|
|
//printf("call to C function \"%s\", argc: %lu\n", rb_id2name(mid), argc);
|
2020-10-15 11:46:37 -04:00
|
|
|
|
2020-10-16 13:42:14 -04:00
|
|
|
// Things we need to do at run-time:
|
|
|
|
// - Check that the cached klass matches
|
|
|
|
// - Check that method entry is not invalidated
|
|
|
|
// - ???
|
|
|
|
// - Create a new frame
|
|
|
|
// - copy function arguments?
|
|
|
|
// - Call the C function
|
|
|
|
// - Remove the frame
|
2020-10-16 14:46:46 -04:00
|
|
|
|
|
|
|
// Create a size-exit to fall back to the interpreter
|
|
|
|
uint8_t* side_exit = ujit_side_exit(ocb, ctx, ctx->pc);
|
|
|
|
|
|
|
|
// Points to the receiver operand on the stack
|
|
|
|
x86opnd_t recv = ctx_stack_opnd(ctx, argc);
|
|
|
|
mov(cb, RCX, recv);
|
|
|
|
|
|
|
|
//print_str(cb, rb_id2name(mid));
|
|
|
|
//print_ptr(cb, RCX);
|
|
|
|
|
2020-10-16 16:57:56 -04:00
|
|
|
// IDEA: may be able to eliminate this in some cases if we know the previous instruction?
|
2020-10-16 14:46:46 -04:00
|
|
|
// TODO: guard_is_object() helper function?
|
2020-10-16 16:57:56 -04:00
|
|
|
// FIXME: an object can have QNil bit 1000 set
|
|
|
|
// need to check for immediate mask, Qnil and Qfalse
|
2020-10-16 14:46:46 -04:00
|
|
|
// Check that the receiver is an object
|
2020-10-16 16:57:56 -04:00
|
|
|
test(cb, RCX, imm_opnd(RUBY_IMMEDIATE_MASK));
|
2020-10-16 14:46:46 -04:00
|
|
|
jnz_ptr(cb, side_exit);
|
2020-10-16 16:57:56 -04:00
|
|
|
cmp(cb, RCX, imm_opnd(Qfalse));
|
|
|
|
je_ptr(cb, side_exit);
|
|
|
|
cmp(cb, RCX, imm_opnd(Qnil));
|
|
|
|
je_ptr(cb, side_exit);
|
2020-10-16 14:46:46 -04:00
|
|
|
|
|
|
|
// Pointer to the klass field of the receiver &(recv->klass)
|
|
|
|
x86opnd_t klass_opnd = mem_opnd(64, RCX, offsetof(struct RBasic, klass));
|
|
|
|
|
|
|
|
// IDEA: Aaron suggested we could possibly treat a changed
|
|
|
|
// class pointer as a cache miss
|
|
|
|
// Check if we have a cache hit
|
|
|
|
mov(cb, RAX, const_ptr_opnd((void*)cd->cc->klass));
|
|
|
|
cmp(cb, RAX, klass_opnd);
|
|
|
|
jne_ptr(cb, side_exit);
|
|
|
|
//print_str(cb, "cache klass hit");
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
|
2020-10-02 12:12:28 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
|
|
|
|
|
2020-10-15 15:15:31 -04:00
|
|
|
|
|
|
|
|
2020-10-16 14:46:46 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
jmp_ptr(cb, side_exit);
|
|
|
|
return true;
|
2020-10-15 11:46:37 -04:00
|
|
|
|
2020-09-30 16:57:54 -04:00
|
|
|
/*
|
2020-10-15 11:46:37 -04:00
|
|
|
// Create a size-exit to fall back to the interpreter
|
|
|
|
uint8_t* side_exit = ujit_side_exit(ocb, ctx, ctx->pc);
|
|
|
|
|
|
|
|
struct rb_calling_info *calling = (struct rb_calling_info*)malloc(sizeof(struct rb_calling_info));
|
|
|
|
calling->block_handler = VM_BLOCK_HANDLER_NONE;
|
|
|
|
calling->kw_splat = 0;
|
|
|
|
calling->argc = argc;
|
|
|
|
|
|
|
|
mov(cb, RAX, const_ptr_opnd(cd));
|
|
|
|
x86opnd_t ptr_to_cc = member_opnd(RAX, struct rb_call_data, cc);
|
|
|
|
mov(cb, RAX, ptr_to_cc);
|
|
|
|
|
2020-09-30 15:17:13 -04:00
|
|
|
x86opnd_t ptr_to_klass = mem_opnd(64, RAX, offsetof(struct rb_callcache, klass));
|
|
|
|
x86opnd_t ptr_to_cme_ = mem_opnd(64, RAX, offsetof(struct rb_callcache, cme_));
|
2020-10-15 11:46:37 -04:00
|
|
|
x86opnd_t ptr_to_call_ = mem_opnd(64, RAX, offsetof(struct rb_callcache, call_));
|
|
|
|
mov(cb, R9, ptr_to_klass);
|
2020-09-30 15:17:13 -04:00
|
|
|
mov(cb, RCX, ptr_to_cme_);
|
|
|
|
|
|
|
|
// Points to the receiver operand on the stack
|
|
|
|
x86opnd_t recv = ctx_stack_opnd(ctx, argc);
|
|
|
|
mov(cb, RDX, recv);
|
2020-10-15 11:46:37 -04:00
|
|
|
//print_int(cb, recv);
|
|
|
|
|
|
|
|
// Store calling->recv
|
|
|
|
mov(cb, R8, const_ptr_opnd(calling));
|
|
|
|
x86opnd_t recv_opnd = mem_opnd(64, R8, offsetof(struct rb_calling_info, recv));
|
|
|
|
mov(cb, recv_opnd, RDX);
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-09-30 15:17:13 -04:00
|
|
|
// Pointer to the klass field of the receiver
|
|
|
|
x86opnd_t klass_opnd = mem_opnd(64, RDX, offsetof(struct RBasic, klass));
|
|
|
|
|
2020-10-15 15:15:31 -04:00
|
|
|
// IDEA: Aaron suggested we could possibly treat a changed
|
|
|
|
// class pointer as a cache miss
|
|
|
|
// Check if we have a cache hit
|
2020-10-15 11:46:37 -04:00
|
|
|
cmp(cb, R9, klass_opnd);
|
2020-09-30 15:17:13 -04:00
|
|
|
jne_ptr(cb, side_exit);
|
2020-10-15 11:46:37 -04:00
|
|
|
//print_int(cb, klass_opnd);
|
2020-09-30 15:17:13 -04:00
|
|
|
print_str(cb, "cache klass hit");
|
|
|
|
|
|
|
|
//#define METHOD_ENTRY_INVALIDATED(me) ((me)->flags & IMEMO_FL_USER5)
|
|
|
|
x86opnd_t flags_opnd = mem_opnd(64, RCX, offsetof( rb_callable_method_entry_t, flags));
|
|
|
|
test(cb, flags_opnd, imm_opnd(IMEMO_FL_USER5));
|
|
|
|
jnz_ptr(cb, side_exit);
|
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
push(cb, RDI);
|
|
|
|
push(cb, RSI);
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
x86opnd_t ptr_to_pc = mem_opnd(64, RDI, offsetof(rb_control_frame_t, pc));
|
|
|
|
mov(cb, ptr_to_pc, const_ptr_opnd(ctx->pc + insn_len(BIN(opt_send_without_block))));
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
// Write the adjusted SP back into the CFP
|
|
|
|
if (ctx->stack_diff != 0)
|
|
|
|
{
|
|
|
|
x86opnd_t stack_pointer = ctx_sp_opnd(ctx, 1);
|
|
|
|
lea(cb, RSI, stack_pointer);
|
|
|
|
mov(cb, mem_opnd(64, RDI, 8), RSI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// val = vm_cc_call(cc)(ec, GET_CFP(), &calling, cd);
|
|
|
|
mov(cb, RSI, RDI);
|
|
|
|
mov(cb, RDI, const_ptr_opnd(rb_current_execution_context()));
|
|
|
|
mov(cb, RDX, R8);
|
|
|
|
print_int(cb, RDX);
|
|
|
|
mov(cb, RCX, const_ptr_opnd(cd));
|
|
|
|
|
|
|
|
call(cb, ptr_to_call_);
|
|
|
|
|
|
|
|
pop(cb, RSI);
|
|
|
|
pop(cb, RDI);
|
|
|
|
|
|
|
|
size_t continue_in_jit = cb_new_label(cb, "continue_in_jit");
|
|
|
|
cmp(cb, RAX, imm_opnd(Qundef));
|
|
|
|
jne(cb, continue_in_jit);
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
//print_str(cb, "method entry not invalidated!!!1");
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
mov(cb, RDI, const_ptr_opnd(rb_current_execution_context()));
|
|
|
|
mov(cb, RDI, mem_opnd(64, RDI, offsetof(rb_execution_context_t, cfp)));
|
2020-09-30 15:17:13 -04:00
|
|
|
|
2020-10-15 11:46:37 -04:00
|
|
|
// Read the PC from the CFP
|
|
|
|
mov(cb, RAX, mem_opnd(64, RDI, 0));
|
|
|
|
|
|
|
|
// Write the post call bytes
|
|
|
|
for (size_t i = 0; i < sizeof(ujit_post_call_bytes); ++i)
|
|
|
|
cb_write_byte(cb, ujit_post_call_bytes[i]);
|
|
|
|
|
|
|
|
cb_write_label(cb, continue_in_jit);
|
|
|
|
cb_link_labels(cb);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
*/
|
2020-09-30 15:17:13 -04:00
|
|
|
}
|
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
rb_ujit_compile_iseq(const rb_iseq_t *iseq)
|
2020-09-28 07:03:28 -04:00
|
|
|
{
|
2020-10-13 11:15:22 -04:00
|
|
|
#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
|
2020-10-15 09:06:42 -04:00
|
|
|
RB_VM_LOCK();
|
2020-10-13 11:15:22 -04:00
|
|
|
VALUE *encoded = (VALUE *)iseq->body->iseq_encoded;
|
|
|
|
|
|
|
|
unsigned int insn_idx;
|
|
|
|
unsigned int next_ujit_idx = 0;
|
|
|
|
|
|
|
|
for (insn_idx = 0; insn_idx < iseq->body->iseq_size; /* */) {
|
|
|
|
int insn = opcode_at_pc(iseq, &encoded[insn_idx]);
|
|
|
|
int len = insn_len(insn);
|
|
|
|
|
|
|
|
uint8_t *native_code_ptr = NULL;
|
|
|
|
|
|
|
|
// If ujit hasn't already compiled this instruction
|
|
|
|
if (insn_idx >= next_ujit_idx) {
|
|
|
|
native_code_ptr = ujit_compile_insn(iseq, insn_idx, &next_ujit_idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (native_code_ptr) {
|
|
|
|
encoded[insn_idx] = (VALUE)native_code_ptr;
|
|
|
|
}
|
|
|
|
insn_idx += len;
|
|
|
|
}
|
2020-10-15 09:06:42 -04:00
|
|
|
RB_VM_UNLOCK();
|
2020-10-13 11:15:22 -04:00
|
|
|
#endif
|
2020-09-28 07:03:28 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rb_ujit_init(void)
|
2020-09-14 13:31:34 -04:00
|
|
|
{
|
2020-10-15 11:46:37 -04:00
|
|
|
if (!ujit_scrape_successful || !PLATFORM_SUPPORTED_P)
|
|
|
|
{
|
2020-10-05 07:21:45 -04:00
|
|
|
return;
|
|
|
|
}
|
2020-10-15 11:46:37 -04:00
|
|
|
|
2020-10-13 11:15:22 -04:00
|
|
|
rb_ujit_enabled = true;
|
2020-09-28 15:50:41 -04:00
|
|
|
// Initialize the code blocks
|
2020-10-05 13:38:17 -04:00
|
|
|
size_t mem_size = 128 * 1024 * 1024;
|
2020-09-28 15:50:41 -04:00
|
|
|
uint8_t* mem_block = alloc_exec_mem(mem_size);
|
2020-09-14 13:31:34 -04:00
|
|
|
cb = █
|
2020-09-28 15:50:41 -04:00
|
|
|
cb_init(cb, mem_block, mem_size/2);
|
|
|
|
ocb = &outline_block;
|
|
|
|
cb_init(ocb, mem_block + mem_size/2, mem_size/2);
|
2020-09-15 17:04:33 -04:00
|
|
|
|
|
|
|
// Initialize the codegen function table
|
|
|
|
gen_fns = rb_st_init_numtable();
|
|
|
|
|
|
|
|
// Map YARV opcodes to the corresponding codegen functions
|
2020-09-18 12:40:05 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(dup), (st_data_t)&gen_dup);
|
2020-09-15 17:04:33 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(nop), (st_data_t)&gen_nop);
|
|
|
|
st_insert(gen_fns, (st_data_t)BIN(pop), (st_data_t)&gen_pop);
|
2020-09-16 15:30:23 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(putnil), (st_data_t)&gen_putnil);
|
2020-09-17 13:40:50 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(putobject), (st_data_t)&gen_putobject);
|
2020-09-16 10:33:34 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(putobject_INT2FIX_0_), (st_data_t)&gen_putobject_int2fix);
|
|
|
|
st_insert(gen_fns, (st_data_t)BIN(putobject_INT2FIX_1_), (st_data_t)&gen_putobject_int2fix);
|
2020-09-18 12:20:43 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(putself), (st_data_t)&gen_putself);
|
2020-09-16 10:33:34 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(getlocal_WC_0), (st_data_t)&gen_getlocal_wc0);
|
2020-09-28 15:50:41 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(setlocal_WC_0), (st_data_t)&gen_setlocal_wc0);
|
2020-10-02 12:12:28 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(opt_minus), (st_data_t)&gen_opt_minus);
|
2020-09-30 15:17:13 -04:00
|
|
|
st_insert(gen_fns, (st_data_t)BIN(opt_send_without_block), (st_data_t)&gen_opt_send_without_block);
|
2020-09-14 13:31:34 -04:00
|
|
|
}
|