porffor 0.1.1 → 0.2.0-09999e8

package/compiler/opt.js

@@ -1,11 +1,7 @@
 import { Opcodes, Valtype } from "./wasmSpec.js";
 import { number } from "./embedding.js";
-
-// deno compat
-if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
-  const textEncoder = new TextEncoder();
-  globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
-}
+import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
+import { log } from "./log.js";
 
 const performWasmOp = (op, a, b) => {
   switch (op) {
@@ -15,12 +11,12 @@ const performWasmOp = (op, a, b) => {
   }
 };
 
-export default (funcs, globals) => {
+export default (funcs, globals, pages) => {
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
   if (optLevel === 0) return;
 
   const tailCall = process.argv.includes('-tail-call');
-  if (tailCall) log('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
+  if (tailCall) log.warning('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
 
   if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
     // inline pass (very WIP)
@@ -95,7 +91,6 @@ export default (funcs, globals) => {
         }
 
         if (t.index > c.index) t.index--; // adjust index if after removed func
-        if (c.memory) t.memory = true;
       }
 
       funcs.splice(funcs.indexOf(c), 1); // remove func from funcs
@@ -108,328 +103,442 @@ export default (funcs, globals) => {
   for (const f of funcs) {
     const wasm = f.wasm;
 
-    let depth = [];
+    const lastType = f.locals['#last_type'];
 
-    let getCount = {}, setCount = {};
-    for (const x in f.locals) {
-      getCount[f.locals[x].idx] = 0;
-      setCount[f.locals[x].idx] = 0;
-    }
+    let runs = 2; // how many by default? add arg?
+    while (runs > 0) {
+      runs--;
+
+      let depth = [];
+
+      let getCount = {}, setCount = {};
+      for (const x in f.locals) {
+        getCount[f.locals[x].idx] = 0;
+        setCount[f.locals[x].idx] = 0;
+      }
+
+      // main pass
+      for (let i = 0; i < wasm.length; i++) {
+        let inst = wasm[i];
+
+        if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
+        if (inst[0] === Opcodes.end) depth.pop();
+
+        if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
+        if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
 
-    // main pass
-    for (let i = 0; i < wasm.length; i++) {
-      let inst = wasm[i];
-
-      if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
-      if (inst[0] === Opcodes.end) depth.pop();
-
-      if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
-      if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
-
-      if (inst[0] === Opcodes.block) {
-        // remove unneeded blocks (no brs inside)
-        // block
-        //   ...
-        // end
-        // -->
-        // ...
-
-        let hasBranch = false, j = i, depth = 0;
-        for (; j < wasm.length; j++) {
-          const op = wasm[j][0];
-          if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) depth++;
-          if (op === Opcodes.end) {
-            depth--;
-            if (depth <= 0) break;
+        if (inst[0] === Opcodes.block) {
+          // remove unneeded blocks (no brs inside)
+          // block
+          //   ...
+          // end
+          // -->
+          // ...
+
+          let hasBranch = false, j = i, depth = 0;
+          for (; j < wasm.length; j++) {
+            const op = wasm[j][0];
+            if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) depth++;
+            if (op === Opcodes.end) {
+              depth--;
+              if (depth <= 0) break;
+            }
+            if (op === Opcodes.br || op === Opcodes.br_if) {
+              hasBranch = true;
+              break;
+            }
           }
-          if (op === Opcodes.br) {
-            hasBranch = true;
-            break;
+
+          if (!hasBranch) {
+            wasm.splice(i, 1); // remove this inst (block)
+            if (i > 0) i--;
+            inst = wasm[i];
+
+            wasm.splice(j - 1, 1); // remove end of this block
+
+            if (optLog) log('opt', `removed unneeded block in for loop`);
           }
         }
 
-        if (!hasBranch) {
-          wasm.splice(i, 1); // remove this inst (block)
-          i--;
+        if (inst[inst.length - 1] === 'string_only' && !pages.hasString) {
+          // remove this inst
+          wasm.splice(i, 1);
+          if (i > 0) i--;
           inst = wasm[i];
+        }
 
-          wasm.splice(j - 1, 1); // remove end of this block
+        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasString) {
+          let j = i;
+          for (; j < wasm.length; j++) {
+            const op = wasm[j];
+            if (op[op.length - 1] === 'string_only|end') break;
+          }
+
+          // remove section
+          wasm.splice(i, 1 + j - i);
 
-          if (optLog) log('opt', `removed unneeded block in for loop`);
+          if (i > 0) i--;
+          inst = wasm[i];
         }
-      }
 
-      if (i < 1) continue;
-      let lastInst = wasm[i - 1];
+        if (inst[0] === Opcodes.if && typeof inst[2] === 'string') {
+          // remove unneeded typeswitch checks
+
+          const type = inst[2].split('|')[1];
+          let missing = false;
+          if (type === 'Array') missing = !pages.hasArray;
+          if (type === 'String') missing = !pages.hasString;
+
+          if (missing) {
+            let j = i, depth = 0;
+            for (; j < wasm.length; j++) {
+              const op = wasm[j][0];
+              if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) depth++;
+              if (op === Opcodes.end) {
+                depth--;
+                if (depth <= 0) break;
+              }
+            }
 
-      if (lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_set && inst[0] === Opcodes.local_get) {
-        // replace set, get -> tee (sets and returns)
-        // local.set 0
-        // local.get 0
-        // -->
-        // local.tee 0
+            wasm.splice(i - 3, 4 + j - i); // remove cond and this if
+            i -= 4;
+            inst = wasm[i];
 
-        lastInst[0] = Opcodes.local_tee; // replace last inst opcode (set -> tee)
-        wasm.splice(i, 1); // remove this inst (get)
+            if (optLog) log('opt', `removed unneeded typeswitch check`);
+          }
+        }
 
-        getCount[inst[1]]--;
-        i--;
-        // if (optLog) log('opt', `consolidated set, get -> tee`);
-        continue;
-      }
+        if (inst[0] === Opcodes.end && inst[1] === 'TYPESWITCH_end') {
+          // remove unneeded entire typeswitch
 
-      if ((lastInst[0] === Opcodes.local_get || lastInst[0] === Opcodes.global_get) && inst[0] === Opcodes.drop) {
-        // replace get, drop -> nothing
-        // local.get 0
-        // drop
-        // -->
-        //
+          let j = i - 1, depth = -1, checks = 0;
+          for (; j > 0; j--) {
+            const op = wasm[j][0];
+            if (op === Opcodes.if || op === Opcodes.block || op === Opcodes.loop || op === Opcodes.try) {
+              depth++;
+              if (depth === 0) break;
+            }
+            if (op === Opcodes.end) depth--;
+            if (wasm[j][2]?.startsWith?.('TYPESWITCH')) checks++;
+          }
 
-        getCount[lastInst[1]]--;
+          if (checks === 0) {
+            // todo: review indexes below
+            wasm.splice(j - 1, 2, [ Opcodes.drop ]); // remove typeswitch start
+            wasm.splice(i - 1, 1); // remove this inst
 
-        wasm.splice(i - 1, 2); // remove this inst and last
-        i -= 2;
-        continue;
-      }
+            if (optLog) log('opt', 'removed unneeded entire typeswitch');
 
-      if (lastInst[0] === Opcodes.local_tee && inst[0] === Opcodes.drop) {
-        // replace tee, drop -> set
-        // local.tee 0
-        // drop
-        // -->
-        // local.set 0
+            if (i > 0) i--;
+            continue;
+          }
+        }
 
-        getCount[lastInst[1]]--;
+        // remove setting last type if it is never gotten
+        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType.idx) {
+          // replace this inst with drop
+          wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
+          if (i > 0) i--;
+        }
 
-        lastInst[0] = Opcodes.local_set; // change last op
+        if (i < 1) continue;
+        let lastInst = wasm[i - 1];
 
-        wasm.splice(i, 1); // remove this inst
-        i--;
-        continue;
-      }
+        if (lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_set && inst[0] === Opcodes.local_get) {
+          // replace set, get -> tee (sets and returns)
+          // local.set 0
+          // local.get 0
+          // -->
+          // local.tee 0
 
-      if ((lastInst[0] === Opcodes.i32_const || lastInst[0] === Opcodes.i64_const || lastInst[0] === Opcodes.f64_const) && inst[0] === Opcodes.drop) {
-        // replace const, drop -> <nothing>
-        // i32.const 0
-        // drop
-        // -->
-        // <nothing>>
+          lastInst[0] = Opcodes.local_tee; // replace last inst opcode (set -> tee)
+          wasm.splice(i, 1); // remove this inst (get)
 
-        wasm.splice(i - 1, 2); // remove this inst
-        i -= 2;
-        continue;
-      }
+          getCount[inst[1]]--;
+          i--;
+          // if (optLog) log('opt', `consolidated set, get -> tee`);
+          continue;
+        }
 
-      if (inst[0] === Opcodes.eq && lastInst[0] === Opcodes.const && lastInst[1] === 0 && valtype !== 'f64') {
-        // replace const 0, eq -> eqz
-        // i32.const 0
-        // i32.eq
-        // -->
-        // i32.eqz
-
-        inst[0] = Opcodes.eqz[0][0]; // eq -> eqz
-        wasm.splice(i - 1, 1); // remove const 0
-        i--;
-        continue;
-      }
+        if ((lastInst[0] === Opcodes.local_get || lastInst[0] === Opcodes.global_get) && inst[0] === Opcodes.drop) {
+          // replace get, drop -> nothing
+          // local.get 0
+          // drop
+          // -->
+          //
 
-      if (inst[0] === Opcodes.i32_wrap_i64 && (lastInst[0] === Opcodes.i64_extend_i32_s || lastInst[0] === Opcodes.i64_extend_i32_u)) {
-        // remove unneeded i32 -> i64 -> i32
-        // i64.extend_i32_s
-        // i32.wrap_i64
-        // -->
-        // <nothing>
-
-        wasm.splice(i - 1, 2); // remove this inst and last
-        i -= 2;
-        // if (optLog) log('opt', `removed redundant i32 -> i64 -> i32 conversion ops`);
-        continue;
-      }
+          getCount[lastInst[1]]--;
 
-      if (inst[0] === Opcodes.i32_trunc_sat_f64_s[0] && (lastInst[0] === Opcodes.f64_convert_i32_u || lastInst[0] === Opcodes.f64_convert_i32_s)) {
-        // remove unneeded i32 -> f64 -> i32
-        // f64.convert_i32_s || f64.convert_i32_u
-        // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
-        // -->
-        // <nothing>
-
-        wasm.splice(i - 1, 2); // remove this inst and last
-        i -= 2;
-        // if (optLog) log('opt', `removed redundant i32 -> f64 -> i32 conversion ops`);
-        continue;
-      }
+          wasm.splice(i - 1, 2); // remove this inst and last
+          i -= 2;
+          continue;
+        }
 
-      if (tailCall && lastInst[0] === Opcodes.call && inst[0] === Opcodes.return) {
-        // replace call, return with tail calls (return_call)
-        // call X
-        // return
-        // -->
-        // return_call X
+        if (lastInst[0] === Opcodes.local_tee && inst[0] === Opcodes.drop) {
+          // replace tee, drop -> set
+          // local.tee 0
+          // drop
+          // -->
+          // local.set 0
 
-        lastInst[0] = Opcodes.return_call; // change last inst return -> return_call
+          getCount[lastInst[1]]--;
 
-        wasm.splice(i, 1); // remove this inst (return)
-        i--;
-        if (optLog) log('opt', `tail called return, call`);
-        continue;
-      }
+          lastInst[0] = Opcodes.local_set; // change last op
 
-      if (false && i === wasm.length - 1 && inst[0] === Opcodes.return) {
-        // replace final return, end -> end (wasm has implicit return)
-        // return
-        // end
-        // -->
-        // end
-
-        wasm.splice(i, 1); // remove this inst (return)
-        i--;
-        // if (optLog) log('opt', `removed redundant return at end`);
-        continue;
-      }
+          wasm.splice(i, 1); // remove this inst
+          i--;
+          continue;
+        }
+
+        if ((lastInst[0] === Opcodes.i32_const || lastInst[0] === Opcodes.i64_const || lastInst[0] === Opcodes.f64_const) && inst[0] === Opcodes.drop) {
+          // replace const, drop -> <nothing>
+          // i32.const 0
+          // drop
+          // -->
+          // <nothing>
+
+          wasm.splice(i - 1, 2); // remove these inst
+          i -= 2;
+          continue;
+        }
 
-      if (i < 2) continue;
-      const lastLastInst = wasm[i - 2];
+        if (inst[0] === Opcodes.eq && lastInst[0] === Opcodes.const && lastInst[1] === 0 && valtype !== 'f64') {
+          // replace const 0, eq -> eqz
+          // i32.const 0
+          // i32.eq
+          // -->
+          // i32.eqz
+
+          inst[0] = Opcodes.eqz[0][0]; // eq -> eqz
+          wasm.splice(i - 1, 1); // remove const 0
+          i--;
+          continue;
+        }
+
+        if (inst[0] === Opcodes.i32_wrap_i64 && (lastInst[0] === Opcodes.i64_extend_i32_s || lastInst[0] === Opcodes.i64_extend_i32_u)) {
+          // remove unneeded i32 -> i64 -> i32
+          // i64.extend_i32_s
+          // i32.wrap_i64
+          // -->
+          // <nothing>
 
-      if (depth.length === 2) {
-        // hack to remove unneeded before get in for loops with (...; i++)
-        if (lastLastInst[0] === Opcodes.end && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get) {
+          wasm.splice(i - 1, 2); // remove this inst and last
+          i -= 2;
+          // if (optLog) log('opt', `removed redundant i32 -> i64 -> i32 conversion ops`);
+          continue;
+        }
+
+        if (inst[0] === Opcodes.i32_trunc_sat_f64_s[0] && (lastInst[0] === Opcodes.f64_convert_i32_u || lastInst[0] === Opcodes.f64_convert_i32_s)) {
+          // remove unneeded i32 -> f64 -> i32
+          // f64.convert_i32_s || f64.convert_i32_u
+          // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+          // -->
+          // <nothing>
+
+          wasm.splice(i - 1, 2); // remove this inst and last
+          i -= 2;
+          // if (optLog) log('opt', `removed redundant i32 -> f64 -> i32 conversion ops`);
+          continue;
+        }
+
+        if (lastInst[0] === Opcodes.const && (inst === Opcodes.i32_to || inst === Opcodes.i32_to_u)) {
+          // change const and immediate i32 convert to i32 const
+          // f64.const 0
+          // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+          // -->
+          // i32.const 0
+
+          wasm[i - 1] = number((valtype === 'f64' ? read_ieee754_binary64 : read_signedLEB128)(lastInst.slice(1)), Valtype.i32)[0]; // f64.const -> i32.const
+
+          wasm.splice(i, 1); // remove this inst
+          i--;
+          if (optLog) log('opt', `converted const -> i32 convert into i32 const`);
+          continue;
+        }
+
+        if (lastInst[0] === Opcodes.i32_const && (inst === Opcodes.i32_from || inst === Opcodes.i32_from_u)) {
+          // change i32 const and immediate convert to const (opposite way of previous)
+          // i32.const 0
+          // f64.convert_i32_s || f64.convert_i32_u
+          // -->
+          // f64.const 0
+
+          wasm[i - 1] = number(read_signedLEB128(lastInst.slice(1)))[0]; // i32.const -> f64.const
+
+          wasm.splice(i, 1); // remove this inst
+          i--;
+          if (optLog) log('opt', `converted i32 const -> convert into const`);
+          continue;
+        }
+
+        if (tailCall && lastInst[0] === Opcodes.call && inst[0] === Opcodes.return) {
+          // replace call, return with tail calls (return_call)
+          // call X
+          // return
+          // -->
+          // return_call X
+
+          lastInst[0] = Opcodes.return_call; // change last inst return -> return_call
+
+          wasm.splice(i, 1); // remove this inst (return)
+          i--;
+          if (optLog) log('opt', `tail called return, call`);
+          continue;
+        }
+
+        if (false && i === wasm.length - 1 && inst[0] === Opcodes.return) {
+          // replace final return, end -> end (wasm has implicit return)
+          // return
+          // end
+          // -->
+          // end
+
+          wasm.splice(i, 1); // remove this inst (return)
+          i--;
+          // if (optLog) log('opt', `removed redundant return at end`);
+          continue;
+        }
+
+        // remove unneeded before get with update exprs (n++, etc) when value is unused
+        if (i < wasm.length - 4 && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get && wasm[i + 1][0] === Opcodes.const && [Opcodes.add, Opcodes.sub].includes(wasm[i + 2][0]) && wasm[i + 3][0] === Opcodes.local_set && wasm[i + 3][1] === inst[1] && (wasm[i + 4][0] === Opcodes.drop || wasm[i + 4][0] === Opcodes.br)) {
           // local.get 1
           // local.get 1
           // -->
           // local.get 1
 
           // remove drop at the end as well
-          if (wasm[i + 4][0] === Opcodes.drop) {
-            wasm.splice(i + 4, 1);
-          }
+          if (wasm[i + 4][0] === Opcodes.drop) wasm.splice(i + 4, 1);
 
           wasm.splice(i, 1); // remove this inst (second get)
           i--;
           continue;
         }
-      }
 
-      if (lastLastInst[1] === inst[1] && inst[0] === Opcodes.local_get && lastInst[0] === Opcodes.local_tee && lastLastInst[0] === Opcodes.local_set) {
-        // local.set x
-        // local.tee y
-        // local.get x
-        // -->
-        // <nothing>
-
-        wasm.splice(i - 2, 3); // remove this, last, 2nd last insts
-        if (optLog) log('opt', `removed redundant inline param local handling`);
-        i -= 3;
-        continue;
+        if (i < 2) continue;
+        const lastLastInst = wasm[i - 2];
+
+        if (lastLastInst[1] === inst[1] && inst[0] === Opcodes.local_get && lastInst[0] === Opcodes.local_tee && lastLastInst[0] === Opcodes.local_set) {
+          // local.set x
+          // local.tee y
+          // local.get x
+          // -->
+          // <nothing>
+
+          wasm.splice(i - 2, 3); // remove this, last, 2nd last insts
+          if (optLog) log('opt', `removed redundant inline param local handling`);
+          i -= 3;
+          continue;
+        }
       }
-    }
 
-    if (optLevel < 2) continue;
+      if (optLevel < 2) continue;
 
-    if (optLog) log('opt', `get counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${getCount[f.locals[x].idx]}`).join(', ')}`);
+      if (optLog) log('opt', `get counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${getCount[f.locals[x].idx]}`).join(', ')}`);
 
-    // remove unneeded var: remove pass
-    // locals only got once. we don't need to worry about sets/else as these are only candidates and we will check for matching set + get insts in wasm
-    let unneededCandidates = Object.keys(getCount).filter(x => getCount[x] === 0 || (getCount[x] === 1 && setCount[x] === 0)).map(x => parseInt(x));
-    if (optLog) log('opt', `found unneeded locals candidates: ${unneededCandidates.join(', ')} (${unneededCandidates.length}/${Object.keys(getCount).length})`);
+      // remove unneeded var: remove pass
+      // locals only got once. we don't need to worry about sets/else as these are only candidates and we will check for matching set + get insts in wasm
+      let unneededCandidates = Object.keys(getCount).filter(x => getCount[x] === 0 || (getCount[x] === 1 && setCount[x] === 0)).map(x => parseInt(x));
+      if (optLog) log('opt', `found unneeded locals candidates: ${unneededCandidates.join(', ')} (${unneededCandidates.length}/${Object.keys(getCount).length})`);
 
-    // note: disabled for now due to instability
-    if (unneededCandidates.length > 0 && false) for (let i = 0; i < wasm.length; i++) {
-      if (i < 1) continue;
+      // note: disabled for now due to instability
+      if (unneededCandidates.length > 0 && false) for (let i = 0; i < wasm.length; i++) {
+        if (i < 1) continue;
 
-      const inst = wasm[i];
-      const lastInst = wasm[i - 1];
+        const inst = wasm[i];
+        const lastInst = wasm[i - 1];
 
-      if (lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_set && inst[0] === Opcodes.local_get && unneededCandidates.includes(inst[1])) {
-        // local.set N
-        // local.get N
-        // -->
-        // <nothing>
+        if (lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_set && inst[0] === Opcodes.local_get && unneededCandidates.includes(inst[1])) {
+          // local.set N
+          // local.get N
+          // -->
+          // <nothing>
 
-        wasm.splice(i - 1, 2); // remove insts
-        i -= 2;
-        delete f.locals[Object.keys(f.locals)[inst[1]]]; // remove from locals
-        if (optLog) log('opt', `removed redundant local (get set ${inst[1]})`);
-      }
+          wasm.splice(i - 1, 2); // remove insts
+          i -= 2;
+          delete f.locals[Object.keys(f.locals)[inst[1]]]; // remove from locals
+          if (optLog) log('opt', `removed redundant local (get set ${inst[1]})`);
+        }
 
-      if (inst[0] === Opcodes.local_tee && unneededCandidates.includes(inst[1])) {
-        // local.tee N
-        // -->
-        // <nothing>
+        if (inst[0] === Opcodes.local_tee && unneededCandidates.includes(inst[1])) {
+          // local.tee N
+          // -->
+          // <nothing>
 
-        wasm.splice(i, 1); // remove inst
-        i--;
+          wasm.splice(i, 1); // remove inst
+          i--;
 
-        const localName = Object.keys(f.locals)[inst[1]];
-        const removedIdx = f.locals[localName].idx;
-        delete f.locals[localName]; // remove from locals
+          const localName = Object.keys(f.locals)[inst[1]];
+          const removedIdx = f.locals[localName].idx;
+          delete f.locals[localName]; // remove from locals
 
-        // fix locals index for locals after
-        for (const x in f.locals) {
-          const local = f.locals[x];
-          if (local.idx > removedIdx) local.idx--;
-        }
+          // fix locals index for locals after
+          for (const x in f.locals) {
+            const local = f.locals[x];
+            if (local.idx > removedIdx) local.idx--;
+          }
 
-        for (const inst of wasm) {
-          if ((inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) && inst[1] > removedIdx) inst[1]--;
-        }
+          for (const inst of wasm) {
+            if ((inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) && inst[1] > removedIdx) inst[1]--;
+          }
 
-        unneededCandidates.splice(unneededCandidates.indexOf(inst[1]), 1);
-        unneededCandidates = unneededCandidates.map(x => x > removedIdx ? (x - 1) : x);
+          unneededCandidates.splice(unneededCandidates.indexOf(inst[1]), 1);
+          unneededCandidates = unneededCandidates.map(x => x > removedIdx ? (x - 1) : x);
 
-        if (optLog) log('opt', `removed redundant local ${localName} (tee ${inst[1]})`);
+          if (optLog) log('opt', `removed redundant local ${localName} (tee ${inst[1]})`);
+        }
       }
-    }
 
-    const useCount = {};
-    for (const x in f.locals) useCount[f.locals[x].idx] = 0;
+      const useCount = {};
+      for (const x in f.locals) useCount[f.locals[x].idx] = 0;
 
-    // final pass
-    depth = [];
-    for (let i = 0; i < wasm.length; i++) {
-      let inst = wasm[i];
-      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) useCount[inst[1]]++;
+      // final pass
+      depth = [];
+      for (let i = 0; i < wasm.length; i++) {
+        let inst = wasm[i];
+        if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) useCount[inst[1]]++;
 
-      if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
-      if (inst[0] === Opcodes.end) depth.pop();
+        if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
+        if (inst[0] === Opcodes.end) depth.pop();
 
-      if (i < 2) continue;
-      const lastInst = wasm[i - 1];
-      const lastLastInst = wasm[i - 2];
+        if (i < 2) continue;
+        const lastInst = wasm[i - 1];
+        const lastLastInst = wasm[i - 2];
 
-      // todo: add more math ops
-      if (optLevel >= 3 && (inst[0] === Opcodes.add || inst[0] === Opcodes.sub || inst[0] === Opcodes.mul) && lastLastInst[0] === Opcodes.const && lastInst[0] === Opcodes.const) {
-        // inline const math ops
-        // i32.const a
-        // i32.const b
-        // i32.add
-        // -->
-        // i32.const a + b
+        // todo: add more math ops
+        if (optLevel >= 3 && (inst[0] === Opcodes.add || inst[0] === Opcodes.sub || inst[0] === Opcodes.mul) && lastLastInst[0] === Opcodes.const && lastInst[0] === Opcodes.const) {
+          // inline const math ops
+          // i32.const a
+          // i32.const b
+          // i32.add
+          // -->
+          // i32.const a + b
 
-        // does not work with leb encoded
-        if (lastInst.length > 2 || lastLastInst.length > 2) continue;
+          // does not work with leb encoded
+          if (lastInst.length > 2 || lastLastInst.length > 2) continue;
 
-        let a = lastLastInst[1];
-        let b = lastInst[1];
+          let a = lastLastInst[1];
+          let b = lastInst[1];
 
-        const val = performWasmOp(inst[0], a, b);
-        if (optLog) log('opt', `inlined math op (${a} ${inst[0].toString(16)} ${b} -> ${val})`);
+          const val = performWasmOp(inst[0], a, b);
+          if (optLog) log('opt', `inlined math op (${a} ${inst[0].toString(16)} ${b} -> ${val})`);
 
-        wasm.splice(i - 2, 3, ...number(val)); // remove consts, math op and add new const
-        i -= 2;
+          wasm.splice(i - 2, 3, ...number(val)); // remove consts, math op and add new const
+          i -= 2;
+        }
       }
-    }
 
-    const localIdxs = Object.values(f.locals).map(x => x.idx);
-    // remove unused locals (cleanup)
-    for (const x in useCount) {
-      if (useCount[x] === 0) {
-        const name = Object.keys(f.locals)[localIdxs.indexOf(parseInt(x))];
-        if (optLog) log('opt', `removed internal local ${x} (${name})`);
-        delete f.locals[name];
+      const localIdxs = Object.values(f.locals).map(x => x.idx);
+      // remove unused locals (cleanup)
+      for (const x in useCount) {
+        if (useCount[x] === 0) {
+          const name = Object.keys(f.locals)[localIdxs.indexOf(parseInt(x))];
+          if (optLog) log('opt', `removed internal local ${x} (${name})`);
+          delete f.locals[name];
+        }
       }
-    }
 
-    if (optLog) log('opt', `final use counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${useCount[f.locals[x].idx]}`).join(', ')}`);
+      if (optLog) log('opt', `final use counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${useCount[f.locals[x].idx]}`).join(', ')}`);
+    }
   }
 
   // return funcs;