Add text format and printing support for dylink.0 (#1135)

* Add text format and printing support for `dylink.0`

This is something I threw together which I think might be helpful in
testing and working on #1133. In theory this should also make it easier
to inspect this custom section in preexisting binaries.

I've invented a text format of this out of nowhere as I don't believe
there's a specification or anything else to follow. I've opted to use
the `@dylink.0` annotation format to emphasize that it's a custom
section, in the same manner that `@producers` uses that today.

Note that this additionally copies some of the `wasmparser`-related
parsing code from #1133.

Co-authored-by: Joel Dice <[email protected]>

* Add more bindings for symbol parsing

---------

Co-authored-by: Joel Dice <[email protected]>

Author: alexcrichton

crates/wasmparser/src/readers/core.rs

@@ -2,6 +2,7 @@ mod code;
 mod coredumps;
 mod custom;
 mod data;
+mod dylink0;
 mod elements;
 mod exports;
 mod functions;
@@ -20,6 +21,7 @@ pub use self::code::*;
 pub use self::coredumps::*;
 pub use self::custom::*;
 pub use self::data::*;
+pub use self::dylink0::*;
 pub use self::elements::*;
 pub use self::exports::*;
 pub use self::functions::*;

crates/wasmparser/src/readers/core/dylink0.rs

@@ -0,0 +1,132 @@
+use crate::{BinaryReader, Result, Subsection, Subsections};
+use std::ops::Range;
+
+/// Parser for the dynamic linking `dylink.0` custom section.
+///
+/// This format is currently defined upstream at
+/// <https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md>.
+pub type Dylink0SectionReader<'a> = Subsections<'a, Dylink0Subsection<'a>>;
+
+const WASM_DYLINK_MEM_INFO: u8 = 1;
+const WASM_DYLINK_NEEDED: u8 = 2;
+const WASM_DYLINK_EXPORT_INFO: u8 = 3;
+const WASM_DYLINK_IMPORT_INFO: u8 = 4;
+
+#[allow(missing_docs)]
+pub const WASM_SYM_BINDING_WEAK: u32 = 1 << 0;
+#[allow(missing_docs)]
+pub const WASM_SYM_BINDING_LOCAL: u32 = 1 << 1;
+#[allow(missing_docs)]
+pub const WASM_SYM_VISIBILITY_HIDDEN: u32 = 1 << 2;
+#[allow(missing_docs)]
+pub const WASM_SYM_UNDEFINED: u32 = 1 << 4;
+#[allow(missing_docs)]
+pub const WASM_SYM_EXPORTED: u32 = 1 << 5;
+#[allow(missing_docs)]
+pub const WASM_SYM_EXPLICIT_NAME: u32 = 1 << 6;
+#[allow(missing_docs)]
+pub const WASM_SYM_NO_STRIP: u32 = 1 << 7;
+
+/// Represents a `WASM_DYLINK_MEM_INFO` field
+#[derive(Debug, Copy, Clone)]
+pub struct MemInfo {
+    /// Size of the memory area the loader should reserve for the module, which
+    /// will begin at `env.__memory_base`.
+    pub memory_size: u32,
+
+    /// The required alignment of the memory area, in bytes, encoded as a power
+    /// of 2.
+    pub memory_alignment: u32,
+
+    /// Size of the table area the loader should reserve for the module, which
+    /// will begin at `env.__table_base`.
+    pub table_size: u32,
+
+    /// The required alignment of the table area, in elements, encoded as a
+    /// power of 2.
+    pub table_alignment: u32,
+}
+
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub struct ExportInfo<'a> {
+    pub name: &'a str,
+
+    /// Note that these flags correspond to those described in
+    /// <https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md>
+    /// with the `WASM_SYM_*` prefix.
+    pub flags: u32,
+}
+
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub struct ImportInfo<'a> {
+    pub module: &'a str,
+    pub field: &'a str,
+
+    /// Note that these flags correspond to those described in
+    /// <https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md>
+    /// with the `WASM_SYM_*` prefix.
+    pub flags: u32,
+}
+
+/// Possible subsections of the `dylink.0` custom section.
+#[derive(Debug)]
+#[allow(missing_docs)]
+pub enum Dylink0Subsection<'a> {
+    MemInfo(MemInfo),
+    Needed(Vec<&'a str>),
+    ExportInfo(Vec<ExportInfo<'a>>),
+    ImportInfo(Vec<ImportInfo<'a>>),
+    Unknown {
+        ty: u8,
+        data: &'a [u8],
+        range: Range<usize>,
+    },
+}
+
+impl<'a> Subsection<'a> for Dylink0Subsection<'a> {
+    fn from_reader(id: u8, mut reader: BinaryReader<'a>) -> Result<Self> {
+        let data = reader.remaining_buffer();
+        let offset = reader.original_position();
+        Ok(match id {
+            WASM_DYLINK_MEM_INFO => Self::MemInfo(MemInfo {
+                memory_size: reader.read_var_u32()?,
+                memory_alignment: reader.read_var_u32()?,
+                table_size: reader.read_var_u32()?,
+                table_alignment: reader.read_var_u32()?,
+            }),
+            WASM_DYLINK_NEEDED => Self::Needed(
+                (0..reader.read_var_u32()?)
+                    .map(|_| reader.read_string())
+                    .collect::<Result<_, _>>()?,
+            ),
+            WASM_DYLINK_EXPORT_INFO => Self::ExportInfo(
+                (0..reader.read_var_u32()?)
+                    .map(|_| {
+                        Ok(ExportInfo {
+                            name: reader.read_string()?,
+                            flags: reader.read_var_u32()?,
+                        })
+                    })
+                    .collect::<Result<_, _>>()?,
+            ),
+            WASM_DYLINK_IMPORT_INFO => Self::ImportInfo(
+                (0..reader.read_var_u32()?)
+                    .map(|_| {
+                        Ok(ImportInfo {
+                            module: reader.read_string()?,
+                            field: reader.read_string()?,
+                            flags: reader.read_var_u32()?,
+                        })
+                    })
+                    .collect::<Result<_, _>>()?,
+            ),
+            ty => Self::Unknown {
+                ty,
+                data,
+                range: offset..offset + data.len(),
+            },
+        })
+    }
+}

crates/wasmprinter/src/lib.rs

@@ -2555,6 +2555,13 @@ impl Printer {
                     section.data_offset(),
                 )?)
             }
+            "dylink.0" => {
+                self.newline(section.range().start);
+                self.print_dylink0_section(Dylink0SectionReader::new(
+                    section.data(),
+                    section.data_offset(),
+                ))
+            }
             _ => Ok(()),
         }
     }
@@ -2577,6 +2584,97 @@ impl Printer {
         self.end_group();
         Ok(())
     }
+
+    fn print_dylink0_section(&mut self, mut section: Dylink0SectionReader<'_>) -> Result<()> {
+        self.start_group("@dylink.0");
+        loop {
+            let start = section.original_position();
+            let next = match section.next() {
+                Some(Ok(next)) => next,
+                Some(Err(e)) => return Err(e.into()),
+                None => break,
+            };
+            match next {
+                Dylink0Subsection::MemInfo(info) => {
+                    self.newline(start);
+                    self.start_group("mem-info");
+                    if info.memory_size > 0 || info.memory_alignment > 0 {
+                        write!(
+                            self.result,
+                            " (memory {} {})",
+                            info.memory_size, info.memory_alignment
+                        )?;
+                    }
+                    if info.table_size > 0 || info.table_alignment > 0 {
+                        write!(
+                            self.result,
+                            " (table {} {})",
+                            info.table_size, info.table_alignment
+                        )?;
+                    }
+                    self.end_group();
+                }
+                Dylink0Subsection::Needed(needed) => {
+                    self.newline(start);
+                    self.start_group("needed");
+                    for s in needed {
+                        self.result.push_str(" ");
+                        self.print_str(s)?;
+                    }
+                    self.end_group();
+                }
+                Dylink0Subsection::ExportInfo(info) => {
+                    for info in info {
+                        self.newline(start);
+                        self.start_group("export-info ");
+                        self.print_str(info.name)?;
+                        self.print_dylink0_flags(info.flags)?;
+                        self.end_group();
+                    }
+                }
+                Dylink0Subsection::ImportInfo(info) => {
+                    for info in info {
+                        self.newline(start);
+                        self.start_group("import-info ");
+                        self.print_str(info.module)?;
+                        self.result.push_str(" ");
+                        self.print_str(info.field)?;
+                        self.print_dylink0_flags(info.flags)?;
+                        self.end_group();
+                    }
+                }
+                Dylink0Subsection::Unknown { ty, .. } => {
+                    bail!("don't know how to print dylink.0 subsection id {ty}");
+                }
+            }
+        }
+        self.end_group();
+        Ok(())
+    }
+
+    fn print_dylink0_flags(&mut self, mut flags: u32) -> Result<()> {
+        macro_rules! print_flag {
+            ($($name:ident = $text:tt)*) => ({$(
+                if flags & wasmparser::$name != 0 {
+                    flags &= !wasmparser::$name;
+                    self.result.push_str(concat!(" ", $text));
+                }
+            )*})
+        }
+        print_flag! {
+            WASM_SYM_BINDING_WEAK = "binding-weak"
+            WASM_SYM_BINDING_LOCAL = "binding-local"
+            WASM_SYM_VISIBILITY_HIDDEN = "visibility-hidden"
+            WASM_SYM_UNDEFINED = "undefined"
+            WASM_SYM_EXPORTED = "exported"
+            WASM_SYM_EXPLICIT_NAME = "explicit-name"
+            WASM_SYM_NO_STRIP = "no-strip"
+        }
+        if flags != 0 {
+            write!(self.result, " {:#x}", flags)?;
+        }
+        Ok(())
+    }
 }
 
 struct NamedLocalPrinter {

crates/wast/src/core/binary.rs

@@ -1062,6 +1062,7 @@ impl Encode for Custom<'_> {
         match self {
             Custom::Raw(r) => r.encode(e),
             Custom::Producers(p) => p.encode(e),
+            Custom::Dylink0(p) => p.encode(e),
         }
     }
 }
@@ -1080,6 +1081,38 @@ impl Encode for Producers<'_> {
     }
 }
 
+impl Encode for Dylink0<'_> {
+    fn encode(&self, e: &mut Vec<u8>) {
+        for section in self.subsections.iter() {
+            e.push(section.id());
+            let mut tmp = Vec::new();
+            section.encode(&mut tmp);
+            tmp.encode(e);
+        }
+    }
+}
+
+impl Encode for Dylink0Subsection<'_> {
+    fn encode(&self, e: &mut Vec<u8>) {
+        match self {
+            Dylink0Subsection::MemInfo {
+                memory_size,
+                memory_align,
+                table_size,
+                table_align,
+            } => {
+                memory_size.encode(e);
+                memory_align.encode(e);
+                table_size.encode(e);
+                table_align.encode(e);
+            }
+            Dylink0Subsection::Needed(libs) => libs.encode(e),
+            Dylink0Subsection::ExportInfo(list) => list.encode(e),
+            Dylink0Subsection::ImportInfo(list) => list.encode(e),
+        }
+    }
+}
+
 impl Encode for Tag<'_> {
     fn encode(&self, e: &mut Vec<u8>) {
         self.ty.encode(e);