waffle/src/frontend.rs

1711 lines
63 KiB
Rust
Raw Normal View History

//! Frontend: convert Wasm to IR.
2021-11-13 03:41:32 -06:00
#![allow(dead_code)]
2022-11-01 22:43:47 -05:00
use crate::entity::EntityRef;
use crate::errors::FrontendError;
use crate::ir::*;
2021-12-25 01:02:20 -06:00
use crate::op_traits::{op_inputs, op_outputs};
use crate::ops::Operator;
use addr2line::gimli;
2021-11-13 03:41:32 -06:00
use anyhow::{bail, Result};
use fxhash::{FxHashMap, FxHashSet};
2021-11-13 02:56:49 -06:00
use log::trace;
2022-11-01 22:43:47 -05:00
use std::convert::TryFrom;
use wasmparser::{
BlockType, DataKind, ExternalKind, Name, NameSectionReader, Parser, Payload, TypeRef,
};
2021-11-13 05:49:19 -06:00
pub fn wasm_to_ir(bytes: &[u8]) -> Result<Module<'_>> {
2022-10-27 00:15:15 -05:00
let mut module = Module::with_orig_bytes(bytes);
2021-11-13 02:56:49 -06:00
let parser = Parser::new(0);
2021-11-13 04:32:05 -06:00
let mut next_func = 0;
let mut dwarf = gimli::Dwarf::default();
let mut extra_sections = ExtraSections::default();
2021-11-13 02:56:49 -06:00
for payload in parser.parse_all(bytes) {
let payload = payload?;
handle_payload(
&mut module,
payload,
&mut next_func,
&mut dwarf,
&mut extra_sections,
)?;
}
dwarf.locations =
gimli::LocationLists::new(extra_sections.debug_loc, extra_sections.debug_loclists);
dwarf.ranges =
gimli::RangeLists::new(extra_sections.debug_ranges, extra_sections.debug_rnglists);
2023-02-14 22:38:52 -06:00
let debug_map = DebugMap::from_dwarf(dwarf, &mut module.debug)?;
module.debug_map = debug_map;
Ok(module)
}
2022-11-23 01:30:11 -06:00
fn parse_init_expr<'a>(init_expr: &wasmparser::ConstExpr<'a>) -> Result<Option<u64>> {
2022-11-02 23:03:02 -05:00
let operators = init_expr
.get_operators_reader()
.into_iter()
.collect::<Result<Vec<wasmparser::Operator>, _>>()?;
2022-11-03 12:57:56 -05:00
if operators.len() == 1 && matches!(&operators[0], &wasmparser::Operator::End) {
return Ok(None);
}
2022-11-02 23:03:02 -05:00
if operators.len() != 2 || !matches!(&operators[1], &wasmparser::Operator::End) {
bail!(FrontendError::UnsupportedFeature(format!(
2022-11-02 23:03:02 -05:00
"Unsupported operator seq in base-address expr: {:?}",
operators
)));
2022-11-02 23:03:02 -05:00
}
Ok(match &operators[0] {
2022-11-03 12:57:56 -05:00
&wasmparser::Operator::I32Const { value } => Some(value as u64),
&wasmparser::Operator::I64Const { value } => Some(value as u64),
&wasmparser::Operator::F32Const { value } => Some(value.bits() as u64),
&wasmparser::Operator::F64Const { value } => Some(value.bits()),
op => anyhow::bail!(FrontendError::UnsupportedFeature(format!(
"Unsupported data segment base-address operator: {:?}",
op
))),
2022-11-02 23:03:02 -05:00
})
}
#[derive(Default)]
struct ExtraSections<'a> {
debug_loc: gimli::DebugLoc<gimli::EndianSlice<'a, gimli::LittleEndian>>,
debug_loclists: gimli::DebugLocLists<gimli::EndianSlice<'a, gimli::LittleEndian>>,
debug_ranges: gimli::DebugRanges<gimli::EndianSlice<'a, gimli::LittleEndian>>,
debug_rnglists: gimli::DebugRngLists<gimli::EndianSlice<'a, gimli::LittleEndian>>,
}
2021-11-13 03:10:22 -06:00
fn handle_payload<'a>(
2021-11-13 04:32:05 -06:00
module: &mut Module<'a>,
2021-11-13 03:10:22 -06:00
payload: Payload<'a>,
2021-11-13 04:32:05 -06:00
next_func: &mut usize,
dwarf: &mut gimli::Dwarf<gimli::EndianSlice<'a, gimli::LittleEndian>>,
extra_sections: &mut ExtraSections<'a>,
2021-11-13 03:10:22 -06:00
) -> Result<()> {
2021-11-13 02:56:49 -06:00
trace!("Wasm parser item: {:?}", payload);
match payload {
2022-11-02 22:29:30 -05:00
Payload::TypeSection(reader) => {
for ty in reader {
let ty = ty?;
2022-11-23 01:30:11 -06:00
let wasmparser::Type::Func(fty) = ty;
module.signatures.push(fty.into());
}
}
2022-11-02 22:29:30 -05:00
Payload::ImportSection(reader) => {
for import in reader {
let import = import?;
let module_name = import.module.to_owned();
2022-11-23 01:30:11 -06:00
let name = import.name.to_owned();
2022-11-02 22:29:30 -05:00
let kind = match import.ty {
2022-11-23 01:30:11 -06:00
TypeRef::Func(sig_idx) => {
let func = module
.funcs
.push(FuncDecl::Import(Signature::from(sig_idx), "".to_owned()));
*next_func += 1;
2022-11-29 12:33:06 -06:00
ImportKind::Func(func)
}
2022-11-23 01:30:11 -06:00
TypeRef::Global(ty) => {
2022-11-21 23:35:23 -06:00
let mutable = ty.mutable;
2022-11-03 12:57:56 -05:00
let ty = ty.content_type.into();
let global = module.globals.push(GlobalData {
2022-11-21 23:35:23 -06:00
ty,
value: None,
mutable,
});
2022-11-29 12:33:06 -06:00
ImportKind::Global(global)
}
2022-11-23 01:30:11 -06:00
TypeRef::Table(ty) => {
2022-11-21 23:35:23 -06:00
let table = module.frontend_add_table(ty.element_type.into(), None);
2022-11-29 12:33:06 -06:00
ImportKind::Table(table)
}
TypeRef::Memory(mem) => {
let mem = module.memories.push(MemoryData {
2022-11-29 12:33:06 -06:00
initial_pages: mem.initial as usize,
maximum_pages: mem.maximum.map(|max| max as usize),
segments: vec![],
});
ImportKind::Memory(mem)
}
t => {
bail!(FrontendError::UnsupportedFeature(format!(
"Unknown import type: {:?}",
t
)));
}
2022-11-02 22:29:30 -05:00
};
module.imports.push(Import {
2022-11-29 12:33:06 -06:00
module: module_name,
name,
kind,
});
2021-11-13 02:59:15 -06:00
}
}
2022-11-02 22:29:30 -05:00
Payload::GlobalSection(reader) => {
for global in reader {
let global = global?;
2022-11-21 23:35:23 -06:00
let mutable = global.ty.mutable;
2022-11-03 12:57:56 -05:00
let ty = global.ty.content_type.into();
let init_expr = parse_init_expr(&global.init_expr)?;
module.globals.push(GlobalData {
2022-11-03 12:57:56 -05:00
ty,
value: init_expr,
2022-11-21 23:35:23 -06:00
mutable,
2022-11-03 12:57:56 -05:00
});
}
}
2022-11-02 22:29:30 -05:00
Payload::TableSection(reader) => {
for table in reader {
let table = table?;
2022-11-21 23:35:23 -06:00
module.frontend_add_table(table.element_type.into(), table.maximum);
}
}
2022-11-02 22:29:30 -05:00
Payload::FunctionSection(reader) => {
for sig_idx in reader {
let sig_idx = Signature::from(sig_idx?);
module.funcs.push(FuncDecl::Body(
sig_idx,
"".to_owned(),
FunctionBody::default(),
));
2021-11-13 03:10:22 -06:00
}
}
Payload::CodeSectionEntry(body) => {
2022-11-01 22:43:47 -05:00
let func_idx = Func::new(*next_func);
2021-11-13 04:32:05 -06:00
*next_func += 1;
let sig = module.funcs[func_idx].sig();
let name = module.funcs[func_idx].name().to_owned();
module.funcs[func_idx] = FuncDecl::Lazy(sig, name, body);
2021-11-13 03:10:22 -06:00
}
2022-11-02 22:29:30 -05:00
Payload::ExportSection(reader) => {
for export in reader {
let export = export?;
2022-11-23 01:30:11 -06:00
let name = export.name.to_owned();
2022-11-02 22:29:30 -05:00
let kind = match export.kind {
2022-11-23 01:30:11 -06:00
ExternalKind::Func => Some(ExportKind::Func(Func::from(export.index))),
2022-11-02 22:29:30 -05:00
ExternalKind::Table => Some(ExportKind::Table(Table::from(export.index))),
ExternalKind::Global => Some(ExportKind::Global(Global::from(export.index))),
ExternalKind::Memory => Some(ExportKind::Memory(Memory::from(export.index))),
_ => None,
};
if let Some(kind) = kind {
module.exports.push(Export { name, kind });
2022-11-02 22:29:30 -05:00
}
}
}
Payload::MemorySection(reader) => {
for memory in reader {
let memory = memory?;
module.memories.push(MemoryData {
2022-11-02 22:29:30 -05:00
initial_pages: memory.initial as usize,
maximum_pages: memory.maximum.map(|max| max as usize),
segments: vec![],
});
}
}
Payload::DataSection(reader) => {
for segment in reader {
let segment = segment?;
match &segment.kind {
DataKind::Passive => {}
DataKind::Active {
memory_index,
2022-11-23 01:30:11 -06:00
offset_expr,
2022-11-02 22:29:30 -05:00
} => {
let data = segment.data.to_vec();
let memory = Memory::from(*memory_index);
2022-11-23 01:30:11 -06:00
let offset = parse_init_expr(offset_expr)?.unwrap_or(0) as usize;
module.memories[memory]
2022-11-02 22:29:30 -05:00
.segments
.push(MemorySegment { offset, data });
}
}
}
}
Payload::CustomSection(reader) if reader.name() == "name" => {
let name_reader = NameSectionReader::new(reader.data(), reader.data_offset())?;
for subsection in name_reader {
let subsection = subsection?;
match subsection {
Name::Function(names) => {
for name in names {
let name = name?;
module.funcs[Func::new(name.index as usize)].set_name(name.name);
}
}
_ => {}
}
}
}
Payload::CustomSection(reader) if reader.name() == ".debug_info" => {
dwarf.debug_info = gimli::DebugInfo::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_abbrev" => {
dwarf.debug_abbrev = gimli::DebugAbbrev::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_addr" => {
dwarf.debug_addr =
gimli::DebugAddr::from(gimli::EndianSlice::new(reader.data(), gimli::LittleEndian));
}
Payload::CustomSection(reader) if reader.name() == ".debug_aranges" => {
dwarf.debug_aranges = gimli::DebugAranges::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_line" => {
dwarf.debug_line = gimli::DebugLine::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_line_str" => {
dwarf.debug_line_str = gimli::DebugLineStr::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_str" => {
dwarf.debug_str = gimli::DebugStr::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_str_offsets" => {
dwarf.debug_str_offsets = gimli::DebugStrOffsets::from(gimli::EndianSlice::new(
reader.data(),
gimli::LittleEndian,
));
}
Payload::CustomSection(reader) if reader.name() == ".debug_types" => {
dwarf.debug_types = gimli::DebugTypes::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_loc" => {
extra_sections.debug_loc = gimli::DebugLoc::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_loclists" => {
extra_sections.debug_loclists =
gimli::DebugLocLists::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_ranges" => {
extra_sections.debug_ranges =
gimli::DebugRanges::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(reader) if reader.name() == ".debug_rnglists" => {
extra_sections.debug_rnglists =
gimli::DebugRngLists::new(reader.data(), gimli::LittleEndian);
}
Payload::CustomSection(_) => {}
2022-11-02 23:03:02 -05:00
Payload::CodeSectionStart { .. } => {}
Payload::Version { .. } => {}
Payload::ElementSection(reader) => {
for element in reader {
let element = element?;
2022-11-23 01:30:11 -06:00
if element.ty != wasmparser::ValType::FuncRef {
bail!(FrontendError::UnsupportedFeature(format!(
"Unsupported table type: {:?}",
element.ty
)));
2022-11-02 23:03:02 -05:00
}
match &element.kind {
wasmparser::ElementKind::Passive => {}
wasmparser::ElementKind::Declared => {}
wasmparser::ElementKind::Active {
table_index,
2022-11-23 01:30:11 -06:00
offset_expr,
2022-11-02 23:03:02 -05:00
} => {
let table = Table::from(*table_index);
2022-11-23 01:30:11 -06:00
let offset = parse_init_expr(&offset_expr)?.unwrap_or(0) as usize;
2022-11-02 23:03:02 -05:00
let items = element
.items
.get_items_reader()?
.into_iter()
.collect::<Result<Vec<_>, _>>()?;
let mut funcs = vec![];
for item in items {
let func = match item {
wasmparser::ElementItem::Func(func_idx) => Func::from(func_idx),
_ => bail!(FrontendError::UnsupportedFeature(format!(
"Unsupported element item: {:?}",
item
))),
2022-11-02 23:03:02 -05:00
};
funcs.push(func);
}
let table_items = module.tables[table].func_elements.as_mut().unwrap();
2022-11-29 12:38:31 -06:00
let new_size = offset.checked_add(funcs.len()).ok_or_else(|| {
FrontendError::TooLarge(format!(
"Overflowing element offset + length: {} + {}",
offset,
funcs.len()
))
})?;
2022-11-29 12:36:45 -06:00
if new_size > table_items.len() {
static MAX_TABLE: usize = 100_000;
if new_size > MAX_TABLE {
bail!(FrontendError::TooLarge(format!(
"Too many table elements: {:?}",
new_size
)));
}
table_items.resize(new_size, Func::invalid());
2022-11-02 23:03:02 -05:00
}
2022-11-29 12:36:45 -06:00
table_items[offset..new_size].copy_from_slice(&funcs[..]);
2022-11-02 23:03:02 -05:00
}
}
}
}
2022-11-23 01:30:11 -06:00
Payload::End(_) => {}
2022-11-29 04:30:37 -06:00
Payload::StartSection { func, .. } => {
module.start_func = Some(Func::from(func));
}
2022-11-02 23:03:02 -05:00
payload => {
log::warn!("Skipping section: {:?}", payload);
}
}
Ok(())
}
2021-11-13 03:10:22 -06:00
2023-02-13 18:17:17 -06:00
struct DebugLocReader<'a> {
locs: &'a [(u32, u32, SourceLoc)],
}
impl<'a> DebugLocReader<'a> {
2023-02-14 22:38:52 -06:00
fn new(module: &'a Module, func_offset_in_file: u32) -> Self {
let start = match module
.debug_map
.tuples
.binary_search_by(|&(start, len, _)| {
use std::cmp::Ordering::*;
if start > func_offset_in_file {
Greater
} else if (start + len) <= func_offset_in_file {
Less
} else {
Equal
}
}) {
Ok(idx) => idx,
Err(idx) => idx,
};
2023-02-13 18:17:17 -06:00
DebugLocReader {
2023-02-14 22:38:52 -06:00
locs: &module.debug_map.tuples[start..],
2023-02-13 18:17:17 -06:00
}
}
fn get_loc(&mut self, offset: usize) -> SourceLoc {
let offset = u32::try_from(offset).unwrap();
2023-02-13 18:17:17 -06:00
while self.locs.len() > 0 {
let (start, len, loc) = self.locs[0];
if offset < start {
break;
}
if offset > (start + len) {
self.locs = &self.locs[1..];
}
return loc;
}
SourceLoc::invalid()
}
}
pub(crate) fn parse_body<'a>(
2021-11-22 01:12:07 -06:00
module: &'a Module,
2022-11-01 22:43:47 -05:00
my_sig: Signature,
body: &mut wasmparser::FunctionBody,
2021-11-22 01:12:07 -06:00
) -> Result<FunctionBody> {
let mut ret: FunctionBody = FunctionBody::default();
2023-02-14 22:38:52 -06:00
let mut debug_locs = DebugLocReader::new(module, body.range().start as u32);
2023-02-13 18:17:17 -06:00
for &param in &module.signatures[my_sig].params[..] {
2022-11-02 14:38:45 -05:00
ret.locals.push(param.into());
}
ret.n_params = module.signatures[my_sig].params.len();
for &r in &module.signatures[my_sig].returns[..] {
2022-11-02 14:38:45 -05:00
ret.rets.push(r.into());
2021-12-24 15:20:30 -06:00
}
2021-11-13 03:10:22 -06:00
let mut locals = body.get_locals_reader()?;
for _ in 0..locals.get_count() {
let (count, ty) = locals.read()?;
for _ in 0..count {
2022-11-02 14:38:45 -05:00
ret.locals.push(ty.into());
2021-11-13 03:10:22 -06:00
}
}
let locals = ret.locals.clone();
2021-11-13 03:10:22 -06:00
2021-11-13 18:44:53 -06:00
trace!(
"Parsing function body: locals = {:?} sig = {:?}",
ret.locals,
module.signatures[my_sig]
2021-11-13 18:44:53 -06:00
);
2021-11-13 05:49:19 -06:00
let mut builder = FunctionBodyBuilder::new(module, my_sig, &mut ret);
2022-11-01 22:43:47 -05:00
let entry = Block::new(0);
2022-11-02 14:38:45 -05:00
builder.body.entry = entry;
2022-11-01 22:43:47 -05:00
builder.locals.seal_block_preds(entry, &mut builder.body);
builder.locals.start_block(entry);
2021-11-14 00:25:27 -06:00
for (arg_idx, &arg_ty) in module.signatures[my_sig].params.iter().enumerate() {
2022-11-01 22:43:47 -05:00
let local_idx = Local::new(arg_idx);
2022-11-02 14:38:45 -05:00
builder.body.add_blockparam(entry, arg_ty);
2022-11-02 21:46:15 -05:00
let value = builder.body.blocks[entry].params.last().unwrap().1;
2021-11-14 00:25:27 -06:00
trace!("defining local {} to value {}", local_idx, value);
builder.locals.declare(local_idx, arg_ty);
builder.locals.set(local_idx, value);
}
let n_args = module.signatures[my_sig].params.len();
2022-11-01 22:43:47 -05:00
for (offset, local_ty) in locals.values().enumerate() {
let local_idx = Local::new(n_args + offset);
builder.locals.declare(local_idx, *local_ty);
2021-11-14 00:25:27 -06:00
}
2021-11-13 03:17:53 -06:00
let ops = body.get_operators_reader()?;
2023-02-13 18:17:17 -06:00
for item in ops.into_iter_with_offsets() {
let (op, offset) = item?;
let loc = debug_locs.get_loc(offset);
2022-11-29 15:22:04 -06:00
if builder.reachable {
2023-02-13 18:17:17 -06:00
builder.handle_op(op, loc)?;
2022-11-29 15:22:04 -06:00
} else {
builder.handle_op_unreachable(op)?;
}
2021-11-13 03:17:53 -06:00
}
2022-11-29 15:22:04 -06:00
if builder.reachable {
2023-02-13 18:17:17 -06:00
builder.handle_op(wasmparser::Operator::Return, SourceLoc::invalid())?;
2021-11-13 18:44:53 -06:00
}
2022-11-01 22:43:47 -05:00
for block in builder.body.blocks.iter() {
2021-12-12 00:25:12 -06:00
log::trace!("checking if block is sealed: {}", block);
2022-11-01 22:43:47 -05:00
debug_assert!(builder.locals.is_sealed(block));
2021-12-12 00:25:12 -06:00
}
2022-11-01 22:43:47 -05:00
for value in builder.body.values.values() {
debug_assert!(!matches!(value, &ValueDef::Placeholder(_)));
2021-12-12 00:40:01 -06:00
}
2021-12-12 00:25:12 -06:00
2021-11-13 18:44:53 -06:00
trace!("Final function body:{:?}", ret);
2021-11-13 03:10:22 -06:00
Ok(ret)
}
2021-11-13 03:17:53 -06:00
#[derive(Debug, Clone, Default)]
struct LocalTracker {
/// Types of locals, as declared.
2022-11-01 22:43:47 -05:00
types: FxHashMap<Local, Type>,
/// The current block.
2022-11-29 15:22:04 -06:00
cur_block: Block,
/// In some block?
in_block: bool,
/// Is the given block sealed?
2022-11-01 22:43:47 -05:00
block_sealed: FxHashSet<Block>,
/// The local-to-value mapping at the start of a block.
2022-11-01 22:43:47 -05:00
block_start: FxHashMap<Block, FxHashMap<Local, Value>>,
/// The local-to-value mapping at the end of a block.
2022-11-01 22:43:47 -05:00
block_end: FxHashMap<Block, FxHashMap<Local, Value>>,
in_cur_block: FxHashMap<Local, Value>,
incomplete_phis: FxHashMap<Block, Vec<(Local, Value)>>,
}
impl LocalTracker {
2022-11-01 22:43:47 -05:00
pub fn declare(&mut self, local: Local, ty: Type) {
let was_present = self.types.insert(local, ty).is_some();
assert!(!was_present);
}
pub fn start_block(&mut self, block: Block) {
2021-12-12 00:25:12 -06:00
log::trace!("start_block: block {}", block);
assert!(!self.in_block);
self.in_block = true;
2022-11-29 15:22:04 -06:00
self.cur_block = block;
}
2022-11-29 15:22:04 -06:00
pub fn finish_block(&mut self, reachable: bool) {
if !self.in_block {
assert!(!reachable);
return;
}
2022-11-29 15:22:04 -06:00
log::trace!("finish_block: block {}", self.cur_block);
if reachable {
let mapping = std::mem::take(&mut self.in_cur_block);
2022-11-30 00:28:44 -06:00
log::trace!(" -> mapping: {:?}", mapping);
let old_mapping = self.block_end.insert(self.cur_block, mapping);
assert!(
old_mapping.is_none(),
"Mapping already present for {}: {:?}",
self.cur_block,
old_mapping
);
2022-11-30 00:37:35 -06:00
} else {
self.in_cur_block.clear();
2022-11-30 00:37:35 -06:00
self.block_end.insert(self.cur_block, FxHashMap::default());
}
self.in_block = false;
}
2022-11-01 22:43:47 -05:00
pub fn seal_block_preds(&mut self, block: Block, body: &mut FunctionBody) {
2021-12-12 00:25:12 -06:00
log::trace!("seal_block_preds: block {}", block);
let not_sealed = self.block_sealed.insert(block);
assert!(not_sealed);
for (local, phi_value) in self
.incomplete_phis
.remove(&block)
.unwrap_or_else(|| vec![])
{
self.compute_blockparam(body, block, local, phi_value);
}
}
2022-11-01 22:43:47 -05:00
fn is_sealed(&self, block: Block) -> bool {
self.block_sealed.contains(&block)
}
2022-11-01 22:43:47 -05:00
pub fn set(&mut self, local: Local, value: Value) {
2021-12-12 00:25:12 -06:00
log::trace!("set: local {} value {:?}", local, value);
self.in_cur_block.insert(local, value);
}
2022-11-01 22:43:47 -05:00
fn get_in_block(&mut self, body: &mut FunctionBody, at_block: Block, local: Local) -> Value {
2022-11-30 00:37:35 -06:00
log::trace!(
"get_in_block: at_block {} local {} cur_block {}",
at_block,
local,
self.cur_block
);
2022-11-01 22:43:47 -05:00
let ty = body.locals[local];
2022-11-29 15:22:04 -06:00
if self.cur_block == at_block {
if let Some(&value) = self.in_cur_block.get(&local) {
2021-12-12 00:25:12 -06:00
log::trace!(" -> {:?}", value);
return value;
}
}
if self.is_sealed(at_block) {
if let Some(end_mapping) = self.block_end.get(&at_block) {
if let Some(&value) = end_mapping.get(&local) {
2021-12-12 21:28:32 -06:00
log::trace!(" -> from end_mapping: {:?}", value);
return value;
}
}
2021-12-12 00:33:15 -06:00
if body.blocks[at_block].preds.is_empty() {
2022-11-02 20:18:33 -05:00
let value = self.create_default_value(body, ty, at_block);
2021-12-12 00:25:12 -06:00
log::trace!(" -> created default: {:?}", value);
return value;
}
let placeholder = body.add_placeholder(ty);
2022-11-11 00:19:08 -06:00
body.mark_value_as_local(placeholder, local);
2022-11-30 00:28:44 -06:00
if at_block == self.cur_block {
self.in_cur_block.insert(local, placeholder);
} else {
self.block_end
.get_mut(&at_block)
.unwrap()
.insert(local, placeholder);
}
2021-12-12 00:25:12 -06:00
log::trace!(" -> created placeholder: {:?}", placeholder);
self.compute_blockparam(body, at_block, local, placeholder);
placeholder
} else {
2022-11-11 00:19:08 -06:00
if let Some(end_mapping) = self.block_end.get(&at_block) {
if let Some(&value) = end_mapping.get(&local) {
log::trace!(" -> from end_mapping: {:?}", value);
return value;
}
}
let placeholder = body.add_placeholder(ty);
2022-11-11 00:19:08 -06:00
body.mark_value_as_local(placeholder, local);
2022-11-30 00:31:12 -06:00
if at_block == self.cur_block {
self.in_cur_block.insert(local, placeholder);
} else {
self.block_end
.get_mut(&at_block)
.unwrap()
.insert(local, placeholder);
}
2021-12-12 00:25:12 -06:00
log::trace!(
" -> created placeholder and added as incomplete phi: {:?}",
placeholder
);
self.incomplete_phis
.entry(at_block)
.or_insert_with(|| vec![])
.push((local, placeholder));
placeholder
}
}
2022-11-01 22:43:47 -05:00
pub fn get(&mut self, body: &mut FunctionBody, local: Local) -> Value {
2022-11-29 15:22:04 -06:00
self.get_in_block(body, self.cur_block, local)
}
2022-11-02 20:18:33 -05:00
fn create_default_value(
&mut self,
body: &mut FunctionBody,
ty: Type,
at_block: Block,
) -> Value {
let val = match ty {
2022-11-01 04:26:21 -05:00
Type::I32 => body.add_value(ValueDef::Operator(
Operator::I32Const { value: 0 },
vec![],
2021-12-23 20:23:42 -06:00
vec![ty],
2022-11-01 04:26:21 -05:00
)),
Type::I64 => body.add_value(ValueDef::Operator(
Operator::I64Const { value: 0 },
vec![],
2021-12-23 20:23:42 -06:00
vec![ty],
2022-11-01 04:26:21 -05:00
)),
Type::F32 => body.add_value(ValueDef::Operator(
2022-11-23 01:30:11 -06:00
Operator::F32Const { value: 0 },
2022-11-01 04:26:21 -05:00
vec![],
2021-12-23 20:23:42 -06:00
vec![ty],
2022-11-01 04:26:21 -05:00
)),
Type::F64 => body.add_value(ValueDef::Operator(
2022-11-23 01:30:11 -06:00
Operator::F64Const { value: 0 },
2022-11-01 04:26:21 -05:00
vec![],
2021-12-23 20:23:42 -06:00
vec![ty],
2022-11-01 04:26:21 -05:00
)),
_ => todo!("unsupported type: {:?}", ty),
2022-11-02 20:18:33 -05:00
};
2022-11-10 02:29:56 -06:00
body.append_to_block(at_block, val);
2022-11-02 21:46:15 -05:00
log::trace!(
"created default value {} of type {} at block {}",
val,
ty,
at_block
);
2022-11-02 20:18:33 -05:00
val
}
fn compute_blockparam(
&mut self,
body: &mut FunctionBody,
2022-11-01 22:43:47 -05:00
block: Block,
local: Local,
value: Value,
) {
2021-12-12 00:25:12 -06:00
log::trace!(
"compute_blockparam: block {} local {} value {:?}",
block,
local,
value
);
let mut results: Vec<Value> = vec![];
2021-12-12 00:33:15 -06:00
let preds = body.blocks[block].preds.clone();
for pred in preds {
let pred_value = self.get_in_block(body, pred, local);
2021-12-12 00:25:12 -06:00
log::trace!(
"compute_blockparam: block {} local {} value {:?}: pred {} -> {:?}",
block,
local,
value,
pred,
pred_value
);
results.push(pred_value);
}
let mut non_self = results.iter().filter(|&&v| v != value);
let trivial_alias = match non_self.next() {
None => None,
2021-12-12 00:36:01 -06:00
Some(&first) if non_self.all(|&v| v == first) && body.resolve_alias(first) != value => {
Some(first)
}
Some(_) => None,
};
if let Some(v) = trivial_alias {
2021-12-12 00:25:12 -06:00
log::trace!(
"compute_blockparam: block {} local {} value {:?}: alias to {:?}",
block,
local,
value,
v
);
body.set_alias(value, v);
} else {
2021-12-12 00:25:12 -06:00
log::trace!(
"compute_blockparam: block {} local {} value {:?}: making blockparam",
block,
local,
value,
);
body.replace_placeholder_with_blockparam(block, value);
2021-12-12 00:33:15 -06:00
for (i, (&pred, result)) in body.blocks[block]
.preds
.clone()
.iter()
.zip(results.into_iter())
.enumerate()
{
let index = body.blocks[block].pos_in_pred_succ[i];
body.blocks[pred].terminator.update_target(index, |target| {
2021-12-12 00:25:12 -06:00
log::trace!(
"compute_blockparam: block {} local {} value {:?}: in pred {}, adding branch arg {:?}",
block,
local,
value,
pred,
result,
);
target.args.push(result);
});
}
}
}
}
2021-11-13 03:17:53 -06:00
#[derive(Debug)]
2021-11-13 04:32:05 -06:00
struct FunctionBodyBuilder<'a, 'b> {
module: &'b Module<'a>,
2022-11-01 22:43:47 -05:00
my_sig: Signature,
2021-11-22 01:12:07 -06:00
body: &'b mut FunctionBody,
locals: LocalTracker,
2022-11-29 15:22:04 -06:00
cur_block: Block,
reachable: bool,
2021-11-13 03:41:32 -06:00
ctrl_stack: Vec<Frame>,
2021-11-21 19:15:26 -06:00
op_stack: Vec<(Type, Value)>,
2021-11-13 03:41:32 -06:00
}
2021-11-13 16:13:31 -06:00
#[derive(Clone, Debug)]
2021-11-13 03:41:32 -06:00
enum Frame {
Block {
2021-11-13 15:49:57 -06:00
start_depth: usize,
2022-11-01 22:43:47 -05:00
out: Block,
2021-11-13 03:41:32 -06:00
params: Vec<Type>,
results: Vec<Type>,
2022-11-29 15:22:04 -06:00
out_reachable: bool,
2021-11-13 03:41:32 -06:00
},
Loop {
2021-11-13 15:49:57 -06:00
start_depth: usize,
2022-11-01 22:43:47 -05:00
header: Block,
out: Block,
2021-11-13 03:41:32 -06:00
params: Vec<Type>,
results: Vec<Type>,
},
If {
2021-11-13 15:49:57 -06:00
start_depth: usize,
2022-11-01 22:43:47 -05:00
out: Block,
el: Block,
2021-11-21 19:15:26 -06:00
param_values: Vec<(Type, Value)>,
2021-11-13 03:41:32 -06:00
params: Vec<Type>,
results: Vec<Type>,
2022-11-29 15:22:04 -06:00
head_reachable: bool,
2022-11-29 20:40:57 -06:00
merge_reachable: bool,
2021-11-13 03:41:32 -06:00
},
Else {
2021-11-13 15:49:57 -06:00
start_depth: usize,
2022-11-01 22:43:47 -05:00
out: Block,
2021-11-13 03:41:32 -06:00
params: Vec<Type>,
results: Vec<Type>,
2022-11-29 15:22:04 -06:00
merge_reachable: bool,
2021-11-13 03:41:32 -06:00
},
2021-11-13 03:17:53 -06:00
}
2021-11-13 15:49:57 -06:00
impl Frame {
fn start_depth(&self) -> usize {
match self {
Frame::Block { start_depth, .. }
| Frame::Loop { start_depth, .. }
| Frame::If { start_depth, .. }
| Frame::Else { start_depth, .. } => *start_depth,
}
}
fn br_args(&self) -> &[Type] {
match self {
Frame::Block { results, .. }
| Frame::If { results, .. }
| Frame::Else { results, .. } => &results[..],
Frame::Loop { params, .. } => &params[..],
}
}
2022-11-01 22:43:47 -05:00
fn br_target(&self) -> Block {
2021-11-13 15:49:57 -06:00
match self {
Frame::Block { out, .. } => *out,
Frame::Loop { header, .. } => *header,
Frame::If { out, .. } | Frame::Else { out, .. } => *out,
}
}
2022-11-01 22:43:47 -05:00
fn out(&self) -> Block {
match self {
Frame::Block { out, .. }
| Frame::Loop { out, .. }
| Frame::If { out, .. }
| Frame::Else { out, .. } => *out,
}
}
fn params(&self) -> &[Type] {
match self {
Frame::Block { params, .. }
| Frame::Loop { params, .. }
| Frame::If { params, .. }
| Frame::Else { params, .. } => &params[..],
}
}
fn results(&self) -> &[Type] {
match self {
Frame::Block { results, .. }
| Frame::Loop { results, .. }
| Frame::If { results, .. }
| Frame::Else { results, .. } => &results[..],
}
}
2022-11-29 15:22:04 -06:00
fn set_reachable(&mut self) {
match self {
Frame::Block { out_reachable, .. } => *out_reachable = true,
2022-11-29 20:40:57 -06:00
Frame::If {
merge_reachable, ..
}
| Frame::Else {
merge_reachable, ..
} => *merge_reachable = true,
2022-11-29 15:22:04 -06:00
_ => {}
}
}
2021-11-13 15:49:57 -06:00
}
2021-11-13 04:32:05 -06:00
impl<'a, 'b> FunctionBodyBuilder<'a, 'b> {
2022-11-01 22:43:47 -05:00
fn new(module: &'b Module<'a>, my_sig: Signature, body: &'b mut FunctionBody) -> Self {
body.blocks.push(BlockDef::default());
2021-11-13 18:44:53 -06:00
let mut ret = Self {
2021-11-13 04:32:05 -06:00
module,
my_sig,
2021-11-13 03:41:32 -06:00
body,
ctrl_stack: vec![],
op_stack: vec![],
2022-11-29 15:22:04 -06:00
cur_block: Block::new(0),
reachable: true,
locals: LocalTracker::default(),
2021-11-13 18:44:53 -06:00
};
// Push initial implicit Block.
let results = module.signatures[my_sig].returns.to_vec();
let out = ret.body.add_block();
2021-12-12 00:25:12 -06:00
ret.add_block_params(out, &results[..]);
2021-11-13 18:44:53 -06:00
ret.ctrl_stack.push(Frame::Block {
start_depth: 0,
out,
params: vec![],
2021-11-13 18:44:53 -06:00
results,
2022-11-29 15:22:04 -06:00
out_reachable: false,
2021-11-13 18:44:53 -06:00
});
ret
2021-11-13 03:17:53 -06:00
}
2021-11-21 19:15:26 -06:00
fn pop_n(&mut self, n: usize) -> Vec<Value> {
2022-11-29 15:43:13 -06:00
assert!(self.reachable);
let new_top = self.op_stack.len() - n;
let ret = self.op_stack[new_top..]
.iter()
.map(|(_ty, value)| *value)
.collect::<Vec<_>>();
self.op_stack.truncate(new_top);
ret
}
2021-11-21 19:15:26 -06:00
fn pop_1(&mut self) -> Value {
2022-11-29 15:43:13 -06:00
assert!(self.reachable);
self.op_stack.pop().unwrap().1
}
2022-11-02 20:18:33 -05:00
fn block_results(&mut self, tys: &[Type], start_depth: usize, at_block: Block) -> Vec<Value> {
if self.op_stack.len() < start_depth + tys.len() {
tys.iter()
2022-11-02 20:18:33 -05:00
.map(|&ty| {
self.locals
.create_default_value(&mut self.body, ty, at_block)
})
.collect()
2021-12-12 21:40:35 -06:00
} else {
self.pop_n(tys.len())
2021-12-12 21:40:35 -06:00
}
}
2023-02-13 18:17:17 -06:00
fn handle_op(&mut self, op: wasmparser::Operator<'a>, loc: SourceLoc) -> Result<()> {
2021-11-13 18:44:53 -06:00
trace!("handle_op: {:?}", op);
trace!("op_stack = {:?}", self.op_stack);
trace!("ctrl_stack = {:?}", self.ctrl_stack);
2021-11-14 00:25:27 -06:00
trace!("locals = {:?}", self.locals);
2022-11-29 15:22:04 -06:00
debug_assert!(self.reachable);
if self.handle_ctrl_op(op.clone())? {
return Ok(());
}
2021-11-13 15:49:57 -06:00
match &op {
wasmparser::Operator::Unreachable => {
2022-11-29 15:22:04 -06:00
self.emit_unreachable();
}
wasmparser::Operator::LocalGet { local_index } => {
2022-11-01 22:43:47 -05:00
let local_index = Local::from(*local_index);
let ty = self.body.locals[local_index];
let value = self.locals.get(&mut self.body, local_index);
2021-12-12 21:40:35 -06:00
self.op_stack.push((ty, value));
2021-11-14 00:25:27 -06:00
}
wasmparser::Operator::LocalSet { local_index } => {
2022-11-01 22:43:47 -05:00
let local_index = Local::from(*local_index);
let (_, value) = self.op_stack.pop().unwrap();
2022-11-29 15:22:04 -06:00
self.locals.set(local_index, value);
}
wasmparser::Operator::LocalTee { local_index } => {
2022-11-01 22:43:47 -05:00
let local_index = Local::from(*local_index);
let (_ty, value) = *self.op_stack.last().unwrap();
2022-11-29 15:22:04 -06:00
self.locals.set(local_index, value);
2021-11-14 00:25:27 -06:00
}
wasmparser::Operator::Call { .. }
| wasmparser::Operator::CallIndirect { .. }
| wasmparser::Operator::Select
| wasmparser::Operator::TypedSelect { .. }
| wasmparser::Operator::GlobalGet { .. }
| wasmparser::Operator::GlobalSet { .. }
| wasmparser::Operator::I32Load { .. }
| wasmparser::Operator::I64Load { .. }
| wasmparser::Operator::F32Load { .. }
| wasmparser::Operator::F64Load { .. }
| wasmparser::Operator::I32Load8S { .. }
| wasmparser::Operator::I32Load8U { .. }
| wasmparser::Operator::I32Load16S { .. }
| wasmparser::Operator::I32Load16U { .. }
| wasmparser::Operator::I64Load8S { .. }
| wasmparser::Operator::I64Load8U { .. }
| wasmparser::Operator::I64Load16S { .. }
| wasmparser::Operator::I64Load16U { .. }
| wasmparser::Operator::I64Load32S { .. }
| wasmparser::Operator::I64Load32U { .. }
| wasmparser::Operator::I32Store { .. }
| wasmparser::Operator::I64Store { .. }
| wasmparser::Operator::F32Store { .. }
| wasmparser::Operator::F64Store { .. }
| wasmparser::Operator::I32Store8 { .. }
| wasmparser::Operator::I32Store16 { .. }
| wasmparser::Operator::I64Store8 { .. }
| wasmparser::Operator::I64Store16 { .. }
| wasmparser::Operator::I64Store32 { .. }
| wasmparser::Operator::MemorySize { .. }
| wasmparser::Operator::MemoryGrow { .. }
| wasmparser::Operator::I32Const { .. }
| wasmparser::Operator::I64Const { .. }
| wasmparser::Operator::F32Const { .. }
| wasmparser::Operator::F64Const { .. }
| wasmparser::Operator::I32Eqz
| wasmparser::Operator::I32Eq
| wasmparser::Operator::I32Ne
| wasmparser::Operator::I32LtS
| wasmparser::Operator::I32LtU
| wasmparser::Operator::I32GtS
| wasmparser::Operator::I32GtU
| wasmparser::Operator::I32LeS
| wasmparser::Operator::I32LeU
| wasmparser::Operator::I32GeS
| wasmparser::Operator::I32GeU
| wasmparser::Operator::I64Eqz
| wasmparser::Operator::I64Eq
| wasmparser::Operator::I64Ne
| wasmparser::Operator::I64LtS
| wasmparser::Operator::I64LtU
| wasmparser::Operator::I64GtU
| wasmparser::Operator::I64GtS
| wasmparser::Operator::I64LeS
| wasmparser::Operator::I64LeU
| wasmparser::Operator::I64GeS
| wasmparser::Operator::I64GeU
| wasmparser::Operator::F32Eq
| wasmparser::Operator::F32Ne
| wasmparser::Operator::F32Lt
| wasmparser::Operator::F32Gt
| wasmparser::Operator::F32Le
| wasmparser::Operator::F32Ge
| wasmparser::Operator::F64Eq
| wasmparser::Operator::F64Ne
| wasmparser::Operator::F64Lt
| wasmparser::Operator::F64Gt
| wasmparser::Operator::F64Le
| wasmparser::Operator::F64Ge
| wasmparser::Operator::I32Clz
| wasmparser::Operator::I32Ctz
| wasmparser::Operator::I32Popcnt
| wasmparser::Operator::I32Add
| wasmparser::Operator::I32Sub
| wasmparser::Operator::I32Mul
| wasmparser::Operator::I32DivS
| wasmparser::Operator::I32DivU
| wasmparser::Operator::I32RemS
| wasmparser::Operator::I32RemU
| wasmparser::Operator::I32And
| wasmparser::Operator::I32Or
| wasmparser::Operator::I32Xor
| wasmparser::Operator::I32Shl
| wasmparser::Operator::I32ShrS
| wasmparser::Operator::I32ShrU
| wasmparser::Operator::I32Rotl
| wasmparser::Operator::I32Rotr
| wasmparser::Operator::I64Clz
| wasmparser::Operator::I64Ctz
| wasmparser::Operator::I64Popcnt
| wasmparser::Operator::I64Add
| wasmparser::Operator::I64Sub
| wasmparser::Operator::I64Mul
| wasmparser::Operator::I64DivS
| wasmparser::Operator::I64DivU
| wasmparser::Operator::I64RemS
| wasmparser::Operator::I64RemU
| wasmparser::Operator::I64And
| wasmparser::Operator::I64Or
| wasmparser::Operator::I64Xor
| wasmparser::Operator::I64Shl
| wasmparser::Operator::I64ShrS
| wasmparser::Operator::I64ShrU
| wasmparser::Operator::I64Rotl
| wasmparser::Operator::I64Rotr
| wasmparser::Operator::F32Abs
| wasmparser::Operator::F32Neg
| wasmparser::Operator::F32Ceil
| wasmparser::Operator::F32Floor
| wasmparser::Operator::F32Trunc
| wasmparser::Operator::F32Nearest
| wasmparser::Operator::F32Sqrt
| wasmparser::Operator::F32Add
| wasmparser::Operator::F32Sub
| wasmparser::Operator::F32Mul
| wasmparser::Operator::F32Div
| wasmparser::Operator::F32Min
| wasmparser::Operator::F32Max
| wasmparser::Operator::F32Copysign
| wasmparser::Operator::F64Abs
| wasmparser::Operator::F64Neg
| wasmparser::Operator::F64Ceil
| wasmparser::Operator::F64Floor
| wasmparser::Operator::F64Trunc
| wasmparser::Operator::F64Nearest
| wasmparser::Operator::F64Sqrt
| wasmparser::Operator::F64Add
| wasmparser::Operator::F64Sub
| wasmparser::Operator::F64Mul
| wasmparser::Operator::F64Div
| wasmparser::Operator::F64Min
| wasmparser::Operator::F64Max
| wasmparser::Operator::F64Copysign
| wasmparser::Operator::I32WrapI64
| wasmparser::Operator::I32TruncF32S
| wasmparser::Operator::I32TruncF32U
| wasmparser::Operator::I32TruncF64S
| wasmparser::Operator::I32TruncF64U
| wasmparser::Operator::I64ExtendI32S
| wasmparser::Operator::I64ExtendI32U
| wasmparser::Operator::I64TruncF32S
| wasmparser::Operator::I64TruncF32U
| wasmparser::Operator::I64TruncF64S
| wasmparser::Operator::I64TruncF64U
| wasmparser::Operator::F32ConvertI32S
| wasmparser::Operator::F32ConvertI32U
| wasmparser::Operator::F32ConvertI64S
| wasmparser::Operator::F32ConvertI64U
| wasmparser::Operator::F32DemoteF64
| wasmparser::Operator::F64ConvertI32S
| wasmparser::Operator::F64ConvertI32U
| wasmparser::Operator::F64ConvertI64S
| wasmparser::Operator::F64ConvertI64U
| wasmparser::Operator::F64PromoteF32
| wasmparser::Operator::I32Extend8S
| wasmparser::Operator::I32Extend16S
| wasmparser::Operator::I64Extend8S
| wasmparser::Operator::I64Extend16S
| wasmparser::Operator::I64Extend32S
| wasmparser::Operator::I32TruncSatF32S
| wasmparser::Operator::I32TruncSatF32U
| wasmparser::Operator::I32TruncSatF64S
| wasmparser::Operator::I32TruncSatF64U
| wasmparser::Operator::I64TruncSatF32S
| wasmparser::Operator::I64TruncSatF32U
| wasmparser::Operator::I64TruncSatF64S
| wasmparser::Operator::I64TruncSatF64U
| wasmparser::Operator::F32ReinterpretI32
| wasmparser::Operator::F64ReinterpretI64
| wasmparser::Operator::I32ReinterpretF32
| wasmparser::Operator::I64ReinterpretF64
| wasmparser::Operator::TableGet { .. }
| wasmparser::Operator::TableSet { .. }
| wasmparser::Operator::TableGrow { .. }
| wasmparser::Operator::TableSize { .. } => {
2023-02-13 18:17:17 -06:00
self.emit(Operator::try_from(&op).unwrap(), loc)?
2021-11-14 00:25:27 -06:00
}
wasmparser::Operator::Nop => {}
wasmparser::Operator::Drop => {
let _ = self.pop_1();
2021-11-13 17:09:47 -06:00
}
2021-11-13 04:32:05 -06:00
2022-11-29 15:22:04 -06:00
wasmparser::Operator::Br { relative_depth }
| wasmparser::Operator::BrIf { relative_depth } => {
let cond = match &op {
wasmparser::Operator::Br { .. } => None,
wasmparser::Operator::BrIf { .. } => Some(self.pop_1()),
_ => unreachable!(),
};
// Get the frame we're branching to.
let frame = self.relative_frame(*relative_depth);
frame.set_reachable();
let frame = frame.clone();
log::trace!("Br/BrIf: dest frame {:?}", frame);
// Finally, generate the branch itself.
match cond {
None => {
// Get the args off the stack unconditionally.
let args = self.pop_n(frame.br_args().len());
self.emit_branch(frame.br_target(), &args[..]);
self.locals.finish_block(self.reachable);
2022-11-29 15:22:04 -06:00
self.reachable = false;
}
Some(cond) => {
let cont = self.body.add_block();
// Get the args off the stack but leave for the fallthrough.
let args = self.op_stack[self.op_stack.len() - frame.br_args().len()..]
.iter()
.map(|(_ty, value)| *value)
.collect::<Vec<_>>();
self.emit_cond_branch(cond, frame.br_target(), &args[..], cont, &[]);
self.locals.seal_block_preds(cont, &mut self.body);
self.cur_block = cont;
self.locals.finish_block(self.reachable);
self.locals.start_block(cont);
2022-11-29 15:22:04 -06:00
}
}
}
wasmparser::Operator::BrTable { targets } => {
// Get the selector index.
let index = self.pop_1();
// Get the signature of the default frame; this tells
// us the signature of all frames (since wasmparser
// validates the input for us). Pop that many args.
let default_frame = self.relative_frame(targets.default());
default_frame.set_reachable();
2022-11-29 15:22:04 -06:00
let default_term_target = default_frame.br_target();
let arg_len = default_frame.br_args().len();
let args = self.pop_n(arg_len);
// Generate a branch terminator with the same args for
// every branch target.
let mut term_targets = vec![];
for target in targets.targets() {
let target = target?;
let frame = self.relative_frame(target);
frame.set_reachable();
assert_eq!(frame.br_args().len(), args.len());
let block = frame.br_target();
term_targets.push(block);
}
self.emit_br_table(index, default_term_target, &term_targets[..], &args[..]);
self.locals.finish_block(self.reachable);
2022-11-29 20:40:57 -06:00
self.reachable = false;
2022-11-29 15:22:04 -06:00
}
wasmparser::Operator::Return => {
let retvals = self.pop_n(self.module.signatures[self.my_sig].returns.len());
2022-11-29 15:22:04 -06:00
self.emit_ret(&retvals[..]);
2022-11-29 20:03:33 -06:00
self.reachable = false;
2022-11-29 15:22:04 -06:00
}
_ => bail!(FrontendError::UnsupportedFeature(format!(
"Unsupported operator: {:?}",
op
))),
}
Ok(())
}
fn handle_op_unreachable(&mut self, op: wasmparser::Operator<'a>) -> Result<()> {
trace!("handle_op_unreachable: {:?}", op);
trace!("op_stack = {:?}", self.op_stack);
trace!("ctrl_stack = {:?}", self.ctrl_stack);
debug_assert!(!self.reachable);
self.handle_ctrl_op(op)?;
Ok(())
}
fn handle_ctrl_op(&mut self, op: wasmparser::Operator<'a>) -> Result<bool> {
2022-11-29 20:03:33 -06:00
log::trace!(
"handle_ctrl_op: op {:?} reachable {} cur_block {}",
op,
self.reachable,
self.cur_block
);
log::trace!("ctrl stack: {:?}", self.ctrl_stack);
2022-11-29 15:22:04 -06:00
match &op {
wasmparser::Operator::End => {
let frame = self.ctrl_stack.pop();
match &frame {
None => {
2022-11-29 15:22:04 -06:00
if self.reachable {
let retvals =
self.pop_n(self.module.signatures[self.my_sig].returns.len());
2022-11-29 15:22:04 -06:00
self.emit_ret(&retvals[..]);
} else {
self.emit_unreachable();
}
}
Some(Frame::Block {
start_depth,
out,
ref results,
..
})
| Some(Frame::Loop {
start_depth,
out,
ref results,
..
}) => {
// Generate a branch to the out-block with
// blockparams for the results.
2022-11-29 20:03:33 -06:00
let was_reachable = self.reachable;
2022-11-29 15:22:04 -06:00
if self.reachable {
2022-11-02 20:18:33 -05:00
let result_values =
2022-11-29 15:22:04 -06:00
self.block_results(&results[..], *start_depth, self.cur_block);
2022-11-02 20:18:33 -05:00
self.emit_branch(*out, &result_values[..]);
}
self.op_stack.truncate(*start_depth);
// Seal the out-block: no more edges will be
// added to it. Also, if we're ending a loop,
// seal thea header: no more back-edges will
// be added to it.
self.locals.seal_block_preds(*out, &mut self.body);
if let Some(Frame::Loop { header, .. }) = &frame {
self.locals.seal_block_preds(*header, &mut self.body);
}
2022-11-29 15:22:04 -06:00
// Set `cur_block` only if currently set (otherwise, unreachable!)
self.cur_block = *out;
self.locals.finish_block(self.reachable);
self.locals.start_block(*out);
2022-11-29 20:03:33 -06:00
self.reachable = was_reachable
2022-11-29 15:22:04 -06:00
|| match &frame {
Some(Frame::Block { out_reachable, .. }) => *out_reachable,
_ => false,
};
self.push_block_params(results.len());
}
Some(Frame::If {
start_depth,
out,
el,
ref param_values,
ref results,
2022-11-29 15:22:04 -06:00
head_reachable,
2022-11-29 20:40:57 -06:00
merge_reachable,
..
}) => {
// Generate a branch to the out-block with
// blockparams for the results.
2022-11-29 20:03:33 -06:00
let was_reachable = self.reachable;
2022-11-29 15:22:04 -06:00
if self.reachable {
2022-11-02 20:18:33 -05:00
let result_values =
2022-11-29 15:22:04 -06:00
self.block_results(&results[..], *start_depth, self.cur_block);
2022-11-02 20:18:33 -05:00
self.emit_branch(*out, &result_values[..]);
}
2022-11-29 15:43:13 -06:00
assert!(self.op_stack.len() >= *start_depth);
self.op_stack.truncate(*start_depth);
2022-11-29 15:22:04 -06:00
if *head_reachable {
// No `else`, so we need to generate a trivial
// branch in the else-block. If the if-block-type
// has results, they must be exactly the params.
let else_result_values = param_values;
assert_eq!(else_result_values.len(), results.len());
let else_result_values = else_result_values
.iter()
.map(|(_ty, value)| *value)
.collect::<Vec<_>>();
self.locals.finish_block(self.reachable);
self.locals.start_block(*el);
2022-11-29 15:22:04 -06:00
self.cur_block = *el;
2022-11-29 21:49:22 -06:00
self.reachable = *head_reachable;
2022-11-29 15:22:04 -06:00
self.emit_branch(*out, &else_result_values[..]);
assert_eq!(self.op_stack.len(), *start_depth);
}
self.cur_block = *out;
2022-11-30 00:28:44 -06:00
let else_reachable = self.reachable;
2022-11-29 21:49:22 -06:00
self.reachable = *head_reachable || was_reachable || *merge_reachable;
self.locals.seal_block_preds(*out, &mut self.body);
self.locals.finish_block(else_reachable);
self.locals.start_block(*out);
self.push_block_params(results.len());
}
Some(Frame::Else {
out,
ref results,
start_depth,
2022-11-29 15:22:04 -06:00
merge_reachable,
..
}) => {
// Generate a branch to the out-block with
// blockparams for the results.
2022-11-29 20:03:33 -06:00
let was_reachable = self.reachable;
2022-11-29 15:22:04 -06:00
if self.reachable {
2022-11-02 20:18:33 -05:00
let result_values =
2022-11-29 15:22:04 -06:00
self.block_results(&results[..], *start_depth, self.cur_block);
2022-11-02 20:18:33 -05:00
self.emit_branch(*out, &result_values[..]);
}
self.op_stack.truncate(*start_depth);
2022-11-29 15:22:04 -06:00
self.cur_block = *out;
self.reachable = *merge_reachable || self.reachable;
self.locals.seal_block_preds(*out, &mut self.body);
self.locals.finish_block(was_reachable);
self.locals.start_block(*out);
self.push_block_params(results.len());
}
2021-11-13 05:38:47 -06:00
}
}
2021-11-13 05:38:47 -06:00
2022-11-23 01:30:11 -06:00
wasmparser::Operator::Block { blockty } => {
let (params, results) = self.block_params_and_results(*blockty);
let out = self.body.add_block();
2021-11-13 15:49:57 -06:00
self.add_block_params(out, &results[..]);
2022-11-29 15:43:13 -06:00
let start_depth = if self.reachable {
self.op_stack.len() - params.len()
} else {
self.op_stack.len()
};
2021-11-13 05:38:47 -06:00
self.ctrl_stack.push(Frame::Block {
2021-11-13 15:49:57 -06:00
start_depth,
out,
params,
results,
2022-11-29 15:22:04 -06:00
out_reachable: false,
2021-11-13 15:49:57 -06:00
});
}
2022-11-23 01:30:11 -06:00
wasmparser::Operator::Loop { blockty } => {
let (params, results) = self.block_params_and_results(*blockty);
let header = self.body.add_block();
2021-11-13 15:49:57 -06:00
self.add_block_params(header, &params[..]);
2022-11-29 15:31:23 -06:00
let initial_args = if self.reachable {
self.pop_n(params.len())
} else {
vec![Value::invalid(); params.len()]
};
2021-11-13 15:49:57 -06:00
let start_depth = self.op_stack.len();
self.emit_branch(header, &initial_args[..]);
2022-11-29 15:22:04 -06:00
self.cur_block = header;
self.locals.finish_block(self.reachable);
self.locals.start_block(header);
self.push_block_params(params.len());
let out = self.body.add_block();
self.add_block_params(out, &results[..]);
2021-11-13 15:49:57 -06:00
self.ctrl_stack.push(Frame::Loop {
start_depth,
header,
2021-11-13 05:38:47 -06:00
out,
params,
results,
});
2021-11-13 04:32:05 -06:00
}
2022-11-23 01:30:11 -06:00
wasmparser::Operator::If { blockty } => {
let (params, results) = self.block_params_and_results(*blockty);
let if_true = self.body.add_block();
let if_false = self.body.add_block();
let join = self.body.add_block();
2021-11-13 15:49:57 -06:00
self.add_block_params(join, &results[..]);
2022-11-29 15:31:23 -06:00
let (cond, param_values) = if self.reachable {
let cond = self.pop_1();
let param_values = self.op_stack[self.op_stack.len() - params.len()..].to_vec();
(cond, param_values)
} else {
(
Value::invalid(),
params.iter().map(|&ty| (ty, Value::invalid())).collect(),
)
};
2022-11-29 15:43:13 -06:00
let start_depth = if self.reachable {
self.op_stack.len() - params.len()
} else {
self.op_stack.len()
};
2021-11-13 15:49:57 -06:00
self.ctrl_stack.push(Frame::If {
start_depth,
out: join,
el: if_false,
param_values,
params,
results,
2022-11-29 15:22:04 -06:00
head_reachable: self.reachable,
2022-11-29 20:40:57 -06:00
merge_reachable: false,
2021-11-13 15:49:57 -06:00
});
self.emit_cond_branch(cond, if_true, &[], if_false, &[]);
self.locals.seal_block_preds(if_true, &mut self.body);
self.locals.seal_block_preds(if_false, &mut self.body);
2022-11-29 15:22:04 -06:00
self.cur_block = if_true;
self.locals.finish_block(self.reachable);
self.locals.start_block(if_true);
2021-11-13 15:49:57 -06:00
}
wasmparser::Operator::Else => {
2021-11-13 15:49:57 -06:00
if let Frame::If {
start_depth,
out,
el,
param_values,
params,
results,
2022-11-29 15:22:04 -06:00
head_reachable,
2022-11-29 20:40:57 -06:00
merge_reachable,
2021-11-13 15:49:57 -06:00
} = self.ctrl_stack.pop().unwrap()
{
2022-11-29 15:22:04 -06:00
if self.reachable {
let if_results =
self.block_results(&results[..], start_depth, self.cur_block);
2022-11-02 20:18:33 -05:00
self.emit_branch(out, &if_results[..]);
}
self.op_stack.truncate(start_depth);
2021-11-13 15:49:57 -06:00
self.op_stack.extend(param_values);
self.ctrl_stack.push(Frame::Else {
start_depth,
out,
params,
results,
2022-11-29 23:39:29 -06:00
merge_reachable: merge_reachable || self.reachable,
2021-11-13 15:49:57 -06:00
});
2022-11-29 15:22:04 -06:00
self.cur_block = el;
self.locals.finish_block(self.reachable);
self.locals.start_block(el);
2022-11-29 15:22:04 -06:00
self.reachable = head_reachable;
2021-11-13 15:49:57 -06:00
} else {
bail!(FrontendError::Internal(format!(
"Else without If on top of frame stack"
)));
2021-11-13 15:49:57 -06:00
}
}
2022-11-29 15:22:04 -06:00
_ => return Ok(false),
2021-11-13 03:17:53 -06:00
}
2022-11-29 15:22:04 -06:00
Ok(true)
2021-11-13 03:17:53 -06:00
}
2021-11-13 03:41:32 -06:00
2022-11-01 22:43:47 -05:00
fn add_block_params(&mut self, block: Block, tys: &[Type]) {
2021-12-12 00:25:12 -06:00
log::trace!("add_block_params: block {} tys {:?}", block, tys);
for &ty in tys {
self.body.add_blockparam(block, ty);
}
}
2022-11-23 01:30:11 -06:00
fn block_params_and_results(&self, ty: BlockType) -> (Vec<Type>, Vec<Type>) {
2021-11-13 05:38:47 -06:00
match ty {
2022-11-23 01:30:11 -06:00
BlockType::Empty => (vec![], vec![]),
BlockType::Type(ret_ty) => (vec![], vec![ret_ty.into()]),
BlockType::FuncType(sig_idx) => {
let sig = &self.module.signatures[Signature::from(sig_idx)];
2021-11-13 05:38:47 -06:00
(
Vec::from(sig.params.clone()),
Vec::from(sig.returns.clone()),
)
}
}
}
2022-11-29 15:22:04 -06:00
fn relative_frame(&mut self, relative_depth: u32) -> &mut Frame {
let index = self.ctrl_stack.len() - 1 - relative_depth as usize;
&mut self.ctrl_stack[index]
2021-11-13 16:13:31 -06:00
}
2022-11-01 22:43:47 -05:00
fn emit_branch(&mut self, target: Block, args: &[Value]) {
2021-12-12 00:25:12 -06:00
log::trace!(
"emit_branch: cur_block {:?} target {} args {:?}",
self.cur_block,
target,
args
);
2022-11-29 15:22:04 -06:00
if self.reachable {
let args = args.to_vec();
2021-11-13 16:13:31 -06:00
let target = BlockTarget {
block: target,
args,
};
2022-11-29 15:22:04 -06:00
self.body
.set_terminator(self.cur_block, Terminator::Br { target });
2021-11-13 16:13:31 -06:00
}
2021-11-13 05:38:47 -06:00
}
2021-11-13 15:49:57 -06:00
fn emit_cond_branch(
&mut self,
2021-11-21 19:15:26 -06:00
cond: Value,
2022-11-01 22:43:47 -05:00
if_true: Block,
2021-11-21 19:15:26 -06:00
if_true_args: &[Value],
2022-11-01 22:43:47 -05:00
if_false: Block,
2021-11-21 19:15:26 -06:00
if_false_args: &[Value],
2021-11-13 15:49:57 -06:00
) {
2021-12-12 00:25:12 -06:00
log::trace!(
"emit_cond_branch: cur_block {:?} if_true {} args {:?} if_false {} args {:?}",
self.cur_block,
if_true,
if_true_args,
if_false,
if_false_args
);
2022-11-29 15:22:04 -06:00
if self.reachable {
let if_true_args = if_true_args.to_vec();
let if_false_args = if_false_args.to_vec();
self.body.set_terminator(
2022-11-29 15:22:04 -06:00
self.cur_block,
2021-12-12 22:11:28 -06:00
Terminator::CondBr {
cond,
if_true: BlockTarget {
block: if_true,
args: if_true_args,
},
if_false: BlockTarget {
block: if_false,
args: if_false_args,
},
2021-11-13 16:13:31 -06:00
},
2021-12-12 22:11:28 -06:00
);
2021-11-13 16:13:31 -06:00
}
}
fn emit_br_table(
&mut self,
2021-11-21 19:15:26 -06:00
index: Value,
2022-11-01 22:43:47 -05:00
default_target: Block,
indexed_targets: &[Block],
2021-11-21 19:15:26 -06:00
args: &[Value],
2021-11-13 16:13:31 -06:00
) {
2021-12-12 00:25:12 -06:00
log::trace!(
"emit_br_table: cur_block {:?} index {:?} default {} indexed {:?} args {:?}",
self.cur_block,
index,
default_target,
indexed_targets,
args,
);
2022-11-29 15:22:04 -06:00
if self.reachable {
2021-11-21 19:15:26 -06:00
let args = args.to_vec();
2021-11-13 16:13:31 -06:00
let targets = indexed_targets
.iter()
2021-11-14 00:25:27 -06:00
.map(|&block| {
let args = args.clone();
2021-11-14 00:25:27 -06:00
BlockTarget { block, args }
2021-11-13 16:13:31 -06:00
})
.collect();
2021-11-14 00:25:27 -06:00
let default_args = args;
2021-11-13 16:13:31 -06:00
let default = BlockTarget {
block: default_target,
2021-11-14 00:25:27 -06:00
args: default_args,
2021-11-13 16:13:31 -06:00
};
self.body.set_terminator(
2022-11-29 15:22:04 -06:00
self.cur_block,
2021-12-12 22:11:28 -06:00
Terminator::Select {
value: index,
targets,
default,
},
);
2021-11-13 16:13:31 -06:00
}
2021-11-13 15:49:57 -06:00
}
2021-11-21 19:15:26 -06:00
fn emit_ret(&mut self, values: &[Value]) {
2022-11-29 20:03:33 -06:00
log::trace!(
"emit_ret: cur_block {} reachable {} values {:?}",
self.cur_block,
self.reachable,
values
);
2022-11-29 15:22:04 -06:00
if self.reachable {
2021-11-21 19:15:26 -06:00
let values = values.to_vec();
2022-11-29 15:22:04 -06:00
self.body
.set_terminator(self.cur_block, Terminator::Return { values });
2022-11-29 15:22:04 -06:00
self.reachable = false;
}
}
fn emit_unreachable(&mut self) {
2022-11-29 21:49:22 -06:00
log::trace!(
"emit_unreachable: cur_block {} reachable {}",
self.cur_block,
self.reachable
);
2022-11-29 15:22:04 -06:00
if self.reachable {
self.body
.set_terminator(self.cur_block, Terminator::Unreachable);
2022-11-29 15:22:04 -06:00
self.reachable = false;
2021-11-13 17:09:47 -06:00
}
}
fn push_block_params(&mut self, num_params: usize) {
2021-12-12 00:25:12 -06:00
log::trace!(
"push_block_params: cur_block {:?}, {} params",
self.cur_block,
num_params
);
for i in 0..num_params {
2022-11-29 15:22:04 -06:00
let (ty, value) = self.body.blocks[self.cur_block].params[i];
2021-12-12 00:25:12 -06:00
log::trace!(" -> push {:?} ty {:?}", value, ty);
2021-11-21 19:15:26 -06:00
self.op_stack.push((ty, value));
2021-11-13 15:49:57 -06:00
}
}
2023-02-13 18:17:17 -06:00
fn emit(&mut self, op: Operator, loc: SourceLoc) -> Result<()> {
2022-11-29 15:22:04 -06:00
let inputs = op_inputs(self.module, &self.op_stack[..], &op)?;
2022-11-29 03:44:19 -06:00
let outputs = op_outputs(self.module, &self.op_stack[..], &op)?;
2021-12-12 00:25:12 -06:00
log::trace!(
"emit into block {:?}: op {:?} inputs {:?}",
self.cur_block,
op,
inputs
);
2021-12-12 21:40:35 -06:00
let n_outputs = outputs.len();
2021-11-13 16:13:31 -06:00
2021-12-12 21:40:35 -06:00
let mut input_operands = vec![];
2022-11-03 01:32:23 -05:00
for &input in inputs.into_iter().rev() {
2021-12-12 21:40:35 -06:00
let (stack_top_ty, stack_top) = self.op_stack.pop().unwrap();
assert_eq!(stack_top_ty, input);
input_operands.push(stack_top);
}
input_operands.reverse();
log::trace!(" -> operands: {:?}", input_operands);
2021-12-23 20:23:42 -06:00
log::trace!(" -> ty {:?}", outputs);
2021-11-13 16:13:31 -06:00
2021-12-25 01:02:20 -06:00
let value = self
.body
2022-11-03 01:32:23 -05:00
.add_value(ValueDef::Operator(op, input_operands, outputs.to_vec()));
2021-12-23 20:23:42 -06:00
log::trace!(" -> value: {:?}", value);
2021-12-12 00:25:12 -06:00
2022-11-29 15:22:04 -06:00
if self.reachable {
self.body.append_to_block(self.cur_block, value);
2021-12-12 21:40:35 -06:00
}
2023-02-13 18:17:17 -06:00
self.body.source_locs[value] = loc;
2021-11-13 04:32:05 -06:00
2021-12-12 21:40:35 -06:00
if n_outputs == 1 {
let output_ty = outputs[0];
self.op_stack.push((output_ty, value));
2021-11-13 16:23:22 -06:00
} else {
2022-11-03 01:32:23 -05:00
for (i, &output_ty) in outputs.into_iter().enumerate() {
2021-12-12 21:40:35 -06:00
let pick = self
.body
2022-11-01 04:26:21 -05:00
.add_value(ValueDef::PickOutput(value, i, output_ty));
2022-11-29 15:22:04 -06:00
if self.reachable {
self.body.append_to_block(self.cur_block, pick);
2022-11-09 13:45:47 -06:00
}
2021-12-12 21:40:35 -06:00
self.op_stack.push((output_ty, pick));
log::trace!(" -> pick {}: {:?} ty {:?}", i, pick, output_ty);
2021-11-13 16:23:22 -06:00
}
2021-11-13 03:41:32 -06:00
}
Ok(())
}
2021-11-13 03:17:53 -06:00
}