1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
#ifndef UJIT_CORE_H
#define UJIT_CORE_H 1
#include "stddef.h"
#include "ujit_asm.h"
// Register uJIT receives the CFP and EC into
#define REG_CFP RDI
#define REG_EC RSI
// Register uJIT loads the SP into
#define REG_SP RDX
// Scratch registers used by uJIT
#define REG0 RAX
#define REG1 RCX
#define REG0_32 EAX
#define REG1_32 ECX
// Maximum number of versions per block
#define MAX_VERSIONS 5
// Maximum number of temp value types we keep track of
#define MAX_TEMP_TYPES 8
/**
Code generation context
Contains information we can use to optimize code
*/
typedef struct CtxStruct
{
// 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];
// Number of values pushed on the temporary stack
uint32_t stack_size;
// Whether we know self is a heap object
bool self_is_object;
} ctx_t;
// Tuple of (iseq, idx) used to idenfity basic blocks
typedef struct BlockId
{
// Instruction sequence
const rb_iseq_t *iseq;
// Index in the iseq where the block starts
uint32_t idx;
} blockid_t;
// Null block id constant
static const blockid_t BLOCKID_NULL = { 0, 0 };
/// Branch code shape enumeration
enum uint8_t
{
SHAPE_NEXT0, // Target 0 is next
SHAPE_NEXT1, // Target 1 is next
SHAPE_DEFAULT // Neither target is next
};
// Branch code generation function signature
typedef void (*branchgen_fn)(codeblock_t* cb, uint8_t* target0, uint8_t* target1, uint8_t shape);
/**
Store info about an outgoing branch in a code segment
Note: care must be taken to minimize the size of branch_t objects
*/
typedef struct BranchEntry
{
// Positions where the generated code starts and ends
uint32_t start_pos;
uint32_t end_pos;
// Context right after the branch instruction
ctx_t src_ctx;
// Branch target blocks and their contexts
blockid_t targets[2];
ctx_t target_ctxs[2];
// Jump target addresses
uint8_t* dst_addrs[2];
// Branch code generation function
branchgen_fn gen_fn;
// Shape of the branch
uint8_t shape;
} branch_t;
/**
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
*/
typedef struct BlockVersion
{
// Bytecode sequence (iseq, idx) this is a version of
blockid_t blockid;
// Index one past the last instruction in the iseq
uint32_t end_idx;
// 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
uint32_t* incoming;
uint32_t num_incoming;
} block_t;
// Context object methods
x86opnd_t ctx_sp_opnd(ctx_t* ctx, int32_t offset_bytes);
x86opnd_t ctx_stack_push(ctx_t* ctx, int type);
x86opnd_t ctx_stack_pop(ctx_t* ctx, size_t n);
x86opnd_t ctx_stack_opnd(ctx_t* ctx, int32_t idx);
int ctx_get_top_type(ctx_t* ctx);
block_t* find_block_version(blockid_t blockid, const ctx_t* ctx);
block_t* gen_block_version(blockid_t blockid, const ctx_t* ctx);
uint8_t* gen_entry_point(const rb_iseq_t *iseq, uint32_t insn_idx);
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
);
void gen_direct_jump(
const ctx_t* ctx,
blockid_t target0
);
void invalidate(block_t* block);
void ujit_init_core(void);
#endif // #ifndef UJIT_CORE_H
|
