Revision control
Copy as Markdown
Other Tools
use crate::parser::{Parse, Parser, Result};
use crate::token::{self, Span};
use crate::{annotation, kw};
/// A custom section within a wasm module.
#[derive(Debug)]
pub enum Custom<'a> {
/// A raw custom section with the manual placement and bytes specified.
Raw(RawCustomSection<'a>),
/// A producers custom section.
Producers(Producers<'a>),
/// The `dylink.0` custom section
Dylink0(Dylink0<'a>),
}
impl Custom<'_> {
/// Where this custom section is placed.
pub fn place(&self) -> CustomPlace {
match self {
Custom::Raw(s) => s.place,
Custom::Producers(_) => CustomPlace::AfterLast,
Custom::Dylink0(_) => CustomPlace::BeforeFirst,
}
}
/// The name of this custom section
pub fn name(&self) -> &str {
match self {
Custom::Raw(s) => s.name,
Custom::Producers(_) => "producers",
Custom::Dylink0(_) => "dylink.0",
}
}
}
impl<'a> Parse<'a> for Custom<'a> {
fn parse(parser: Parser<'a>) -> Result<Self> {
if parser.peek::<annotation::producers>()? {
Ok(Custom::Producers(parser.parse()?))
} else if parser.peek::<annotation::dylink_0>()? {
Ok(Custom::Dylink0(parser.parse()?))
} else {
Ok(Custom::Raw(parser.parse()?))
}
}
}
/// A wasm custom section within a module.
#[derive(Debug)]
pub struct RawCustomSection<'a> {
/// Where this `@custom` was defined.
pub span: Span,
/// Name of the custom section.
pub name: &'a str,
/// Where the custom section is being placed,
pub place: CustomPlace,
/// Payload of this custom section.
pub data: Vec<&'a [u8]>,
}
/// Possible locations to place a custom section within a module.
#[derive(Debug, PartialEq, Copy, Clone)]
pub enum CustomPlace {
/// This custom section will appear before the first section in the module.
BeforeFirst,
/// This custom section will be placed just before a known section.
Before(CustomPlaceAnchor),
/// This custom section will be placed just after a known section.
After(CustomPlaceAnchor),
/// This custom section will appear after the last section in the module.
AfterLast,
}
/// Known sections that custom sections can be placed relative to.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[allow(missing_docs)]
pub enum CustomPlaceAnchor {
Type,
Import,
Func,
Table,
Memory,
Global,
Export,
Start,
Elem,
Code,
Data,
Tag,
}
impl<'a> Parse<'a> for RawCustomSection<'a> {
fn parse(parser: Parser<'a>) -> Result<Self> {
let span = parser.parse::<annotation::custom>()?.0;
let name = parser.parse()?;
let place = if parser.peek::<token::LParen>()? {
parser.parens(|p| p.parse())?
} else {
CustomPlace::AfterLast
};
let mut data = Vec::new();
while !parser.is_empty() {
data.push(parser.parse()?);
}
Ok(RawCustomSection {
span,
name,
place,
data,
})
}
}
impl<'a> Parse<'a> for CustomPlace {
fn parse(parser: Parser<'a>) -> Result<Self> {
let mut l = parser.lookahead1();
let ctor = if l.peek::<kw::before>()? {
parser.parse::<kw::before>()?;
if l.peek::<kw::first>()? {
parser.parse::<kw::first>()?;
return Ok(CustomPlace::BeforeFirst);
}
CustomPlace::Before as fn(CustomPlaceAnchor) -> _
} else if l.peek::<kw::after>()? {
parser.parse::<kw::after>()?;
if l.peek::<kw::last>()? {
parser.parse::<kw::last>()?;
return Ok(CustomPlace::AfterLast);
}
CustomPlace::After
} else {
return Err(l.error());
};
Ok(ctor(parser.parse()?))
}
}
impl<'a> Parse<'a> for CustomPlaceAnchor {
fn parse(parser: Parser<'a>) -> Result<Self> {
if parser.peek::<kw::r#type>()? {
parser.parse::<kw::r#type>()?;
return Ok(CustomPlaceAnchor::Type);
}
if parser.peek::<kw::import>()? {
parser.parse::<kw::import>()?;
return Ok(CustomPlaceAnchor::Import);
}
if parser.peek::<kw::func>()? {
parser.parse::<kw::func>()?;
return Ok(CustomPlaceAnchor::Func);
}
if parser.peek::<kw::table>()? {
parser.parse::<kw::table>()?;
return Ok(CustomPlaceAnchor::Table);
}
if parser.peek::<kw::memory>()? {
parser.parse::<kw::memory>()?;
return Ok(CustomPlaceAnchor::Memory);
}
if parser.peek::<kw::global>()? {
parser.parse::<kw::global>()?;
return Ok(CustomPlaceAnchor::Global);
}
if parser.peek::<kw::export>()? {
parser.parse::<kw::export>()?;
return Ok(CustomPlaceAnchor::Export);
}
if parser.peek::<kw::start>()? {
parser.parse::<kw::start>()?;
return Ok(CustomPlaceAnchor::Start);
}
if parser.peek::<kw::elem>()? {
parser.parse::<kw::elem>()?;
return Ok(CustomPlaceAnchor::Elem);
}
if parser.peek::<kw::code>()? {
parser.parse::<kw::code>()?;
return Ok(CustomPlaceAnchor::Code);
}
if parser.peek::<kw::data>()? {
parser.parse::<kw::data>()?;
return Ok(CustomPlaceAnchor::Data);
}
if parser.peek::<kw::tag>()? {
parser.parse::<kw::tag>()?;
return Ok(CustomPlaceAnchor::Tag);
}
Err(parser.error("expected a valid section name"))
}
}
/// A producers custom section
#[allow(missing_docs)]
#[derive(Debug)]
pub struct Producers<'a> {
pub fields: Vec<(&'a str, Vec<(&'a str, &'a str)>)>,
}
impl<'a> Parse<'a> for Producers<'a> {
fn parse(parser: Parser<'a>) -> Result<Self> {
parser.parse::<annotation::producers>()?.0;
let mut languages = Vec::new();
let mut sdks = Vec::new();
let mut processed_by = Vec::new();
while !parser.is_empty() {
parser.parens(|parser| {
let mut l = parser.lookahead1();
let dst = if l.peek::<kw::language>()? {
parser.parse::<kw::language>()?;
&mut languages
} else if l.peek::<kw::sdk>()? {
parser.parse::<kw::sdk>()?;
&mut sdks
} else if l.peek::<kw::processed_by>()? {
parser.parse::<kw::processed_by>()?;
&mut processed_by
} else {
return Err(l.error());
};
dst.push((parser.parse()?, parser.parse()?));
Ok(())
})?;
}
let mut fields = Vec::new();
if !languages.is_empty() {
fields.push(("language", languages));
}
if !sdks.is_empty() {
fields.push(("sdk", sdks));
}
if !processed_by.is_empty() {
fields.push(("processed-by", processed_by));
}
Ok(Producers { fields })
}
}
/// A `dylink.0` custom section
#[allow(missing_docs)]
#[derive(Debug)]
pub struct Dylink0<'a> {
pub subsections: Vec<Dylink0Subsection<'a>>,
}
/// Possible subsections of the `dylink.0` custom section
#[derive(Debug)]
#[allow(missing_docs)]
pub enum Dylink0Subsection<'a> {
MemInfo {
memory_size: u32,
memory_align: u32,
table_size: u32,
table_align: u32,
},
Needed(Vec<&'a str>),
ExportInfo(Vec<(&'a str, u32)>),
ImportInfo(Vec<(&'a str, &'a str, u32)>),
}
impl<'a> Parse<'a> for Dylink0<'a> {
fn parse(parser: Parser<'a>) -> Result<Self> {
parser.parse::<annotation::dylink_0>()?.0;
let mut ret = Dylink0 {
subsections: Vec::new(),
};
while !parser.is_empty() {
parser.parens(|p| ret.parse_next(p))?;
}
Ok(ret)
}
}
impl<'a> Dylink0<'a> {
fn parse_next(&mut self, parser: Parser<'a>) -> Result<()> {
let mut l = parser.lookahead1();
if l.peek::<kw::mem_info>()? {
parser.parse::<kw::mem_info>()?;
let mut memory_size = 0;
let mut memory_align = 0;
let mut table_size = 0;
let mut table_align = 0;
if parser.peek2::<kw::memory>()? {
parser.parens(|p| {
p.parse::<kw::memory>()?;
memory_size = p.parse()?;
memory_align = p.parse()?;
Ok(())
})?;
}
if parser.peek2::<kw::table>()? {
parser.parens(|p| {
p.parse::<kw::table>()?;
table_size = p.parse()?;
table_align = p.parse()?;
Ok(())
})?;
}
self.subsections.push(Dylink0Subsection::MemInfo {
memory_size,
memory_align,
table_size,
table_align,
});
} else if l.peek::<kw::needed>()? {
parser.parse::<kw::needed>()?;
let mut names = Vec::new();
while !parser.is_empty() {
names.push(parser.parse()?);
}
self.subsections.push(Dylink0Subsection::Needed(names));
} else if l.peek::<kw::export_info>()? {
parser.parse::<kw::export_info>()?;
let name = parser.parse()?;
let flags = parse_sym_flags(parser)?;
match self.subsections.last_mut() {
Some(Dylink0Subsection::ExportInfo(list)) => list.push((name, flags)),
_ => self
.subsections
.push(Dylink0Subsection::ExportInfo(vec![(name, flags)])),
}
} else if l.peek::<kw::import_info>()? {
parser.parse::<kw::import_info>()?;
let module = parser.parse()?;
let name = parser.parse()?;
let flags = parse_sym_flags(parser)?;
match self.subsections.last_mut() {
Some(Dylink0Subsection::ImportInfo(list)) => list.push((module, name, flags)),
_ => self
.subsections
.push(Dylink0Subsection::ImportInfo(vec![(module, name, flags)])),
}
} else {
return Err(l.error());
}
Ok(())
}
}
fn parse_sym_flags(parser: Parser<'_>) -> Result<u32> {
let mut flags = 0;
while !parser.is_empty() {
let mut l = parser.lookahead1();
if l.peek::<u32>()? {
flags |= parser.parse::<u32>()?;
continue;
}
macro_rules! parse_flags {
($($kw:tt = $val:expr,)*) => {$({
custom_keyword!(flag = $kw);
if l.peek::<flag>()? {
parser.parse::<flag>()?;
flags |= $val;
continue;
}
})*};
}
// N.B.: Keep in sync with `print_dylink0_flags` in `crates/wasmprinter/src/lib.rs`.
parse_flags! {
"binding-weak" = 1 << 0,
"binding-local" = 1 << 1,
"visibility-hidden" = 1 << 2,
"undefined" = 1 << 4,
"exported" = 1 << 5,
"explicit-name" = 1 << 6,
"no-strip" = 1 << 7,
"tls" = 1 << 8,
"absolute" = 1 << 9,
}
return Err(l.error());
}
Ok(flags)
}
mod flag {}
impl Dylink0Subsection<'_> {
/// Returns the byte id of this subsection used to identify it.
pub fn id(&self) -> u8 {
use Dylink0Subsection::*;
match self {
MemInfo { .. } => 1,
Needed(..) => 2,
ExportInfo(..) => 3,
ImportInfo(..) => 4,
}
}
}