Improve elimination of call to caml_js_strict_equals

Author: vouillon

compiler/lib-wasm/gc_target.ml

@@ -540,30 +540,46 @@ module Value = struct
 
   let ( >>| ) x f = map f x
 
+  let may_be_js js x =
+    let* ty = expression_type x in
+    match ty with
+    | None -> return true
+    | Some (Ref { typ; _ }) -> heap_type_sub (Type js) typ
+    | Some (I32 | I64 | F32 | F64) -> return false
+
   let eq_gen ~negate x y =
-    let xv = Code.Var.fresh () in
-    let yv = Code.Var.fresh () in
+    let* x = x in
+    let* y = y in
     let* js = Type.js_type in
-    let n =
-      if_expr
-        I32
-        (* We mimic an "and" on the two conditions, but in a way that is nicer to the
+    let* bx = may_be_js js x in
+    let* by = may_be_js js y in
+    if bx && by
+    then
+      let xv = Code.Var.fresh () in
+      let yv = Code.Var.fresh () in
+      let n =
+        if_expr
+          I32
+          (* We mimic an "and" on the two conditions, but in a way that is nicer to the
            binaryen optimizer. *)
-        (if_expr
-           I32
-           (ref_test (ref js) (load xv))
-           (ref_test (ref js) (load yv))
-           (Arith.const 0l))
-        (caml_js_strict_equals (load xv) (load yv)
-        >>| (fun e -> W.RefCast ({ nullable = false; typ = I31 }, e))
-        >>| fun e -> W.I31Get (S, e))
-        (ref_eq (load xv) (load yv))
-    in
-    seq
-      (let* () = store xv x in
-       let* () = store yv y in
-       return ())
-      (if negate then Arith.eqz n else n)
+          (if_expr
+             I32
+             (ref_test (ref js) (load xv))
+             (ref_test (ref js) (load yv))
+             (Arith.const 0l))
+          (caml_js_strict_equals (load xv) (load yv)
+          >>| (fun e -> W.RefCast ({ nullable = false; typ = I31 }, e))
+          >>| fun e -> W.I31Get (S, e))
+          (ref_eq (load xv) (load yv))
+      in
+      seq
+        (let* () = store xv (return x) in
+         let* () = store yv (return y) in
+         return ())
+        (if negate then Arith.eqz n else n)
+    else
+      let n = ref_eq (return x) (return y) in
+      if negate then Arith.eqz n else n
 
   let eq x y = eq_gen ~negate:false x y