couchemar/wa_parser - Change 3RX7PY4U2WNHO6H77BQHLGGZTA7NDPGEHRRBRAB5SNLNAUDBIA6QC

Parse factorial

Created by couchemar on October 16, 2021

3RX7PY4U2WNHO6H77BQHLGGZTA7NDPGEHRRBRAB5SNLNAUDBIA6QC

Dependencies

In channels

main

Change contents

Insertion in test/wa_parser_test.exs at line 151 [7.21]

[5.1350]

[6.81]

  test "3_int_factorial" do
    assert parse_file("test_data/3_int_factorial.opt.wasm")
           |> Enum.filter(fn {k, _} -> k == :section_type or k == :section_body end) ==
             [
               {:section_type, :type},
               {:section_body, [{[:i32], [:i32]}]},
               {:section_type, :function},
               {:section_body, [0]},
               {:section_type, :memory},
               {:section_body, [{2, nil}]},
               {:section_type, :global},
               {:section_body,
                [{{:i32, :const}, ["i32.const": 66560]}, {{:i32, :const}, ["i32.const": 1024]}]},
               {:section_type, :export},
               {:section_body,
                [
                  {"memory", {:mem, 0}},
                  {"__heap_base", {:global, 0}},
                  {"__data_end", {:global, 1}},
                  {"factorial", {:func, 0}}
                ]},
               {:section_type, :code},
               {:section_body,
                [
                  %{
                    code: %{
                      expr: [
                        {:"i32.const", 1},
                        {:"local.set", 1},
                        {:"local.get", 0},
                        {:"i32.const", 1},
                        :"i32.ge_s",
                        {:if,
                         %{
                           blocktype: :empty,
                           instr: [
                             loop: %{
                               blocktype: :empty,
                               instr: [
                                 {:"local.get", 2},
                                 {:"i32.const", 1},
                                 :"i32.add",
                                 {:"local.tee", 2},
                                 {:"local.get", 1},
                                 :"i32.mul",
                                 {:"local.set", 1},
                                 {:"local.get", 0},
                                 {:"local.get", 2},
                                 :"i32.ne",
                                 {:br_if, 0}
                               ]
                             }
                           ]
                         }},
                        {:"local.get", 1}
                      ],
                      locals: [%{num: 2, type: :i32}]
                    },
                    size: 40
                  }
                ]}
             ]
  end

Replacement in test/wa_parser_test.exs at line 226 [7.21]

B:BD[6.400] → [8.1318:1370]

               {:section_body, [1, 0, 0, 0, 0, 0]},

[6.400]

[6.440]

               {:section_body, [1, 0, 0, 0, 0, 0, 0]},

Replacement in test/wa_parser_test.exs at line 243 [7.21]

B:BD[8.1488] → [8.1488:1528]

                  {"third", {:func, 5}}

[8.1488]

[6.1010]

                  {"third", {:func, 5}},
                  {"factorial", {:func, 6}}

Insertion in test/wa_parser_test.exs at line 294 [7.21]

[5.2000]

                  },
                  %{
                    code: %{
                      expr: [
                        {:"i32.const", 1},
                        {:"local.set", 1},
                        {:"local.get", 0},
                        {:"i32.const", 1},
                        :"i32.ge_s",
                        {:if,
                         %{
                           blocktype: :empty,
                           instr: [
                             loop: %{
                               blocktype: :empty,
                               instr: [
                                 {:"local.get", 2},
                                 {:"i32.const", 1},
                                 :"i32.add",
                                 {:"local.tee", 2},
                                 {:"local.get", 1},
                                 :"i32.mul",
                                 {:"local.set", 1},
                                 {:"local.get", 0},
                                 {:"local.get", 2},
                                 :"i32.ne",
                                 {:br_if, 0}
                               ]
                             }
                           ]
                         }},
                        {:"local.get", 1}
                      ],
                      locals: [%{num: 2, type: :i32}]
                    },
                    size: 40

Replacement in lib/wa_parser.ex at line 123 [9.693]

B:BD[2.360] → [2.360:394]

  defp locals(:TODO) do
    :TODO

[2.360]

[2.394]

  defp locals(binary) do
    {num, rest} = Atomic.u32(binary)
    {type, rest} = valtype(rest)
    {%{num: num, type: type}, rest}

Insertion in lib/wa_parser.ex at line 181 [9.693]

[10.478]

  end
  defp expr(<<0x03, rest::binary>>, acc) do
    {bt, rest} = blocktype(rest)
    {exprs, rest} = expr(rest)
    expr(rest, [
      {:loop, %{blocktype: bt, instr: exprs}} | acc
    ])

Insertion in lib/wa_parser.ex at line 192 [9.693]

[10.485]

  defp expr(<<0x04, rest::binary>>, acc) do
    {bt, rest} = blocktype(rest)
    {exprs, rest} = expr(rest)
    expr(rest, [
      {:if, %{blocktype: bt, instr: exprs}}
      | acc
    ])
  end

Insertion in lib/wa_parser.ex at line 206 [9.693]

[10.570]

[11.1448]

  defp expr(<<0x0D, rest::binary>>, acc) do
    {l, rest} = labelidx(rest)
    expr(rest, [{:br_if, l} | acc])
  end

Insertion in lib/wa_parser.ex at line 214 [9.693]

[11.1569]

  end
  defp expr(<<0x21, rest::binary>>, acc) do
    {idx, rest} = localidx(rest)
    expr(rest, [{:"local.set", idx} | acc])

Insertion in lib/wa_parser.ex at line 221 [9.693]

[11.1576]

[10.570]

  defp expr(<<0x22, rest::binary>>, acc) do
    {idx, rest} = localidx(rest)
    expr(rest, [{:"local.tee", idx} | acc])
  end

Insertion in lib/wa_parser.ex at line 231 [9.693]

[5.2028]

[4.0]

  defp expr(<<0x47, rest::binary>>, acc), do: expr(rest, [:"i32.ne" | acc])
  defp expr(<<0x4E, rest::binary>>, acc), do: expr(rest, [:"i32.ge_s" | acc])

Insertion in lib/wa_parser.ex at line 237 [9.693]

[4.310]

[8.2531]


  defp blocktype(<<0x40, rest::binary>>), do: {:empty, rest}

Deletion in lib/wa_parser.ex at line 296 [9.693]
B:BD[10.765] → [10.765:766]
B:BD[12.476] → [13.1251:1277]
B:BD[13.1277] → [14.259:282]
∅:D[14.282] → [15.1977:1984]
∅:D[12.516] → [15.1977:1984]
∅:D[13.1293] → [15.1977:1984]
B:BD[15.1977] → [15.1977:1984]
B:BD[15.1984] → [16.703:757]
```
  defp typeidx(binary) do
    Atomic.u32(binary)
  end
  defp memidx(binary) do
    Atomic.u32(binary)
  end
```

Replacement in lib/wa_parser.ex at line 297 [9.693]

B:BD[16.758] → [16.758:872]

B:BD[16.872] → [11.1577:1633]

  defp globalidx(binary) do
    Atomic.u32(binary)
  end
  defp funcidx(binary) do
    Atomic.u32(binary)
  end
  defp localidx(binary) do
    Atomic.u32(binary)
  end

[16.758]

[9.894]

  defp funcidx(binary), do: Atomic.u32(binary)
  defp globalidx(binary), do: Atomic.u32(binary)
  defp labelidx(binary), do: Atomic.u32(binary)
  defp localidx(binary), do: Atomic.u32(binary)
  defp memidx(binary), do: Atomic.u32(binary)
  defp typeidx(binary), do: Atomic.u32(binary)