2021-03-06 18:46:56 -05:00
|
|
|
#ifndef YJIT_CORE_H
|
|
|
|
#define YJIT_CORE_H 1
|
2020-12-08 16:54:41 -05:00
|
|
|
|
|
|
|
#include "stddef.h"
|
2021-03-06 18:46:56 -05:00
|
|
|
#include "yjit_asm.h"
|
2020-12-08 16:54:41 -05:00
|
|
|
|
2021-03-06 18:46:56 -05:00
|
|
|
// Register YJIT receives the CFP and EC into
|
2020-12-08 16:54:41 -05:00
|
|
|
#define REG_CFP RDI
|
|
|
|
#define REG_EC RSI
|
|
|
|
|
2021-03-06 18:46:56 -05:00
|
|
|
// Register YJIT loads the SP into
|
2020-12-08 16:54:41 -05:00
|
|
|
#define REG_SP RDX
|
|
|
|
|
2021-03-06 18:46:56 -05:00
|
|
|
// Scratch registers used by YJIT
|
2020-12-08 16:54:41 -05:00
|
|
|
#define REG0 RAX
|
|
|
|
#define REG1 RCX
|
|
|
|
#define REG0_32 EAX
|
|
|
|
#define REG1_32 ECX
|
|
|
|
|
2021-01-20 12:44:24 -05:00
|
|
|
// Maximum number of temp value types we keep track of
|
|
|
|
#define MAX_TEMP_TYPES 8
|
|
|
|
|
2021-03-30 15:37:20 -04:00
|
|
|
// Maximum number of local variable types we keep track of
|
|
|
|
#define MAX_LOCAL_TYPES 8
|
|
|
|
|
2021-03-05 15:45:44 -05:00
|
|
|
// Default versioning context (no type information)
|
|
|
|
#define DEFAULT_CTX ( (ctx_t){ 0 } )
|
|
|
|
|
2021-03-30 10:59:53 -04:00
|
|
|
/**
|
|
|
|
Represent the type of a value (local/stack/self) in YJIT
|
|
|
|
*/
|
|
|
|
typedef struct yjit_val_type
|
|
|
|
{
|
|
|
|
// Value is definitely a heap object
|
|
|
|
uint8_t is_heap : 1;
|
|
|
|
|
|
|
|
// Value is definitely an immediate
|
|
|
|
uint8_t is_imm : 1;
|
|
|
|
|
2021-03-30 16:40:26 -04:00
|
|
|
// Not Qfalse or Qnil
|
|
|
|
// Is this useful?
|
|
|
|
//uint8_t is_truthy: 1;
|
|
|
|
|
|
|
|
// NOTE: we could switch to using an enum to track multiple types
|
2021-03-30 10:59:53 -04:00
|
|
|
// but then we also need a value for "unknown type"
|
|
|
|
uint8_t is_fixnum : 1;
|
2021-03-30 15:37:20 -04:00
|
|
|
//uint8_t is_array : 1; // for opt_aref
|
|
|
|
//uint8_t is_hash : 1; // for opt_aref
|
|
|
|
//uint8_t is_symbol : 1;
|
|
|
|
//uint8_t is_string : 1;
|
2021-03-30 10:59:53 -04:00
|
|
|
|
|
|
|
} val_type_t;
|
|
|
|
STATIC_ASSERT(val_type_size, sizeof(val_type_t) == 1);
|
|
|
|
|
|
|
|
// Unknown type, could be anything, all zeroes
|
|
|
|
#define TYPE_UNKNOWN ( (val_type_t){ 0 } )
|
|
|
|
|
|
|
|
// Could be any heap object
|
|
|
|
#define TYPE_HEAP ( (val_type_t){ .is_heap = 1 } )
|
|
|
|
|
|
|
|
// Could be any immediate
|
|
|
|
#define TYPE_IMM ( (val_type_t){ .is_imm = 1 } )
|
|
|
|
|
|
|
|
// Immediate integer
|
|
|
|
#define TYPE_FIXNUM ( (val_type_t){ .is_imm = 1, .is_fixnum = 1 } )
|
|
|
|
|
|
|
|
typedef enum yjit_temp_loc
|
|
|
|
{
|
|
|
|
TEMP_STACK = 0,
|
|
|
|
TEMP_SELF,
|
2021-03-30 15:37:20 -04:00
|
|
|
//TEMP_LOCAL, // Local with index
|
2021-03-30 10:59:53 -04:00
|
|
|
//TEMP_CONST, // Small constant
|
|
|
|
|
|
|
|
} temp_loc_t;
|
|
|
|
|
|
|
|
typedef struct yjit_temp_mapping
|
|
|
|
{
|
|
|
|
// Where/how is the local stored?
|
|
|
|
uint8_t kind: 2;
|
|
|
|
|
|
|
|
// Index of the local variale,
|
2021-03-30 15:37:20 -04:00
|
|
|
// or small non-negative constant in [0, 63]
|
2021-03-30 10:59:53 -04:00
|
|
|
uint8_t idx : 6;
|
|
|
|
|
|
|
|
} temp_mapping_t;
|
|
|
|
STATIC_ASSERT(temp_mapping_size, sizeof(temp_mapping_t) == 1);
|
|
|
|
|
|
|
|
// By default, temps are just temps on the stack
|
|
|
|
#define MAP_STACK ( (temp_mapping_t) { 0 } )
|
|
|
|
|
|
|
|
// Temp value is actually self
|
|
|
|
#define MAP_SELF ( (temp_mapping_t) { .kind = TEMP_SELF } )
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-01-22 12:22:34 -05:00
|
|
|
/**
|
|
|
|
Code generation context
|
|
|
|
Contains information we can use to optimize code
|
|
|
|
*/
|
2021-03-17 11:00:36 -04:00
|
|
|
typedef struct yjit_context
|
2020-12-08 16:54:41 -05:00
|
|
|
{
|
2021-03-05 15:45:44 -05:00
|
|
|
// Depth of this block in the sidechain (eg: inline-cache chain)
|
2021-03-05 15:55:10 -05:00
|
|
|
uint8_t chain_depth;
|
2021-03-05 15:45:44 -05:00
|
|
|
|
2021-01-20 12:44:24 -05:00
|
|
|
// Temporary variable types we keep track of
|
|
|
|
// Values are `ruby_value_type`
|
|
|
|
// T_NONE==0 is the unknown type
|
|
|
|
uint8_t temp_types[MAX_TEMP_TYPES];
|
|
|
|
|
2021-02-09 16:24:06 -05:00
|
|
|
// Number of values currently on the temporary stack
|
2021-01-26 16:51:44 -05:00
|
|
|
uint16_t stack_size;
|
2020-12-10 00:06:10 -05:00
|
|
|
|
2021-02-09 16:24:06 -05:00
|
|
|
// Offset of the JIT SP relative to the interpreter SP
|
2021-03-03 14:58:42 -05:00
|
|
|
// This represents how far the JIT's SP is from the "real" SP
|
2021-02-09 16:24:06 -05:00
|
|
|
int16_t sp_offset;
|
|
|
|
|
2021-03-30 15:37:20 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// FIXME: no longer need this bit after type mapping refactoring
|
2020-12-08 16:54:41 -05:00
|
|
|
// Whether we know self is a heap object
|
2021-01-26 16:51:44 -05:00
|
|
|
bool self_is_object : 1;
|
2020-12-08 16:54:41 -05:00
|
|
|
|
2021-03-30 15:37:20 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-12-08 16:54:41 -05:00
|
|
|
} ctx_t;
|
|
|
|
|
2020-12-16 17:07:18 -05:00
|
|
|
// Tuple of (iseq, idx) used to idenfity basic blocks
|
|
|
|
typedef struct BlockId
|
|
|
|
{
|
|
|
|
// Instruction sequence
|
|
|
|
const rb_iseq_t *iseq;
|
|
|
|
|
2021-01-18 17:03:04 -05:00
|
|
|
// Index in the iseq where the block starts
|
|
|
|
uint32_t idx;
|
2020-12-16 17:07:18 -05:00
|
|
|
|
|
|
|
} blockid_t;
|
|
|
|
|
2021-01-08 15:18:03 -05:00
|
|
|
// Null block id constant
|
|
|
|
static const blockid_t BLOCKID_NULL = { 0, 0 };
|
|
|
|
|
2020-12-16 17:07:18 -05:00
|
|
|
/// Branch code shape enumeration
|
2021-03-05 15:54:21 -05:00
|
|
|
typedef enum branch_shape
|
2020-12-16 17:07:18 -05:00
|
|
|
{
|
2020-12-16 21:45:51 -05:00
|
|
|
SHAPE_NEXT0, // Target 0 is next
|
|
|
|
SHAPE_NEXT1, // Target 1 is next
|
|
|
|
SHAPE_DEFAULT // Neither target is next
|
2021-03-05 15:45:44 -05:00
|
|
|
} branch_shape_t;
|
2020-12-16 17:07:18 -05:00
|
|
|
|
|
|
|
// Branch code generation function signature
|
|
|
|
typedef void (*branchgen_fn)(codeblock_t* cb, uint8_t* target0, uint8_t* target1, uint8_t shape);
|
|
|
|
|
2021-01-22 12:22:34 -05:00
|
|
|
/**
|
|
|
|
Store info about an outgoing branch in a code segment
|
|
|
|
Note: care must be taken to minimize the size of branch_t objects
|
|
|
|
*/
|
2020-12-16 17:07:18 -05:00
|
|
|
typedef struct BranchEntry
|
|
|
|
{
|
|
|
|
// Positions where the generated code starts and ends
|
|
|
|
uint32_t start_pos;
|
|
|
|
uint32_t end_pos;
|
|
|
|
|
2021-01-08 15:18:03 -05:00
|
|
|
// Context right after the branch instruction
|
|
|
|
ctx_t src_ctx;
|
|
|
|
|
|
|
|
// Branch target blocks and their contexts
|
2020-12-16 17:07:18 -05:00
|
|
|
blockid_t targets[2];
|
2021-01-08 15:18:03 -05:00
|
|
|
ctx_t target_ctxs[2];
|
2020-12-16 17:07:18 -05:00
|
|
|
|
2020-12-16 21:45:51 -05:00
|
|
|
// Jump target addresses
|
|
|
|
uint8_t* dst_addrs[2];
|
|
|
|
|
2020-12-16 17:07:18 -05:00
|
|
|
// Branch code generation function
|
|
|
|
branchgen_fn gen_fn;
|
|
|
|
|
2020-12-16 21:45:51 -05:00
|
|
|
// Shape of the branch
|
2021-03-05 15:45:44 -05:00
|
|
|
branch_shape_t shape;
|
2020-12-16 21:45:51 -05:00
|
|
|
|
2020-12-16 17:07:18 -05:00
|
|
|
} branch_t;
|
2020-12-14 15:57:55 -05:00
|
|
|
|
2021-02-19 16:04:23 -05:00
|
|
|
typedef rb_darray(uint32_t) int32_array_t;
|
2021-02-19 15:03:12 -05:00
|
|
|
|
2021-01-22 12:22:34 -05:00
|
|
|
/**
|
|
|
|
Basic block version
|
|
|
|
Represents a portion of an iseq compiled with a given context
|
|
|
|
Note: care must be taken to minimize the size of block_t objects
|
|
|
|
*/
|
2021-03-06 18:46:56 -05:00
|
|
|
typedef struct yjit_block_version
|
2021-01-13 15:18:35 -05:00
|
|
|
{
|
2021-01-14 13:33:19 -05:00
|
|
|
// Bytecode sequence (iseq, idx) this is a version of
|
2021-01-13 15:18:35 -05:00
|
|
|
blockid_t blockid;
|
|
|
|
|
|
|
|
// Context at the start of the block
|
|
|
|
ctx_t ctx;
|
|
|
|
|
|
|
|
// Positions where the generated code starts and ends
|
|
|
|
uint32_t start_pos;
|
|
|
|
uint32_t end_pos;
|
|
|
|
|
|
|
|
// List of incoming branches indices
|
2021-02-19 16:04:23 -05:00
|
|
|
int32_array_t incoming;
|
2021-01-13 15:18:35 -05:00
|
|
|
|
2021-02-25 15:10:38 -05:00
|
|
|
// Offsets for GC managed objects in the mainline code block
|
|
|
|
int32_array_t gc_object_offsets;
|
|
|
|
|
2021-03-17 19:07:20 -04:00
|
|
|
// In case this block is invalidated, these two pieces of info
|
|
|
|
// help to remove all pointers to this block in the system.
|
|
|
|
VALUE receiver_klass;
|
|
|
|
VALUE callee_cme;
|
2021-02-25 15:10:38 -05:00
|
|
|
|
|
|
|
// Index one past the last instruction in the iseq
|
|
|
|
uint32_t end_idx;
|
2021-01-14 13:33:19 -05:00
|
|
|
} block_t;
|
2021-01-13 15:18:35 -05:00
|
|
|
|
2020-12-10 16:59:13 -05:00
|
|
|
// Context object methods
|
2020-12-08 16:54:41 -05:00
|
|
|
x86opnd_t ctx_sp_opnd(ctx_t* ctx, int32_t offset_bytes);
|
2021-01-20 16:58:09 -05:00
|
|
|
x86opnd_t ctx_stack_push(ctx_t* ctx, int type);
|
2020-12-08 16:54:41 -05:00
|
|
|
x86opnd_t ctx_stack_pop(ctx_t* ctx, size_t n);
|
|
|
|
x86opnd_t ctx_stack_opnd(ctx_t* ctx, int32_t idx);
|
2021-01-20 16:58:09 -05:00
|
|
|
int ctx_get_top_type(ctx_t* ctx);
|
2021-01-22 14:57:44 -05:00
|
|
|
int ctx_diff(const ctx_t* src, const ctx_t* dst);
|
2020-12-08 16:54:41 -05:00
|
|
|
|
2021-01-14 13:33:19 -05:00
|
|
|
block_t* find_block_version(blockid_t blockid, const ctx_t* ctx);
|
2021-03-01 20:43:58 -05:00
|
|
|
block_t* gen_block_version(blockid_t blockid, const ctx_t* ctx, rb_execution_context_t *ec);
|
|
|
|
uint8_t* gen_entry_point(const rb_iseq_t *iseq, uint32_t insn_idx, rb_execution_context_t *ec);
|
2021-03-06 18:46:56 -05:00
|
|
|
void yjit_free_block(block_t *block);
|
|
|
|
void yjit_branches_update_references(void);
|
2021-01-08 15:18:03 -05:00
|
|
|
|
|
|
|
void gen_branch(
|
|
|
|
const ctx_t* src_ctx,
|
|
|
|
blockid_t target0,
|
|
|
|
const ctx_t* ctx0,
|
|
|
|
blockid_t target1,
|
|
|
|
const ctx_t* ctx1,
|
|
|
|
branchgen_fn gen_fn
|
|
|
|
);
|
2020-12-16 17:07:18 -05:00
|
|
|
|
2021-01-19 11:11:11 -05:00
|
|
|
void gen_direct_jump(
|
|
|
|
const ctx_t* ctx,
|
|
|
|
blockid_t target0
|
|
|
|
);
|
|
|
|
|
2021-03-05 15:45:44 -05:00
|
|
|
void defer_compilation(
|
|
|
|
block_t* block,
|
|
|
|
uint32_t insn_idx,
|
|
|
|
ctx_t* cur_ctx
|
|
|
|
);
|
|
|
|
|
2021-01-29 12:07:18 -05:00
|
|
|
void invalidate_block_version(block_t* block);
|
2021-01-12 17:03:54 -05:00
|
|
|
|
2021-03-06 18:46:56 -05:00
|
|
|
void yjit_init_core(void);
|
2020-12-10 16:59:13 -05:00
|
|
|
|
2021-03-06 18:46:56 -05:00
|
|
|
#endif // #ifndef YJIT_CORE_H
|