@grain/binaryen.ml 0.18.0 → 0.19.0

binaryen-archive/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@grain/binaryen.ml",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "OCaml bindings for Binaryen.",
   "author": "Oscar Spencer <oscar@grain-lang.org>",
   "license": "Apache-2.0",
   "dependencies": {
     "ocaml": ">= 4.12.0",
-    "@grain/libbinaryen": ">= 108.0.0 < 109.0.0",
+    "@grain/libbinaryen": ">= 109.0.0 < 110.0.0",
     "@opam/dune": ">= 2.9.1",
     "@opam/dune-configurator": ">= 2.9.1"
   },

binaryen-archive/src/binaryen_stubs_imports.c

@@ -74,6 +74,13 @@ caml_binaryen_function_import_get_module(value _fun) {
   CAMLreturn(caml_copy_string(BinaryenFunctionImportGetModule(fun)));
 }
 
+CAMLprim value
+caml_binaryen_memory_import_get_module(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetModule(module)));
+}
+
 CAMLprim value
 caml_binaryen_global_import_get_module(value _global) {
   CAMLparam1(_global);
@@ -88,6 +95,13 @@ caml_binaryen_function_import_get_base(value _fun) {
   CAMLreturn(caml_copy_string(BinaryenFunctionImportGetBase(fun)));
 }
 
+CAMLprim value
+caml_binaryen_memory_import_get_base(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetBase(module)));
+}
+
 CAMLprim value
 caml_binaryen_global_import_get_base(value _global) {
   CAMLparam1(_global);

binaryen-archive/src/binaryen_stubs_imports.js

@@ -100,6 +100,13 @@ function caml_binaryen_function_import_get_module(func) {
   return caml_string_of_jsstring(func_info.module);
 }
 
+//Provides: caml_binaryen_memory_import_get_module
+//Requires: caml_string_of_jsstring
+function caml_binaryen_memory_import_get_module(mod) {
+  var memory_info = mod.getMemoryInfo();
+  return caml_string_of_jsstring(memory_info.module);
+}
+
 //Provides: caml_binaryen_global_import_get_module
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -116,6 +123,13 @@ function caml_binaryen_function_import_get_base(func) {
   return caml_string_of_jsstring(func_info.base);
 }
 
+//Provides: caml_binaryen_memory_import_get_base
+//Requires: caml_string_of_jsstring
+function caml_binaryen_memory_import_get_base(mod) {
+  var memory_info = mod.getMemoryInfo();
+  return caml_string_of_jsstring(memory_info.base);
+}
+
 //Provides: caml_binaryen_global_import_get_base
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring

binaryen-archive/src/binaryen_stubs_memory.c

@@ -47,3 +47,43 @@ CAMLprim value
 caml_binaryen_set_memory__bytecode(value * argv) {
   return caml_binaryen_set_memory(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
 }
+
+CAMLprim value
+caml_binaryen_has_memory(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_bool(BinaryenHasMemory(module)));
+}
+
+CAMLprim value
+caml_binaryen_memory_get_initial(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_int(BinaryenMemoryGetInitial(module)));
+}
+
+CAMLprim value
+caml_binaryen_memory_has_max(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_bool(BinaryenMemoryHasMax(module)));
+}
+
+CAMLprim value
+caml_binaryen_memory_get_max(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  if (BinaryenMemoryHasMax(module)) {
+    CAMLreturn(Val_int(BinaryenMemoryGetMax(module)));
+  } else {
+    // This ensures that our return is equal to Memory.unlimited
+    CAMLreturn(Val_int(-1));
+  }
+}
+
+CAMLprim value
+caml_binaryen_memory_is_shared(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_bool(BinaryenMemoryIsShared(module)));
+}

binaryen-archive/src/binaryen_stubs_memory.js

@@ -25,3 +25,44 @@ function caml_binaryen_set_memory(wasm_mod, initial, maximum, exportName, segmen
 function caml_binaryen_set_memory__bytecode() {
   return caml_binaryen_set_memory(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8]);
 }
+
+//Provides: caml_binaryen_has_memory
+//Requires: caml_js_to_bool
+function caml_binaryen_has_memory(mod) {
+  return caml_js_to_bool(mod.hasMemory());
+}
+
+//Provides: caml_binaryen_memory_get_initial
+function caml_binaryen_memory_get_initial(mod) {
+  var memory_info = mod.getMemoryInfo();
+  return memory_info.initial;
+}
+
+//Provides: caml_binaryen_memory_has_max
+//Requires: caml_js_to_bool
+function caml_binaryen_memory_has_max(mod) {
+  var memory_info = mod.getMemoryInfo();
+  if (memory_info.max != null) {
+    return caml_js_to_bool(true);
+  } else {
+    return caml_js_to_bool(false);
+  }
+}
+
+//Provides: caml_binaryen_memory_get_max
+function caml_binaryen_memory_get_max(mod) {
+  var memory_info = mod.getMemoryInfo();
+  if (memory_info.max != null) {
+    return memory_info.max;
+  } else {
+    // This ensures that our return is equal to Memory.unlimited
+    return -1;
+  }
+}
+
+//Provides: caml_binaryen_memory_is_shared
+//Requires: caml_js_to_bool
+function caml_binaryen_memory_is_shared(mod) {
+  var memory_info = mod.getMemoryInfo();
+  return caml_js_to_bool(memory_info.shared);
+}

binaryen-archive/src/binaryen_stubs_modules.c

@@ -52,6 +52,13 @@ caml_binaryen_module_print_asmjs(value module) {
   CAMLreturn(Val_unit);
 }
 
+CAMLprim value
+caml_binaryen_module_print_stack_ir(value module) {
+  CAMLparam1(module);
+  BinaryenModulePrintStackIR(BinaryenModuleRef_val(module));
+  CAMLreturn(Val_unit);
+}
+
 CAMLprim value
 caml_binaryen_module_validate(value module) {
   CAMLparam1(module);
@@ -125,6 +132,19 @@ caml_binaryen_module_write_text(value _module) {
   CAMLreturn(text);
 }
 
+// There is something weird with this function that causes a bunch of newlines to
+// be printed on stdout when calling it. Not sure if that's a bug in Binaryen.
+CAMLprim value
+caml_binaryen_module_write_stack_ir(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* result = BinaryenModuleAllocateAndWriteStackIR(module);
+  CAMLlocal1(text);
+  text = caml_copy_string(result);
+  free(result);
+  CAMLreturn(text);
+}
+
 CAMLprim value
 caml_binaryen_module_read(value _bytes) {
   CAMLparam1(_bytes);

binaryen-archive/src/binaryen_stubs_modules.js

@@ -36,6 +36,16 @@ function caml_binaryen_module_print_asmjs(wasm_mod) {
   caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
 }
 
+//Provides: caml_binaryen_module_print_stack_ir
+//Requires: caml_string_of_jsstring
+//Requires: caml_ml_output, caml_ml_string_length
+function caml_binaryen_module_print_stack_ir(wasm_mod) {
+  var stackir = wasm_mod.emitStackIR()
+  var chanid = 1; // stdout
+  var s = caml_string_of_jsstring(stackir);
+  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+}
+
 //Provides: caml_binaryen_module_validate
 function caml_binaryen_module_validate(wasm_mod) {
   return wasm_mod.validate();
@@ -82,6 +92,13 @@ function caml_binaryen_module_write_text(wasm_mod) {
   return caml_string_of_jsstring(text);
 }
 
+//Provides: caml_binaryen_module_write_stack_ir
+//Requires: caml_string_of_jsstring
+function caml_binaryen_module_write_stack_ir(wasm_mod) {
+  var text = wasm_mod.emitStackIR();
+  return caml_string_of_jsstring(text);
+}
+
 //Provides: caml_binaryen_module_read
 //Requires: Binaryen
 //Requires: caml_array_of_bytes

binaryen-archive/src/import.ml

@@ -20,11 +20,15 @@ external add_global_import :
 external function_import_get_module : Function.t -> string
   = "caml_binaryen_function_import_get_module"
 
+external memory_import_get_module : Module.t -> string = "caml_binaryen_memory_import_get_module"
+
 external global_import_get_module : Global.t -> string
   = "caml_binaryen_global_import_get_module"
 
 external function_import_get_base : Function.t -> string
   = "caml_binaryen_function_import_get_base"
 
+external memory_import_get_base : Module.t -> string = "caml_binaryen_memory_import_get_base"
+
 external global_import_get_base : Global.t -> string
   = "caml_binaryen_global_import_get_base"

binaryen-archive/src/import.mli

@@ -8,6 +8,8 @@ val add_global_import :
   Module.t -> string -> string -> string -> Type.t -> bool -> unit
 
 val function_import_get_module : Function.t -> string
+val memory_import_get_module : Module.t -> string
 val global_import_get_module : Global.t -> string
 val function_import_get_base : Function.t -> string
+val memory_import_get_base : Module.t -> string
 val global_import_get_base : Global.t -> string

binaryen-archive/src/memory.ml

@@ -39,4 +39,14 @@ let set_memory wasm_mod initial maximum export_name (segments : segment list)
   set_memory wasm_mod initial maximum export_name segment_data segment_passive
     segment_offsets segment_sizes shared
 
+external has_memory : Module.t -> bool = "caml_binaryen_has_memory"
+
+external get_initial : Module.t -> int = "caml_binaryen_memory_get_initial"
+
+external has_max : Module.t -> bool = "caml_binaryen_memory_has_max"
+
+external get_max : Module.t -> int = "caml_binaryen_memory_get_max"
+
+external is_shared : Module.t -> bool = "caml_binaryen_memory_is_shared"
+
 let unlimited = -1

binaryen-archive/src/memory.mli

@@ -4,4 +4,14 @@ and segment_kind = Passive | Active of { offset : Expression.t }
 val set_memory :
   Module.t -> int -> int -> string -> segment list -> bool -> unit
 
+val has_memory : Module.t -> bool
+
+val get_initial : Module.t -> int
+
+val has_max : Module.t -> bool
+
+val get_max : Module.t -> int
+
+val is_shared : Module.t -> bool
+
 val unlimited : int

binaryen-archive/src/module.ml

@@ -87,6 +87,7 @@ external add_custom_section : t -> string -> string -> unit
 external parse : string -> t = "caml_binaryen_module_parse"
 external print : t -> unit = "caml_binaryen_module_print"
 external print_asmjs : t -> unit = "caml_binaryen_module_print_asmjs"
+external print_stack_ir : t -> unit = "caml_binaryen_module_print_stack_ir"
 external validate : t -> int = "caml_binaryen_module_validate"
 external optimize : t -> unit = "caml_binaryen_module_optimize"
 external get_features : t -> int = "caml_binaryen_module_get_features"
@@ -117,6 +118,7 @@ external write : t -> string option -> bytes * string option
   = "caml_binaryen_module_write"
 
 external write_text : t -> string = "caml_binaryen_module_write_text"
+external write_stack_ir : t -> string = "caml_binaryen_module_write_stack_ir"
 external read : bytes -> t = "caml_binaryen_module_read"
 external interpret : t -> unit = "caml_binaryen_module_interpret"
 

binaryen-archive/src/module.mli

@@ -28,6 +28,7 @@ val add_custom_section : t -> string -> string -> unit
 val parse : string -> t
 val print : t -> unit
 val print_asmjs : t -> unit
+val print_stack_ir : t -> unit
 val validate : t -> int
 val optimize : t -> unit
 val get_features : t -> Feature.t list
@@ -36,6 +37,7 @@ val run_passes : t -> Passes.t list -> unit
 val auto_drop : t -> unit
 val write : t -> string option -> bytes * string option
 val write_text : t -> string
+val write_stack_ir : t -> string
 val read : bytes -> t
 val interpret : t -> unit
 val add_debug_info_filename : t -> string -> int

binaryen-archive/src/passes.ml

@@ -90,6 +90,9 @@ let global_refining = "global-refining"
 (** globally optimize GC types *)
 let gto = "gto"
 
+(** globally optimize struct values *)
+let gsi = "gsi"
+
 (** apply more specific subtypes to type fields where possible *)
 let type_refining = "type-refining"
 
@@ -311,6 +314,9 @@ let souperify = "souperify"
 (** emit Souper IR in text form (single-use nodes only) *)
 let souperify_single_use = "souperify-single-use"
 
+(** spill pointers to the C stack (useful for Boehm-style GC) *)
+let spill_pointers = "spill-pointers"
+
 (** stub out unsupported JS operations *)
 let stub_unsupported_js = "stub-unsupported-js"
 

binaryen-archive/src/passes.mli

@@ -90,6 +90,9 @@ val global_refining : t
 val gto : t
 (** globally optimize GC types *)
 
+val gsi : t
+(** globally optimize struct values *)
+
 val type_refining : t
 (** apply more specific subtypes to type fields where possible *)
 
@@ -309,6 +312,9 @@ val souperify : t
 val souperify_single_use : t
 (** emit Souper IR in text form (single-use nodes only) *)
 
+val spill_pointers : t
+(** spill pointers to the C stack (useful for Boehm-style GC) *)
+
 val stub_unsupported_js : t
 (** stub out unsupported JS operations *)
 

binaryen-archive/test/test.expected

@@ -143,3 +143,39 @@
   )
  )
 )
+(module
+ (type $type$0 (func (param anyref i32 i32) (result i32)))
+ (type $type$1 (func (param i32 i32) (result i32)))
+ (type $type$2 (func))
+ (type $type$3 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $fimport$0 (param anyref i32 i32) (result i32)))
+ (memory $0 1)
+ (data (i32.const 0) "hello")
+ (table $0 1 1 funcref)
+ (elem (i32.const 0) $0)
+ (export "adder" (func $0))
+ (export "memory" (memory $0))
+ (export "hello" (func $2))
+ (start $1)
+ (func $0 (param $0 i32) (param $1 i32) (result i32)
+  local.get $0
+  local.get $1
+  i32.load8_s
+  i32.const 1
+  select
+  local.get $1
+  i32.add
+ )
+ (func $1
+  i32.const 3
+  i32.const 5
+  call $0
+  drop
+ )
+ (func $2 (param $0 anyref) (result i32)
+  local.get $0
+  i32.const 0
+  i32.const 1
+  call $fimport$0
+ )
+)

binaryen-archive/test/test.ml

@@ -19,6 +19,19 @@ let _ = assert (Settings.get_low_memory_unused () == true)
 let _ = Settings.set_low_memory_unused false
 let wasm_mod = Module.create ()
 let _ = Module.set_features wasm_mod [ Module.Feature.all ]
+let import_wasm_mod = Module.create ()
+
+let _ =
+  Import.add_memory_import import_wasm_mod "internal_name" "external_name"
+    "external_base_name" true
+
+let _ =
+  assert (Import.memory_import_get_module import_wasm_mod = "external_name")
+
+let _ =
+  assert (Import.memory_import_get_base import_wasm_mod = "external_base_name")
+
+let _ = assert (Memory.is_shared import_wasm_mod = true)
 
 (* Testing Return.get_value *)
 let _ =
@@ -137,11 +150,22 @@ let passive_segment : Binaryen.Memory.segment =
   let size = Bytes.length data in
   { data; kind; size }
 
+let _ = assert (Memory.has_memory wasm_mod = false)
+
 let _ =
   Memory.set_memory wasm_mod 1 Memory.unlimited "memory"
     [ segment; passive_segment ]
     false
 
+let _ = assert (Memory.has_memory wasm_mod = true)
+let _ = assert (Memory.get_initial wasm_mod = 1)
+let _ = assert (Memory.has_max wasm_mod = false)
+let _ = assert (Memory.get_max wasm_mod = Memory.unlimited)
+let max_memory_wasm_mod = Module.create ()
+let _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false
+let _ = assert (Memory.has_max max_memory_wasm_mod = true)
+let _ = assert (Memory.get_max max_memory_wasm_mod = 2)
+
 (* Create an imported "write" function i32 (anyref, i32, i32) *)
 (* Similar to the example here: https://bytecodealliance.org/articles/reference-types-in-wasmtime *)
 
@@ -191,7 +215,7 @@ let new_mod = Module.read byts
 
 let _ =
   Module.run_passes new_mod
-    [ Passes.name_types; Passes.merge_similar_functions ]
+    [ Passes.name_types; Passes.merge_similar_functions; Passes.spill_pointers ]
 
 let _ =
   Module.set_features new_mod
@@ -218,6 +242,8 @@ let _ =
 let _ = Module.validate new_mod
 let _ = Module.print new_mod
 
+let _ = Module.print_stack_ir new_mod
+
 (* Dispose the modules 👋 *)
 
 let _ = Module.dispose wasm_mod

binaryen-archive/esy.lock/opam/omd.1.3.1/opam

@@ -1,39 +0,0 @@
-opam-version: "2.0"
-maintainer: "Philippe Wang <philippe.wang@gmail.com>"
-authors: [ "Philippe Wang <philippe.wang@gmail.com>" ]
-license: "ISC"
-homepage: "https://github.com/ocaml/omd"
-dev-repo: "git+https://github.com/ocaml/omd.git"
-bug-reports: "https://github.com/ocaml/omd/issues"
-tags: [ "org:ocamllabs" "org:mirage"  ]
-build: [
-  ["ocaml" "setup.ml" "-configure" "--prefix" prefix]
-  ["ocaml" "setup.ml" "-build"]
-  ["ocaml" "setup.ml" "-configure" "--enable-tests"] {with-test}
-  ["ocaml" "setup.ml" "-build"] {with-test}
-  ["ocaml" "setup.ml" "-test"] {with-test}
-]
-install: ["ocaml" "setup.ml" "-install"]
-remove: [
-  ["ocaml" "%{etc}%/omd/setup.ml" "-C" "%{etc}%/omd" "-uninstall"]
-]
-depends: [
-  "ocaml" {>= "4.01"}
-  "base-bigarray"
-  "base-bytes"
-  "ocamlbuild" {build}
-  "ocamlfind" {build & >= "1.5"}
-]
-synopsis: "A Markdown frontend in pure OCaml."
-description: """
-This Markdown library is implemented using only pure OCaml (including
-I/O operations provided by the standard OCaml compiler distribution).
-OMD is meant to be as faithful as possible to the original Markdown.
-Additionally, OMD implements a few Github markdown features, an
-extension mechanism, and some other features. Note that the opam
-package installs both the OMD library and the command line tool `omd`."""
-url {
-  src:
-    "https://github.com/Chris00/omd/releases/download/1.3.1/omd-1.3.1.tar.gz"
-  checksum: "md5=845fc38e86ec0e85721130f2dd044d00"
-}

binaryen-archive/esy.lock/opam/uucp.14.0.0/opam

@@ -1,41 +0,0 @@
-opam-version: "2.0"
-synopsis: """Unicode character properties for OCaml"""
-maintainer: ["Daniel Bünzli <daniel.buenzl i@erratique.ch>"]
-authors: ["The uucp programmers"]
-homepage: "https://erratique.ch/software/uucp"
-doc: "https://erratique.ch/software/uucp/doc/"
-dev-repo: "git+https://erratique.ch/repos/uucp.git"
-bug-reports: "https://github.com/dbuenzli/uucp/issues"
-license: ["ISC"]
-tags: ["unicode" "text" "character" "org:erratique"]
-depends: ["ocaml" {>= "4.03.0"}
-          "ocamlfind" {build}
-          "ocamlbuild" {build}
-          "topkg" {build & >= "1.0.3"}
-          "uucd" {with-test}
-          "uunf" {with-test}
-          "uutf" {with-test}]
-depopts: ["uutf"
-          "uunf"
-          "cmdliner"]
-conflicts: ["uutf" {< "1.0.1"}
-            "cmdliner" {< "1.0.0"}]
-build: [["ocaml" "pkg/pkg.ml" "build" "--dev-pkg" "%{dev}%"
-         "--with-uutf" "%{uutf:installed}%"
-         "--with-uunf" "%{uunf:installed}%"
-         "--with-cmdliner" "%{cmdliner:installed}%" ]]
-description: """
-Uucp is an OCaml library providing efficient access to a selection of
-character properties of the [Unicode character database][1].
-
-Uucp is independent from any Unicode text data structure and has no
-dependencies. It is distributed under the ISC license.
-
-[1]: http://www.unicode.org/reports/tr44/
-
-Home page: http://erratique.ch/software/uucp"""
-url {
-  src: "https://erratique.ch/software/uucp/releases/uucp-14.0.0.tbz"
-  checksum: "sha512=2d0224aed5d5accbb121624898f08598e8c74a2415942f159a54221c0cdac62ed64fc70a039c833e50110cefce77754ada9ac2d58f79a6fc9331135326fe6899"}
-post-messages: ["If the build fails with \"ocamlopt.opt got signal and exited\", issue 'ulimit -s unlimited' and retry."
-                {failure & (arch = "ppc64" | arch = "arm64")}]