ethonion10/v86
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Simplify (remove c_api)

Browse source
This commit is contained in:
Fabian 2020-12-31 19:14:30 -06:00
parent 4e68de9c4d
commit e1f8a563ad
10 changed files with 119 additions and 214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/browser/starter.js
View file

@ -178,7 +178,7 @@ function V86Starter(options)
cpu.codegen_finalize(wasm_table_index, start, end, first_opcode, state_flags);
},
"jit_clear_func": (wasm_table_index) => cpu.jit_clear_func(wasm_table_index),
"jit_clear_cache": () => cpu.jit_clear_cache(),
"jit_clear_all_funcs": () => cpu.jit_clear_all_funcs(),
"do_task_switch": (selector, has_error_code, error_code) => {
cpu.do_task_switch(selector, has_error_code, error_code);
},
@ -206,7 +206,7 @@ function V86Starter(options)
{ "env": wasm_shared_funcs },
v86_wasm => {
wasm_memory = v86_wasm.exports.memory;
v86_wasm.exports["rust_setup"]();
v86_wasm.exports["rust_init"]();
const emulator = this.v86 = new v86(this.emulator_bus, v86_wasm);
cpu = emulator.cpu;

24
src/cpu.js
View file

@ -322,7 +322,7 @@ CPU.prototype.wasm_patch = function(wm)
this.jit_force_generate_unsafe = get_optional_import("jit_force_generate_unsafe");
}
this.jit_empty_cache = get_import("jit_empty_cache");
this.jit_clear_cache = get_import("jit_clear_cache_js");
this.jit_dirty_cache = get_import("jit_dirty_cache");
this.codegen_finalize_finished = get_import("codegen_finalize_finished");
@ -351,6 +351,16 @@ CPU.prototype.jit_clear_func = function(index)
this.wm.imports["env"][WASM_EXPORT_TABLE_NAME].set(index + WASM_TABLE_OFFSET, null);
};
CPU.prototype.jit_clear_all_funcs = function()
{
const table = this.wm.imports["env"][WASM_EXPORT_TABLE_NAME];
for(let i = 0; i < WASM_TABLE_SIZE; i++)
{
table.set(WASM_TABLE_OFFSET + i, null);
}
};
CPU.prototype.get_state = function()
{
var state = [];
@ -1568,18 +1578,6 @@ CPU.prototype.cpl_changed = function()
this.last_virt_esp[0] = -1;
};
CPU.prototype.jit_clear_cache = function()
{
this.jit_empty_cache();
const table = this.wm.imports["env"][WASM_EXPORT_TABLE_NAME];
for(let i = 0; i < WASM_TABLE_SIZE; i++)
{
table.set(WASM_TABLE_OFFSET + i, null);
}
};
CPU.prototype.far_return = function(eip, selector, stack_adjust, is_osize_32)
{
dbg_assert(typeof selector === "number" && selector < 0x10000 && selector >= 0);

134
src/rust/c_api.rs
View file

@ -1,134 +0,0 @@
use std::mem;
use std::ptr::NonNull;
use jit::JitState;
use page::Page;
use state_flags::CachedStateFlags;
static mut MODULE_PTR: NonNull<JitState> =
unsafe { NonNull::new_unchecked(mem::align_of::<JitState>() as *mut _) };
pub fn get_module<'a>() -> &'a mut JitState { unsafe { MODULE_PTR.as_mut() } }
#[no_mangle]
/// Called from JS, not C
pub fn rust_setup() {
let x = Box::new(JitState::create_and_initialise());
unsafe {
MODULE_PTR = NonNull::new(Box::into_raw(x)).expect("assigning module ptr");
}
use std::panic;
panic::set_hook(Box::new(|panic_info| {
console_log!("{}", panic_info.to_string());
}));
}
#[no_mangle]
/// Called from JS, not C
pub fn codegen_finalize_finished(
wasm_table_index: u16,
phys_addr: u32,
end_addr: u32,
first_opcode: u32,
state_flags: u32,
) {
::jit::codegen_finalize_finished(
get_module(),
wasm_table_index,
phys_addr,
end_addr,
first_opcode,
CachedStateFlags::of_u32(state_flags),
)
}
pub fn jit_increase_hotness_and_maybe_compile(
phys_address: u32,
cs_offset: u32,
state_flags: CachedStateFlags,
hotness: u32,
) {
::jit::jit_increase_hotness_and_maybe_compile(
get_module(),
phys_address,
cs_offset,
state_flags,
hotness,
)
}
#[no_mangle]
#[cfg(debug_assertions)]
/// Called from JS
pub fn jit_force_generate_unsafe(phys_addr: u32, cs_offset: u32, state_flags: u32) {
::jit::jit_force_generate_unsafe(
get_module(),
phys_addr,
cs_offset,
CachedStateFlags::of_u32(state_flags),
)
}
#[no_mangle]
/// Called from JS
pub fn jit_dirty_cache(start_addr: u32, end_addr: u32) {
::jit::jit_dirty_cache(get_module(), start_addr, end_addr);
}
pub fn jit_dirty_cache_small(start_addr: u32, end_addr: u32) {
::jit::jit_dirty_cache_small(get_module(), start_addr, end_addr);
}
pub fn jit_dirty_page(page: Page) { ::jit::jit_dirty_page(get_module(), page); }
pub fn jit_page_has_code(page: u32) -> bool {
::jit::jit_page_has_code(get_module(), Page::page_of(page << 12))
}
#[no_mangle]
/// Called from JS, not C
pub fn jit_empty_cache() { ::jit::jit_empty_cache(get_module()) }
#[no_mangle]
/// Called from JS, not C
pub fn jit_get_op_ptr() -> *const u8 { ::jit::jit_get_op_ptr(get_module()) }
#[no_mangle]
/// Called from JS, not C
pub fn jit_get_op_len() -> u32 { ::jit::jit_get_op_len(get_module()) }
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_unused_cache_stat() -> u32 { ::jit::jit_unused_cache_stat() }
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_get_entry_length(i: u32) -> u32 { ::jit::jit_get_entry_length(i) }
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_get_entry_address(i: u32) -> u32 { ::jit::jit_get_entry_address(i) }
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_get_entry_pending(i: u32) -> bool { ::jit::jit_get_entry_pending(i) }
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_get_wasm_table_index_free_list_count() -> u32 {
::jit::jit_get_wasm_table_index_free_list_count(get_module())
}
#[no_mangle]
#[cfg(not(debug_assertions))]
pub fn jit_unused_cache_stat() -> u32 { 0 }
#[no_mangle]
#[cfg(not(debug_assertions))]
pub fn jit_get_entry_length(_: u32) -> u32 { 0 }
#[no_mangle]
#[cfg(not(debug_assertions))]
pub fn jit_get_entry_address(_: u32) -> u32 { 0 }
#[no_mangle]
#[cfg(not(debug_assertions))]
pub fn jit_get_entry_pending(_: u32) -> bool { false }
#[no_mangle]
#[cfg(not(debug_assertions))]
pub fn jit_get_wasm_table_index_free_list_count() -> u32 { 0 }

6
src/rust/codegen.rs
View file

@ -2,6 +2,7 @@ use cpu::BitSize;
use cpu2::cpu::{
FLAG_CARRY, FLAG_ZERO, TLB_GLOBAL, TLB_HAS_CODE, TLB_NO_USER, TLB_READONLY, TLB_VALID,
};
use cpu2::imports::mem8;
use global_pointers;
use jit::JitContext;
use jit_instructions::LocalOrImmedate;
@ -12,11 +13,6 @@ use wasmgen::module_init;
use wasmgen::module_init::{WasmBuilder, WasmLocal, WasmLocalI64};
use wasmgen::wasm_util::WasmBuf;
extern "C" {
#[no_mangle]
static mut mem8: *mut u8;
}
const CONDITION_FUNCTIONS: [&str; 16] = [
"test_o", "test_no", "test_b", "test_nb", "test_z", "test_nz", "test_be", "test_nbe", "test_s",
"test_ns", "test_p", "test_np", "test_l", "test_nl", "test_le", "test_nle",

4
src/rust/cpu.rs
View file

@ -14,7 +14,7 @@ mod unsafe_cpu {
state_flags: u32,
);
pub fn jit_clear_func(wasm_table_index: u16);
pub fn jit_clear_cache();
pub fn jit_clear_all_funcs();
}
}
@ -70,4 +70,4 @@ pub fn jit_clear_func(wasm_table_index: u16) {
unsafe { unsafe_cpu::jit_clear_func(wasm_table_index) }
}
pub fn jit_clear_cache() { unsafe { unsafe_cpu::jit_clear_cache() } }
pub fn jit_clear_all_funcs() { unsafe { unsafe_cpu::jit_clear_all_funcs() } }

7
src/rust/cpu2/cpu.rs
View file

@ -1200,8 +1200,7 @@ pub unsafe fn do_page_walk(addr: i32, for_writing: bool, user: bool) -> Result<i
dbg_assert!(found);
}
let is_in_mapped_range = in_mapped_range(high as u32);
let physical_page = (high as u32 >> 12) as i32;
let has_code = !is_in_mapped_range && ::c_api::jit_page_has_code(physical_page as u32);
let has_code = !is_in_mapped_range && ::jit::jit_page_has_code(Page::page_of(high as u32));
let info_bits = TLB_VALID
| if can_write { 0 } else { TLB_READONLY }
| if allow_user { 0 } else { TLB_NO_USER }
@ -1873,7 +1872,7 @@ pub unsafe fn cycle_internal() {
}
}
else {
::jit::record_entry_point(::c_api::get_module(), phys_addr);
::jit::record_entry_point(phys_addr);
#[cfg(feature = "profiler")]
{
@ -1893,7 +1892,7 @@ pub unsafe fn cycle_internal() {
let initial_tsc = *timestamp_counter;
jit_run_interpreted(phys_addr as i32);
::c_api::jit_increase_hotness_and_maybe_compile(
::jit::jit_increase_hotness_and_maybe_compile(
phys_addr,
get_seg_cs() as u32,
state_flags,

14
src/rust/cpu2/memory.rs
View file

@ -105,7 +105,7 @@ pub unsafe fn write8(addr: u32, value: i32) {
mmap_write8(addr, value);
}
else {
::c_api::jit_dirty_page(Page::page_of(addr));
::jit::jit_dirty_page(::jit::get_jit_state(), Page::page_of(addr));
write8_no_mmap_or_dirty_check(addr, value);
};
}
@ -120,7 +120,7 @@ pub unsafe fn write16(addr: u32, value: i32) {
mmap_write16(addr, value);
}
else {
::c_api::jit_dirty_cache_small(addr, addr.wrapping_add(2 as u32));
::jit::jit_dirty_cache_small(addr, addr.wrapping_add(2 as u32));
*(mem8.offset(addr as isize) as *mut u16) = value as u16
};
}
@ -132,7 +132,7 @@ pub unsafe fn write_aligned16(addr: u32, value: u32) {
mmap_write16(phys_addr, value as i32);
}
else {
::c_api::jit_dirty_cache_small(phys_addr, phys_addr.wrapping_add(2 as u32));
::jit::jit_dirty_cache_small(phys_addr, phys_addr.wrapping_add(2 as u32));
*mem16.offset(addr as isize) = value as u16
};
}
@ -142,7 +142,7 @@ pub unsafe fn write32(addr: u32, value: i32) {
mmap_write32(addr, value);
}
else {
::c_api::jit_dirty_cache_small(addr, addr.wrapping_add(4 as u32));
::jit::jit_dirty_cache_small(addr, addr.wrapping_add(4 as u32));
*(mem8.offset(addr as isize) as *mut i32) = value
};
}
@ -159,7 +159,7 @@ pub unsafe fn write_aligned32(addr: u32, value: i32) {
mmap_write32(phys_addr, value);
}
else {
::c_api::jit_dirty_cache_small(phys_addr, phys_addr.wrapping_add(4 as u32));
::jit::jit_dirty_cache_small(phys_addr, phys_addr.wrapping_add(4 as u32));
write_aligned32_no_mmap_or_dirty_check(addr, value);
};
}
@ -173,7 +173,7 @@ pub unsafe fn write64(addr: u32, value: i64) {
mmap_write32(addr.wrapping_add(4 as u32), (value >> 32) as i32);
}
else {
::c_api::jit_dirty_cache_small(addr, addr.wrapping_add(8 as u32));
::jit::jit_dirty_cache_small(addr, addr.wrapping_add(8 as u32));
*(mem8.offset(addr as isize) as *mut i64) = value
};
}
@ -189,7 +189,7 @@ pub unsafe fn write128(addr: u32, value: reg128) {
);
}
else {
::c_api::jit_dirty_cache_small(addr, addr.wrapping_add(16 as u32));
::jit::jit_dirty_cache_small(addr, addr.wrapping_add(16 as u32));
*(mem8.offset(addr as isize) as *mut i64) = value.i64_0[0];
*(mem8.offset(addr as isize).offset(8) as *mut i64) = value.i64_0[1]
};

14
src/rust/cpu2/string.rs
View file

@ -64,7 +64,7 @@ pub unsafe fn movsb_rep(is_asize_32: bool, ds: i32) {
let mut phys_src: i32 = return_on_pagefault!(translate_address_read(src)) as i32;
let mut phys_dest: i32 = return_on_pagefault!(translate_address_write(dest)) as i32;
if !in_mapped_range(phys_dest as u32) {
::c_api::jit_dirty_page(Page::page_of(phys_dest as u32));
::jit::jit_dirty_page(::jit::get_jit_state(), Page::page_of(phys_dest as u32));
loop {
write8_no_mmap_or_dirty_check(phys_dest as u32, read8(phys_src as u32));
phys_dest += size;
@ -211,7 +211,10 @@ pub unsafe fn movsd_rep(is_asize_32: bool, ds: i32) {
(return_on_pagefault!(translate_address_write(dest)) >> 2) as i32;
cycle_counter = string_get_cycle_count2(size, src, dest);
if !in_mapped_range((phys_dest << 2) as u32) {
::c_api::jit_dirty_page(Page::page_of((phys_dest << 2) as u32));
::jit::jit_dirty_page(
::jit::get_jit_state(),
Page::page_of((phys_dest << 2) as u32),
);
loop {
write_aligned32_no_mmap_or_dirty_check(
phys_dest as u32,
@ -527,7 +530,7 @@ pub unsafe fn stosb_rep(is_asize_32: bool) {
let mut cycle_counter: i32 = string_get_cycle_count(size, dest);
let mut phys_dest: i32 = return_on_pagefault!(translate_address_write(dest)) as i32;
if !in_mapped_range(phys_dest as u32) {
::c_api::jit_dirty_page(Page::page_of(phys_dest as u32));
::jit::jit_dirty_page(::jit::get_jit_state(), Page::page_of(phys_dest as u32));
loop {
write8_no_mmap_or_dirty_check(phys_dest as u32, data);
phys_dest += size;
@ -663,7 +666,10 @@ pub unsafe fn stosd_rep(is_asize_32: bool) {
(return_on_pagefault!(translate_address_write(dest)) >> 2) as i32;
cycle_counter = string_get_cycle_count(size, dest);
if !in_mapped_range(phys_dest as u32) {
::c_api::jit_dirty_page(Page::page_of((phys_dest << 2) as u32));
::jit::jit_dirty_page(
::jit::get_jit_state(),
Page::page_of((phys_dest << 2) as u32),
);
loop {
write_aligned32_no_mmap_or_dirty_check(phys_dest as u32, data);
phys_dest += single_size;

125
src/rust/jit.rs
View file

@ -1,5 +1,7 @@
use std::collections::{BTreeMap, HashMap, HashSet};
use std::iter::FromIterator;
use std::mem;
use std::ptr::NonNull;
use analysis::AnalysisType;
use codegen;
@ -30,6 +32,26 @@ pub const JIT_THRESHOLD: u32 = 200 * 1000;
const CODE_CACHE_SEARCH_SIZE: u32 = 8;
const MAX_INSTRUCTION_LENGTH: u32 = 16;
#[allow(non_upper_case_globals)]
static mut jit_state: NonNull<JitState> =
unsafe { NonNull::new_unchecked(mem::align_of::<JitState>() as *mut _) };
pub fn get_jit_state() -> &'static mut JitState { unsafe { jit_state.as_mut() } }
#[no_mangle]
pub fn rust_init() {
let x = Box::new(JitState::create_and_initialise());
unsafe {
jit_state = NonNull::new(Box::into_raw(x)).unwrap()
}
use std::panic;
panic::set_hook(Box::new(|panic_info| {
console_log!("{}", panic_info.to_string());
}));
}
mod jit_cache_array {
use page::Page;
use state_flags::CachedStateFlags;
@ -321,15 +343,13 @@ impl JitState {
// don't assign 0 (XXX: Check)
let wasm_table_indices = 1..=(WASM_TABLE_SIZE - 1) as u16;
let mut c = JitState {
JitState {
hot_pages: [0; HASH_PRIME as usize],
wasm_table_index_free_list: Vec::from_iter(wasm_table_indices),
wasm_table_index_pending_free: vec![],
entry_points: HashMap::new(),
wasm_builder,
};
jit_empty_cache(&mut c);
c
}
}
}
@ -428,7 +448,8 @@ pub fn jit_find_cache_entry(phys_address: u32, state_flags: CachedStateFlags) ->
cached_code::NONE
}
pub fn record_entry_point(ctx: &mut JitState, phys_address: u32) {
pub fn record_entry_point(phys_address: u32) {
let ctx = get_jit_state();
if is_near_end_of_page(phys_address) {
return;
}
@ -760,14 +781,11 @@ fn create_cache_entry(ctx: &mut JitState, entry: jit_cache_array::Entry) {
jit_cache_array::insert(found_entry_index, entry);
}
#[no_mangle]
#[cfg(debug_assertions)]
pub fn jit_force_generate_unsafe(
ctx: &mut JitState,
phys_addr: u32,
cs_offset: u32,
state_flags: CachedStateFlags,
) {
record_entry_point(ctx, phys_addr);
pub fn jit_force_generate_unsafe(phys_addr: u32, cs_offset: u32, state_flags: CachedStateFlags) {
let ctx = get_jit_state();
record_entry_point(phys_addr);
jit_analyze_and_generate(ctx, Page::page_of(phys_addr), cs_offset, state_flags);
}
@ -817,7 +835,7 @@ fn jit_analyze_and_generate(
// size of the table, but this way the initial size acts as an upper bound for the
// number of wasm modules that we generate, which we want anyway to avoid getting our
// tab killed by browsers due to memory constraints.
cpu::jit_clear_cache();
jit_clear_cache(ctx);
profiler::stat_increment(stat::INVALIDATE_ALL_MODULES_NO_FREE_WASM_INDICES);
@ -884,10 +902,7 @@ fn jit_analyze_and_generate(
}
}
profiler::stat_increment_by(
stat::COMPILE_WASM_TOTAL_BYTES,
::c_api::jit_get_op_len() as u64,
);
profiler::stat_increment_by(stat::COMPILE_WASM_TOTAL_BYTES, jit_get_op_len() as u64);
dbg_assert!(entry_point_count > 0);
@ -917,14 +932,16 @@ fn jit_analyze_and_generate(
}
}
#[no_mangle]
pub fn codegen_finalize_finished(
ctx: &mut JitState,
wasm_table_index: u16,
phys_addr: u32,
_end_addr: u32,
_first_opcode: u32,
_state_flags: CachedStateFlags,
) {
let ctx = get_jit_state();
dbg_assert!(wasm_table_index != 0);
match ctx
@ -1282,13 +1299,14 @@ fn jit_generate_basic_block(ctx: &mut JitContext, block: &BasicBlock) {
}
}
#[no_mangle]
pub fn jit_increase_hotness_and_maybe_compile(
ctx: &mut JitState,
phys_address: u32,
cs_offset: u32,
state_flags: CachedStateFlags,
hotness: u32,
) {
let ctx = get_jit_state();
let page = Page::page_of(phys_address);
let address_hash = jit_hot_hash_page(page) as usize;
ctx.hot_pages[address_hash] += hotness;
@ -1348,7 +1366,7 @@ fn remove_jit_cache_wasm_index(ctx: &mut JitState, page: Page, wasm_table_index:
free_wasm_table_index(ctx, wasm_table_index);
}
if !jit_page_has_code(ctx, page) {
if !jit_page_has_code(page) {
cpu::tlb_set_has_code(page, false);
}
@ -1437,42 +1455,50 @@ pub fn jit_dirty_page(ctx: &mut JitState, page: Page) {
}
}
pub fn jit_dirty_cache(ctx: &mut JitState, start_addr: u32, end_addr: u32) {
#[no_mangle]
pub fn jit_dirty_cache(start_addr: u32, end_addr: u32) {
dbg_assert!(start_addr < end_addr);
let start_page = Page::page_of(start_addr);
let end_page = Page::page_of(end_addr - 1);
for page in start_page.to_u32()..end_page.to_u32() + 1 {
jit_dirty_page(ctx, Page::page_of(page << 12));
jit_dirty_page(get_jit_state(), Page::page_of(page << 12));
}
}
pub fn jit_dirty_cache_small(ctx: &mut JitState, start_addr: u32, end_addr: u32) {
/// dirty pages in the range of start_addr and end_addr, which must span at most two pages
pub fn jit_dirty_cache_small(start_addr: u32, end_addr: u32) {
dbg_assert!(start_addr < end_addr);
let start_page = Page::page_of(start_addr);
let end_page = Page::page_of(end_addr - 1);
jit_dirty_page(ctx, start_page);
jit_dirty_page(get_jit_state(), start_page);
// Note: This can't happen when paging is enabled, as writes across
// boundaries are split up on two pages
if start_page != end_page {
dbg_assert!(start_page.to_u32() + 1 == end_page.to_u32());
jit_dirty_page(ctx, end_page);
jit_dirty_page(get_jit_state(), end_page);
}
}
pub fn jit_empty_cache(ctx: &mut JitState) {
#[no_mangle]
pub fn jit_clear_cache_js() { jit_clear_cache(get_jit_state()) }
pub fn jit_clear_cache(ctx: &mut JitState) {
ctx.entry_points.clear();
for page_index in 0..0x100000 {
jit_dirty_page(ctx, Page::page_of(page_index << 12))
}
cpu::jit_clear_all_funcs();
}
pub fn jit_page_has_code(ctx: &JitState, page: Page) -> bool {
pub fn jit_page_has_code(page: Page) -> bool {
let ctx = get_jit_state();
// Does the page have compiled code
jit_cache_array::get_page_index(page) != None ||
// Or are there any entry points that need to be removed on write to the page
@ -1502,29 +1528,44 @@ pub fn jit_page_has_pending_code(_ctx: &JitState, page: Page) -> bool {
return false;
}
#[cfg(debug_assertions)]
#[no_mangle]
pub fn jit_unused_cache_stat() -> u32 {
let mut count = 0;
for i in 0..jit_cache_array::SIZE {
if (jit_cache_array::get(i)).start_addr == 0 {
count += 1
if cfg!(debug_assertions) {
for i in 0..jit_cache_array::SIZE {
if (jit_cache_array::get(i)).start_addr == 0 {
count += 1
}
}
}
return count;
}
#[cfg(debug_assertions)]
pub fn jit_get_entry_length(i: u32) -> u32 { (jit_cache_array::get(i)).len }
#[cfg(debug_assertions)]
pub fn jit_get_entry_address(i: u32) -> u32 { (jit_cache_array::get(i)).start_addr }
#[cfg(debug_assertions)]
pub fn jit_get_entry_pending(i: u32) -> bool { (jit_cache_array::get(i)).pending }
#[cfg(debug_assertions)]
pub fn jit_get_wasm_table_index_free_list_count(ctx: &JitState) -> u32 {
ctx.wasm_table_index_free_list.len() as u32
#[no_mangle]
pub fn jit_get_entry_length(i: u32) -> u32 {
if cfg!(debug_assertions) { jit_cache_array::get(i).len } else { 0 }
}
#[no_mangle]
pub fn jit_get_entry_address(i: u32) -> u32 {
if cfg!(debug_assertions) { jit_cache_array::get(i).start_addr } else { 0 }
}
#[no_mangle]
pub fn jit_get_entry_pending(i: u32) -> bool {
if cfg!(debug_assertions) { jit_cache_array::get(i).pending } else { false }
}
#[no_mangle]
pub fn jit_get_wasm_table_index_free_list_count() -> u32 {
if cfg!(debug_assertions) {
get_jit_state().wasm_table_index_free_list.len() as u32
}
else {
0
}
}
pub fn jit_get_op_len(ctx: &JitState) -> u32 { ctx.wasm_builder.get_op_len() }
pub fn jit_get_op_ptr(ctx: &JitState) -> *const u8 { ctx.wasm_builder.get_op_ptr() }
#[no_mangle]
pub fn jit_get_op_len() -> u32 { get_jit_state().wasm_builder.get_op_len() }
#[no_mangle]
pub fn jit_get_op_ptr() -> *const u8 { get_jit_state().wasm_builder.get_op_ptr() }
#[cfg(feature = "profiler")]
pub fn check_missed_entry_points(phys_address: u32, state_flags: CachedStateFlags) {

1
src/rust/lib.rs
View file

@ -13,7 +13,6 @@ mod paging;
pub mod cpu2;
pub mod c_api;
pub mod js_api;
pub mod profiler;