couchemar/wa_parser - Change HSU2JRJRNTEP3LCTMNECDEUGYMGB7JVTL55GISKYNY6KTWDDC42AC

Int comparison instructions

Created by couchemar on February 9, 2022

HSU2JRJRNTEP3LCTMNECDEUGYMGB7JVTL55GISKYNY6KTWDDC42AC

Dependencies

In channels

main

Change contents

File addition: 4_int_comp.c (----------)

[3.12]

int eq(int a, int b) {
    return a == b;
}
int ne(int a, int b) {
    return a != b;
}
int lt(int a, int b) {
    return a < b;
}
int gt(int a, int b) {
    return a > b;
}
int le(int a, int b) {
    return a <= b;
}
int ge(int a, int b) {
    return a >= b;
}

Replacement in test_data/3_int_cond.c at line 1 [2.58]
B:BD[2.58] → [2.59:82]
```
int ge(int a, int b) {
```
[2.58]
[2.82]
```
int ge_select(int a, int b) {
```

Replacement in test/wa_parser_test.exs at line 170 [5.21]

B:BD[4.845] → [2.305:342]

                  {"ge", {:func, 0}}

[4.845]

[4.889]

                  {"ge_select", {:func, 0}}

Replacement in test/wa_parser_test.exs at line 193 [5.21]

∅:D[6.1350] → [7.81:149]

∅:D[4.2453] → [7.81:149]

B:BD[7.81] → [7.81:149]

  test "9_all" do
    assert parse_file("test_data/9_all.opt.wasm")

[4.2453]

[7.149]

  test "4_int_comp" do
    assert parse_file("test_data/4_int_comp.opt.wasm")

Insertion in test/wa_parser_test.exs at line 198 [5.21]

[7.291]

[6.1351]

               {:section_body, [{[:i32, :i32], [:i32]}]},
               {:section_type, :function},
               {:section_body, [0, 0, 0, 0, 0, 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},

Replacement in test/wa_parser_test.exs at line 209 [5.21]

B:BD[6.1400] → [6.1400:1436]

B:BD[6.1436] → [2.607:680]

                  {[:i32], [:i32]},
                  {[], [:i32]},
                  {[:i32, :i32], [:i32]}

[6.1400]

[6.1467]

                  {"memory", {:mem, 0}},
                  {"__heap_base", {:global, 0}},
                  {"__data_end", {:global, 1}},
                  {"eq", {:func, 0}},
                  {"ne", {:func, 1}},
                  {"lt", {:func, 2}},
                  {"gt", {:func, 3}},
                  {"le", {:func, 4}},
                  {"ge", {:func, 5}}

Insertion in test/wa_parser_test.exs at line 219 [5.21]

[6.1487]

[7.357]

               {:section_type, :code},
               {:section_body,
                [
                  %{
                    code: %{
                      expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.eq"],
                      locals: []
                    },
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.ne"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.lt_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.gt_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.le_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.ge_s"], locals: []},
                    size: 7
                  }
                ]}
             ]
  end
  test "9_all" do
    assert parse_file("test_data/9_all.opt.wasm")
           |> Enum.filter(fn {k, _} -> k == :section_type or k == :section_body end) ==
             [
               {:section_type, :type},
               {:section_body, [{[:i32, :i32], [:i32]}, {[:i32], [:i32]}, {[], [:i32]}]},

Replacement in test/wa_parser_test.exs at line 260 [5.21]

B:BD[7.400] → [2.681:736]

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

[7.400]

[7.440]

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

Replacement in test/wa_parser_test.exs at line 278 [5.21]

B:BD[4.2551] → [2.737:774]

                  {"ge", {:func, 6}}

[4.2551]

[7.1010]

                  {"ge_select", {:func, 6}},
                  {"eq", {:func, 7}},
                  {"ne", {:func, 8}},
                  {"lt", {:func, 9}},
                  {"gt", {:func, 10}},
                  {"le", {:func, 11}},
                  {"ge", {:func, 12}}

Insertion in test/wa_parser_test.exs at line 348 [5.21]

[2.1038]

[6.2000]

                  },
                  %{
                    code: %{
                      expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.eq"],
                      locals: []
                    },
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.ne"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.lt_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.gt_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.le_s"], locals: []},
                    size: 7
                  },
                  %{
                    code: %{expr: [{:"local.get", 0}, {:"local.get", 1}, :"i32.ge_s"], locals: []},
                    size: 7

Insertion in lib/wa_parser.ex at line 241 [9.693]
[4.5068]
[8.167]
```
  defp plain_numeric_instr(0x46), do: :"i32.eq"
```

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

[2.1228]

[8.215]

  defp plain_numeric_instr(0x4A), do: :"i32.gt_s"
  defp plain_numeric_instr(0x4C), do: :"i32.le_s"