@grain/binaryen.ml 0.18.0 → 0.20.0

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 -> 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 -> string
 val global_import_get_base : Global.t -> string

binaryen-archive/src/memory.ml

@@ -8,6 +8,7 @@ external set_memory :
   Expression.t list ->
   int list ->
   bool ->
+  string ->
   unit = "caml_binaryen_set_memory__bytecode" "caml_binaryen_set_memory"
 
 type segment = { data : bytes; kind : segment_kind; size : int }
@@ -39,4 +40,27 @@ 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 -> string -> int
+  = "caml_binaryen_memory_get_initial"
+
+external has_max : Module.t -> string -> bool = "caml_binaryen_memory_has_max"
+external get_max : Module.t -> string -> int = "caml_binaryen_memory_get_max"
+
+external is_shared : Module.t -> string -> bool
+  = "caml_binaryen_memory_is_shared"
+
 let unlimited = -1
+
+external get_num_segments : Module.t -> int
+  = "caml_binaryen_get_num_memory_segments"
+
+external get_segment_byte_offset : Module.t -> int -> int
+  = "caml_binaryen_get_memory_segment_byte_offset"
+
+external get_segment_passive : Module.t -> int -> bool
+  = "caml_binaryen_get_memory_segment_passive"
+
+external get_segment_data : Module.t -> int -> bytes
+  = "caml_binaryen_get_memory_segment_data"

binaryen-archive/src/memory.mli

@@ -2,6 +2,15 @@ type segment = { data : bytes; kind : segment_kind; size : int }
 and segment_kind = Passive | Active of { offset : Expression.t }
 
 val set_memory :
-  Module.t -> int -> int -> string -> segment list -> bool -> unit
+  Module.t -> int -> int -> string -> segment list -> bool -> string -> unit
 
+val has_memory : Module.t -> bool
+val get_initial : Module.t -> string -> int
+val has_max : Module.t -> string -> bool
+val get_max : Module.t -> string -> int
+val is_shared : Module.t -> string -> bool
 val unlimited : int
+val get_num_segments : Module.t -> int
+val get_segment_byte_offset : Module.t -> int -> int
+val get_segment_passive : Module.t -> int -> bool
+val get_segment_data : Module.t -> int -> bytes

binaryen-archive/src/module.ml

@@ -73,6 +73,10 @@ module Feature = struct
 
   let extended_const = extended_const ()
 
+  external strings : unit -> t = "caml_binaryen_feature_strings"
+
+  let strings = strings ()
+
   external all : unit -> t = "caml_binaryen_feature_all"
 
   let all = all ()
@@ -87,6 +91,10 @@ 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 -> bool -> 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 +125,10 @@ 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 -> bool -> 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

@@ -19,6 +19,7 @@ module Feature : sig
   val typed_function_references : t
   val relaxed_simd : t
   val extended_const : t
+  val strings : t
   val all : t
 end
 
@@ -28,6 +29,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 -> bool -> unit
 val validate : t -> int
 val optimize : t -> unit
 val get_features : t -> Feature.t list
@@ -36,6 +38,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 -> bool -> string
 val read : bytes -> t
 val interpret : t -> unit
 val add_debug_info_filename : t -> string -> int

binaryen-archive/src/ocaml_helpers.h

@@ -23,6 +23,7 @@ static struct custom_operations binaryen_ops = {
 
 #define BinaryenModuleRef_val(v) (*((BinaryenModuleRef*) Data_custom_val(v)))
 #define BinaryenType_val(v) (*((BinaryenType*) Data_custom_val(v)))
+#define BinaryenHeapType_val(v) (*((BinaryenHeapType*) Data_custom_val(v)))
 #define BinaryenExpressionRef_val(v) (*((BinaryenExpressionRef*) Data_custom_val(v)))
 #define BinaryenOp_val(v) (*((BinaryenOp*) Data_custom_val(v)))
 #define BinaryenLiteral_val(v) (*((struct BinaryenLiteral*) Data_custom_val(v)))

binaryen-archive/src/packed_type.ml

@@ -0,0 +1,13 @@
+type t = int
+
+external not_packed : unit -> t = "caml_binaryen_packed_type_not_packed"
+
+let not_packed = not_packed ()
+
+external int8 : unit -> t = "caml_binaryen_packed_type_int8"
+
+let int8 = int8 ()
+
+external int16 : unit -> t = "caml_binaryen_packed_type_int16"
+
+let int16 = int16 ()

binaryen-archive/src/packed_type.mli

@@ -0,0 +1,5 @@
+type t
+
+val not_packed : t
+val int8 : t
+val int16 : t

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/src/type.ml

@@ -44,6 +44,22 @@ external dataref : unit -> t = "caml_binaryen_type_dataref"
 
 let dataref = dataref ()
 
+external stringref : unit -> t = "caml_binaryen_type_stringref"
+
+let stringref = stringref ()
+
+external stringview_wtf8 : unit -> t = "caml_binaryen_type_stringview_wtf8"
+
+let stringview_wtf8 = stringview_wtf8 ()
+
+external stringview_wtf16 : unit -> t = "caml_binaryen_type_stringview_wtf16"
+
+let stringview_wtf16 = stringview_wtf16 ()
+
+external stringview_iter : unit -> t = "caml_binaryen_type_stringview_iter"
+
+let stringview_iter = stringview_iter ()
+
 external unreachable : unit -> t = "caml_binaryen_type_unreachable"
 
 let unreachable = unreachable ()
@@ -54,3 +70,6 @@ let auto = auto ()
 
 external create : t array -> t = "caml_binaryen_type_create"
 external expand : t -> t array = "caml_binaryen_type_expand"
+external is_nullable : t -> bool = "caml_binaryen_type_is_nullable"
+external from_heap_type : Heap_type.t -> t = "caml_binaryen_type_from_heap_type"
+external get_heap_type : t -> Heap_type.t = "caml_binaryen_type_get_heap_type"

binaryen-archive/src/type.mli

@@ -11,7 +11,14 @@ val anyref : t
 val eqref : t
 val i31ref : t
 val dataref : t
+val stringref : t
+val stringview_wtf8 : t
+val stringview_wtf16 : t
+val stringview_iter : t
 val unreachable : t
 val auto : t
 val create : t array -> t
 val expand : t -> t array
+val is_nullable : t -> bool
+val from_heap_type : Heap_type.t -> t
+val get_heap_type : t -> Heap_type.t

binaryen-archive/src/type_system.ml

@@ -0,0 +1,7 @@
+type t = int
+
+external equirecursive : unit -> t = "caml_binaryen_type_system_equirecursive"
+external nominal : unit -> t = "caml_binaryen_type_system_nominal"
+external isorecursive : unit -> t = "caml_binaryen_type_system_isorecursive"
+external get_type_system : unit -> t = "caml_binaryen_get_type_system"
+external set_type_system : t -> unit = "caml_binaryen_set_type_system"

binaryen-archive/src/type_system.mli

@@ -0,0 +1,7 @@
+type t
+
+val equirecursive : unit -> t
+val nominal : unit -> t
+val isorecursive : unit -> t
+val get_type_system : unit -> t
+val set_type_system : t -> unit

binaryen-archive/test/dune

@@ -1,30 +1,29 @@
-(test
+(executable
  (name test)
- (modules test)
  (libraries binaryen)
- (ocamlopt_flags
+ (modes exe js)
+ (flags
+  :standard
   (:include ./config/ocamlopt_flags.sexp))
- (action
-  (run %{test})))
-
-; Tests for binaryen.js implementation
+ (js_of_ocaml
+  (flags --no-sourcemap)))
 
 (rule
- (target test_js.ml)
+ (alias runtest)
  (action
   (progn
-   (copy %{dep:test.ml} %{target})
-   (copy test.expected test_js.expected))))
+   (with-stdout-to
+    test.out
+    (run %{exe:test.exe}))
+   (diff test.out test.expected))))
 
-(test
- (name test_js)
+(rule
+ (alias runtest)
  (enabled_if
-  (<> %{system} mingw64))
- (modules test_js)
- (modes
-  (byte js))
- (libraries binaryen)
+  (= %{bin-available:node} true))
  (action
-  (run node %{dep:test_js.bc.js}))
- (js_of_ocaml
-  (flags --no-sourcemap --disable share)))
+  (progn
+   (with-stdout-to
+    test_js.out
+    (run node %{dep:test.bc.js}))
+   (diff test_js.out test.expected))))

binaryen-archive/test/test.expected

@@ -43,11 +43,18 @@
   )
  )
  (func $start
-  (drop
-   (call_indirect $table (type $i32_i32_=>_i32)
-    (i32.const 3)
-    (i32.const 5)
+  (block $start
+   (memory.init 1
+    (i32.const 2048)
     (i32.const 0)
+    (i32.const 5)
+   )
+   (drop
+    (call_indirect $table (type $i32_i32_=>_i32)
+     (i32.const 3)
+     (i32.const 5)
+     (i32.const 0)
+    )
    )
   )
  )
@@ -67,6 +74,7 @@
  (import "future-wasi" "write" (func $write (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data (i32.const 0) "hello")
+ (data "world")
  (table $table 1 1 funcref)
  (elem $elem (i32.const 0) $adder)
  (export "adder" (func $adder))
@@ -86,6 +94,11 @@
   )
  )
  (func $start (; has Stack IR ;)
+  (memory.init 1
+   (i32.const 2048)
+   (i32.const 0)
+   (i32.const 5)
+  )
   (drop
    (call $adder
     (i32.const 3)
@@ -109,6 +122,7 @@
  (import "future-wasi" "write" (func $fimport$0 (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data (i32.const 0) "hello")
+ (data "world")
  (table $0 1 1 funcref)
  (elem (i32.const 0) $0)
  (export "adder" (func $0))
@@ -128,6 +142,11 @@
   )
  )
  (func $1
+  (memory.init 1
+   (i32.const 2048)
+   (i32.const 0)
+   (i32.const 5)
+  )
   (drop
    (call $0
     (i32.const 3)
@@ -143,3 +162,44 @@
   )
  )
 )
+(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")
+ (data "world")
+ (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 $0
+  i32.const 1
+  select
+  local.get $1
+  i32.add
+ )
+ (func $1
+  i32.const 2048
+  i32.const 0
+  i32.const 5
+  memory.init $0 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,23 @@ 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 "internal_name"
+    = "external_name")
+
+let _ =
+  assert (
+    Import.memory_import_get_base import_wasm_mod "internal_name"
+    = "external_base_name")
+
+let _ = assert (Memory.is_shared import_wasm_mod "internal_name" = true)
 
 (* Testing Return.get_value *)
 let _ =
@@ -39,7 +56,9 @@ let params () = Type.create [| Type.int32; Type.int32 |]
 let results = Type.int32
 let x () = Expression.Local_get.make wasm_mod 0 Type.int32
 let y () = Expression.Local_get.make wasm_mod 1 Type.int32
-let load = Expression.Load.make wasm_mod 1 ~signed:true 0 0 Type.int32 (y ())
+
+let load =
+  Expression.Load.make wasm_mod 1 ~signed:true 0 0 Type.int32 (y ()) "0"
 
 let select =
   Expression.Select.make wasm_mod
@@ -75,7 +94,15 @@ let call_adder =
 
 let start =
   Function.add_function wasm_mod "start" Type.none Type.none [||]
-    (Expression.Drop.make wasm_mod call_adder)
+    (Expression.Block.make wasm_mod ~return_type:Type.none "start"
+       [
+         Expression.Memory_init.make wasm_mod 1
+           (Expression.Const.make wasm_mod (Literal.int32 2048l))
+           (Expression.Const.make wasm_mod (Literal.int32 0l))
+           (Expression.Const.make wasm_mod (Literal.int32 5l))
+           "0";
+         Expression.Drop.make wasm_mod call_adder;
+       ])
 
 let _ = Export.add_function_export wasm_mod "adder" "adder"
 let _ = Table.add_table wasm_mod "table" 1 1 Type.funcref
@@ -137,12 +164,27 @@ 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
+    false "0"
+
+let _ = assert (Memory.has_memory wasm_mod = true)
+let _ = assert (Memory.get_initial wasm_mod "0" = 1)
+let _ = assert (Memory.has_max wasm_mod "0" = false)
+let _ = assert (Memory.get_max wasm_mod "0" = Memory.unlimited)
+let max_memory_wasm_mod = Module.create ()
+let _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false "0"
+let _ = assert (Memory.has_max max_memory_wasm_mod "0" = true)
+let _ = assert (Memory.get_max max_memory_wasm_mod "0" = 2)
+
+let _ =
+  assert (
+    Bytes.equal (Memory.get_segment_data wasm_mod 1) (Bytes.of_string "world"))
 
-(* Create an imported "write" function i32 (anyref, i32, i32) *)
+(* Create an imported "write" function i32 (externref, i32, i32) *)
 (* Similar to the example here: https://bytecodealliance.org/articles/reference-types-in-wasmtime *)
 
 let _ =
@@ -191,7 +233,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
@@ -212,11 +254,13 @@ let _ =
       Module.Feature.typed_function_references;
       Module.Feature.relaxed_simd;
       Module.Feature.extended_const;
+      Module.Feature.strings;
       Module.Feature.all;
     ]
 
 let _ = Module.validate new_mod
 let _ = Module.print new_mod
+let _ = Module.print_stack_ir new_mod false
 
 (* Dispose the modules 👋 *)
 

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")}]

binaryen-archive/esy.lock/overrides/opam__s__js__of__ocaml_compiler_opam__c__4.0.0_opam_override/package.json

@@ -1,3 +0,0 @@
-{
-  "build": "dune build -p js_of_ocaml-compiler"
-}