code
stringlengths 40
729k
| docstring
stringlengths 22
46.3k
| func_name
stringlengths 1
97
| language
stringclasses 1
value | repo
stringlengths 6
48
| path
stringlengths 8
176
| url
stringlengths 47
228
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
fn translate_br_table_targets(
&mut self,
values: &[TypedProvider],
make_target: impl Fn(BoundedRegSpan, BranchOffset) -> Instruction,
) -> Result<(), Error> {
let engine = self.engine().clone();
let fuel_info = self.fuel_info();
let targets = &self.br_table_targets;
for &target in targets {
match self.control_stack.acquire_target(target) {
AcquiredTarget::Return(_) => {
self.instr_encoder
.encode_return(&mut self.stack, values, &fuel_info)?;
}
AcquiredTarget::Branch(frame) => {
frame.branch_to();
let branch_params = frame.branch_params(&engine);
let branch_dst = frame.branch_destination();
let branch_offset = self.instr_encoder.try_resolve_label(branch_dst)?;
let instr = match branch_params.len() {
0 => Instruction::branch(branch_offset),
1..=3 => {
Instruction::branch_table_target(branch_params.span(), branch_offset)
}
_ => make_target(branch_params, branch_offset),
};
self.instr_encoder.append_instr(instr)?;
}
}
}
Ok(())
}
|
Translates the branching targets of a Wasm `br_table` instruction.
The `make_target` closure allows to define the branch table target instruction being used
for each branch that copies 4 or more values to the destination.
|
translate_br_table_targets
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_1(&mut self, index: Reg) -> Result<(), Error> {
let targets = &self.br_table_targets;
let len_targets = targets.len() as u32;
let fuel_info = self.fuel_info();
self.instr_encoder.push_fueled_instr(
Instruction::branch_table_1(index, len_targets),
&fuel_info,
FuelCostsProvider::base,
)?;
let stack = &mut self.stack;
let value = stack.pop();
let param_instr = match value {
TypedProvider::Register(register) => Instruction::register(register),
TypedProvider::Const(immediate) => match immediate.ty() {
ValType::I32 | ValType::F32 => Instruction::const32(u32::from(immediate.untyped())),
ValType::I64 => match <Const32<i64>>::try_from(i64::from(immediate)) {
Ok(value) => Instruction::i64const32(value),
Err(_) => {
let register = self.stack.provider2reg(&value)?;
Instruction::register(register)
}
},
ValType::F64 => match <Const32<f64>>::try_from(f64::from(immediate)) {
Ok(value) => Instruction::f64const32(value),
Err(_) => {
let register = self.stack.provider2reg(&value)?;
Instruction::register(register)
}
},
ValType::V128 | ValType::ExternRef | ValType::FuncRef => {
let register = self.stack.provider2reg(&value)?;
Instruction::register(register)
}
},
};
self.append_instr(param_instr)?;
self.translate_br_table_targets_simple(&[value])?;
self.reachable = false;
Ok(())
}
|
Translates a Wasm `br_table` instruction with a single input.
|
translate_br_table_1
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_2(&mut self, index: Reg) -> Result<(), Error> {
let targets = &self.br_table_targets;
let len_targets = targets.len() as u32;
let fuel_info = self.fuel_info();
self.instr_encoder.push_fueled_instr(
Instruction::branch_table_2(index, len_targets),
&fuel_info,
FuelCostsProvider::base,
)?;
let stack = &mut self.stack;
let (v0, v1) = stack.pop2();
self.instr_encoder.append_instr(Instruction::register2_ext(
stack.provider2reg(&v0)?,
stack.provider2reg(&v1)?,
))?;
self.translate_br_table_targets_simple(&[v0, v1])?;
self.reachable = false;
Ok(())
}
|
Translates a Wasm `br_table` instruction with exactly two inputs.
|
translate_br_table_2
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_3(&mut self, index: Reg) -> Result<(), Error> {
let targets = &self.br_table_targets;
let len_targets = targets.len() as u32;
let fuel_info = self.fuel_info();
self.instr_encoder.push_fueled_instr(
Instruction::branch_table_3(index, len_targets),
&fuel_info,
FuelCostsProvider::base,
)?;
let stack = &mut self.stack;
let (v0, v1, v2) = stack.pop3();
self.instr_encoder.append_instr(Instruction::register3_ext(
stack.provider2reg(&v0)?,
stack.provider2reg(&v1)?,
stack.provider2reg(&v2)?,
))?;
self.translate_br_table_targets_simple(&[v0, v1, v2])?;
self.reachable = false;
Ok(())
}
|
Translates a Wasm `br_table` instruction with exactly three inputs.
|
translate_br_table_3
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_n(&mut self, index: Reg, len_values: u16) -> Result<(), Error> {
debug_assert!(len_values > 3);
let values = &mut self.providers;
self.stack.pop_n(usize::from(len_values), values);
match BoundedRegSpan::from_providers(values) {
Some(span) => self.translate_br_table_span(index, span),
None => self.translate_br_table_many(index),
}
}
|
Translates a Wasm `br_table` instruction with 4 or more inputs.
|
translate_br_table_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_span(&mut self, index: Reg, values: BoundedRegSpan) -> Result<(), Error> {
debug_assert!(values.len() > 3);
let fuel_info = self.fuel_info();
let targets = &mut self.br_table_targets;
let len_targets = targets.len() as u32;
self.instr_encoder.push_fueled_instr(
Instruction::branch_table_span(index, len_targets),
&fuel_info,
FuelCostsProvider::base,
)?;
self.instr_encoder
.append_instr(Instruction::register_span(values))?;
self.apply_providers_buffer(|this, buffer| {
this.translate_br_table_targets(buffer, |branch_params, branch_offset| {
debug_assert_eq!(values.len(), branch_params.len());
let len = values.len();
let results = branch_params.span();
let values = values.span();
let make_instr =
match InstrEncoder::has_overlapping_copy_spans(results, values, len) {
true => Instruction::branch_table_target,
false => Instruction::branch_table_target_non_overlapping,
};
make_instr(branch_params.span(), branch_offset)
})
})?;
self.reachable = false;
Ok(())
}
|
Translates a Wasm `br_table` instruction with 4 or more inputs that form a [`RegSpan`].
|
translate_br_table_span
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_br_table_many(&mut self, index: Reg) -> Result<(), Error> {
let targets = &mut self.br_table_targets;
let len_targets = targets.len() as u32;
let fuel_info = self.fuel_info();
self.instr_encoder.push_fueled_instr(
Instruction::branch_table_many(index, len_targets),
&fuel_info,
FuelCostsProvider::base,
)?;
let stack = &mut self.stack;
let values = &self.providers[..];
debug_assert!(values.len() > 3);
self.instr_encoder.encode_register_list(stack, values)?;
self.apply_providers_buffer(|this, values| {
this.translate_br_table_targets(&[], |branch_params, branch_offset| {
let make_instr = match InstrEncoder::has_overlapping_copies(branch_params, values) {
true => Instruction::branch_table_target,
false => Instruction::branch_table_target_non_overlapping,
};
make_instr(branch_params.span(), branch_offset)
})
})?;
self.reachable = false;
Ok(())
}
|
Translates a Wasm `br_table` instruction with 4 or more inputs that cannot form a [`RegSpan`].
|
translate_br_table_many
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_i64_binop128(
&mut self,
make_instr: fn(results: [Reg; 2], lhs_lo: Reg) -> Instruction,
const_eval: fn(lhs_lo: i64, lhs_hi: i64, rhs_lo: i64, rhs_hi: i64) -> (i64, i64),
) -> Result<(), Error> {
bail_unreachable!(self);
let (rhs_lo, rhs_hi) = self.stack.pop2();
let (lhs_lo, lhs_hi) = self.stack.pop2();
if let (
Provider::Const(lhs_lo),
Provider::Const(lhs_hi),
Provider::Const(rhs_lo),
Provider::Const(rhs_hi),
) = (lhs_lo, lhs_hi, rhs_lo, rhs_hi)
{
let (result_lo, result_hi) =
const_eval(lhs_lo.into(), lhs_hi.into(), rhs_lo.into(), rhs_hi.into());
self.stack.push_const(result_lo);
self.stack.push_const(result_hi);
return Ok(());
}
let rhs_lo = match rhs_lo {
Provider::Register(reg) => reg,
Provider::Const(rhs_lo) => self.stack.alloc_const(rhs_lo)?,
};
let rhs_hi = match rhs_hi {
Provider::Register(reg) => reg,
Provider::Const(rhs_hi) => self.stack.alloc_const(rhs_hi)?,
};
let lhs_lo = match lhs_lo {
Provider::Register(reg) => reg,
Provider::Const(lhs_lo) => self.stack.alloc_const(lhs_lo)?,
};
let lhs_hi = match lhs_hi {
Provider::Register(reg) => reg,
Provider::Const(lhs_hi) => self.stack.alloc_const(lhs_hi)?,
};
let result_lo = self.stack.push_dynamic()?;
let result_hi = self.stack.push_dynamic()?;
self.push_fueled_instr(
make_instr([result_lo, result_hi], lhs_lo),
FuelCostsProvider::base,
)?;
self.instr_encoder
.append_instr(Instruction::register3_ext(lhs_hi, rhs_lo, rhs_hi))?;
Ok(())
}
|
Translates a Wasm `i64.binop128` instruction from the `wide-arithmetic` proposal.
|
translate_i64_binop128
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn translate_i64_mul_wide_sx(
&mut self,
make_instr: fn(results: FixedRegSpan<2>, lhs: Reg, rhs: Reg) -> Instruction,
const_eval: fn(lhs: i64, rhs: i64) -> (i64, i64),
) -> Result<(), Error> {
bail_unreachable!(self);
let (lhs, rhs) = self.stack.pop2();
let (lhs, rhs) = match (lhs, rhs) {
(Provider::Register(lhs), Provider::Register(rhs)) => (lhs, rhs),
(Provider::Register(lhs), Provider::Const(rhs)) => {
if self.try_opt_i64_mul_wide_sx(lhs, rhs)? {
return Ok(());
}
let rhs = self.stack.alloc_const(rhs)?;
(lhs, rhs)
}
(Provider::Const(lhs), Provider::Register(rhs)) => {
if self.try_opt_i64_mul_wide_sx(rhs, lhs)? {
return Ok(());
}
let lhs = self.stack.alloc_const(lhs)?;
(lhs, rhs)
}
(Provider::Const(lhs), Provider::Const(rhs)) => {
let (result_lo, result_hi) = const_eval(lhs.into(), rhs.into());
self.stack.push_const(result_lo);
self.stack.push_const(result_hi);
return Ok(());
}
};
let results = self.stack.push_dynamic_n(2)?;
let results = <FixedRegSpan<2>>::new(results).unwrap_or_else(|_| {
panic!("`i64.mul_wide_sx` requires 2 results but found: {results:?}")
});
self.push_fueled_instr(make_instr(results, lhs, rhs), FuelCostsProvider::base)?;
Ok(())
}
|
Translates a Wasm `i64.mul_wide_sx` instruction from the `wide-arithmetic` proposal.
|
translate_i64_mul_wide_sx
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn try_opt_i64_mul_wide_sx(&mut self, reg_in: Reg, imm_in: TypedVal) -> Result<bool, Error> {
let imm_in = i64::from(imm_in);
if imm_in == 0 {
// Case: `mul(x, 0)` or `mul(0, x)` always evaluates to 0.
self.stack.push_const(0_i64); // lo-bits
self.stack.push_const(0_i64); // hi-bits
return Ok(true);
}
if imm_in == 1 {
// Case: `mul(x, 1)` or `mul(0, x)` always evaluates to just `x`.
self.stack.push_register(reg_in)?; // lo-bits
self.stack.push_const(0_i64); // hi-bits
return Ok(true);
}
Ok(false)
}
|
Try to optimize a `i64.mul_wide_sx` instruction with one [`Reg`] and one immediate input.
- Returns `Ok(true)` if the optimiation was applied successfully.
- Returns `Ok(false)` if no optimization was applied.
|
try_opt_i64_mul_wide_sx
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/mod.rs
|
Apache-2.0
|
fn from_index(index: usize) -> Result<Self, Error> {
u32::try_from(index)
.map_err(|_| Error::from(TranslationError::ProviderSliceOverflow))
.map(AnyConst32::from)
.map(Self)
}
|
Returns a new [`ProviderSliceRef`] from the given `usize` index.
|
from_index
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub fn into_register(self) -> Option<Reg> {
match self {
Self::Register(register) => Some(register),
Self::Const(_) => None,
}
}
|
Returns `Some` if `self` is a [`Provider::Register`].
|
into_register
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub fn map_const<U>(self, f: impl FnOnce(T) -> U) -> Provider<U> {
match self {
Provider::Register(reg) => Provider::Register(reg),
Provider::Const(value) => Provider::Const(f(value)),
}
}
|
Maps the constant value with `f` if `self` is [`Provider::Const`] and returns the result.
|
map_const
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub fn reset(&mut self) {
self.ends.clear();
self.providers.clear();
}
|
Resets the [`ProviderSliceStack`] to allow for reuse.
|
reset
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub fn push<I>(&mut self, providers: I) -> Result<ProviderSliceRef, Error>
where
I: IntoIterator<Item = Provider<T>>,
{
self.providers.extend(providers);
let end = self.providers.len();
let index = self.ends.len();
self.ends.push(end);
ProviderSliceRef::from_index(index)
}
|
Pushes a new [`Provider`] slice and returns its [`ProviderSliceRef`].
|
push
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub fn pop(&mut self) -> Option<Drain<Provider<T>>> {
let end = self.ends.pop()?;
let start = self.ends.last().copied().unwrap_or(0);
Some(self.providers.drain(start..end))
}
|
Pops the top-most [`Reg`] slice from the [`ProviderSliceStack`] and returns it.
|
pop
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/provider.rs
|
Apache-2.0
|
pub(super) fn as_index_type_const16(
&mut self,
provider: TypedProvider,
index_type: IndexType,
) -> Result<Provider<Const16<u64>>, Error> {
let value = match provider {
Provider::Register(reg) => return Ok(Provider::Register(reg)),
Provider::Const(value) => value,
};
match index_type {
IndexType::I64 => {
if let Ok(value) = Const16::try_from(u64::from(value)) {
return Ok(Provider::Const(value));
}
}
IndexType::I32 => {
if let Ok(value) = Const16::try_from(u32::from(value)) {
return Ok(Provider::Const(<Const16<u64>>::cast(value)));
}
}
}
let register = self.stack.alloc_const(value)?;
Ok(Provider::Register(register))
}
|
Converts the `provider` to a 16-bit index-type constant value.
# Note
- Turns immediates that cannot be 16-bit encoded into function local constants.
- The behavior is different whether `memory64` is enabled or disabled.
|
as_index_type_const16
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/utils.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/utils.rs
|
Apache-2.0
|
pub(super) fn as_index_type_const32(
&mut self,
provider: TypedProvider,
index_type: IndexType,
) -> Result<Provider<Const32<u64>>, Error> {
let value = match provider {
Provider::Register(reg) => return Ok(Provider::Register(reg)),
Provider::Const(value) => value,
};
match index_type {
IndexType::I64 => {
if let Ok(value) = Const32::try_from(u64::from(value)) {
return Ok(Provider::Const(value));
}
}
IndexType::I32 => {
let value = Const32::from(u32::from(value));
return Ok(Provider::Const(<Const32<u64>>::cast(value)));
}
}
let register = self.stack.alloc_const(value)?;
Ok(Provider::Register(register))
}
|
Converts the `provider` to a 32-bit index-type constant value.
# Note
- Turns immediates that cannot be 32-bit encoded into function local constants.
- The behavior is different whether `memory64` is enabled or disabled.
|
as_index_type_const32
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/utils.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/utils.rs
|
Apache-2.0
|
fn register_index(&self) -> Option<i16> {
match self {
TypedProvider::Register(index) => Some(i16::from(*index)),
TypedProvider::Const(_) => None,
}
}
|
Returns the `i16` [`Reg`] index if the [`TypedProvider`] is a [`Reg`].
|
register_index
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/utils.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/utils.rs
|
Apache-2.0
|
fn translate_simd_splat<T, Wrapped>(
&mut self,
make_instr: fn(result: Reg, value: Reg) -> Instruction,
const_eval: fn(Wrapped) -> V128,
) -> Result<(), Error>
where
T: From<TypedVal> + Wrap<Wrapped>,
{
bail_unreachable!(self);
let value = self.stack.pop();
let value = match value {
Provider::Register(value) => value,
Provider::Const(value) => {
let value = T::from(value).wrap();
let result = const_eval(value);
self.stack.push_const(result);
return Ok(());
}
};
let result = self.stack.push_dynamic()?;
self.push_fueled_instr(make_instr(result, value), FuelCostsProvider::simd)?;
Ok(())
}
|
Generically translate any of the Wasm `simd` splat instructions.
|
translate_simd_splat
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/simd/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/simd/mod.rs
|
Apache-2.0
|
fn translate_extract_lane<T: IntoLaneIdx, R>(
&mut self,
lane: u8,
make_instr: fn(result: Reg, input: Reg, lane: T::LaneIdx) -> Instruction,
const_eval: fn(input: V128, lane: T::LaneIdx) -> R,
) -> Result<(), Error>
where
R: Into<TypedVal>,
{
bail_unreachable!(self);
let Ok(lane) = <T::LaneIdx>::try_from(lane) else {
panic!("encountered out of bounds lane index: {lane}")
};
let input = self.stack.pop();
let input = match input {
Provider::Register(input) => input,
Provider::Const(input) => {
let result = const_eval(input.into(), lane);
self.stack.push_const(result);
return Ok(());
}
};
let result = self.stack.push_dynamic()?;
self.push_fueled_instr(make_instr(result, input, lane), FuelCostsProvider::simd)?;
Ok(())
}
|
Generically translate any of the Wasm `simd` extract lane instructions.
|
translate_extract_lane
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/simd/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/simd/mod.rs
|
Apache-2.0
|
fn translate_simd_shift<T>(
&mut self,
make_instr: fn(result: Reg, lhs: Reg, rhs: Reg) -> Instruction,
make_instr_imm: fn(
result: Reg,
lhs: Reg,
rhs: <T as IntoShiftAmount>::Output,
) -> Instruction,
const_eval: fn(lhs: V128, rhs: u32) -> V128,
) -> Result<(), Error>
where
T: IntoShiftAmount<Input: From<TypedVal>>,
{
bail_unreachable!(self);
let (lhs, rhs) = self.stack.pop2();
if let (Provider::Const(lhs), Provider::Const(rhs)) = (lhs, rhs) {
// Case: both inputs are immediates so we can const-eval the result.
let result = const_eval(lhs.into(), rhs.into());
self.stack.push_const(result);
return Ok(());
}
let lhs = self.stack.provider2reg(&lhs)?;
let rhs = match rhs {
Provider::Register(rhs) => rhs,
Provider::Const(rhs) => {
let Some(rhs) = T::into_shift_amount(rhs.into()) else {
// Case: the shift operation is a no-op
self.stack.push_register(lhs)?;
return Ok(());
};
let result = self.stack.push_dynamic()?;
self.push_fueled_instr(make_instr_imm(result, lhs, rhs), FuelCostsProvider::simd)?;
return Ok(());
}
};
let result = self.stack.push_dynamic()?;
self.push_fueled_instr(make_instr(result, lhs, rhs), FuelCostsProvider::simd)?;
Ok(())
}
|
Generically translate a Wasm SIMD shift instruction.
|
translate_simd_shift
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/simd/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/simd/mod.rs
|
Apache-2.0
|
pub fn alloc(&mut self, value: UntypedVal) -> Result<Reg, Error> {
if self.next_idx == Self::last_index() {
return Err(Error::from(TranslationError::TooManyFuncLocalConstValues));
}
match self.const2idx.entry(value) {
btree_map::Entry::Occupied(entry) => Ok(*entry.get()),
btree_map::Entry::Vacant(entry) => {
let register = Reg::from(self.next_idx);
self.next_idx -= 1;
entry.insert(register);
self.idx2const.push(value);
Ok(register)
}
}
}
|
Allocates a new constant `value` on the [`FuncLocalConsts`] and returns its identifier.
# Note
If the constant `value` already exists in this [`FuncLocalConsts`] no new value is
allocated and the identifier of the existing constant `value` returned instead.
# Errors
If too many constant values have been allocated for this [`FuncLocalConsts`].
|
alloc
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/consts.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/consts.rs
|
Apache-2.0
|
pub fn get(&self, register: Reg) -> Option<UntypedVal> {
if !register.is_const() {
return None;
}
let index = i16::from(register).wrapping_add(1).unsigned_abs() as usize;
self.idx2const.get(index).copied()
}
|
Returns the function local constant [`UntypedVal`] of the [`Reg`] if any.
|
get
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/consts.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/consts.rs
|
Apache-2.0
|
pub fn new(consts: &'a FuncLocalConsts) -> Self {
// Note: we need to revert the iteration since we allocate new
// function local constants in reverse order of their absolute
// vector indices in the function call frame during execution.
Self {
iter: consts.idx2const.as_slice().iter().rev(),
}
}
|
Creates a new [`FuncLocalConstsIter`] from the given slice of [`UntypedVal`].
|
new
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/consts.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/consts.rs
|
Apache-2.0
|
pub fn register_locals(&mut self, _amount: u32) {
// Nothing to do here.
}
|
Registers an `amount` of function inputs or local variables.
# Errors
If too many registers have been registered.
|
register_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
fn update_last(&mut self, index: EntryIndex, local: Reg) -> Option<EntryIndex> {
match self.locals_last.entry(local) {
btree_map::Entry::Vacant(entry) => {
entry.insert(index);
None
}
btree_map::Entry::Occupied(mut entry) => {
let prev = *entry.get();
entry.insert(index);
Some(prev)
}
}
}
|
Updates the last index for `local` to `index` and returns the previous last index.
|
update_last
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
pub fn push_at(&mut self, local: Reg, slot: StackIndex) {
match self.entries.next_free() {
Some(index) => {
let prev = self.update_last(index, local);
self.entries.reuse_vacant(index, slot, prev);
}
None => {
let index = self.entries.next_index();
let prev = self.update_last(index, local);
let pushed = self.entries.push_occupied(slot, prev);
debug_assert_eq!(pushed, index);
}
};
}
|
Pushes the stack index of a `local.get` on the [`ProviderStack`].
# Panics
If the `local` index is out of bounds.
|
push_at
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
pub fn pop_at(&mut self, local: Reg) -> StackIndex {
let btree_map::Entry::Occupied(mut last) = self.locals_last.entry(local) else {
panic!("missing stack index for local on the provider stack: {local:?}")
};
let index = *last.get();
let (prev, slot) = self.entries.remove_entry(index);
match prev {
Some(prev) => last.insert(prev),
None => last.remove(),
};
self.reset_if_empty();
slot
}
|
Pops the stack index of a `local.get` on the [`ProviderStack`].
# Panics
- If the `local` index is out of bounds.
- If there is no `local.get` stack index on the stack.
|
pop_at
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
pub fn drain_at(
&mut self,
local: Reg,
f: impl FnMut(StackIndex) -> Result<(), Error>,
) -> Result<(), Error> {
let Some(last) = self.locals_last.remove(&local) else {
return Ok(());
};
self.drain_list_at(last, f)?;
self.reset_if_empty();
Ok(())
}
|
Drains all local indices of the `local` variable on the [`ProviderStack`].
# Note
Calls `f` with the index of each local on the [`ProviderStack`] that matches `local`.
|
drain_at
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
pub fn drain_all(
&mut self,
mut f: impl FnMut(Reg, StackIndex) -> Result<(), Error>,
) -> Result<(), Error> {
let local_last = mem::take(&mut self.locals_last);
for (local, last) in &local_last {
let local = *local;
self.drain_list_at(*last, |index| f(local, index))?;
}
self.locals_last = local_last;
self.locals_last.clear();
self.entries.reset();
Ok(())
}
|
Drains all local indices on the [`ProviderStack`].
# Note
Calls `f` with the pair of local and its index of each local on the [`ProviderStack`].
|
drain_all
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/locals.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/locals.rs
|
Apache-2.0
|
pub fn into_untyped(self) -> UntypedProvider {
match self {
Self::Register(register) => UntypedProvider::Register(register),
Self::Const(value) => UntypedProvider::Const(UntypedVal::from(value)),
}
}
|
Converts the [`TypedProvider`] to a resolved [`UntypedProvider`].
|
into_untyped
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn trunc(&mut self, height: usize) {
assert!(height <= self.height());
while self.height() != height {
self.drop();
}
}
|
Pops [`Provider`] from the [`ValueStack`] until it has the given stack `height`.
|
trunc
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn preserve_locals(&mut self, preserve_index: u32) -> Result<Option<Reg>, Error> {
self.providers
.preserve_locals(preserve_index, &mut self.reg_alloc)
}
|
Preserves `local.get` on the [`ProviderStack`] by shifting to the preservation space.
In case there are `local.get n` with `n == preserve_index` on the [`ProviderStack`]
there is a [`Reg`] on the storage space allocated for them. The [`Reg`]
allocated this way is returned. Otherwise `None` is returned.
|
preserve_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn preserve_all_locals(
&mut self,
f: impl FnMut(PreservedLocal) -> Result<(), Error>,
) -> Result<(), Error> {
self.providers.preserve_all_locals(&mut self.reg_alloc, f)
}
|
Preserves all locals on the [`ProviderStack`] by shifting them to the preservation space.
Calls `f(local_register, preserved_register)` for each `local_register` preserved this way with its
newly allocated `preserved_register` on the presevation register space.
|
preserve_all_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn len_registers(&self) -> u16 {
// The addition won't overflow since both operands are in the range of `0..i16::MAX`.
self.consts.len_consts() + self.reg_alloc.len_registers()
}
|
Returns the number of registers allocated by the [`RegisterAlloc`].
|
len_registers
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn register_locals(&mut self, amount: u32) -> Result<(), Error> {
self.providers.register_locals(amount);
self.reg_alloc.register_locals(amount)?;
Ok(())
}
|
Registers an `amount` of function inputs or local variables.
# Errors
If too many registers have been registered.
# Panics
If the [`RegisterAlloc`] is not in its initialization phase.
|
register_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn alloc_const<T>(&mut self, value: T) -> Result<Reg, Error>
where
T: Into<UntypedVal>,
{
self.consts.alloc(value.into())
}
|
Allocates a new function local constant value and returns its [`Reg`].
# Note
Constant values allocated this way are deduplicated and return shared [`Reg`].
|
alloc_const
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn provider2reg(&mut self, provider: &TypedProvider) -> Result<Reg, Error> {
match provider {
Provider::Register(register) => Ok(*register),
Provider::Const(value) => self.alloc_const(*value),
}
}
|
Converts a [`TypedProvider`] into a [`Reg`].
This allocates constant values for [`TypedProvider::Const`].
|
provider2reg
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_provider(&mut self, provider: TypedProvider) -> Result<(), Error> {
match provider {
Provider::Register(register) => self.push_register(register)?,
Provider::Const(value) => self.push_const(value),
}
Ok(())
}
|
Pushes the given [`TypedProvider`] to the [`ValueStack`].
# Note
This is a convenice method for [`ValueStack::push_register`] and [`ValueStack::push_const`].
|
push_provider
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_const<T>(&mut self, value: T)
where
T: Into<TypedVal>,
{
self.providers.push_const_value(value)
}
|
Pushes a constant value to the [`ProviderStack`].
|
push_const
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_register(&mut self, reg: Reg) -> Result<(), Error> {
match self.reg_alloc.register_space(reg) {
RegisterSpace::Dynamic => {
self.reg_alloc.push_dynamic()?;
self.providers.push_dynamic(reg);
return Ok(());
}
RegisterSpace::Preserve => {
// Note: we currently do not call `self.reg_alloc.push_storage()`
// since that API would push always another register on the preservation
// stack instead of trying to bump the amount of already existing
// preservation slots for the same register if possible.
self.reg_alloc.bump_preserved(reg);
self.providers.push_preserved(reg);
}
RegisterSpace::Local => {
self.providers.push_local(reg);
}
RegisterSpace::Const => {
self.providers.push_const_local(reg);
}
}
Ok(())
}
|
Pushes the given [`Reg`] to the [`ValueStack`].
# Errors
If too many registers have been registered.
|
push_register
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_local(&mut self, local_index: u32) -> Result<Reg, Error> {
let reg = i16::try_from(local_index)
.ok()
.map(Reg::from)
.filter(|reg| self.reg_alloc.is_local(*reg))
.ok_or_else(|| Error::from(TranslationError::RegisterOutOfBounds))?;
self.providers.push_local(reg);
Ok(reg)
}
|
Pushes a [`Reg`] to the [`ValueStack`] referring to a function parameter or local variable.
# Errors
If too many registers have been registered.
|
push_local
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_dynamic(&mut self) -> Result<Reg, Error> {
let reg = self.reg_alloc.push_dynamic()?;
self.providers.push_dynamic(reg);
Ok(reg)
}
|
Pushes a dynamically allocated [`Reg`] to the [`ValueStack`].
# Errors
If too many registers have been registered.
|
push_dynamic
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn pop2(&mut self) -> (TypedProvider, TypedProvider) {
let rhs = self.pop();
let lhs = self.pop();
(lhs, rhs)
}
|
Pops the two top-most [`Provider`] from the [`ValueStack`].
|
pop2
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn pop3(&mut self) -> (TypedProvider, TypedProvider, TypedProvider) {
let (v1, v2) = self.pop2();
let v0 = self.pop();
(v0, v1, v2)
}
|
Pops the three top-most [`Provider`] from the [`ValueStack`].
|
pop3
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn pop_n(&mut self, n: usize, result: &mut Vec<TypedProvider>) {
result.clear();
for _ in 0..n {
let provider = self.pop();
result.push(provider);
}
result[..].reverse()
}
|
Popn the `n` top-most [`Provider`] from the [`ValueStack`] and store them in `result`.
# Note
- The top-most [`Provider`] will be the n-th item in `result`.
- The `result` [`Vec`] will be cleared before refilled.
|
pop_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn remove_n(&mut self, n: usize) {
for _ in 0..n {
self.drop();
}
}
|
Removes the `n` top-most [`Provider`] from the [`ValueStack`].
|
remove_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn peek_n(&mut self, n: usize, result: &mut Vec<TypedProvider>) {
result.clear();
result.extend(
self.providers
.peek_n(n)
.iter()
.copied()
.map(TypedProvider::from),
);
}
|
Peeks the `n` top-most [`Provider`] from the [`ValueStack`] and store them in `result`.
# Note
- The top-most [`Provider`] will be the n-th item in `result`.
- The `result` [`Vec`] will be cleared before refilled.
|
peek_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_n(&mut self, providers: &[TypedProvider]) -> Result<(), Error> {
for provider in providers {
match *provider {
TypedProvider::Register(register) => self.push_register(register)?,
TypedProvider::Const(value) => self.push_const(value),
}
}
Ok(())
}
|
Pushes the given `providers` into the [`ValueStack`].
# Errors
If too many registers have been registered.
|
push_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn push_dynamic_n(&mut self, n: usize) -> Result<RegSpan, Error> {
let registers = self.reg_alloc.push_dynamic_n(n)?;
for register in registers.iter_sized(n) {
self.providers.push_dynamic(register);
}
Ok(registers)
}
|
Returns a [`RegSpan`] of `n` registers as if they were dynamically allocated.
# Note
- This procedure pushes dynamic [`Reg`] onto the [`ValueStack`].
- This is primarily used to allocate branch parameters for control
flow frames such as Wasm `block`, `loop` and `if` as well as for
instructions that may return multiple values such as `call`.
# Errors
If this procedure would allocate more registers than are available.
|
push_dynamic_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
pub fn peek_dynamic_n(&mut self, n: usize) -> Result<RegSpan, Error> {
let registers = self.reg_alloc.push_dynamic_n(n)?;
self.reg_alloc.pop_dynamic_n(n);
Ok(registers)
}
|
Returns a [`RegSpan`] of `n` registers as if they were dynamically allocated.
# Note
- This procedure does not push anything onto the [`ValueStack`].
- This is primarily used to allocate branch parameters for control
flow frames such as Wasm `block`, `loop` and `if`.
# Errors
If this procedure would allocate more registers than are available.
|
peek_dynamic_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/mod.rs
|
Apache-2.0
|
fn sync_local_refs(&mut self) {
if self.use_locals || self.providers.len() < Self::PRESERVE_THRESHOLD {
return;
}
for (index, provider) in self.providers.iter().enumerate() {
let TaggedProvider::Local(local) = provider else {
continue;
};
self.locals.push_at(*local, index);
}
self.use_locals = true;
}
|
Synchronizes [`LocalRefs`] with the current state of the `providers` stack.
This is required to initialize usage of the attack-immune [`LocalRefs`] before first use.
|
sync_local_refs
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn preserve_locals(
&mut self,
preserve_index: u32,
reg_alloc: &mut RegisterAlloc,
) -> Result<Option<Reg>, Error> {
if self.len_locals == 0 {
return Ok(None);
}
self.sync_local_refs();
let local = i16::try_from(preserve_index)
.map(Reg::from)
.unwrap_or_else(|_| {
panic!("encountered invalid local register index: {preserve_index}")
});
match self.use_locals {
false => self.preserve_locals_inplace(local, reg_alloc),
true => self.preserve_locals_extern(local, reg_alloc),
}
}
|
Preserves `local.get` on the [`ProviderStack`] by shifting to the preservation space.
In case there are `local.get n` with `n == preserve_index` on the [`ProviderStack`]
there is a [`Reg`] on the preservation space allocated for them. The [`Reg`]
allocated this way is returned. Otherwise `None` is returned.
|
preserve_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn preserve_all_locals(
&mut self,
reg_alloc: &mut RegisterAlloc,
f: impl FnMut(PreservedLocal) -> Result<(), Error>,
) -> Result<(), Error> {
if self.len_locals == 0 {
return Ok(());
}
self.sync_local_refs();
match self.use_locals {
false => self.preserve_all_locals_inplace(reg_alloc, f),
true => self.preserve_all_locals_extern(reg_alloc, f),
}
}
|
Preserves all locals on the [`ProviderStack`] by shifting them to the preservation space.
# Note
- Calls `f(local_index, preserved_register)` for each local preserved this way with its `local_index`
and the newly allocated `preserved_register` on the presevation register space.
- If the same local appears multiple times on the provider stack `f` is only called once
representing all of them.
|
preserve_all_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
fn preserve_locals_inplace(
&mut self,
local: Reg,
reg_alloc: &mut RegisterAlloc,
) -> Result<Option<Reg>, Error> {
debug_assert!(!self.use_locals);
let mut preserved = None;
for provider in &mut self.providers {
let TaggedProvider::Local(register) = *provider else {
continue;
};
debug_assert!(reg_alloc.is_local(register));
if register != local {
continue;
}
let preserved_register = match preserved {
None => {
let register = reg_alloc.push_preserved()?;
preserved = Some(register);
register
}
Some(register) => {
reg_alloc.bump_preserved(register);
register
}
};
*provider = TaggedProvider::Preserved(preserved_register);
self.len_locals -= 1;
if self.len_locals == 0 {
break;
}
}
Ok(preserved)
}
|
Preserves the `local` [`Reg`] on the provider stack in-place.
# Note
- This is the efficient case which is susceptible to malicious inputs
since it needs to iterate over the entire provider stack and might be
called roughly once per Wasm instruction in the worst-case.
- Therefore we only use it behind a safety guard to remove the attack surface.
|
preserve_locals_inplace
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
fn preserve_all_locals_inplace(
&mut self,
reg_alloc: &mut RegisterAlloc,
mut f: impl FnMut(PreservedLocal) -> Result<(), Error>,
) -> Result<(), Error> {
debug_assert!(!self.use_locals);
let mut preserved = <ArrayVec<PreservedLocal, { Self::PRESERVE_THRESHOLD }>>::new();
for provider in self.providers.iter_mut().rev() {
let TaggedProvider::Local(local_register) = *provider else {
continue;
};
debug_assert!(reg_alloc.is_local(local_register));
let (preserved_register, is_new) =
// Note: linear search is fine since we operate only on very small sets of data.
match preserved.iter().find(|p| p.local == local_register) {
Some(preserved_local) => {
let preserved_register = preserved_local.preserved;
reg_alloc.bump_preserved(preserved_register);
(preserved_register, false)
}
None => {
let preserved_register = reg_alloc.push_preserved()?;
preserved.push(PreservedLocal::new(local_register, preserved_register));
(preserved_register, true)
}
};
*provider = TaggedProvider::Preserved(preserved_register);
self.len_locals -= 1;
if is_new {
f(PreservedLocal::new(local_register, preserved_register))?;
}
if self.len_locals == 0 {
break;
}
}
debug_assert_eq!(self.len_locals, 0);
Ok(())
}
|
Preserves all locals on the [`ProviderStack`] by shifting them to the preservation space.
# Note
- Calls `f(local_index, preserved_register)` for each local preserved this way with its `local_index`
and the newly allocated `preserved_register` on the presevation register space.
- If the same local appears multiple times on the provider stack `f` is only called once
representing all of them.
# Dev. Note
- This is the efficient case which is susceptible to malicious inputs
since it needs to iterate over the entire provider stack and might be
called roughly once per Wasm instruction in the worst-case.
- Therefore we only use it behind a safety guard to remove the attack surface.
|
preserve_all_locals_inplace
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
fn preserve_locals_extern(
&mut self,
local: Reg,
reg_alloc: &mut RegisterAlloc,
) -> Result<Option<Reg>, Error> {
debug_assert!(self.use_locals);
let mut preserved = None;
self.locals.drain_at(local, |provider_index| {
let provider = &mut self.providers[provider_index];
debug_assert!(matches!(provider, TaggedProvider::Local(_)));
let preserved_register = match preserved {
Some(register) => {
reg_alloc.bump_preserved(register);
register
}
None => {
let register = reg_alloc.push_preserved()?;
preserved = Some(register);
register
}
};
*provider = TaggedProvider::Preserved(preserved_register);
self.len_locals -= 1;
Ok(())
})?;
Ok(preserved)
}
|
Preserves the `local` [`Reg`] on the provider stack out-of-place.
# Note
- This is the inefficient case which is immune to malicious inputs
since it only iterates over the locals required for preservation
which are stored out-of-place of the provider stack.
- Since this is slower we only use it when necessary.
|
preserve_locals_extern
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
fn preserve_all_locals_extern(
&mut self,
reg_alloc: &mut RegisterAlloc,
mut f: impl FnMut(PreservedLocal) -> Result<(), Error>,
) -> Result<(), Error> {
debug_assert!(self.use_locals);
let mut group = None;
self.locals.drain_all(|local, index| {
let preserved = match group {
Some((group, preserved)) if group == local => {
reg_alloc.bump_preserved(preserved);
preserved
}
_ => {
let preserved = reg_alloc.push_preserved()?;
group = Some((local, preserved));
f(PreservedLocal::new(local, preserved))?;
preserved
}
};
self.providers[index] = TaggedProvider::Preserved(preserved);
self.len_locals -= 1;
Ok(())
})?;
debug_assert_eq!(self.len_locals, 0);
Ok(())
}
|
Preserves all locals on the [`ProviderStack`] by shifting them to the preservation space.
# Note
- Calls `f(local_index, preserved_register)` for each local preserved this way with its `local_index`
and the newly allocated `preserved_register` on the presevation register space.
- If the same local appears multiple times on the provider stack `f` is only called once
representing all of them.
# Dev. Note
- This is the inefficient case which is immune to malicious inputs
since it only iterates over the locals required for preservation
which are stored out-of-place of the provider stack.
- Since this is slower we only use it when necessary.
|
preserve_all_locals_extern
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn push_local(&mut self, reg: Reg) {
debug_assert!(!reg.is_const());
self.push(TaggedProvider::Local(reg));
}
|
Pushes a [`Reg`] to the [`ProviderStack`] referring to a function parameter or local variable.
|
push_local
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn push_dynamic(&mut self, reg: Reg) {
debug_assert!(!reg.is_const());
self.push(TaggedProvider::Dynamic(reg));
}
|
Pushes a dynamically allocated [`Reg`] to the [`ProviderStack`].
|
push_dynamic
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn push_preserved(&mut self, reg: Reg) {
debug_assert!(!reg.is_const());
self.push(TaggedProvider::Preserved(reg));
}
|
Pushes a preservation allocated [`Reg`] to the [`ProviderStack`].
|
push_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn push_const_local(&mut self, reg: Reg) {
debug_assert!(reg.is_const());
self.push(TaggedProvider::ConstLocal(reg));
}
|
Pushes a [`Reg`] to the [`ProviderStack`] referring to a function parameter or local variable.
|
push_const_local
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn push_const_value<T>(&mut self, value: T)
where
T: Into<TypedVal>,
{
self.push(TaggedProvider::ConstValue(value.into()));
}
|
Pushes a constant value to the [`ProviderStack`].
|
push_const_value
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn peek(&self) -> TaggedProvider {
self.providers
.last()
.copied()
.unwrap_or_else(|| panic!("tried to peek provider from empty provider stack"))
}
|
Pops the top-most [`TaggedProvider`] from the [`ProviderStack`].
# Panics
If the [`ProviderStack`] is empty.
|
peek
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn pop(&mut self) -> TaggedProvider {
let popped = self
.providers
.pop()
.unwrap_or_else(|| panic!("tried to pop provider from empty provider stack"));
if let TaggedProvider::Local(register) = popped {
self.len_locals -= 1;
if self.use_locals {
// If a `local.get` was popped from the provider stack we
// also need to pop it from the `local.get` indices stack.
let stack_index = self.locals.pop_at(register);
debug_assert_eq!(self.providers.len(), stack_index);
}
}
popped
}
|
Pops the top-most [`TaggedProvider`] from the [`ProviderStack`].
# Panics
If the [`ProviderStack`] is empty.
|
pop
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn peek_n(&self, n: usize) -> &[TaggedProvider] {
let len = self.providers.len();
assert!(
n <= len,
"tried to peek {n} items from provider stack with only {len} items"
);
&self.providers[(len - n)..]
}
|
Peeks the `n` top-most [`TaggedProvider`] items of the [`ProviderStack`].
# Panics
If the [`ProviderStack`] does not contain at least `n` [`TaggedProvider`] items.
|
peek_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/provider.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/provider.rs
|
Apache-2.0
|
pub fn reset(&mut self) {
self.preservations.clear();
self.phase = AllocPhase::Init;
self.len_locals = 0;
self.next_dynamic = 0;
self.max_dynamic = 0;
self.min_preserve = Self::INITIAL_PRESERVATION_INDEX;
self.defrag_offset = 0;
}
|
Resets the [`RegisterAlloc`] to start compiling a new function.
|
reset
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn pop_provider(&mut self, provider: TaggedProvider) -> TypedProvider {
match provider {
TaggedProvider::Local(reg) => TypedProvider::Register(reg),
TaggedProvider::Dynamic(reg) => {
self.pop_dynamic();
TypedProvider::Register(reg)
}
TaggedProvider::Preserved(reg) => {
self.pop_preserved(reg);
TypedProvider::Register(reg)
}
TaggedProvider::ConstLocal(reg) => TypedProvider::Register(reg),
TaggedProvider::ConstValue(value) => TypedProvider::Const(value),
}
}
|
Adjusts the [`RegisterAlloc`] for the popped [`TaggedProvider`] and returns a [`TypedProvider`].
|
pop_provider
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn register_space(&self, register: Reg) -> RegisterSpace {
if register.is_const() {
return RegisterSpace::Const;
}
if self.is_local(register) {
return RegisterSpace::Local;
}
if self.is_preserved(register) {
return RegisterSpace::Preserve;
}
RegisterSpace::Dynamic
}
|
Returns the [`RegisterSpace`] for the given [`Reg`].
|
register_space
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn min_dynamic(&self) -> i16 {
self.len_locals() as i16
}
|
Returns the minimum index of any dynamically allocated [`Reg`].
|
min_dynamic
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn len_registers(&self) -> u16 {
Self::MAX_LEN_LOCALS - self.max_dynamic.abs_diff(self.min_preserve)
}
|
Returns the number of registers allocated by the [`RegisterAlloc`].
|
len_registers
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn register_locals(&mut self, amount: u32) -> Result<(), Error> {
/// Bumps `len_locals` by `amount` if possible.
fn bump_locals(len_locals: u16, amount: u32) -> Option<u16> {
let amount = u16::try_from(amount).ok()?;
let new_len = len_locals.checked_add(amount)?;
if new_len >= RegisterAlloc::MAX_LEN_LOCALS {
return None;
}
Some(new_len)
}
assert!(matches!(self.phase, AllocPhase::Init));
self.len_locals = bump_locals(self.len_locals, amount)
.ok_or_else(|| Error::from(TranslationError::AllocatedTooManyRegisters))?;
// We can convert `len_locals` to `i16` because it is always without bounds of `0..i16::MAX`.
self.next_dynamic = self.len_locals as i16;
self.max_dynamic = self.len_locals as i16;
Ok(())
}
|
Registers an `amount` of function inputs or local variables.
# Errors
If too many registers have been registered.
# Panics
If the current [`AllocPhase`] is not [`AllocPhase::Init`].
|
register_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn finish_register_locals(&mut self) {
assert!(matches!(self.phase, AllocPhase::Init));
self.phase = AllocPhase::Alloc;
}
|
Finishes [`AllocPhase::Init`].
# Note
After this operation no local variable can be registered anymore.
However, it is then possible to push and pop dynamic and preserved registers to the stack.
|
finish_register_locals
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn assert_alloc_phase(&self) {
assert!(matches!(self.phase, AllocPhase::Alloc));
}
|
Asserts that the [`RegisterAlloc`] is in [`AllocPhase::Init`] or [`AllocPhase::Alloc`].
Makes sure the [`RegisterAlloc`] is in [`AllocPhase::Alloc`] after this call.
|
assert_alloc_phase
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn push_dynamic(&mut self) -> Result<Reg, Error> {
self.assert_alloc_phase();
if self.next_dynamic == self.min_preserve {
return Err(Error::from(TranslationError::AllocatedTooManyRegisters));
}
let reg = Reg::from(self.next_dynamic);
self.next_dynamic += 1;
self.max_dynamic = max(self.max_dynamic, self.next_dynamic);
Ok(reg)
}
|
Allocates a new [`Reg`] on the dynamic allocation stack and returns it.
# Errors
If too many registers have been registered.
# Panics
If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
push_dynamic
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn push_dynamic_n(&mut self, n: usize) -> Result<RegSpan, Error> {
fn next_dynamic_n(this: &mut RegisterAlloc, n: usize) -> Option<RegSpan> {
let n = i16::try_from(n).ok()?;
let next_dynamic = this.next_dynamic.checked_add(n)?;
if next_dynamic >= this.min_preserve {
return None;
}
let register = RegSpan::new(Reg::from(this.next_dynamic));
this.next_dynamic += n;
this.max_dynamic = max(this.max_dynamic, this.next_dynamic);
Some(register)
}
self.assert_alloc_phase();
next_dynamic_n(self, n)
.ok_or_else(|| Error::from(TranslationError::AllocatedTooManyRegisters))
}
|
Allocates `n` new [`Reg`] on the dynamic allocation stack and returns them.
# Errors
If too many registers have been registered.
# Panics
If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
push_dynamic_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn pop_dynamic(&mut self) {
self.assert_alloc_phase();
assert_ne!(
self.next_dynamic,
self.min_dynamic(),
"dynamic register allocation stack is empty"
);
self.next_dynamic -= 1;
}
|
Pops the top-most dynamically allocated [`Reg`] from the allocation stack.
# Panics
- If the dynamic register allocation stack is empty.
- If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
pop_dynamic
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn pop_dynamic_n(&mut self, n: usize) {
fn pop_impl(this: &mut RegisterAlloc, n: usize) -> Option<()> {
let n = i16::try_from(n).ok()?;
let new_next_dynamic = this.next_dynamic.checked_sub(n)?;
if new_next_dynamic < this.min_dynamic() {
return None;
}
this.next_dynamic = new_next_dynamic;
Some(())
}
self.assert_alloc_phase();
pop_impl(self, n).expect("dynamic register underflow")
}
|
Pops the `n` top-most dynamically allocated [`Reg`] from the allocation stack.
# Panics
- If the dynamic register allocation stack is empty.
- If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
pop_dynamic_n
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn push_preserved(&mut self) -> Result<Reg, Error> {
const NZ_TWO: NonZeroUsize = match NonZeroUsize::new(2) {
Some(value) => value,
None => unreachable!(),
};
self.assert_alloc_phase();
// Now we can clear the removed preserved registers.
self.removed_preserved.clear();
let key = self.preservations.put(NZ_TWO, ());
let reg = Self::key2reg(key);
self.update_min_preserved(reg.prev())?;
Ok(reg)
}
|
Allocates a new [`Reg`] on the preservation stack and returns it.
# Note
Registers allocated to the preservation space generally need
to be readjusted later on in order to have a consecutive register space.
# Errors
If too many registers have been registered.
# Panics
If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
push_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn gc_preservations(&mut self) {
self.assert_alloc_phase();
if self.removed_preserved.is_empty() {
return;
}
for &key in &self.removed_preserved {
let entry = self.preservations.get(key);
debug_assert!(
!matches!(entry, Some((0, _))),
"found preserved register allocation entry with invalid 0 amount"
);
if let Some((1, _)) = entry {
// Case: we only have one preservation left which
// indicates that all preserved registers have
// been used, thus we can remove this entry
// which makes it available for allocation again.
self.preservations.take_all(key);
}
}
}
|
Frees all preservation slots that are flagged for removal.
This is important to allow them for reuse for future preservations.
|
gc_preservations
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn bump_preserved(&mut self, register: Reg) {
debug_assert!(matches!(
self.register_space(register),
RegisterSpace::Preserve
));
let key = Self::reg2key(register);
let old_amount = self.preservations.bump(key, 1);
debug_assert!(
// Note: We check that the returned value is `Some` to guard
// against unexpected vacant entries at the `register` slot.
old_amount.is_some()
);
}
|
Bumps the [`Reg`] quantity on the preservation stack by one.
# Panics
If `register` is not a preservation [`Reg`].
|
bump_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn pop_preserved(&mut self, register: Reg) {
self.assert_alloc_phase();
let key = Self::reg2key(register);
self.removed_preserved.insert(key);
self.preservations
.take_one(key)
.unwrap_or_else(|| panic!("missing preservation slot for {register:?}"));
}
|
Pops the [`Reg`] from the preservation stack.
# Panics
- If the dynamic register allocation stack is empty.
- If the current [`AllocPhase`] is not [`AllocPhase::Alloc`].
|
pop_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn update_min_preserved(&mut self, register: Reg) -> Result<(), Error> {
self.min_preserve = min(self.min_preserve, i16::from(register));
if self.next_dynamic == self.min_preserve {
return Err(Error::from(TranslationError::AllocatedTooManyRegisters));
}
Ok(())
}
|
Updates the minimum preservation [`Reg`] index if needed.
|
update_min_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn is_local(&self, reg: Reg) -> bool {
!reg.is_const() && i16::from(reg) < self.min_dynamic()
}
|
Returns `true` if the [`Reg`] is allocated in the [`RegisterSpace::Local`].
|
is_local
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
fn is_preserved(&self, reg: Reg) -> bool {
self.min_preserve < i16::from(reg)
}
|
Returns `true` if the [`Reg`] is allocated in the [`RegisterSpace::Preserve`].
|
is_preserved
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn finalize_alloc(&mut self) {
assert!(matches!(self.phase, AllocPhase::Alloc));
self.phase = AllocPhase::Defrag;
self.defrag_offset = (self.min_preserve - self.max_dynamic).saturating_add(1);
}
|
Finalizes register allocation and allows to defragment the register space.
|
finalize_alloc
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn inc_register_usage(&mut self, register: Reg) {
if !self.is_preserved(register) {
return;
}
self.bump_preserved(register)
}
|
Increase preservation [`Reg`] usage.
# Note
- This is mainly used to extend the lifetime of `else` providers on the stack.
- This does nothing if `register` is not a preservation [`Reg`].
|
inc_register_usage
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn dec_register_usage(&mut self, register: Reg) {
if !self.is_preserved(register) {
return;
}
self.pop_preserved(register)
}
|
Decrease preservation [`Reg`] usage.
# Note
- This is mainly used to shorten the lifetime of `else` providers on the stack.
- This does nothing if `register` is not a preservation [`Reg`].
|
dec_register_usage
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/func/stack/register_alloc.rs
|
Apache-2.0
|
pub fn new<I>(instrs: I) -> Self
where
I: IntoIterator<Item = Instruction>,
{
let instrs: Vec<_> = instrs.into_iter().collect();
assert!(
!instrs.is_empty(),
"an expected function must have instructions"
);
Self {
instrs,
consts: Vec::new(),
}
}
|
Create a new [`ExpectedFunc`] with the given Wasmi bytecode [`Instruction`] sequence.
|
new
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
pub fn consts<I, T>(mut self, consts: I) -> Self
where
I: IntoIterator<Item = T>,
T: Into<UntypedVal>,
{
assert!(
self.expected_consts().is_empty(),
"tried to call `expect_consts` twice"
);
self.consts.extend(consts.into_iter().map(Into::into));
assert!(
!self.expected_consts().is_empty(),
"called `expect_consts` with empty set"
);
self
}
|
Add expected function local constant values to this [`ExpectedFunc`].
# Note
The function local constant values are in the order of their expected
and deduplicated allocations during the translation phase.
# Panics
- If the `consts` iterator yields no values.
- If this [`ExpectedFunc`] already expects some function local constant values.
|
consts
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
fn assert_func(&self, engine: &Engine, func_type: DedupFuncType, engine_func: EngineFunc) {
self.assert_instrs(engine, engine_func, func_type);
self.assert_consts(engine, engine_func);
}
|
Asserts that properties of the [`ExpectedFunc`] have been translated as expected.
|
assert_func
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
fn assert_instrs(&self, engine: &Engine, engine_func: EngineFunc, func_type: DedupFuncType) {
let expected_instrs = self.expected_instrs();
let len_expected = expected_instrs.len();
let func_type = engine.resolve_func_type(&func_type, Clone::clone);
for (index, actual, expected) in
expected_instrs
.iter()
.copied()
.enumerate()
.map(|(index, expected_instr)| {
let actual_instr =
engine
.resolve_instr(engine_func, index)
.unwrap_or_else(|error| panic!("failed to compiled lazily initialized function: {}", error))
.unwrap_or_else(|| {
panic!("missing instruction at index {index} for {engine_func:?} ({func_type:?})")
});
(index, actual_instr, expected_instr)
})
{
assert!(
actual == expected,
"instruction mismatch at index {index} for {engine_func:?} ({func_type:?})\n \
- expected: {expected:?}\n \
- found: {actual:?}",
);
}
if let Ok(Some(unexpected)) = engine.resolve_instr(engine_func, len_expected) {
panic!("unexpected instruction at index {len_expected}: {unexpected:?}");
}
}
|
Asserts that the instructions of the [`ExpectedFunc`] have been translated as expected.
|
assert_instrs
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
fn assert_consts(&self, engine: &Engine, func: EngineFunc) {
let expected_consts = self.expected_consts();
for (index, expected_value) in expected_consts.iter().copied().enumerate() {
let actual_value = engine
.get_func_const(func, index)
.unwrap_or_else(|error| {
panic!("failed to compiled lazily initialized function: {}", error)
})
.unwrap_or_else(|| {
panic!("missing function local constant value of for {func:?} at index {index}")
});
assert_eq!(
actual_value, expected_value,
"function local constant value mismatch for {func:?} at index {index}"
);
}
// Check that there are not more function local constants than we already expected.
let len_consts = expected_consts.len();
if let Ok(Some(unexpected)) = engine.get_func_const(func, len_consts) {
panic!("unexpected function local constant value (= {unexpected:?}) for {func:?} at index {len_consts}")
}
}
|
Asserts that the function local constant values of the [`ExpectedFunc`] have been translated as expected.
|
assert_consts
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
pub fn expect_func_instrs<I>(&mut self, instrs: I) -> &mut Self
where
I: IntoIterator<Item = Instruction>,
{
self.expect_func(ExpectedFunc::new(instrs))
}
|
Add an expected function with its instructions.
# Note
This is a convenience method for [`TranslationTest::expect_func_ext`].
|
expect_func_instrs
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
pub fn run(&self) {
self.has_run.store(true, Ordering::SeqCst);
let module = create_module(self.config(), self.wasm());
let engine = module.engine();
self.assert_funcs(engine, &module);
}
|
Runs the [`TranslationTest`].
# Panics
If the translation test was not successful.
|
run
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
fn assert_funcs(&self, engine: &Engine, module: &Module) {
{
let len_compiled = module.internal_funcs().len();
let len_expected = self.expected_funcs().len();
assert_eq!(
len_compiled,
len_expected,
"number of compiled functions (={len_compiled}) do not match the expected amount (= {len_expected})",
);
}
for ((func_type, engine_func), expected_func) in
module.internal_funcs().zip(self.expected_funcs())
{
expected_func.assert_func(engine, func_type, engine_func);
}
}
|
Asserts that all expected functions of the translated Wasm module are as expected.
|
assert_funcs
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/driver.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/driver.rs
|
Apache-2.0
|
fn create_module(config: &Config, bytes: &[u8]) -> Module {
let engine = Engine::new(config);
Module::new(&engine, bytes).unwrap()
}
|
Compiles the `wasm` encoded bytes into a [`Module`].
# Panics
If an error occurred upon module compilation, validation or translation.
|
create_module
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/mod.rs
|
Apache-2.0
|
fn assert_func_bodies<E, T>(wasm: &str, expected: E)
where
E: IntoIterator<Item = T>,
T: IntoIterator<Item = Instruction>,
<T as IntoIterator>::IntoIter: ExactSizeIterator,
{
let mut testcase = TranslationTest::new(wasm);
for instrs in expected {
testcase.expect_func_instrs(instrs);
}
testcase.run();
}
|
Asserts that the given `wasm` bytes yield functions with expected instructions.
Uses the given [`Config`] to configure the [`Engine`] that the tests are run on.
# Note
This enables the register machine bytecode translation.
# Panics
If any of the yielded functions consists of instruction different from the
expected instructions for that function.
|
assert_func_bodies
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/mod.rs
|
Apache-2.0
|
fn bspan(reg: impl Into<Reg>, len: u16) -> BoundedRegSpan {
BoundedRegSpan::new(RegSpan::new(reg.into()), len)
}
|
Creates a new [`BoundedRegSpan`] starting with `reg` and with `len`.
|
bspan
|
rust
|
wasmi-labs/wasmi
|
crates/wasmi/src/engine/translator/tests/mod.rs
|
https://github.com/wasmi-labs/wasmi/blob/master/crates/wasmi/src/engine/translator/tests/mod.rs
|
Apache-2.0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.