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
|
use std::ffi::CStr;
// Command-line options
#[derive(Clone, PartialEq, Eq, Debug)]
#[repr(C)]
pub struct Options {
// Size of the executable memory block to allocate in MiB
pub exec_mem_size: usize,
// Number of method calls after which to start generating code
// Threshold==1 means compile on first execution
pub call_threshold: usize,
// Generate versions greedily until the limit is hit
pub greedy_versioning: bool,
// Disable the propagation of type information
pub no_type_prop: bool,
// Maximum number of versions per block
// 1 means always create generic versions
pub max_versions: usize,
// Capture and print out stats
pub gen_stats: bool,
// Trace locations of exits
pub gen_trace_exits: bool,
/// Dump compiled and executed instructions for debugging
pub dump_insns: bool,
/// Print when specific ISEQ items are compiled or invalidated
pub dump_iseq_disasm: Option<String>,
/// Verify context objects (debug mode only)
pub verify_ctx: bool,
/// Whether or not to assume a global constant state (and therefore
/// invalidating code whenever any constant changes) versus assuming
/// constant name components (and therefore invalidating code whenever a
/// matching name component changes)
pub global_constant_state: bool,
}
// Initialize the options to default values
pub static mut OPTIONS: Options = Options {
exec_mem_size: 256,
call_threshold: 10,
greedy_versioning: false,
no_type_prop: false,
max_versions: 4,
gen_stats: false,
gen_trace_exits: false,
dump_insns: false,
verify_ctx: false,
global_constant_state: false,
dump_iseq_disasm: None,
};
/// Macro to get an option value by name
macro_rules! get_option {
// Unsafe is ok here because options are initialized
// once before any Ruby code executes
($option_name:ident) => {
unsafe { OPTIONS.$option_name }
};
}
pub(crate) use get_option;
/// Macro to reference an option value by name; we assume it's a cloneable type like String or an Option of same.
macro_rules! get_option_ref {
// Unsafe is ok here because options are initialized
// once before any Ruby code executes
($option_name:ident) => {
unsafe { &(OPTIONS.$option_name) }
};
}
pub(crate) use get_option_ref;
/// Expected to receive what comes after the third dash in "--yjit-*".
/// Empty string means user passed only "--yjit". C code rejects when
/// they pass exact "--yjit-".
pub fn parse_option(str_ptr: *const std::os::raw::c_char) -> Option<()> {
let c_str: &CStr = unsafe { CStr::from_ptr(str_ptr) };
let opt_str: &str = c_str.to_str().ok()?;
//println!("{}", opt_str);
// Split the option name and value strings
// Note that some options do not contain an assignment
let parts = opt_str.split_once('=');
let (opt_name, opt_val) = match parts {
Some((before_eq, after_eq)) => (before_eq, after_eq),
None => (opt_str, ""),
};
// Match on the option name and value strings
match (opt_name, opt_val) {
("", "") => (), // Simply --yjit
("exec-mem-size", _) => match opt_val.parse() {
Ok(n) => unsafe { OPTIONS.exec_mem_size = n },
Err(_) => {
return None;
}
},
("call-threshold", _) => match opt_val.parse() {
Ok(n) => unsafe { OPTIONS.call_threshold = n },
Err(_) => {
return None;
}
},
("max-versions", _) => match opt_val.parse() {
Ok(n) => unsafe { OPTIONS.max_versions = n },
Err(_) => {
return None;
}
},
("dump-iseq-disasm", _) => unsafe {
OPTIONS.dump_iseq_disasm = Some(opt_val.to_string());
},
("greedy-versioning", "") => unsafe { OPTIONS.greedy_versioning = true },
("no-type-prop", "") => unsafe { OPTIONS.no_type_prop = true },
("stats", "") => unsafe { OPTIONS.gen_stats = true },
("trace-exits", "") => unsafe { OPTIONS.gen_trace_exits = true; OPTIONS.gen_stats = true },
("dump-insns", "") => unsafe { OPTIONS.dump_insns = true },
("verify-ctx", "") => unsafe { OPTIONS.verify_ctx = true },
("global-constant-state", "") => unsafe { OPTIONS.global_constant_state = true },
// Option name not recognized
_ => {
return None;
}
}
// dbg!(unsafe {OPTIONS});
// Option successfully parsed
return Some(());
}
|
