@grain/binaryen.ml 0.17.1 → 0.19.0

binaryen-archive/test/test.expected

@@ -9,14 +9,15 @@
 (module
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
  (type $none_=>_none (func))
- (type $externref_i32_i32_=>_i32 (func (param externref i32 i32) (result i32)))
- (type $externref_=>_i32 (func (param externref) (result i32)))
- (import "future-wasi" "write" (func $write (param externref i32 i32) (result i32)))
+ (type $anyref_i32_i32_=>_i32 (func (param anyref i32 i32) (result i32)))
+ (type $anyref_=>_i32 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $write (param anyref i32 i32) (result i32)))
  (global $max_int64 i64 (i64.const 9223372036854775807))
  (global $max_int64_mut (mut i64) (i64.const 9223372036854775807))
  (global $test_float64_bits f64 (f64.const 1.23))
  (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))
@@ -50,7 +51,7 @@
    )
   )
  )
- (func $hello (param $0 externref) (result i32)
+ (func $hello (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
@@ -61,9 +62,9 @@
 (module
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
  (type $none_=>_none (func))
- (type $externref_i32_i32_=>_i32 (func (param externref i32 i32) (result i32)))
- (type $externref_=>_i32 (func (param externref) (result i32)))
- (import "future-wasi" "write" (func $write (param externref i32 i32) (result i32)))
+ (type $anyref_i32_i32_=>_i32 (func (param anyref i32 i32) (result i32)))
+ (type $anyref_=>_i32 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $write (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data (i32.const 0) "hello")
  (table $table 1 1 funcref)
@@ -92,7 +93,7 @@
    )
   )
  )
- (func $hello (; has Stack IR ;) (param $0 externref) (result i32)
+ (func $hello (; has Stack IR ;) (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
@@ -101,11 +102,11 @@
  )
 )
 (module
- (type $type$0 (func (param externref i32 i32) (result i32)))
+ (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 externref) (result i32)))
- (import "future-wasi" "write" (func $fimport$0 (param externref i32 i32) (result i32)))
+ (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)
@@ -134,7 +135,7 @@
    )
   )
  )
- (func $2 (param $0 externref) (result i32)
+ (func $2 (param $0 anyref) (result i32)
   (call $fimport$0
    (local.get $0)
    (i32.const 0)
@@ -142,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 _ =
@@ -123,28 +136,50 @@ let _ =
 let _ = Function.set_start wasm_mod start
 
 let segment : Binaryen.Memory.segment =
-  let data = "hello" in
-  let passive = false in
-  let offset = Expression.Const.make wasm_mod (Literal.int32 0l) in
-  let size = String.length data in
-  { data; passive; offset; size }
-
-let _ = Memory.set_memory wasm_mod 1 Memory.unlimited "memory" [ segment ] false
+  let data = Bytes.of_string "hello" in
+  let kind =
+    Binaryen.Memory.Active
+      { offset = Expression.Const.make wasm_mod (Literal.int32 0l) }
+  in
+  let size = Bytes.length data in
+  { data; kind; size }
+
+let passive_segment : Binaryen.Memory.segment =
+  let data = Bytes.of_string "world" in
+  let kind = Binaryen.Memory.Passive in
+  let size = Bytes.length data in
+  { data; kind; size }
+
+let _ = assert (Memory.has_memory wasm_mod = false)
 
-(* Create an imported "write" function i32 (externref, i32, i32) *)
+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 *)
 
 let _ =
   Import.add_function_import wasm_mod "write" "future-wasi" "write"
-    (Type.create [| Type.externref; Type.int32; Type.int32 |])
+    (Type.create [| Type.anyref; Type.int32; Type.int32 |])
     Type.int32
 
 (* Create a function that calls the imported write function *)
 let _ =
-  Function.add_function wasm_mod "hello" Type.externref Type.int32 [||]
+  Function.add_function wasm_mod "hello" Type.anyref Type.int32 [||]
     (Expression.Call.make wasm_mod "write"
        [
-         Expression.Local_get.make wasm_mod 0 Type.externref;
+         Expression.Local_get.make wasm_mod 0 Type.anyref;
          Expression.Const.make wasm_mod (Literal.int32 0l);
          Expression.Const.make wasm_mod (Literal.int32 1l);
        ]
@@ -180,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
@@ -207,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/biniou.1.2.1/opam

@@ -1,45 +0,0 @@
-opam-version: "2.0"
-build: [
-  ["dune" "subst"] {dev}
-  ["dune" "build" "-p" name "-j" jobs]
-  ["dune" "runtest" "-p" name "-j" jobs] {with-test}
-  ["dune" "build" "-p" name "@doc"] {with-doc}
-]
-maintainer: ["martin@mjambon.com"]
-authors: ["Martin Jambon"]
-bug-reports: "https://github.com/mjambon/biniou/issues"
-homepage: "https://github.com/mjambon/biniou"
-doc: "https://mjambon.github.io/biniou/"
-license: "BSD-3-Clause"
-dev-repo: "git+https://github.com/mjambon/biniou.git"
-synopsis:
-  "Binary data format designed for speed, safety, ease of use and backward compatibility as protocols evolve"
-description: """
-
-Biniou (pronounced "be new") is a binary data format designed for speed, safety,
-ease of use and backward compatibility as protocols evolve. Biniou is vastly
-equivalent to JSON in terms of functionality but allows implementations several
-times faster (4 times faster than yojson), with 25-35% space savings.
-
-Biniou data can be decoded into human-readable form without knowledge of type
-definitions except for field and variant names which are represented by 31-bit
-hashes. A program named bdump is provided for routine visualization of biniou
-data files.
-
-The program atdgen is used to derive OCaml-Biniou serializers and deserializers
-from type definitions.
-
-Biniou format specification: mjambon.github.io/atdgen-doc/biniou-format.txt"""
-depends: [
-  "easy-format"
-  "dune" {>= "1.10"}
-  "ocaml" {>= "4.02.3"}
-]
-url {
-  src:
-    "https://github.com/mjambon/biniou/releases/download/1.2.1/biniou-1.2.1.tbz"
-  checksum: [
-    "sha256=35546c68b1929a8e6d27a3b39ecd17b38303a0d47e65eb9d1480c2061ea84335"
-    "sha512=82670cc77bf3e869ee26e5fbe5a5affa45a22bc8b6c4bd7e85473912780e0111baca59b34a2c14feae3543ce6e239d7fddaeab24b686a65bfe642cdb91d27ebf"
-  ]
-}

binaryen-archive/esy.lock/opam/easy-format.1.3.4/opam

@@ -1,56 +0,0 @@
-opam-version: "2.0"
-synopsis:
-  "High-level and functional interface to the Format module of the OCaml standard library"
-description: """
-
-This module offers a high-level and functional interface to the Format module of
-the OCaml standard library. It is a pretty-printing facility, i.e. it takes as
-input some code represented as a tree and formats this code into the most
-visually satisfying result, breaking and indenting lines of code where
-appropriate.
-
-Input data must be first modelled and converted into a tree using 3 kinds of
-nodes:
-
-* atoms
-* lists
-* labelled nodes
-
-Atoms represent any text that is guaranteed to be printed as-is. Lists can model
-any sequence of items such as arrays of data or lists of definitions that are
-labelled with something like "int main", "let x =" or "x:"."""
-maintainer: ["martin@mjambon.com" "rudi.grinberg@gmail.com"]
-authors: ["Martin Jambon"]
-license: "BSD-3-Clause"
-homepage: "https://github.com/ocaml-community/easy-format"
-doc: "https://mjambon.github.io/easy-format/"
-bug-reports: "https://github.com/ocaml-community/easy-format/issues"
-depends: [
-  "dune" {>= "3.2" & >= "1.10"}
-  "ocaml" {>= "4.08"}
-  "odoc" {with-doc}
-]
-build: [
-  ["dune" "subst"] {dev}
-  [
-    "dune"
-    "build"
-    "-p"
-    name
-    "-j"
-    jobs
-    "@install"
-    "@runtest" {with-test}
-    "@doc" {with-doc}
-  ]
-]
-dev-repo: "git+https://github.com/ocaml-community/easy-format.git"
-url {
-  src:
-    "https://github.com/ocaml-community/easy-format/releases/download/1.3.4/easy-format-1.3.4.tbz"
-  checksum: [
-    "sha256=1dbf051e9f68574dde6e2e254a66b9c524ca425e80b36e99af96ed964ab610c3"
-    "sha512=90264864dde4cbf51f60fb5c21cf033e11bdeb662e76b62ce27b496c298ca9102174885ed7a6d29a6b8e43089e27d5bb5be247f88d9739c15cfd8470fec29d33"
-  ]
-}
-x-commit-hash: "ba4962884509ceec63905dd6e0ccb429be4f9f66"

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