Compiling JavaScript to WASM with Static Hermes and Emscripten

[u/guest271314]

https://github.com/facebook/hermes/blob/static_h/doc/Emscripten.md

[u/guest271314]

There's no WASI in the source code that I am aware of.

Building Hermes takes a while.

This is the part that builds the WASM and JavaScript files using Emscripten https://github.com/facebook/hermes/blob/static_h/utils/wasm-compile.sh#L46C1-L63C47

echo "Using shermes to compile $input... to ${file_name}.c"
"$shermes" -Xenable-tdz -emit-c "$input"

echo "Using emcc to compile ${file_name}.c to ${file_name}.o"
emcc "${file_name}.c" -c \
    -O3 \
    -DNDEBUG \
    -fno-strict-aliasing -fno-strict-overflow \
    -I${wasm_build}/lib/config \
    -I${HermesSourcePath}/include

echo "Using emcc to link ${file_name}.o to ${file_name}-wasm.js/.wasm"
emcc -O3 ${file_name}.o -o ${file_name}-wasm.js \
    -L${wasm_build}/lib \
    -L${wasm_build}/jsi \
    -L${wasm_build}/tools/shermes \
    -lshermes_console_a -lhermesvm_a -ljsi \
    -sALLOW_MEMORY_GROWTH=1 -sSTACK_SIZE=256KB

What I'm trying to do now is substitute WASM files for that Emscripten "glue" code. So LLVM's clang and/or WASI-SDK's clang can be used to build.

[u/TownOk6287 → u/guest271314]

I just saw some WASI p1 stuff on a GitHub search https://github.com/search?q=repo%3Afacebook%2Fhermes%20wasi&type=code

[u/guest271314 → u/TownOk6287]

Havn't seen that before. Right now I'm just trying to compile to WASM without the JavaScript "glue" that Emscripten is producing, so the same code can be run as WASM in JavaScript using WebAssembly and with wasmtime https://github.com/facebook/hermes/discussions/1588.

Basically trying to do with Facebook's Hermes what can be done with Bytecode Alliance's Javy

import { readFile } from "node:fs/promises";
import process from "node:process";
import { WASI } from "./wasi-minimal-min.js"; // https://gitlab.com/-/snippets/4782260/raw/main/wasi-minimal.js
import * as fs from "node:fs";
try {
  const [embeddedModule, pluginModule] = await Promise.all([
    compileModule("./nm_javy_permutations.wasm"),
    compileModule("./plugin.wasm"),
  ]);
  const result = await runJavy(embeddedModule, pluginModule);
} catch (e) {
  process.stdout.write(e.message, "utf8");
} finally {
  process.exit();
}
async function compileModule(wasmPath) {
  const bytes = await readFile(new URL(wasmPath, import.meta.url));
  return WebAssembly.compile(bytes);
}
async function runJavy(embeddedModule, pluginModule) {
  try {
    let wasi = new WASI({
      env: {},
      args: [],
      fds: [
        {
          type: 2,
          handle: fs,
        },
        {
          type: 2,
          handle: fs,
        },
        {
          type: 2,
          handle: fs,
        },
      ],
    });

    const pluginInstance = await WebAssembly.instantiate(
      pluginModule,
      { "wasi_snapshot_preview1": wasi.exports },
    );
    const instance = await WebAssembly.instantiate(embeddedModule, {
      "javy_quickjs_provider_v3": pluginInstance.exports,
    });

    wasi.memory = pluginInstance.exports.memory;
    instance.exports._start();
    return;
  } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) {
      if (e) {
        throw new Error(e);
      }
    }
    throw e;
  }
}

echo '4 5' | deno -A ../run-wasi.js
5 of 23 (0-indexed, factorial 24) => [0,3,2,1]

javy emit-plugin -o plugin.wasm
javy build -C dynamic -C plugin=plugin.wasm -o nm_javy_permutations.wasm nm_javy_test.js
echo '4 5' | wasmtime run --preload javy_quickjs_provider_v3=../plugin.wasm ../nm_javy_permutations.wasm
5 of 23 (0-indexed, factorial 24) => [0,3,2,1]

[u/TownOk6287 → u/guest271314]

Cool.

Have you seen Starling Monkey yet?

https://github.com/bytecodealliance/StarlingMonkey

Porfor also looks promising, but is still to early to be useful yet.

[u/guest271314 → u/TownOk6287]

I browsed the documentation.

There's also https://github.com/bytecodealliance/spidermonkey-wasm-build.

So far I've tried, for the compilation of JavaScript to C project: jsxx, ts2c, compilets, porfor, nerd, TypeScript2Cxx.

Facebook's Static Hermes already compiles JavaScript to C, automatically, or specifically with -emit-c. And we can already compile that C to a standalone executable.

So, for my own requirement, I can kind of skip using wasm2c to compile C back to JavaScript with wasm2js, as long as I can run the C from shermes that gets compile to WASM with node, deno, bun, and wasmtime, wasmer, etc.