fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-06-20 04:06:30 +00:00
Code Issues Projects Releases Wiki Activity

Read stack values based on state map.

Browse Source
This commit is contained in:
losfair
2019-06-12 22:02:15 +08:00
parent 00b6bf632a
commit 32008eba88
8 changed files with 599 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/runtime-core/src/backend.rs
View File

@ -1,10 +1,10 @@
use crate::{
error::CompileResult,
module::ModuleInner,
state::ModuleStateMap,
typed_func::Wasm,
types::{LocalFuncIndex, SigIndex},
vm,
state::ModuleStateMap,
};
use crate::{
@ -85,9 +85,9 @@ pub trait RunnableModule: Send + Sync {
local_func_index: LocalFuncIndex,
) -> Option<NonNull<vm::Func>>;
fn get_module_state_map(
&self,
) -> Option<ModuleStateMap> { None }
fn get_module_state_map(&self) -> Option<ModuleStateMap> {
None
}
/// A wasm trampoline contains the necesarry data to dynamically call an exported wasm function.
/// Given a particular signature index, we are returned a trampoline that is matched with that

168
lib/runtime-core/src/state.rs
View File

@ -1,4 +1,5 @@
use std::collections::BTreeMap;
use std::fmt::Debug;
use std::ops::Bound::{Included, Unbounded};
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@ -23,7 +24,7 @@ pub enum MachineValue {
Undefined,
PreserveRegister(RegisterIndex),
CopyStackBPRelative(i32), // relative to Base Pointer, in byte offset
ExplicitShadow, // indicates that all values above this are above the shadow region
ExplicitShadow, // indicates that all values above this are above the shadow region
WasmStack(usize),
WasmLocal(usize),
}
@ -43,14 +44,64 @@ pub struct ModuleStateMap {
pub total_size: usize,
}
#[derive(Clone, Debug)]
pub struct DenseArrayMap<T: Clone + Debug> {
pub elements: Vec<Option<T>>,
}
impl<T: Clone + Debug> DenseArrayMap<T> {
pub fn new() -> DenseArrayMap<T> {
DenseArrayMap { elements: vec![] }
}
pub fn set(&mut self, idx: usize, elem: T) {
while self.elements.len() < idx + 1 {
self.elements.push(None);
}
self.elements[idx] = Some(elem);
}
pub fn into_vec(self) -> Option<Vec<T>> {
let mut ret: Vec<T> = Vec::with_capacity(self.elements.len());
for elem in self.elements {
if elem.is_none() {
return None;
}
ret.push(elem.unwrap());
}
Some(ret)
}
}
#[derive(Clone, Debug)]
pub struct WasmFunctionState {
stack: Vec<Option<u64>>,
locals: Vec<u64>,
}
impl ModuleStateMap {
pub fn lookup_call_ip(&self, ip: usize, base: usize) -> Option<(&FunctionStateMap, MachineState)> {
pub fn lookup_call_ip(
&self,
ip: usize,
base: usize,
) -> Option<(&FunctionStateMap, MachineState)> {
if ip < base || ip - base >= self.total_size {
None
} else {
//println!("lookup ip: {} in {:?}", ip - base, self.local_functions);
let fsm = self.local_functions.range((Unbounded, Included(&(ip - base)))).last().map(|x| x.1).unwrap();
Some((fsm, fsm.call_offsets.get(&(ip - base)).map(|x| fsm.diffs[*x].build_state(fsm)).unwrap()))
let fsm = self
.local_functions
.range((Unbounded, Included(&(ip - base))))
.last()
.map(|x| x.1)
.unwrap();
Some((
fsm,
fsm.call_offsets
.get(&(ip - base))
.map(|x| fsm.diffs[*x].build_state(fsm))
.unwrap(),
))
}
}
}
@ -69,11 +120,20 @@ impl FunctionStateMap {
impl MachineState {
pub fn diff(&self, old: &MachineState) -> MachineStateDiff {
let first_diff_stack_depth: usize = self.stack_values.iter().zip(old.stack_values.iter()).enumerate()
.find(|&(_, (&a, &b))| a != b).map(|x| x.0)
let first_diff_stack_depth: usize = self
.stack_values
.iter()
.zip(old.stack_values.iter())
.enumerate()
.find(|&(_, (&a, &b))| a != b)
.map(|x| x.0)
.unwrap_or(old.stack_values.len().min(self.stack_values.len()));
assert_eq!(self.register_values.len(), old.register_values.len());
let reg_diff: Vec<_> = self.register_values.iter().zip(old.register_values.iter()).enumerate()
let reg_diff: Vec<_> = self
.register_values
.iter()
.zip(old.register_values.iter())
.enumerate()
.filter(|&(_, (&a, &b))| a != b)
.map(|(i, (&a, _))| (RegisterIndex(i), a))
.collect();
@ -124,31 +184,83 @@ pub mod x64 {
}
}
pub fn read_stack(msm: &ModuleStateMap, code_base: usize, mut stack: *const u64) {
#[warn(unused_variables)]
pub unsafe fn read_stack(msm: &ModuleStateMap, code_base: usize, mut stack: *const u64) {
let r15 = *stack;
let r14 = *stack.offset(1);
let r13 = *stack.offset(2);
let r12 = *stack.offset(3);
let rbx = *stack.offset(4);
stack = stack.offset(5);
let mut next_known_registers: [Option<u64>; 24] = [None; 24];
next_known_registers[X64Register::GPR(GPR::R15).to_index().0] = Some(r15);
next_known_registers[X64Register::GPR(GPR::R14).to_index().0] = Some(r14);
next_known_registers[X64Register::GPR(GPR::R13).to_index().0] = Some(r13);
next_known_registers[X64Register::GPR(GPR::R12).to_index().0] = Some(r12);
next_known_registers[X64Register::GPR(GPR::RBX).to_index().0] = Some(rbx);
for i in 0.. {
unsafe {
let ret_addr = *stack;
stack = stack.offset(1);
let (fsm, state) = match msm.lookup_call_ip(ret_addr as usize, code_base) {
Some(x) => x,
_ => break
};
let mut found_shadow = false;
for v in &state.stack_values {
match *v {
MachineValue::ExplicitShadow => {
stack = stack.offset((fsm.shadow_size / 8) as isize);
found_shadow = true;
}
_ => {
stack = stack.offset(1);
}
let known_registers = ::std::mem::replace(&mut next_known_registers, [None; 24]);
let mut wasm_stack: DenseArrayMap<u64> = DenseArrayMap::new();
let mut wasm_locals: DenseArrayMap<u64> = DenseArrayMap::new();
let ret_addr = *stack;
stack = stack.offset(1);
let (fsm, state) = match msm.lookup_call_ip(ret_addr as usize, code_base) {
Some(x) => x,
_ => break,
};
let mut found_shadow = false;
for v in state.stack_values.iter().rev() {
match *v {
MachineValue::ExplicitShadow => {
stack = stack.offset((fsm.shadow_size / 8) as isize);
found_shadow = true;
}
MachineValue::Undefined => {
stack = stack.offset(1);
}
MachineValue::PreserveRegister(idx) => {
next_known_registers[idx.0] = Some(*stack);
stack = stack.offset(1);
}
MachineValue::CopyStackBPRelative(offset) => {
stack = stack.offset(1);
}
MachineValue::WasmStack(idx) => {
wasm_stack.set(idx, *stack);
stack = stack.offset(1);
}
MachineValue::WasmLocal(idx) => {
wasm_locals.set(idx, *stack);
stack = stack.offset(1);
}
}
assert_eq!(found_shadow, true);
stack = stack.offset(1); // RBP
println!("Frame #{}: {:p} {:?}", i, ret_addr as *const u8, state);
}
for (i, v) in state.register_values.iter().enumerate() {
match *v {
MachineValue::Undefined => {}
MachineValue::WasmStack(idx) => {
if let Some(v) = known_registers[i] {
wasm_stack.set(idx, v);
}
}
MachineValue::WasmLocal(idx) => {
if let Some(v) = known_registers[i] {
wasm_locals.set(idx, v);
}
}
_ => unreachable!(),
}
}
assert_eq!(found_shadow, true);
stack = stack.offset(1); // RBP
let wfs = WasmFunctionState {
stack: wasm_stack.elements,
locals: wasm_locals.into_vec().unwrap(),
};
println!("Frame #{}: {:p} {:?}", i, ret_addr as *const u8, wfs);
}
}

23
lib/runtime-core/src/trampoline_x64.rs
View File

@ -7,9 +7,9 @@
//! Variadic functions are not supported because `rax` is used by the trampoline code.
use crate::loader::CodeMemory;
use std::{mem, slice};
use crate::vm::Ctx;
use std::fmt;
use std::{mem, slice};
lazy_static! {
/// Reads the context pointer from `mm0`.
@ -100,13 +100,21 @@ impl TrampolineBufferBuilder {
idx
}
pub fn add_context_rsp_trampoline(
pub fn add_context_rsp_state_preserving_trampoline(
&mut self,
target: unsafe extern "C" fn (&mut Ctx, *const CallContext, *const u64),
target: unsafe extern "C" fn(&mut Ctx, *const CallContext, *const u64),
context: *const CallContext,
) -> usize {
let idx = self.offsets.len();
self.offsets.push(self.code.len());
self.code.extend_from_slice(&[
0x53, // push %rbx
0x41, 0x54, // push %r12
0x41, 0x55, // push %r13
0x41, 0x56, // push %r14
0x41, 0x57, // push %r15
]);
self.code.extend_from_slice(&[
0x48, 0xbe, // movabsq ?, %rsi
]);
@ -120,7 +128,14 @@ impl TrampolineBufferBuilder {
]);
self.code.extend_from_slice(value_to_bytes(&target));
self.code.extend_from_slice(&[
0xff, 0xe0, // jmpq *%rax
0xff, 0xd0, // callq *%rax
]);
self.code.extend_from_slice(&[
0x48, 0x81, 0xc4, // add ?, %rsp
]);
self.code.extend_from_slice(value_to_bytes(&40i32)); // 5 * 8
self.code.extend_from_slice(&[
0xc3, //retq
]);
idx
}