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
|
use std::ffi::CStr;
// Command-line options
#[derive(Copy, 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,
/// Dump compiled and executed instructions for debugging
pub dump_insns: bool,
/// 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,
dump_insns: false,
verify_ctx: false,
global_constant_state: false,
};
/// 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;
/// 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;
}
},
("greedy-versioning", "") => unsafe { OPTIONS.greedy_versioning = true },
("no-type-prop", "") => unsafe { OPTIONS.no_type_prop = true },
("stats", "") => unsafe { 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(());
}
|
