wasmtime / issue #5537 Reimplement Wasmtime's DWARF trans... · git-wasmtime

@philipc regarding line tables, I still think that, from a user perspective, the desired interface is handing an impl Fn(Pc) -> Pc function (or visitor or whatever) to a generic line-tables rewriting function. Perhaps, as you point out, that cannot be implemented in a single pass, and might require materializing some intermediate representation that then needs to be re-sorted or whatever before emitting the actual encoded tables. I think that is fine.

Below is a sketch of what this might look like, but I'm sure I'm overlooking or missing something -- it's been a while since I was deep in DWARF stuff!

pub trait LineProgramRewriter {
    type Error: From<gimli::read::Result>;

    /// Rewrite a PC address in the line program.
    ///
    /// By default, it is unmodified.
    fn address(&mut self, address: u64) -> Result<u64, Self::Error> {
        Ok(address)
    }

    /// Rewrite a directory in the line program.
    ///
    /// By default, it is unmodified.
    fn directory(
        &mut self,
        dir: gimli::read::LineString,
    ) -> Result<gimli::read::LineString, Self::Error> {
        Ok(dir)
    }

    /// Rewrite a source line number in the line program.
    ///
    /// By default, it is unmodified.
    fn line(&mut self, line: u64) -> Result<u64, Self::Error> {
        Ok(line)
    }

    // Etc...
}

pub fn rewrite_line_program<Reader, Offset, Rewriter>(
    input: gimli::read::IncompleteLineProgram<Reader, Offset>,
    rewriter: &mut Rewriter,
) -> Result<gimli::write::LineProgram, Rewriter::Error>
where
    Rewriter: LineProgramRewriter,
{
    let mut rewritten_rows = vec![];

    let (program, sequences) = input.sequences()?;
    for seq in sequences {
        let mut rows = program.resume_from(seq);
        while let Some(row) = rows.next_row()? {
            // Apply each method of the `rewriter` to each part of the row.
            let new_row = rewrite_one_row(row, rewriter)?;
            rewritten_rows.push(new_row);
        }
    }

    // Sort the rows such that they are in an order that we can correctly
    // encode.
    rewritten_rows.sort();

    // Encode the rewritten rows into a new line program.
    let mut program = gimli::write::LineProgram::new(...);
    for row in rewritten_rows {
        // Encode each row, decide whether to start a new sequence or continue
        // the existing sequence, etc...
    }

    Ok(program)
}

I think the biggest difference from what you laid out in "this is how I would have expected this work" is that I want to factor out the wasmtime-specific bits around the DWARF<sub>Wasm</sub>-to-DWARF<sub>native</sub> mapping from the generic, possibly-generally-useful bits of "I have some kind of new mapping, and I want to apply it to this input DWARF to get a new rewritten DWARF".

The other thing is that, again as you mentioned, line tables are only one piece, and we would want to do this for every single section.

Stream: git-wasmtime

Topic: wasmtime / issue #5537 Reimplement Wasmtime's DWARF trans...

Wasmtime GitHub notifications bot (Jan 05 2023 at 23:29):

Testing

Wasmtime GitHub notifications bot (Jan 05 2023 at 23:29):

Testing

Wasmtime GitHub notifications bot (Jan 17 2023 at 19:39):

Wasmtime GitHub notifications bot (Jul 21 2024 at 05:50):

Wasmtime GitHub notifications bot (Jul 22 2024 at 15:21):

Wasmtime GitHub notifications bot (Jul 22 2024 at 19:43):

Wasmtime GitHub notifications bot (Jul 23 2024 at 00:31):

Wasmtime GitHub notifications bot (Jul 23 2024 at 16:55):

Wasmtime GitHub notifications bot (Jul 23 2024 at 16:57):

Wasmtime GitHub notifications bot (Jul 23 2024 at 16:57):

Wasmtime GitHub notifications bot (Jul 27 2024 at 04:53):

Wasmtime GitHub notifications bot (Jul 27 2024 at 16:22):

Wasmtime GitHub notifications bot (Aug 15 2024 at 09:42):

Wasmtime GitHub notifications bot (Nov 08 2024 at 01:37):