initial call_indirect support in ttf mode

3 files changed, 916 insertions, 1009 deletions

diff --git a/src/passes/RemoveUnusedModuleElements.cpp b/src/passes/RemoveUnusedModuleElements.cpp
index 259c5b942..d9f6a7978 100644
--- a/src/passes/RemoveUnusedModuleElements.cpp
+++ b/src/passes/RemoveUnusedModuleElements.cpp
@@ -185,6 +185,7 @@ struct RemoveUnusedModuleElements : public Pass {
     std::unordered_map<std::string, FunctionType*> canonicals;
     std::unordered_set<FunctionType*> needed;
     auto canonicalize = [&](Name name) {
+      if (!name.is()) return name;
       FunctionType* type = module->getFunctionType(name);
       auto sig = getSig(type);
       auto iter = canonicals.find(sig);
diff --git a/src/tools/translate-to-fuzz.h b/src/tools/translate-to-fuzz.h
index 74a457013..e84ffd364 100644
--- a/src/tools/translate-to-fuzz.h
+++ b/src/tools/translate-to-fuzz.h
@@ -19,6 +19,13 @@
 // This is helpful for fuzzing.
 //
 
+/*
+memory too
+high chance for set at start of loop
+  high chance of get of a set local in the scope of that scope
+    high chance of a tee in that case => loop var
+*/
+
 #include <wasm-builder.h>
 
 namespace wasm {
@@ -132,6 +139,7 @@ private:
 
   void build() {
     setupMemory();
+    setupTable();
     // keep adding functions until we run out of input
     while (!finishedInput) {
       addFunction();
@@ -142,6 +150,7 @@ private:
     if (DE_NAN) {
       addDeNanSupport();
     }
+    finalizeTable();
   }
 
   void setupMemory() {
@@ -150,6 +159,16 @@ private:
     wasm.memory.initial = wasm.memory.max = 1;
   }
 
+  void setupTable() {
+    wasm.table.exists = true;
+    wasm.table.segments.emplace_back(builder.makeConst(Literal(int32_t(0))));
+  }
+
+  void finalizeTable() {
+    wasm.table.initial = wasm.table.segments[0].data.size();
+    wasm.table.max = oneIn(2) ? Address(Table::kMaxSize) : wasm.table.initial;
+  }
+
   const Name HANG_LIMIT_GLOBAL = "hangLimit";
 
   void addHangLimitSupport() {
@@ -282,12 +301,17 @@ private:
     // export some, but not all (to allow inlining etc.). make sure to
     // export at least one, though, to keep each testcase interesting
     if (num == 0 || oneIn(2)) {
+      func->type = ensureFunctionType(getSig(func), &wasm)->name;
       auto* export_ = new Export;
       export_->name = func->name;
       export_->value = func->name;
       export_->kind = ExternalKind::Function;
       wasm.addExport(export_);
     }
+    // add some to the table
+    while (oneIn(3)) {
+      wasm.table.segments[0].data.push_back(func->name);
+    }
     // cleanup
     typeLocals.clear();
   }
@@ -651,7 +675,41 @@ private:
   }
 
   Expression* makeCallIndirect(WasmType type) {
-    return make(type); // TODO
+    auto& data = wasm.table.segments[0].data;
+    if (data.empty()) return make(type);
+    // look for a call target with the right type
+    Index start = upTo(data.size());
+    Index i = start;
+    Function* func;
+    while (1) {
+      // TODO: handle unreachable
+      func = wasm.getFunction(data[i]);
+      if (func->result == type) {
+        break;
+      }
+      i++;
+      if (i == data.size()) i = 0;
+      if (i == start) return make(type);
+    }
+    // with high probability, make sure the type is valid  otherwise, most are
+    // going to trap
+    Expression* target;
+    if (!oneIn(10)) {
+      target = builder.makeConst(Literal(int32_t(i)));
+    } else {
+      target = make(i32);
+    }
+    std::vector<Expression*> args;
+    for (auto type : func->params) {
+      args.push_back(make(type));
+    }
+    func->type = ensureFunctionType(getSig(func), &wasm)->name;
+    return builder.makeCallIndirect(
+      func->type,
+      target,
+      args,
+      func->result
+    );
   }
 
   Expression* makeGetLocal(WasmType type) {
@@ -1069,7 +1127,6 @@ private:
   // pick from a vector
   template<typename T>
   const T& vectorPick(const std::vector<T>& vec) {
-    // TODO: get32?
     assert(!vec.empty());
     auto index = upTo(vec.size());
     return vec[index];
diff --git a/test/passes/translate-to-fuzz.txt b/test/passes/translate-to-fuzz.txt
index b966a4164..172441cc3 100644
--- a/test/passes/translate-to-fuzz.txt
+++ b/test/passes/translate-to-fuzz.txt
@@ -1,10 +1,33 @@
 (module
+ (type $FUNCSIG$i (func (result i32)))
+ (type $FUNCSIG$ifd (func (param f32 f64) (result i32)))
+ (type $FUNCSIG$j (func (result i64)))
+ (type $FUNCSIG$d (func (result f64)))
+ (type $FUNCSIG$fdd (func (param f64 f64) (result f32)))
+ (type $FUNCSIG$ji (func (param i32) (result i64)))
+ (type $FUNCSIG$dd (func (param f64) (result f64)))
+ (type $FUNCSIG$df (func (param f32) (result f64)))
+ (type $FUNCSIG$v (func))
+ (type $FUNCSIG$djf (func (param i64 f32) (result f64)))
  (global $hangLimit (mut i32) (i32.const 100))
+ (table 10 anyfunc)
+ (elem (i32.const 0) $func_0 $func_0 $func_1 $func_4 $func_5 $func_5 $func_8 $func_11 $func_15 $func_17)
  (memory $0 1 1)
  (export "func_0" (func $func_0))
+ (export "func_1" (func $func_1))
+ (export "func_2" (func $func_2))
+ (export "func_3" (func $func_3))
+ (export "func_4" (func $func_4))
  (export "func_6" (func $func_6))
+ (export "func_9" (func $func_9))
+ (export "func_13" (func $func_13))
+ (export "func_15" (func $func_15))
+ (export "func_17" (func $func_17))
+ (export "func_18" (func $func_18))
+ (export "func_19" (func $func_19))
+ (export "func_21" (func $func_21))
  (export "hangLimitInitializer" (func $hangLimitInitializer))
- (func $func_0 (result i32)
+ (func $func_0 (type $FUNCSIG$i) (result i32)
   (local $0 f32)
   (local $1 i64)
   (local $2 f32)
@@ -68,16 +91,14 @@
    )
   )
  )
- (func $func_1 (result f64)
-  (local $0 i32)
-  (local $1 f64)
+ (func $func_1 (type $FUNCSIG$ifd) (param $0 f32) (param $1 f64) (result i32)
   (block
    (if
     (i32.eqz
      (get_global $hangLimit)
     )
     (return
-     (f64.const 9223372036854775808)
+     (i32.const -34)
     )
    )
    (set_global $hangLimit
@@ -87,620 +108,263 @@
     )
    )
   )
-  (block $label$0 (result f64)
-   (drop
-    (if (result i64)
-     (select
-      (get_local $0)
-      (i32.const 84414006)
+  (block $label$0 (result i32)
+   (return
+    (i32.const 66)
+   )
+  )
+ )
+ (func $func_2 (type $FUNCSIG$j) (result i64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (i64.const -6)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result i64)
+   (return
+    (i64.const 6174)
+   )
+  )
+ )
+ (func $func_3 (type $FUNCSIG$d) (result f64)
+  (local $0 i64)
+  (local $1 i64)
+  (local $2 f64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (get_local $2)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (call $deNan64
+   (f64.max
+    (f64.const -nan:0xfffffffffffb3)
+    (tee_local $2
+     (call $deNan64
       (select
-       (i32.const 32767)
-       (i32.const -1)
-       (loop $label$1 (result i32)
-        (block
-         (if
-          (i32.eqz
-           (get_global $hangLimit)
-          )
-          (return
-           (get_local $1)
-          )
-         )
-         (set_global $hangLimit
-          (i32.sub
-           (get_global $hangLimit)
-           (i32.const 1)
-          )
-         )
-        )
-        (block $label$2 (result i32)
-         (return
-          (get_local $1)
-         )
-        )
-       )
-      )
-     )
-     (if (result i64)
-      (i32.eqz
-       (loop $label$9 (result i32)
-        (block
-         (if
-          (i32.eqz
-           (get_global $hangLimit)
-          )
+       (call $deNan64
+        (f64.div
+         (block $label$1 (result f64)
           (return
-           (f64.const 19)
+           (f64.const 2147483647)
           )
          )
-         (set_global $hangLimit
-          (i32.sub
-           (get_global $hangLimit)
-           (i32.const 1)
-          )
-         )
-        )
-        (block $label$10 (result i32)
-         (i32.load8_s offset=3
-          (i32.and
-           (tee_local $0
-            (tee_local $0
-             (select
-              (i32.load16_u offset=4 align=1
-               (i32.and
-                (select
-                 (get_local $0)
-                 (get_local $0)
-                 (select
-                  (i64.lt_s
-                   (loop $label$12 (result i64)
-                    (block
-                     (if
-                      (i32.eqz
-                       (get_global $hangLimit)
-                      )
-                      (return
-                       (get_local $1)
-                      )
-                     )
-                     (set_global $hangLimit
-                      (i32.sub
-                       (get_global $hangLimit)
-                       (i32.const 1)
-                      )
-                     )
-                    )
-                    (i64.const 32767)
-                   )
-                   (i64.const 251)
-                  )
-                  (i32.trunc_u/f64
-                   (get_local $1)
-                  )
-                  (br_if $label$10
-                   (i32.load16_u offset=3
-                    (i32.and
-                     (i32.const 20)
-                     (i32.const 31)
-                    )
-                   )
-                   (get_local $0)
-                  )
-                 )
-                )
-                (i32.const 31)
-               )
-              )
-              (loop $label$13 (result i32)
-               (block
-                (if
-                 (i32.eqz
-                  (get_global $hangLimit)
-                 )
-                 (return
-                  (get_local $1)
-                 )
-                )
-                (set_global $hangLimit
-                 (i32.sub
-                  (get_global $hangLimit)
-                  (i32.const 1)
-                 )
+         (call $deNan64
+          (f64.mul
+           (call $deNan64
+            (select
+             (loop $label$2 (result f64)
+              (block
+               (if
+                (i32.eqz
+                 (get_global $hangLimit)
                 )
-               )
-               (block $label$14 (result i32)
                 (return
-                 (get_local $1)
+                 (f64.const 18446744073709551615)
                 )
                )
-              )
-              (if (result i32)
-               (i32.eqz
-                (get_local $0)
-               )
-               (block $label$11 (result i32)
-                (get_local $0)
-               )
-               (i32.popcnt
-                (get_local $0)
+               (set_global $hangLimit
+                (i32.sub
+                 (get_global $hangLimit)
+                 (i32.const 1)
+                )
                )
               )
+              (f64.const -nan:0xffffffffffff4)
              )
-            )
-           )
-           (i32.const 31)
-          )
-         )
-        )
-       )
-      )
-      (block $label$15 (result i64)
-       (block $label$16 (result i64)
-        (select
-         (br_if $label$16
-          (i64.const 1)
-          (i32.eqz
-           (tee_local $0
-            (select
-             (get_local $0)
-             (get_local $0)
-             (get_local $0)
-            )
-           )
-          )
-         )
-         (loop $label$21 (result i64)
-          (block
-           (if
-            (i32.eqz
-             (get_global $hangLimit)
-            )
-            (return
-             (get_local $1)
-            )
-           )
-           (set_global $hangLimit
-            (i32.sub
-             (get_global $hangLimit)
-             (i32.const 1)
-            )
-           )
-          )
-          (block $label$22 (result i64)
-           (return
-            (get_local $1)
-           )
-          )
-         )
-         (loop $label$17 (result i32)
-          (block
-           (if
-            (i32.eqz
-             (get_global $hangLimit)
-            )
-            (return
-             (f64.const -9223372036854775808)
-            )
-           )
-           (set_global $hangLimit
-            (i32.sub
-             (get_global $hangLimit)
-             (i32.const 1)
-            )
-           )
-          )
-          (block $label$18 (result i32)
-           (if
-            (i32.eqz
-             (select
-              (i32.const -128)
-              (i32.const -12)
-              (i32.const 1561467741)
-             )
-            )
-            (block $label$19
-             (nop)
-            )
-            (loop $label$20
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
-               )
-               (return
-                (f64.const -nan:0xfffffffffff83)
-               )
-              )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
+             (get_local $2)
+             (i32.load8_s offset=3
+              (i32.and
+               (i32.load16_s offset=4
+                (i32.and
+                 (i32.const 12602)
+                 (i32.const 31)
+                )
                )
-              )
-             )
-             (set_local $0
-              (get_local $0)
-             )
-            )
-           )
-           (tee_local $0
-            (f32.lt
-             (call $deNan32
-              (f32.min
-               (f32.const 18446744073709551615)
-               (f32.const 11)
-              )
-             )
-             (call $deNan32
-              (select
-               (f32.const 2147483648)
-               (f32.const 18446744073709551615)
-               (get_local $0)
+               (i32.const 31)
               )
              )
             )
            )
+           (get_local $2)
           )
          )
         )
        )
-      )
-      (select
-       (i64.load32_u offset=3 align=2
-        (i32.and
-         (i32.load16_u offset=4
+       (call $deNan64
+        (select
+         (f64.load offset=22
           (i32.and
-           (tee_local $0
-            (if (result i32)
-             (i32.trunc_u/f64
-              (get_local $1)
-             )
-             (block $label$27 (result i32)
-              (get_local $0)
-             )
-             (block $label$28 (result i32)
-              (get_local $0)
-             )
+           (i32.load16_u offset=22 align=1
+            (i32.and
+             (i32.const 32767)
+             (i32.const 31)
             )
            )
            (i32.const 31)
           )
          )
-         (i32.const 31)
-        )
-       )
-       (i64.const 80)
-       (i32.trunc_s/f32
-        (call $deNan32
-         (f32.copysign
-          (f32.const 1.8061622339155704e-31)
-          (if (result f32)
-           (i32.eqz
-            (loop $label$23 (result i32)
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
-               )
-               (return
-                (f64.const 2.1384722118162242e-260)
-               )
-              )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
-               )
-              )
-             )
-             (i32.wrap/i64
-              (if (result i64)
-               (i32.eqz
-                (get_local $0)
-               )
-               (i64.const 18752)
-               (select
-                (i64.const 650785547958815753)
-                (i64.const 8463519829359949880)
-                (block $label$24 (result i32)
-                 (select
-                  (get_local $0)
-                  (i32.const 65535)
-                  (get_local $0)
-                 )
-                )
-               )
-              )
-             )
-            )
-           )
-           (block $label$25 (result f32)
-            (f32.const 14385)
-           )
-           (f32.const 4.2612939233197215e-37)
+         (call $deNan64
+          (f64.convert_s/i32
+           (i32.const 176)
           )
          )
+         (i32.const 1)
         )
        )
-      )
-     )
-     (block $label$29 (result i64)
-      (block $label$30 (result i64)
-       (return
-        (get_local $1)
+       (block $label$0 (result i32)
+        (return
+         (f64.const 110)
+        )
        )
       )
      )
     )
    )
+  )
+ )
+ (func $func_4 (type $FUNCSIG$fdd) (param $0 f64) (param $1 f64) (result f32)
+  (local $2 i64)
+  (block
    (if
-    (block $label$31 (result i32)
-     (block $label$32
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (f32.const 4.136946824350359e-25)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result f32)
+   (block $label$1 (result f32)
+    (loop $label$2 (result f32)
+     (block
       (if
-       (block $label$33 (result i32)
-        (loop $label$34 (result i32)
-         (block
-          (if
-           (i32.eqz
-            (get_global $hangLimit)
-           )
-           (return
-            (f64.const -nan:0xffffffffffff8)
-           )
-          )
-          (set_global $hangLimit
-           (i32.sub
-            (get_global $hangLimit)
-            (i32.const 1)
-           )
-          )
-         )
-         (if (result i32)
-          (i32.eqz
-           (if (result i32)
-            (block $label$35 (result i32)
-             (return
-              (get_local $1)
-             )
-            )
-            (i32.trunc_s/f64
-             (call $deNan64
-              (f64.convert_u/i32
-               (select
-                (get_local $0)
-                (if (result i32)
-                 (i32.eqz
-                  (block $label$36 (result i32)
-                   (get_local $0)
-                  )
-                 )
-                 (i64.gt_u
-                  (i64.const 155730402379)
-                  (i64.const 15)
-                 )
-                 (i32.const -2147483648)
-                )
-                (get_local $0)
-               )
-              )
-             )
-            )
-            (block $label$37 (result i32)
-             (drop
-              (f64.const 65483)
-             )
-             (select
-              (get_local $0)
-              (i32.trunc_s/f64
-               (block $label$38 (result f64)
-                (loop $label$39 (result f64)
-                 (block
-                  (if
-                   (i32.eqz
-                    (get_global $hangLimit)
-                   )
-                   (return
-                    (get_local $1)
-                   )
-                  )
-                  (set_global $hangLimit
-                   (i32.sub
-                    (get_global $hangLimit)
-                    (i32.const 1)
-                   )
-                  )
-                 )
-                 (call $deNan64
-                  (f64.add
-                   (get_local $1)
-                   (get_local $1)
-                  )
-                 )
-                )
-               )
-              )
-              (i32.const 1751457892)
-             )
-            )
-           )
-          )
-          (i32.reinterpret/f32
-           (f32.const 9223372036854775808)
-          )
-          (get_local $0)
-         )
-        )
+       (i32.eqz
+        (get_global $hangLimit)
        )
-       (nop)
-       (block $label$40
-        (set_local $1
-         (call $deNan64
-          (select
-           (f64.load offset=22 align=4
-            (i32.and
-             (if (result i32)
-              (i32.const -124)
-              (block $label$43 (result i32)
-               (br $label$32)
-              )
-              (block $label$44 (result i32)
-               (get_local $0)
-              )
-             )
-             (i32.const 31)
-            )
-           )
-           (call $deNan64
-            (f64.copysign
-             (call $deNan64
-              (f64.reinterpret/i64
-               (i64.ctz
-                (i64.trunc_u/f32
-                 (f32.const 65525)
-                )
-               )
-              )
-             )
-             (get_local $1)
-            )
-           )
-           (loop $label$41 (result i32)
-            (block
-             (if
-              (i32.eqz
-               (get_global $hangLimit)
-              )
-              (return
-               (f64.const 9)
-              )
-             )
-             (set_global $hangLimit
-              (i32.sub
-               (get_global $hangLimit)
-               (i32.const 1)
-              )
-             )
-            )
-            (block $label$42 (result i32)
-             (br $label$40)
-            )
-           )
-          )
-         )
-        )
+       (return
+        (f32.const -2147483648)
        )
       )
-     )
-     (return
-      (get_local $1)
-     )
-    )
-    (block $label$45
-     (block $label$46
-      (br_if $label$45
-       (tee_local $0
-        (i32.trunc_s/f64
-         (loop $label$47 (result f64)
-          (block
-           (if
-            (i32.eqz
-             (get_global $hangLimit)
-            )
-            (return
-             (get_local $1)
-            )
-           )
-           (set_global $hangLimit
-            (i32.sub
-             (get_global $hangLimit)
-             (i32.const 1)
-            )
-           )
-          )
-          (block $label$48 (result f64)
-           (br $label$45)
-          )
-         )
-        )
+      (set_global $hangLimit
+       (i32.sub
+        (get_global $hangLimit)
+        (i32.const 1)
        )
       )
      )
+     (f32.const 1.5518369315425492e-36)
     )
-    (block $label$49
-     (nop)
-     (br_if $label$49
-      (get_local $0)
-     )
+   )
+  )
+ )
+ (func $func_5 (type $FUNCSIG$dd) (param $0 f64) (result f64)
+  (local $1 f64)
+  (local $2 i64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (get_local $1)
     )
    )
-   (if (result f64)
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result f64)
+   (return
+    (f64.const -nan:0xfffffffffffeb)
+   )
+  )
+ )
+ (func $func_6 (type $FUNCSIG$ji) (param $0 i32) (result i64)
+  (local $1 f64)
+  (block
+   (if
     (i32.eqz
-     (i32.trunc_u/f32
-      (f32.const 2.0658355161339533e-21)
-     )
+     (get_global $hangLimit)
     )
-    (call $deNan64
-     (select
-      (get_local $1)
-      (if (result f64)
-       (i32.eqz
-        (get_local $0)
-       )
-       (block $label$50 (result f64)
-        (return
-         (get_local $1)
-        )
-       )
-       (block $label$51 (result f64)
-        (return
-         (get_local $1)
-        )
-       )
-      )
-      (get_local $0)
-     )
+    (return
+     (i64.const 9223372036854775807)
     )
-    (block $label$52 (result f64)
-     (if
-      (i32.reinterpret/f32
-       (f32.const -nan:0x7fffb9)
-      )
-      (nop)
-      (drop
-       (f64.const 8.308760937752171e-246)
-      )
-     )
-     (drop
-      (loop $label$53 (result i64)
-       (block
-        (if
-         (i32.eqz
-          (get_global $hangLimit)
-         )
-         (return
-          (get_local $1)
-         )
-        )
-        (set_global $hangLimit
-         (i32.sub
-          (get_global $hangLimit)
-          (i32.const 1)
-         )
-        )
-       )
-       (block $label$54 (result i64)
-        (i64.const -48)
-       )
-      )
-     )
-     (return
-      (f64.const 65520)
-     )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result i64)
+   (block $label$1 (result i64)
+    (return
+     (i64.const -94)
     )
    )
   )
  )
- (func $func_2 (param $0 f32)
+ (func $func_7 (result f64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (f64.const 246)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result f64)
+   (return
+    (f64.const 2)
+   )
+  )
+ )
+ (func $func_8 (type $FUNCSIG$v)
+  (local $0 f32)
+  (local $1 i64)
+  (local $2 f64)
+  (local $3 i64)
   (block
    (if
     (i32.eqz
@@ -715,348 +379,313 @@
     )
    )
   )
-  (block $label$0
+  (i64.store8 offset=4
+   (i32.and
+    (i32.const 48)
+    (i32.const 31)
+   )
+   (call $func_2)
+  )
+ )
+ (func $func_9 (type $FUNCSIG$d) (result f64)
+  (local $0 i64)
+  (local $1 i64)
+  (local $2 f32)
+  (local $3 i64)
+  (local $4 f32)
+  (block
    (if
     (i32.eqz
-     (if (result i32)
-      (call $func_0)
-      (block $label$1 (result i32)
-       (block $label$2
-        (loop $label$3
-         (block
-          (if
-           (i32.eqz
-            (get_global $hangLimit)
-           )
-           (return)
-          )
-          (set_global $hangLimit
-           (i32.sub
-            (get_global $hangLimit)
-            (i32.const 1)
-           )
-          )
-         )
-         (block $label$4
-          (nop)
-         )
-        )
-       )
-       (if (result i32)
-        (i32.eqz
-         (if (result i32)
-          (i32.load8_s offset=4
-           (i32.and
-            (if (result i32)
-             (i32.eqz
-              (call $func_0)
-             )
-             (block $label$5 (result i32)
-              (br $label$0)
-             )
-             (block $label$6 (result i32)
-              (br $label$0)
-             )
-            )
-            (i32.const 31)
-           )
-          )
-          (i32.const 359492883)
-          (call $func_0)
-         )
-        )
-        (block $label$7 (result i32)
-         (br $label$0)
-        )
-        (block $label$8 (result i32)
-         (i32.const 22536)
-        )
-       )
-      )
-      (block $label$9 (result i32)
-       (nop)
-       (br_if $label$0
-        (i32.eqz
-         (block $label$10 (result i32)
-          (br $label$0)
-         )
-        )
-       )
-       (br $label$0)
-      )
-     )
+     (get_global $hangLimit)
     )
-    (if
-     (i32.const 65441)
-     (nop)
-     (block $label$11
-      (loop $label$12
-       (block
-        (if
-         (i32.eqz
-          (get_global $hangLimit)
-         )
-         (return)
-        )
-        (set_global $hangLimit
-         (i32.sub
-          (get_global $hangLimit)
-          (i32.const 1)
-         )
-        )
-       )
-       (block $label$13
-        (nop)
-       )
+    (return
+     (f64.const 18446744073709551615)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (f64.load offset=4
+   (i32.and
+    (block $label$0 (result i32)
+     (block $label$1 (result i32)
+      (return
+       (f64.const -99)
       )
      )
     )
-    (block $label$14
-     (if
-      (i32.eqz
-       (call $func_0)
-      )
-      (block $label$15
-       (loop $label$16
-        (block
-         (if
-          (i32.eqz
-           (get_global $hangLimit)
-          )
-          (return)
-         )
-         (set_global $hangLimit
-          (i32.sub
-           (get_global $hangLimit)
-           (i32.const 1)
-          )
-         )
-        )
-        (block $label$17
-         (block $label$18
-          (loop $label$19
-           (block
-            (if
-             (i32.eqz
-              (get_global $hangLimit)
+    (i32.const 31)
+   )
+  )
+ )
+ (func $func_10 (result f32)
+  (local $0 i64)
+  (local $1 f32)
+  (local $2 f32)
+  (local $3 f64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (get_local $1)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0
+   (return
+    (get_local $2)
+   )
+  )
+ )
+ (func $func_11 (type $FUNCSIG$i) (result i32)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (i32.const 1954248050)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (i32.popcnt
+   (block $label$0 (result i32)
+    (call_indirect $FUNCSIG$i
+     (i32.const 0)
+    )
+   )
+  )
+ )
+ (func $func_12 (result f64)
+  (local $0 i32)
+  (local $1 i32)
+  (local $2 i32)
+  (local $3 f64)
+  (local $4 i64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (f64.const -88)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result f64)
+   (call_indirect $FUNCSIG$dd
+    (call_indirect $FUNCSIG$dd
+     (call_indirect $FUNCSIG$dd
+      (f64.load offset=4 align=1
+       (i32.and
+        (tee_local $0
+         (i32.rem_s
+          (call $func_1
+           (f32.const 20)
+           (tee_local $3
+            (if (result f64)
+             (select
+              (i32.wrap/i64
+               (i64.const 0)
+              )
+              (i32.load offset=4 align=2
+               (i32.and
+                (get_local $1)
+                (i32.const 31)
+               )
+              )
+              (i32.trunc_s/f64
+               (f64.const 4294967295)
+              )
              )
-             (return)
-            )
-            (set_global $hangLimit
-             (i32.sub
-              (get_global $hangLimit)
-              (i32.const 1)
+             (block $label$1 (result f64)
+              (return
+               (get_local $3)
+              )
+             )
+             (block $label$2 (result f64)
+              (return
+               (get_local $3)
+              )
              )
-            )
-           )
-           (nop)
-          )
-         )
-        )
-       )
-      )
-      (block $label$20
-       (loop $label$21
-        (block
-         (if
-          (i32.eqz
-           (get_global $hangLimit)
-          )
-          (return)
-         )
-         (set_global $hangLimit
-          (i32.sub
-           (get_global $hangLimit)
-           (i32.const 1)
-          )
-         )
-        )
-        (if
-         (i32.trunc_u/f64
-          (call $deNan64
-           (f64.convert_u/i32
-            (i32.clz
-             (call $func_0)
             )
            )
           )
-         )
-         (nop)
-         (drop
-          (if (result i64)
+          (if (result i32)
            (i32.eqz
-            (loop $label$22 (result i32)
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
+            (i64.le_s
+             (if (result i64)
+              (i32.eqz
+               (select
+                (i32.div_u
+                 (i32.const 4)
+                 (i32.const 65533)
+                )
+                (i32.load offset=22 align=2
+                 (i32.and
+                  (get_local $1)
+                  (i32.const 31)
+                 )
+                )
+                (tee_local $1
+                 (tee_local $0
+                  (i32.const 10282)
+                 )
+                )
                )
-               (return)
               )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
+              (block $label$3 (result i64)
+               (return
+                (f64.const 14675337377663989850308608)
                )
               )
-             )
-             (block $label$23 (result i32)
-              (select
-               (i32.const 2113936401)
-               (i32.const 0)
-               (select
-                (i32.const 2147483647)
-                (i32.const 1297751887)
-                (i32.const 5191)
+              (block $label$4 (result i64)
+               (return
+                (f64.const 2147483647)
                )
               )
              )
-            )
-           )
-           (block $label$24 (result i64)
-            (br $label$0)
-           )
-           (block $label$25 (result i64)
-            (loop $label$26 (result i64)
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
+             (loop $label$5 (result i64)
+              (block
+               (if
+                (i32.eqz
+                 (get_global $hangLimit)
+                )
+                (return
+                 (get_local $3)
+                )
                )
-               (return)
-              )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
+               (set_global $hangLimit
+                (i32.sub
+                 (get_global $hangLimit)
+                 (i32.const 1)
+                )
                )
               )
-             )
-             (block $label$27 (result i64)
-              (i64.reinterpret/f64
-               (f64.const -nan:0xfffffffffffb7)
+              (block $label$6 (result i64)
+               (return
+                (get_local $3)
+               )
               )
              )
             )
            )
-          )
-         )
-        )
-       )
-       (drop
-        (call $func_1)
-       )
-       (block $label$28
-        (if
-         (i32.const 18500)
-         (nop)
-         (if
-          (i32.eqz
-           (i32.const -122)
-          )
-          (block $label$29
-           (set_local $0
-            (loop $label$30 (result f32)
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
-               )
-               (return)
-              )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
+           (block $label$7 (result i32)
+            (return
+             (get_local $3)
+            )
+           )
+           (i32.trunc_u/f32
+            (call $func_4
+             (loop $label$8 (result f64)
+              (block
+               (if
+                (i32.eqz
+                 (get_global $hangLimit)
+                )
+                (return
+                 (get_local $3)
+                )
                )
-              )
-             )
-             (f32.load offset=22 align=2
-              (i32.and
-               (block $label$31 (result i32)
-                (i64.eqz
-                 (i64.const -2147483648)
+               (set_global $hangLimit
+                (i32.sub
+                 (get_global $hangLimit)
+                 (i32.const 1)
                 )
                )
-               (i32.const 31)
+              )
+              (if (result f64)
+               (get_local $2)
+               (f64.const 18446744073709551615)
+               (get_local $3)
               )
              )
-            )
-           )
-          )
-          (f32.store offset=4 align=1
-           (i32.and
-            (loop $label$32 (result i32)
-             (block
-              (if
-               (i32.eqz
-                (get_global $hangLimit)
-               )
-               (return)
+             (br_if $label$0
+              (br_if $label$0
+               (f64.const 0)
+               (i32.const 110)
               )
-              (set_global $hangLimit
-               (i32.sub
-                (get_global $hangLimit)
-                (i32.const 1)
+              (if (result i32)
+               (i32.eqz
+                (get_local $1)
                )
+               (i32.const 255)
+               (i32.const -128)
               )
              )
-             (i32.wrap/i64
-              (i64.const -125)
-             )
-            )
-            (i32.const 31)
-           )
-           (f32.load offset=4 align=1
-            (i32.and
-             (i32.const 23)
-             (i32.const 31)
             )
            )
           )
          )
         )
-        (br_if $label$0
-         (i32.eqz
-          (i32.const -128)
-         )
-        )
+        (i32.const 31)
        )
       )
+      (i32.const 4)
      )
+     (i32.const 4)
     )
+    (i32.const 4)
    )
-   (br_if $label$0
-    (loop $label$33 (result i32)
-     (block
-      (if
-       (i32.eqz
-        (get_global $hangLimit)
-       )
-       (return)
-      )
-      (set_global $hangLimit
-       (i32.sub
-        (get_global $hangLimit)
-        (i32.const 1)
-       )
-      )
-     )
-     (block $label$34 (result i32)
-      (br $label$0)
-     )
+  )
+ )
+ (func $func_13 (type $FUNCSIG$i) (result i32)
+  (local $0 f32)
+  (local $1 i32)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (i32.const -45)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
     )
    )
   )
+  (block $label$0 (result i32)
+   (return
+    (get_local $1)
+   )
+  )
  )
- (func $func_3 (param $0 f64) (param $1 f64) (param $2 f64) (result f32)
+ (func $func_14 (result i64)
   (block
    (if
     (i32.eqz
      (get_global $hangLimit)
     )
     (return
-     (f32.const -nan:0x7fff97)
+     (i64.const 255)
     )
    )
    (set_global $hangLimit
@@ -1066,50 +695,170 @@
     )
    )
   )
-  (call $deNan32
-   (f32.sqrt
-    (if (result f32)
-     (loop $label$0 (result i32)
-      (block
-       (if
-        (i32.eqz
-         (get_global $hangLimit)
-        )
-        (return
-         (f32.const 9223372036854775808)
+  (i64.rotr
+   (if (result i64)
+    (f64.le
+     (f64.const 9223372036854775808)
+     (f64.const -nan:0xfffffffffffca)
+    )
+    (block $label$0 (result i64)
+     (i64.const -75)
+    )
+    (block $label$1 (result i64)
+     (nop)
+     (nop)
+     (select
+      (block $label$8 (result i64)
+       (i64.load16_s offset=4
+        (i32.and
+         (i32.load8_u offset=2
+          (i32.and
+           (loop $label$9 (result i32)
+            (block
+             (if
+              (i32.eqz
+               (get_global $hangLimit)
+              )
+              (return
+               (i64.const -1)
+              )
+             )
+             (set_global $hangLimit
+              (i32.sub
+               (get_global $hangLimit)
+               (i32.const 1)
+              )
+             )
+            )
+            (block $label$10 (result i32)
+             (i32.const 0)
+            )
+           )
+           (i32.const 31)
+          )
+         )
+         (i32.const 31)
         )
        )
-       (set_global $hangLimit
-        (i32.sub
-         (get_global $hangLimit)
-         (i32.const 1)
+      )
+      (if (result i64)
+       (i32.eqz
+        (i32.const 0)
+       )
+       (block $label$12 (result i64)
+        (return
+         (i64.const 796316177068464396)
         )
        )
-      )
-      (block $label$1 (result i32)
-       (return
-        (f32.const 9223372036854775808)
+       (block $label$13 (result i64)
+        (i64.const -106)
        )
       )
+      (i32.const 1259697983)
      )
-     (block $label$2 (result f32)
-      (block $label$3 (result f32)
-       (f32.const 2147483648)
-      )
-     )
-     (f32.const 8764)
     )
    )
+   (select
+    (call $func_2)
+    (i64.extend_u/i32
+     (i32.const 256)
+    )
+    (i32.const 169)
+   )
   )
  )
- (func $func_4
-  (local $0 i64)
+ (func $func_15 (type $FUNCSIG$j) (result i64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (i64.const 255)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (i64.const 2821)
+ )
+ (func $func_16 (result i32)
+  (local $0 i32)
   (local $1 i64)
-  (local $2 f32)
-  (local $3 f64)
-  (local $4 f64)
-  (local $5 f64)
-  (local $6 f32)
+  (local $2 f64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (get_local $0)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result i32)
+   (return
+    (i32.const -1)
+   )
+  )
+ )
+ (func $func_17 (type $FUNCSIG$df) (param $0 f32) (result f64)
+  (local $1 f64)
+  (local $2 f64)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (f64.const 1.1754943508222875e-38)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (call $func_7)
+ )
+ (func $func_18 (type $FUNCSIG$j) (result i64)
+  (local $0 f32)
+  (local $1 i32)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (i64.const -82)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result i64)
+   (return
+    (i64.const -70)
+   )
+  )
+ )
+ (func $func_19 (type $FUNCSIG$v)
   (block
    (if
     (i32.eqz
@@ -1126,14 +875,18 @@
   )
   (nop)
  )
- (func $func_5 (param $0 i64) (param $1 i64) (result f64)
+ (func $func_20 (result i64)
+  (local $0 i32)
+  (local $1 f64)
+  (local $2 f32)
+  (local $3 f64)
   (block
    (if
     (i32.eqz
      (get_global $hangLimit)
     )
     (return
-     (f64.const -100)
+     (i64.const -9223372036854775808)
     )
    )
    (set_global $hangLimit
@@ -1143,17 +896,21 @@
     )
    )
   )
-  (f64.const 1)
+  (block $label$0 (result i64)
+   (return
+    (i64.const 168)
+   )
+  )
  )
- (func $func_6 (result i32)
-  (local $0 f64)
+ (func $func_21 (type $FUNCSIG$djf) (param $0 i64) (param $1 f32) (result f64)
+  (local $2 i64)
   (block
    (if
     (i32.eqz
      (get_global $hangLimit)
     )
     (return
-     (i32.const 2147483647)
+     (f64.const -nan:0xfffffffffffdc)
     )
    )
    (set_global $hangLimit
@@ -1163,160 +920,252 @@
     )
    )
   )
-  (select
+  (call $deNan64
    (select
-    (loop $label$1 (result i32)
-     (block
-      (if
-       (i32.eqz
-        (get_global $hangLimit)
+    (if (result f64)
+     (i32.eqz
+      (select
+       (i32.reinterpret/f32
+        (call $func_4
+         (if (result f64)
+          (i32.const 241)
+          (call_indirect $FUNCSIG$dd
+           (call $deNan64
+            (f64.neg
+             (f64.const 0)
+            )
+           )
+           (i32.const 4)
+          )
+          (loop $label$5 (result f64)
+           (block
+            (if
+             (i32.eqz
+              (get_global $hangLimit)
+             )
+             (return
+              (f64.const 21)
+             )
+            )
+            (set_global $hangLimit
+             (i32.sub
+              (get_global $hangLimit)
+              (i32.const 1)
+             )
+            )
+           )
+           (block $label$6 (result f64)
+            (return
+             (f64.const -1)
+            )
+           )
+          )
+         )
+         (call $deNan64
+          (select
+           (f64.const 1.1754943508222875e-38)
+           (f64.const 0)
+           (select
+            (i32.const 117834755)
+            (block $label$7 (result i32)
+             (return
+              (f64.const -37)
+             )
+            )
+            (call_indirect $FUNCSIG$i
+             (i32.const 0)
+            )
+           )
+          )
+         )
+        )
        )
-       (return
-        (i32.const 0)
+       (block $label$8 (result i32)
+        (return
+         (f64.const -9223372036854775808)
+        )
        )
+       (i32.const 101346317)
       )
-      (set_global $hangLimit
-       (i32.sub
-        (get_global $hangLimit)
-        (i32.const 1)
-       )
+     )
+     (call_indirect $FUNCSIG$df
+      (f32.const 1.3078619610967781e-22)
+      (i32.const 9)
+     )
+     (block $label$9 (result f64)
+      (return
+       (f64.const -82)
       )
      )
-     (block $label$2 (result i32)
-      (i32.load offset=4
-       (br_if $label$2
-        (i32.const -76)
-        (i32.eqz
-         (i32.load8_s offset=4
-          (i32.and
-           (i32.load offset=22 align=1
-            (i32.and
-             (i32.const 92)
-             (i32.const 31)
-            )
-           )
-           (i32.const 31)
+    )
+    (f64.const -112)
+    (if (result i32)
+     (if (result i32)
+      (i32.const 22)
+      (block $label$0 (result i32)
+       (return
+        (f64.const 9223372036854775808)
+       )
+      )
+      (block $label$1 (result i32)
+       (i32.store offset=3
+        (i32.and
+         (call $func_13)
+         (i32.const 31)
+        )
+        (call $func_1
+         (tee_local $1
+          (tee_local $1
+           (get_local $1)
+          )
+         )
+         (block $label$2 (result f64)
+          (call_indirect $FUNCSIG$v
+           (i32.const 6)
+          )
+          (return
+           (f64.const -nan:0xfffffffffffe8)
           )
          )
         )
        )
+       (call_indirect $FUNCSIG$v
+        (i32.const 6)
+       )
+       (return
+        (f64.const -94)
+       )
       )
      )
-    )
-    (block $label$3 (result i32)
-     (return
-      (i32.const 26)
+     (block $label$3 (result i32)
+      (return
+       (f64.const -nan:0xfffffffffffa0)
+      )
+     )
+     (block $label$4 (result i32)
+      (i32.const -20)
      )
     )
-    (call $func_0)
    )
-   (select
-    (block $label$9 (result i32)
-     (loop $label$10
-      (block
-       (if
-        (i32.eqz
-         (get_global $hangLimit)
-        )
-        (return
-         (i32.const 1)
-        )
-       )
-       (set_global $hangLimit
-        (i32.sub
-         (get_global $hangLimit)
-         (i32.const 1)
+  )
+ )
+ (func $func_22 (result f32)
+  (block
+   (if
+    (i32.eqz
+     (get_global $hangLimit)
+    )
+    (return
+     (f32.const 0)
+    )
+   )
+   (set_global $hangLimit
+    (i32.sub
+     (get_global $hangLimit)
+     (i32.const 1)
+    )
+   )
+  )
+  (block $label$0 (result f32)
+   (call_indirect $FUNCSIG$v
+    (if (result i32)
+     (i32.eqz
+      (if (result i32)
+       (i32.eqz
+        (loop $label$1 (result i32)
+         (block
+          (if
+           (i32.eqz
+            (get_global $hangLimit)
+           )
+           (return
+            (f32.const 515)
+           )
+          )
+          (set_global $hangLimit
+           (i32.sub
+            (get_global $hangLimit)
+            (i32.const 1)
+           )
+          )
+         )
+         (block $label$2 (result i32)
+          (return
+           (f32.const 2315)
+          )
+         )
         )
        )
-      )
-      (block $label$11
-       (i32.store16 offset=2 align=1
-        (i32.const -91)
-        (i32.load16_s offset=4 align=1
-         (i32.ctz
-          (block $label$12 (result i32)
-           (select
-            (i32.load offset=4 align=2
-             (i32.and
-              (i32.const -113)
-              (i32.const 31)
+       (block $label$3 (result i32)
+        (loop $label$4 (result i32)
+         (block
+          (if
+           (i32.eqz
+            (get_global $hangLimit)
+           )
+           (return
+            (f32.const 18446744073709551615)
+           )
+          )
+          (set_global $hangLimit
+           (i32.sub
+            (get_global $hangLimit)
+            (i32.const 1)
+           )
+          )
+         )
+         (block $label$5 (result i32)
+          (drop
+           (loop $label$6 (result i64)
+            (block
+             (if
+              (i32.eqz
+               (get_global $hangLimit)
+              )
+              (return
+               (f32.const -1)
+              )
+             )
+             (set_global $hangLimit
+              (i32.sub
+               (get_global $hangLimit)
+               (i32.const 1)
+              )
              )
             )
-            (call $func_0)
-            (block $label$13 (result i32)
+            (block $label$7 (result i64)
              (return
-              (i32.const -32768)
+              (f32.const 1)
              )
             )
            )
           )
-         )
-        )
-       )
-      )
-     )
-     (i32.const 255)
-    )
-    (i32.const 127)
-    (select
-     (if (result i32)
-      (block $label$4 (result i32)
-       (i32.load offset=22
-        (i32.and
-         (br_if $label$4
-          (i32.load16_u offset=2
+          (i32.load8_s offset=22
            (i32.and
-            (i32.const 226)
+            (i32.const 65505)
             (i32.const 31)
            )
           )
-          (i32.eqz
-           (select
-            (block $label$5 (result i32)
-             (i32.const -32768)
-            )
-            (i32.const 354161438)
-            (i64.gt_s
-             (i64.const -18)
-             (i64.const 2835340575676513842)
-            )
-           )
-          )
          )
-         (i32.const 31)
         )
        )
-      )
-      (i32.const -128)
-      (block $label$6 (result i32)
-       (return
-        (i32.const 65442)
-       )
-      )
-     )
-     (block $label$7 (result i32)
-      (i32.load offset=22 align=1
-       (i32.and
-        (block $label$8 (result i32)
-         (return
-          (i32.const 255)
-         )
+       (block $label$8 (result i32)
+        (return
+         (f32.const 252)
         )
-        (i32.const 31)
        )
       )
      )
-     (i32.lt_s
-      (i32.const -20)
-      (i32.const -2147483648)
+     (block $label$9 (result i32)
+      (nop)
+      (i32.const 65535)
+     )
+     (block $label$19 (result i32)
+      (i32.const -115)
      )
     )
    )
-   (block $label$0 (result i32)
-    (return
-     (i32.const -86)
-    )
-   )
+   (f32.const -nan:0x7fff82)
   )
  )
  (func $hangLimitInitializer