Calculating the GCD - Wasmtime

# Calculating the GCD

You can also browse this source code online and clone the wasmtime repository to run the example locally.

This example shows off how run a wasm program which calculates the GCD of two numbers.

## `gcd.wat`

    (module
      (func $gcd (param i32 i32) (result i32)
        (local i32)
        block  ;; label = @1
          block  ;; label = @2
            local.get 0
            br_if 0 (;@2;)
            local.get 1
            local.set 2
            br 1 (;@1;)
          end
          loop  ;; label = @2
            local.get 1
            local.get 0
            local.tee 2
            i32.rem_u
            local.set 0
            local.get 2
            local.set 1
            local.get 0
            br_if 0 (;@2;)
          end
        end
        local.get 2
      )
      (export "gcd" (func $gcd))
    )

## `gcd.c`

    /*
    Example of instantiating of the WebAssembly module and invoking its exported
    function.

    You can compile and run this example on Linux with:

       cargo build --release -p wasmtime-c-api
       cc examples/gcd.c \
           -I crates/c-api/include \
           target/release/libwasmtime.a \
           -lpthread -ldl -lm \
           -o gcd
       ./gcd

    Note that on Windows and macOS the command will be similar, but you'll need
    to tweak the `-lpthread` and such annotations.

    You can also build using cmake:

    mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-gcd
    */

    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <wasm.h>
    #include <wasmtime.h>

    static void exit_with_error(const char *message, wasmtime_error_t *error,
                                wasm_trap_t *trap);

    int main() {
      int ret = 0;
      // Set up our context
      wasm_engine_t *engine = wasm_engine_new();
      assert(engine != NULL);
      wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
      assert(store != NULL);
      wasmtime_context_t *context = wasmtime_store_context(store);

      // Load our input file to parse it next
      FILE *file = fopen("examples/gcd.wat", "r");
      if (!file) {
        printf("> Error loading file!\n");
        return 1;
      }
      fseek(file, 0L, SEEK_END);
      size_t file_size = ftell(file);
      fseek(file, 0L, SEEK_SET);
      wasm_byte_vec_t wat;
      wasm_byte_vec_new_uninitialized(&wat, file_size);
      if (fread(wat.data, file_size, 1, file) != 1) {
        printf("> Error loading module!\n");
        return 1;
      }
      fclose(file);

      // Parse the wat into the binary wasm format
      wasm_byte_vec_t wasm;
      wasmtime_error_t *error = wasmtime_wat2wasm(wat.data, wat.size, &wasm);
      if (error != NULL)
        exit_with_error("failed to parse wat", error, NULL);
      wasm_byte_vec_delete(&wat);

      // Compile and instantiate our module
      wasmtime_module_t *module = NULL;
      error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
      if (module == NULL)
        exit_with_error("failed to compile module", error, NULL);
      wasm_byte_vec_delete(&wasm);

      wasm_trap_t *trap = NULL;
      wasmtime_instance_t instance;
      error = wasmtime_instance_new(context, module, NULL, 0, &instance, &trap);
      if (error != NULL || trap != NULL)
        exit_with_error("failed to instantiate", error, trap);

      // Lookup our `gcd` export function
      wasmtime_extern_t gcd;
      bool ok = wasmtime_instance_export_get(context, &instance, "gcd", 3, &gcd);
      assert(ok);
      assert(gcd.kind == WASMTIME_EXTERN_FUNC);

      // And call it!
      int a = 6;
      int b = 27;
      wasmtime_val_t params[2];
      params[0].kind = WASMTIME_I32;
      params[0].of.i32 = a;
      params[1].kind = WASMTIME_I32;
      params[1].of.i32 = b;
      wasmtime_val_t results[1];
      error =
          wasmtime_func_call(context, &gcd.of.func, params, 2, results, 1, &trap);
      if (error != NULL || trap != NULL)
        exit_with_error("failed to call gcd", error, trap);
      assert(results[0].kind == WASMTIME_I32);

      printf("gcd(%d, %d) = %d\n", a, b, results[0].of.i32);

      // Clean up after ourselves at this point
      ret = 0;

      wasmtime_module_delete(module);
      wasmtime_store_delete(store);
      wasm_engine_delete(engine);
      return ret;
    }

    static void exit_with_error(const char *message, wasmtime_error_t *error,
                                wasm_trap_t *trap) {
      fprintf(stderr, "error: %s\n", message);
      wasm_byte_vec_t error_message;
      if (error != NULL) {
        wasmtime_error_message(error, &error_message);
      } else {
        wasm_trap_message(trap, &error_message);
      }
      fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
      wasm_byte_vec_delete(&error_message);
      exit(1);
    }