wasm-tools 1.247.0

CLI tools for interoperating with WebAssembly files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use anyhow::Result;
use clap::Parser;

/// Print the textual form of a WebAssembly binary.
#[derive(Parser)]
#[clap(after_help = "\
Examples:

    # Print the textual form of `foo.wasm` to stdout.
    $ wasm-tools print foo.wasm
(module
  (type (;0;) (func (param i32 i32) (result i32)))
  (func $add (;0;) (type 0) (param $lhs i32) (param $rhs i32) (result i32)
    local.get $lhs
    local.get $rhs
    i32.add
 )

    # Print a \"skeleton\" form of `foo.wasm` to stdout.
    $ wasm-tools print foo.wasm --skeleton
(module
  (type (;0;) (func (param i32 i32) (result i32)))
  (func $add (;0;) (type 0) (param $lhs i32) (param $rhs i32) (result i32) ...)

    # Print the textual form of `foo.wasm` to stdout, with folded instructions,
    # binary offsets, and indented 6 spaces.
    $ wasm-tools print foo.wasm -p -f --indent 6
(module
(;@b     ;)      (type (;0;) (func (param i32 i32) (result i32)))
(;@37    ;)      (func $add (;0;) (type 0) (param $lhs i32) (param $rhs i32) (result i32)
(;@3c    ;)            (i32.add
(;@38    ;)                  (local.get $lhs)
(;@3a    ;)                  (local.get $rhs))
                 )

    # Print the textual form of `foo.wasm` to stdout, with synthesized names for
    # items without a name in the `name` section. (Notice below that the type
    # denoted by ;0; in the previous examples has been given a name.)
    $ wasm-tools print foo.wasm --name-unnamed
(module
  (type $#type0 (;0;) (func (param i32 i32) (result i32)))
  (func $add (;0;) (type $#type0) (param $lhs i32) (param $rhs i32) (result i32)
...

    # Print the textual form of `foo.wasm` to the file `foo.wat`.
    $ wasm-tools print foo.wasm -o foo.wat

Exit status:
    0 on success,
    nonzero if the input file fails to parse.
")]
pub struct Opts {
    #[clap(flatten)]
    generate_dwarf: wasm_tools::GenerateDwarfArg,

    #[clap(flatten)]
    io: wasm_tools::InputOutput,

    /// Whether or not to print binary offsets intermingled in the text format
    /// as comments for debugging.
    #[clap(short, long)]
    print_offsets: bool,

    /// Indicates that the "skeleton" of a module should be printed.
    ///
    /// Items such as function bodies, data segments, and element segments are
    /// replaced with "..." instead of printing their actual contents.
    #[clap(long)]
    skeleton: bool,

    /// Ensure all wasm items have `$`-based names, even if they don't have an
    /// entry in the `name` section.
    ///
    /// This option, when enabled, will synthesize names for any item which
    /// doesn't previously have a name.
    #[clap(long)]
    name_unnamed: bool,

    /// Print instructions in the folded format.
    /// (See https://webassembly.github.io/spec/core/text/instructions.html#folded-instructions)
    #[clap(short, long)]
    fold_instructions: bool,

    /// Print the contents of the operand stack within function bodies
    #[clap(long)]
    print_operand_stack: bool,

    /// The string to use when indenting.
    #[clap(long)]
    indent_text: Option<String>,
    /// Number of spaces used for indentation, has lower priority than `--indent-text`
    #[clap(long)]
    indent: Option<usize>,
}

impl Opts {
    pub fn general_opts(&self) -> &wasm_tools::GeneralOpts {
        self.io.general_opts()
    }

    pub fn run(&self) -> Result<()> {
        let wasm = self.io.get_input_wasm(Some(&self.generate_dwarf))?;

        let mut config = wasmprinter::Config::new();
        config.print_offsets(self.print_offsets);
        config.print_skeleton(self.skeleton);
        config.name_unnamed(self.name_unnamed);
        config.fold_instructions(self.fold_instructions);
        config.print_operand_stack(self.print_operand_stack);
        match self.indent_text.as_ref() {
            Some(s) => {
                config.indent_text(s);
            }
            None => {
                if let Some(s) = self.indent {
                    config.indent_text(&" ".repeat(s));
                }
            }
        }
        self.io.output(wasm_tools::Output::Wat {
            wasm: &wasm,
            config,
        })
    }
}