/ 
Wasm-0.23
River stage one • 1 direct dependent • 1 total dependent
/ Wasm::Wasmtime::Linker

NAME

Wasm::Wasmtime::Linker - Wasmtime linker class

VERSION

version 0.23

SYNOPSIS

use Wasm::Wasmtime;

my $store  = Wasm::Wasmtime::Store->new;
my $linker = Wasm::Wasmtime::Linker->new($store);

# Instanciate and define a WASI instance
my $wasi = Wasm::Wasmtime::WasiInstance->new(
  $store,
  "wasi_snapshot_preview1",
  Wasm::Wasmtime::WasiConfig
    ->new
    ->inherit_stdout
);
$linker->define_wasi($wasi);

# Create a logger module + instance
my $logger = $linker->instantiate(
  Wasm::Wasmtime::Module->new(
    $store->engine,
    wat => q{
      (module
        (type $fd_write_ty (func (param i32 i32 i32 i32) (result i32)))
        (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (type $fd_write_ty)))

        (func (export "log") (param i32 i32)
          ;; store the pointer in the first iovec field
          i32.const 4
          local.get 0
          i32.store

          ;; store the length in the first iovec field
          i32.const 4
          local.get 1
          i32.store offset=4

          ;; call the `fd_write` import
          i32.const 1     ;; stdout fd
          i32.const 4     ;; iovs start
          i32.const 1     ;; number of iovs
          i32.const 0     ;; where to write nwritten bytes
          call $fd_write
          drop
        )

        (memory (export "memory") 2)
        (global (export "memory_offset") i32 (i32.const 65536))
      )
    },
  )
);
$linker->define_instance("logger", $logger);

# Create a caller module + instance
my $caller = $linker->instantiate(
  Wasm::Wasmtime::Module->new(
    $store->engine,
    wat => q{
      (module
        (import "logger" "log" (func $log (param i32 i32)))
        (import "logger" "memory" (memory 1))
        (import "logger" "memory_offset" (global $offset i32))

        (func (export "run")
          ;; Our `data` segment initialized our imported memory, so let's print the
          ;; string there now.
          global.get $offset
          i32.const 14
          call $log
        )

        (data (global.get $offset) "Hello, world!\n")
      )
    },
  ),
);
$caller->exports->run->();

DESCRIPTION

WARNING: WebAssembly and Wasmtime are a moving target and the interface for these modules is under active development. Use with caution.

This class represents a WebAssembly linker.

CONSTRUCTOR

new

my $linker = Wasm::Wasmtime::Linker->new(
  $store,        # Wasm::Wasmtime::Store
);

Create a new WebAssembly linker object.

METHODS

allow_shadowing

$linker->allow_shadowing($bool);

Sets the allow shadowing property.

define

$linker->define(
  $module,
  $name,
  $extern,    # Wasm::Wasmtime::Extern
);

Define the given extern. You can use a func, global, table or memory object in its place and this method will get the extern for you.

define_wasi

$linker->define_wasi(
  $wasi,   # Wasm::Wasmtime::WasiInstance
);

Define WASI instance.

define_instance

$linker->define_instance(
  $name,       # string
  $instance,   # Wasm::Wasmtime::Instance
);

Define WebAssembly instance.

instantiate

my $instance = $linker->instantiate(
  $module,
);

Instantiate the module using the linker. Returns the new Wasm::Wasmtime::Instance object.

get_one_by_name

my $extern = $linker->get_one_by_name($module,$name);

Returns the Wasm::Wasmtime::Extern for the given $module and $name. undef is returned if there is no such extern with that $name.

get_default

my $func = $linker->get_default($name);

Acquires the "default export" of the named module in this linker. Returns a Wasm::Wasmtime::Func.

store

my $store = $linker->store;

Returns the Wasm::Wasmtime::Store for the linker.

SEE ALSO

Wasm
Wasm::Wasmtime

AUTHOR

Graham Ollis <plicease@cpan.org>

COPYRIGHT AND LICENSE

This software is copyright (c) 2020-2022 by Graham Ollis.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.