@grain/binaryen.ml 0.20.1 → 0.21.0

binaryen-archive/src/op.mli

@@ -316,3 +316,41 @@ val ref_as_non_null : t
 val ref_as_func : t
 val ref_as_data : t
 val ref_as_i31 : t
+val ref_as_extern_internalize : unit -> t
+val ref_as_extern_externalize : unit -> t
+val br_on_null : unit -> t
+val br_on_non_null : unit -> t
+val br_on_cast : unit -> t
+val br_on_cast_fail : unit -> t
+val br_on_func : unit -> t
+val br_on_non_func : unit -> t
+val br_on_data : unit -> t
+val br_on_non_data : unit -> t
+val br_on_i31 : unit -> t
+val br_on_non_i31 : unit -> t
+val string_new_utf8 : unit -> t
+val string_new_wtf8 : unit -> t
+val string_new_replace : unit -> t
+val string_new_wtf16 : unit -> t
+val string_new_utf8_array : unit -> t
+val string_new_wtf8_array : unit -> t
+val string_new_replace_array : unit -> t
+val string_new_wtf16_array : unit -> t
+val string_measure_utf8 : unit -> t
+val string_measure_wtf8 : unit -> t
+val string_measure_wtf16 : unit -> t
+val string_measure_is_usv : unit -> t
+val string_measure_wtf16_view : unit -> t
+val string_encode_utf8 : unit -> t
+val string_encode_wtf8 : unit -> t
+val string_encode_wtf16 : unit -> t
+val string_encode_utf8_array : unit -> t
+val string_encode_wtf8_array : unit -> t
+val string_encode_wtf16_array : unit -> t
+val string_as_wtf8 : unit -> t
+val string_as_wtf16 : unit -> t
+val string_as_iter : unit -> t
+val string_iter_move_advance : unit -> t
+val string_iter_move_rewind : unit -> t
+val string_slice_wtf8 : unit -> t
+val string_slice_wtf16 : unit -> t

binaryen-archive/src/passes.ml

@@ -45,6 +45,9 @@ let denan = "denan"
 (** turns indirect calls into direct ones *)
 let directize = "directize"
 
+(** discards global effect info *)
+let discard_global_effects = "discard-global-effects"
+
 (** optimizes using the DataFlow SSA IR *)
 let dfo = "dfo"
 
@@ -81,6 +84,9 @@ let generate_dyncalls = "generate-dyncalls"
 (** generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support). *)
 let generate_i64_dyncalls = "generate-i64-dyncalls"
 
+(** generate global effect info (helps later passes) *)
+let generate_global_effects = "generate-global-effects"
+
 (** generate Stack IR *)
 let generate_stack_ir = "generate-stack-ir"
 
@@ -117,6 +123,9 @@ let inlining_optimizing = "inlining-optimizing"
 (** lower away binaryen intrinsics *)
 let intrinsic_lowering = "intrinsic-lowering"
 
+(** wrap imports and exports for JavaScript promise integration *)
+let jspi = "jspi"
+
 (** legalizes i64 types on the import/export boundary *)
 let legalize_js_interface = "legalize-js-interface"
 
@@ -181,6 +190,15 @@ let mod_asyncify_always_and_only_unwind = "mod-asyncify-always-and-only-unwind"
 (** apply the assumption that asyncify never unwinds *)
 let mod_asyncify_never_unwind = "mod-asyncify-never-unwind"
 
+(** creates specialized versions of functions *)
+let monomorphize = "monomorphize"
+
+(** creates specialized versions of functions (even if unhelpful) *)
+let monomorphize_always = "monomorphize-always"
+
+(** combines multiple memories into a single memory *)
+let multi_memory_lowering = "multi-memory-lowering"
+
 (** name list *)
 let nm = "nm"
 
@@ -196,6 +214,9 @@ let optimize_added_constants = "optimize-added-constants"
 (** optimizes added constants into load/store offsets, propagating them across locals too *)
 let optimize_added_constants_propagate = "optimize-added-constants-propagate"
 
+(** eliminate and reuse casts *)
+let optimize_casts = "optimize-casts"
+
 (** optimizes instruction combinations *)
 let optimize_instructions = "optimize-instructions"
 
@@ -269,6 +290,12 @@ let remove_unused_names = "remove-unused-names"
 (** sorts functions by access frequency *)
 let reorder_functions = "reorder-functions"
 
+(** sorts globals by access frequency *)
+let reorder_globals = "reorder-globals"
+
+(** sorts globals by access frequency (even if there are few) *)
+let reorder_globals_always = "reorder-globals-always"
+
 (** sorts locals by access frequency *)
 let reorder_locals = "reorder-locals"
 
@@ -293,6 +320,9 @@ let signature_pruning = "signature-pruning"
 (** apply more specific subtypes to signature types where possible *)
 let signature_refining = "signature-refining"
 
+(** lower sign-ext operations to wasm mvp *)
+let signext_lowering = "signext-lowering"
+
 (** miscellaneous globals-related optimizations *)
 let simplify_globals = "simplify-globals"
 

binaryen-archive/src/passes.mli

@@ -45,6 +45,9 @@ val denan : t
 val directize : t
 (** turns indirect calls into direct ones *)
 
+val discard_global_effects : t
+(** discards global effect info *)
+
 val dfo : t
 (** optimizes using the DataFlow SSA IR *)
 
@@ -81,6 +84,9 @@ val generate_dyncalls : t
 val generate_i64_dyncalls : t
 (** generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support). *)
 
+val generate_global_effects : t
+(** generate global effect info (helps later passes) *)
+
 val generate_stack_ir : t
 (** generate Stack IR *)
 
@@ -117,6 +123,9 @@ val inlining_optimizing : t
 val intrinsic_lowering : t
 (** lower away binaryen intrinsics *)
 
+val jspi : t
+(** wrap imports and exports for JavaScript promise integration *)
+
 val legalize_js_interface : t
 (** legalizes i64 types on the import/export boundary *)
 
@@ -180,6 +189,15 @@ val mod_asyncify_always_and_only_unwind : t
 val mod_asyncify_never_unwind : t
 (** apply the assumption that asyncify never unwinds *)
 
+val monomorphize : t
+(** creates specialized versions of functions *)
+
+val monomorphize_always : t
+(** creates specialized versions of functions (even if unhelpful) *)
+
+val multi_memory_lowering : t
+(** combines multiple memories into a single memory *)
+
 val nm : t
 (** name list *)
 
@@ -195,6 +213,9 @@ val optimize_added_constants : t
 val optimize_added_constants_propagate : t
 (** optimizes added constants into load/store offsets, propagating them across locals too *)
 
+val optimize_casts : t
+(** eliminate and reuse casts *)
+
 val optimize_instructions : t
 (** optimizes instruction combinations *)
 
@@ -267,6 +288,12 @@ val remove_unused_names : t
 val reorder_functions : t
 (** sorts functions by access frequency *)
 
+val reorder_globals : t
+(** sorts globals by access frequency *)
+
+val reorder_globals_always : t
+(** sorts globals by access frequency (even if there are few) *)
+
 val reorder_locals : t
 (** sorts locals by access frequency *)
 
@@ -291,6 +318,9 @@ val signature_pruning : t
 val signature_refining : t
 (** apply more specific subtypes to signature types where possible *)
 
+val signext_lowering : t
+(** lower sign-ext operations to wasm mvp *)
+
 val simplify_globals : t
 (** miscellaneous globals-related optimizations *)
 

binaryen-archive/src/signature_type.c

@@ -0,0 +1,23 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_binaryen_signature_type_get_params(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenType ty = BinaryenSignatureTypeGetParams(heapType);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_signature_type_get_results(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenType ty = BinaryenSignatureTypeGetResults(heapType);
+  CAMLreturn(alloc_BinaryenType(ty));
+}

binaryen-archive/src/signature_type.js

@@ -0,0 +1,11 @@
+//Provides: caml_binaryen_signature_type_get_params
+//Requires: Binaryen
+function caml_binaryen_signature_type_get_params(heapType) {
+  return Binaryen._BinaryenSignatureTypeGetParams(heapType);
+}
+
+//Provides: caml_binaryen_signature_type_get_results
+//Requires: Binaryen
+function caml_binaryen_signature_type_get_results(heapType) {
+  return Binaryen._BinaryenSignatureTypeGetResults(heapType);
+}

binaryen-archive/src/signature_type.ml

@@ -0,0 +1,5 @@
+external get_params : Heap_type.t -> Type.t
+  = "caml_binaryen_signature_type_get_params"
+
+external get_results : Heap_type.t -> Type.t
+  = "caml_binaryen_signature_type_get_results"

binaryen-archive/src/signature_type.mli

@@ -0,0 +1,2 @@
+val get_params : Heap_type.t -> Type.t
+val get_results : Heap_type.t -> Type.t

binaryen-archive/src/struct_type.c

@@ -0,0 +1,39 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_binaryen_struct_type_get_num_fields(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  CAMLreturn(Val_int(BinaryenStructTypeGetNumFields(heapType)));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_get_field_type(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenType ty = BinaryenStructTypeGetFieldType(heapType, index);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_get_field_packed_type(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(Val_int(BinaryenStructTypeGetFieldPackedType(heapType, index)));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_is_field_mutable(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(Val_bool(BinaryenStructTypeIsFieldMutable(heapType, index)));
+}

binaryen-archive/src/struct_type.js

@@ -0,0 +1,23 @@
+//Provides: caml_binaryen_struct_type_get_num_fields
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_num_fields(heapType) {
+  return Binaryen._BinaryenStructTypeGetNumFields(heapType);
+}
+
+//Provides: caml_binaryen_struct_type_get_field_type
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_field_type(heapType, index) {
+  return Binaryen._BinaryenStructTypeGetFieldType(heapType, index);
+}
+
+//Provides: caml_binaryen_struct_type_get_field_packed_type
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_field_packed_type(heapType, index) {
+  return Binaryen._BinaryenStructTypeGetFieldPackedType(heapType, index);
+}
+
+//Provides: caml_binaryen_struct_type_is_field_mutable
+//Requires: Binaryen
+function caml_binaryen_struct_type_is_field_mutable(heapType, index) {
+  return Binaryen._BinaryenStructTypeIsFieldMutable(heapType, index);
+}

binaryen-archive/src/struct_type.ml

@@ -0,0 +1,11 @@
+external get_num_fields : Heap_type.t -> int
+  = "caml_binaryen_struct_type_get_num_fields"
+
+external get_field_type : Heap_type.t -> int -> Type.t
+  = "caml_binaryen_struct_type_get_field_type"
+
+external get_field_packed_type : Heap_type.t -> int -> Packed_type.t
+  = "caml_binaryen_struct_type_get_field_packed_type"
+
+external is_field_mutable : Heap_type.t -> int -> bool
+  = "caml_binaryen_struct_type_is_field_mutable"

binaryen-archive/src/struct_type.mli

@@ -0,0 +1,4 @@
+val get_num_fields : Heap_type.t -> int
+val get_field_type : Heap_type.t -> int -> Type.t
+val get_field_packed_type : Heap_type.t -> int -> Packed_type.t
+val is_field_mutable : Heap_type.t -> int -> bool

binaryen-archive/src/{binaryen_stubs_tables.c → table.c}

@@ -7,31 +7,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenTableRef */
-static value alloc_BinaryenTableRef(BinaryenTableRef table)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenTableRef), 0, 1);
-  BinaryenTableRef_val(v) = table;
-  return v;
-}
-
-/* Allocating an OCaml custom block to hold the given BinaryenElementSegmentRef */
-static value alloc_BinaryenElementSegmentRef(BinaryenElementSegmentRef elem)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenElementSegmentRef), 0, 1);
-  BinaryenElementSegmentRef_val(v) = elem;
-  return v;
-}
-
-/* Allocating an OCaml custom block to hold the given BinaryenExpressionRef */
-static value alloc_BinaryenExpressionRef(BinaryenExpressionRef exp)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenExpressionRef), 0, 1);
-  BinaryenExpressionRef_val(v) = exp;
-  return v;
-}
-
 CAMLprim value
 caml_binaryen_add_table(value _module, value _table, value _initial, value _maximum, value _tableType) {
   CAMLparam5(_module, _table, _initial, _maximum, _tableType);

binaryen-archive/src/{binaryen_stubs_types.c → type.c}

@@ -6,16 +6,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenType */
-static value alloc_BinaryenType(BinaryenType typ)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenType), 0, 1);
-  BinaryenType_val(v) = typ;
-  return v;
-}
-
-
 CAMLprim value
 caml_binaryen_type_none(value unit) {
   CAMLparam1(unit);
@@ -93,6 +83,13 @@ caml_binaryen_type_dataref(value unit) {
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
+CAMLprim value
+caml_binaryen_type_arrayref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeArrayref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
 CAMLprim value
 caml_binaryen_type_stringref(value unit) {
   CAMLparam1(unit);
@@ -121,6 +118,27 @@ caml_binaryen_type_stringview_iter(value unit) {
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
+CAMLprim value
+caml_binaryen_type_nullref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_null_externref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullExternref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_null_funcref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullFuncref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
 CAMLprim value
 caml_binaryen_type_unreachable(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/{binaryen_stubs_types.js → type.js}

@@ -64,6 +64,13 @@ function caml_binaryen_type_dataref() {
   return Binaryen.dataref;
 }
 
+//Provides: caml_binaryen_type_arrayref
+//Requires: Binaryen
+function caml_binaryen_type_arrayref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeArrayref();
+}
+
 //Provides: caml_binaryen_type_stringref
 //Requires: Binaryen
 function caml_binaryen_type_stringref() {
@@ -88,6 +95,27 @@ function caml_binaryen_type_stringview_iter() {
   return Binaryen.stringview_iter;
 }
 
+//Provides: caml_binaryen_type_nullref
+//Requires: Binaryen
+function caml_binaryen_type_nullref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeNullref();
+}
+
+//Provides: caml_binaryen_type_null_externref
+//Requires: Binaryen
+function caml_binaryen_type_null_externref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeNullExternref();
+}
+
+//Provides: caml_binaryen_type_null_funcref
+//Requires: Binaryen
+function caml_binaryen_type_null_funcref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeNullFuncref();
+}
+
 //Provides: caml_binaryen_type_unreachable
 //Requires: Binaryen
 function caml_binaryen_type_unreachable() {

binaryen-archive/src/type.ml

@@ -44,6 +44,10 @@ external dataref : unit -> t = "caml_binaryen_type_dataref"
 
 let dataref = dataref ()
 
+external arrayref : unit -> t = "caml_binaryen_type_arrayref"
+
+let arrayref = arrayref ()
+
 external stringref : unit -> t = "caml_binaryen_type_stringref"
 
 let stringref = stringref ()
@@ -60,6 +64,18 @@ external stringview_iter : unit -> t = "caml_binaryen_type_stringview_iter"
 
 let stringview_iter = stringview_iter ()
 
+external nullref : unit -> t = "caml_binaryen_type_nullref"
+
+let nullref = nullref ()
+
+external null_externref : unit -> t = "caml_binaryen_type_null_externref"
+
+let null_externref = null_externref ()
+
+external null_funcref : unit -> t = "caml_binaryen_type_null_funcref"
+
+let null_funcref = null_funcref ()
+
 external unreachable : unit -> t = "caml_binaryen_type_unreachable"
 
 let unreachable = unreachable ()

binaryen-archive/src/type.mli

@@ -11,10 +11,14 @@ val anyref : t
 val eqref : t
 val i31ref : t
 val dataref : t
+val arrayref : t
 val stringref : t
 val stringview_wtf8 : t
 val stringview_wtf16 : t
 val stringview_iter : t
+val nullref : t
+val null_externref : t
+val null_funcref : t
 val unreachable : t
 val auto : t
 val create : t array -> t

binaryen-archive/test/test.expected

@@ -3,7 +3,7 @@
 )
 (table.size $table)
 (table.grow $table
- (ref.null func)
+ (ref.null nofunc)
  (i32.const 0)
 )
 (module

binaryen-archive/test/test.ml

@@ -36,6 +36,7 @@ let _ =
     = "external_base_name")
 
 let _ = assert (Memory.is_shared import_wasm_mod "internal_name" = true)
+let _ = assert (Memory.is_64 import_wasm_mod "internal_name" = false)
 
 (* Testing Return.get_value *)
 let _ =
@@ -169,14 +170,14 @@ let _ = assert (Memory.has_memory wasm_mod = false)
 let _ =
   Memory.set_memory wasm_mod 1 Memory.unlimited "memory"
     [ segment; passive_segment ]
-    false "0"
+    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 _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false false "0"
 let _ = assert (Memory.has_max max_memory_wasm_mod "0" = true)
 let _ = assert (Memory.get_max max_memory_wasm_mod "0" = 2)
 
@@ -235,11 +236,18 @@ let new_mod = Module.read byts
 let _ =
   Module.run_passes new_mod
     [
+      Passes.generate_global_effects;
       Passes.name_types;
       Passes.merge_similar_functions;
       Passes.spill_pointers;
       Passes.gufa;
       Passes.gufa_optimizing;
+      Passes.reorder_globals;
+      Passes.optimize_casts;
+      Passes.multi_memory_lowering;
+      Passes.monomorphize;
+      Passes.signext_lowering;
+      Passes.discard_global_effects;
     ]
 
 let _ =
@@ -258,10 +266,10 @@ let _ =
       Module.Feature.multivalue;
       Module.Feature.gc;
       Module.Feature.memory64;
-      Module.Feature.typed_function_references;
       Module.Feature.relaxed_simd;
       Module.Feature.extended_const;
       Module.Feature.strings;
+      Module.Feature.multi_memories;
       Module.Feature.all;
     ]
 

binaryen-archive/esy.lock/opam/fiber.3.6.1/opam

@@ -1,41 +0,0 @@
-opam-version: "2.0"
-synopsis: "Structured concurrency library"
-description:
-  "This library offers no backwards compatibility guarantees. Use at your own risk."
-maintainer: ["Jane Street Group, LLC <opensource@janestreet.com>"]
-authors: ["Jane Street Group, LLC <opensource@janestreet.com>"]
-license: "MIT"
-homepage: "https://github.com/ocaml/dune"
-doc: "https://dune.readthedocs.io/"
-bug-reports: "https://github.com/ocaml/dune/issues"
-depends: [
-  "dune" {>= "3.5"}
-  "ocaml" {>= "4.08.0"}
-  "stdune" {= version}
-  "dyn" {= version}
-  "odoc" {with-doc}
-]
-dev-repo: "git+https://github.com/ocaml/dune.git"
-build: [
-  ["dune" "subst"] {dev}
-  ["rm" "-rf" "vendor/csexp"]
-  ["rm" "-rf" "vendor/pp"]
-  [
-    "dune"
-    "build"
-    "-p"
-    name
-    "-j"
-    jobs
-    "@install"
-    "@doc" {with-doc}
-  ]
-]
-url {
-  src: "https://github.com/ocaml/dune/releases/download/3.6.1/dune-3.6.1.tbz"
-  checksum: [
-    "sha256=f1d5ac04b7a027f3d549e25cf885ebf7acc135e0291c18e6b43123a799c143ce"
-    "sha512=64714ab6155cd04bc33d693fc7a6d9d61aa7a278357eeff159df324e083914fcd556459a3945acacf1bbc3775f2232ab0c78006ab8a434dc58dcf95ffdffac52"
-  ]
-}
-x-commit-hash: "7d2788fc94a071bca897aefc95f1464911870a4c"

binaryen-archive/esy.lock/opam/ocamlfind.1.9.5/files/0001-Fix-bug-when-installing-with-a-system-compiler.patch

@@ -1,26 +0,0 @@
-From f53247f546375972789b96c3f612cd7f524bf2aa Mon Sep 17 00:00:00 2001
-From: Louis Gesbert <louis.gesbert@ocamlpro.com>
-Date: Mon, 11 Jul 2022 18:12:18 +0200
-Subject: [PATCH] Fix bug when installing with a system compiler
-
-See https://discuss.ocaml.org/t/problem-installing-ocamlfind-on-latest-ocamlpro-alpine-docker-image/10147
----
- src/findlib/Makefile | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/findlib/Makefile b/src/findlib/Makefile
-index 84514b6f22..ea23f4a10c 100644
---- a/src/findlib/Makefile
-+++ b/src/findlib/Makefile
-@@ -123,7 +123,7 @@ clean:
- install: all
- 	$(INSTALLDIR) "$(DESTDIR)$(prefix)$(OCAML_SITELIB)/$(NAME)"
- 	$(INSTALLDIR) "$(DESTDIR)$(prefix)$(OCAMLFIND_BIN)"
--	$(INSTALLDIR) "$(DESTDIR)$(prefix)$(OCAML_CORE_STDLIB)"
-+	test $(INSTALL_TOPFIND) -eq 0 || $(INSTALLDIR) "$(DESTDIR)$(prefix)$(OCAML_CORE_STDLIB)"
- 	test $(INSTALL_TOPFIND) -eq 0 || $(INSTALLFILE) topfind "$(DESTDIR)$(prefix)$(OCAML_CORE_STDLIB)/"
- 	files=`$(SH) $(TOP)/tools/collect_files $(TOP)/Makefile.config \
- 	findlib.cmi findlib.mli findlib.cma findlib.cmxa findlib$(LIB_SUFFIX) findlib.cmxs \
--- 
-2.35.1
-