Compile to Webassembly

[trdthg]

I did some interesting experiments and proved that it is possible to compile sail to WebAssembly. Maybe it can be of some help

• Maybe someone wants to create a RISC-V encoder/decoder on the web based on Sail
• Maybe someone wants to run an operating system on the web

Compile Steps

1. Prepare emscripten (which uses the llvm webassembly target)

2. Prepare zlib (compiled with emscripten), gmp, softfloat

3. Compile sail model

   • replace libs to wasm

   • replace gcc with emcc

      c_emulator/wasm_riscv_sim_$(ARCH):  generated_definitions/c/riscv_model_$(ARCH).c $(C_INCS) $(C_SRCS) $(SOFTFLOAT_LIBS) Makefile
      	emcc -g $(C_WARNINGS) $(C_FLAGS) $< $(C_SRCS) $(SAIL_LIB_DIR)/*.c $(C_LIBS) -o riscv_sim_RV64.wasm

Output

size 4.3M

file ./riscv_sim_RV64.wasm     
./riscv_sim_RV64.wasm: WebAssembly (wasm) binary module version 0x1 (MVP)

Show

run it on web

But wasm can't access file system (I found some information saying you can package files together with wasm), the experiment ends here

[Timmmm]

That is very cool! I was wondering about this but I always assumed libgmp would be a right pig to compile to wasm.

Do you think you could provide a script or something (maybe a Dockerfile) to show all of your steps?

Maybe someone wants to create a RISC-V encoder/decoder on the web based on Sail.

Yes! I have actually made a basic frontend for our internal use for this:

It's not as fancy as rvcodec.js but it's useful for instructions that that doesn't have.

It also decodes CHERI capabilities

Currently I just execute a native binary but it would be nice to use WASM.

I think it would also be very cool to make an interactive emulator where you can load some example ELFs and then step through the assembly, and it would show all the register values and memory accesses and so on. That's kind of a huge project though.

[trdthg]

Do you think you could provide a script or something (maybe a Dockerfile) to show all of your steps?

I put them(include the web page) here: https://github.com/trdthg/sail-riscv-wasm

[trdthg]

Yes! I have actually made a basic frontend for our internal use for this:

We have also been wanting a better version that supports more extensions than rvcodec.js . It would be great if you could open source it and, for example, deploy it on GitHub Pages.

[Timmmm]

This is great, thanks! I think tbh I won't have time to do this (so many projects!) but hopefully someone else will. There's really not much to my version. I just run a Fresh web server with this route:

import { FreshContext } from "$fresh/server.ts";

type Model = "rv32" | "rv64" | "rv32_cheri" | "rv64_cheri"

async function decompileInstruction(model: Model, instruction: string): Promise<string> {
  try {
    const command = new Deno.Command("rvutil", {
      args: [
          "dis",
          model,
          instruction,
      ],
    });

    const { code, stdout, stderr } = await command.output();

    if (code !== 0) {
      throw Error(`Disassembly failed\n\nStdout\n\n${stdout}\n\nStderr\n\n${stderr}`)
    }
    return new TextDecoder().decode(stdout);
  } catch (e) {
    return `Error: ${e}`;
  }
}


export default async function Decompiler(req: Request, _ctx: FreshContext) {
  const url = new URL(req.url);
  const instruction = url.searchParams.get("instruction") || "";
  // TODO: Allow choosing model.
  const decompilation = instruction === "" ? "" : await decompileInstruction("rv64_cheri", instruction);

  return <div class="m-10 max-w-3xl mx-auto">
    <h1 class="mb-4 text-4xl font-extrabold">RISC-V Instruction Decompiler</h1>
      <p>Model: <code>rv64_cheri</code></p>
      <form>
        <input type="text" name="instruction" placeholder="0x..." value={instruction}
          class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 p-2.5 w-96 my-2"
        />
        <button type="submit" class="text-white bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:outline-none focus:ring-blue-300 rounded-lg w-auto px-5 py-2.5 text-center m-2">
          Decompile
        </button>
      </form>
      <pre>{decompilation}</pre>
    </div>;
}

rvutil is a very simple binary that I added to the model:

#include <iostream>

#include "model.h"

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <command> ...\n\nCommands are: dis, cap\n";
        return 1;
    }

    std::string command = argv[1];
    if (command == "dis") {
        // Disassemble
        if (argc != 4) {
            std::cerr << "Usage: " << argv[0] << " dis <architecture> <instruction opcode in hex with no 0x>\n";
            return 1;
        }

        std::string arch = argv[2];
        uint32_t instruction = std::stoul(argv[3], nullptr, 16);

        // For disassembly, enable lots of things that are disabled by default.
        auto config = sail::RiscvConfig();
        config.sys_enable_zfh = true;
        config.sys_enable_zcb = true;
        config.sys_enable_bext = true;
        config.sys_enable_zkn = true;
        config.sys_enable_zks = true;
        config.sys_enable_zkr = true;
        config.sys_enable_svinval = true;
        config.sys_enable_vext = true;
        config.sys_enable_zvfh = true;

        auto model = sail::Model::make(sail::architectureFromString(arch), config);
        std::cout << model->disassemble(instruction) << "\n";
    } else if (command == "cap") {
        // Decode cap
        if (argc != 6) {
            std::cerr
                << "Usage: " << argv[0]
                << " cap <architecture> <tag: 1 or 0> <capability metadata in hex with no 0x> <capability address in "
                   "hex with no 0x>\n";
            return 1;
        }

        std::string arch = argv[2];
        uint64_t tag = std::stoull(argv[3], nullptr, 16);
        uint64_t metadata = std::stoull(argv[4], nullptr, 16);
        uint64_t address = std::stoull(argv[5], nullptr, 16);

        if (tag != 0 && tag != 1) {
            std::cerr << "Tag must be 0 or 1";
            return 1;
        }

        auto model = sail::Model::make(sail::architectureFromString(arch), sail::RiscvConfig());
        std::cout << model->decodeCapability(tag == 1, metadata, address) << "\n";
    }
    return 0;
}

The sail::Model stuff is our C++ wrapper, but if you follow it to the Sail it's just calling this Sail function:

// Little wrapper to perform disassembly on a 16 bit RVC or 32 bit instruction.

function disassemble(instruction: bits(32)) -> string = {
    // Save and restore the FS/VS flags. If they are zero then those extensions are disabled.
    let prev_mstatus = mstatus;

    mstatus[FS] = 0b01;
    mstatus[VS] = 0b01;

    let disassembly = assembly(
        if isRVC(instruction[15..0])
        then encdec_compressed(instruction[15..0])
        else encdec(instruction)
    );

    mstatus = prev_mstatus;

    disassembly
}

[Alasdair]

An entirely different approach is to compile the Sail into OCaml and then use Js_of_ocaml to run the OCaml bytecode as javascript. That's how the RISC-V support in RMEM was implemented e.g. this RISC-V concurrency test but it's quite a bit out-of-date now.

[Timmmm]

Does that use JS BigInt? That's probably better. Although I think you lose float support?

[Alasdair]

Yes, the Zarith library in OCaml can use JS BigInt with Js_of_ocaml. You do indeed lose float support though.