Remove unused js int64 primitive

Author: bobzhang

Diff for: jscomp/core/js_long.ml

@@ -159,12 +159,6 @@ let compare (args : J.expression list) =
 
 let of_string (args : J.expression list) = 
   int64_call "of_string" args 
-let discard_sign (args : J.expression list) =
-  int64_call "discard_sign" args
-let div_mod (args : J.expression list) =
-  int64_call "div_mod" args
-let to_hex (args : J.expression list) =
-  int64_call "to_hex"  args
 let get64 = int64_call "get64"
 let float_of_bits  =  int64_call "float_of_bits" 
 let bits_of_float = int64_call "bits_of_float"

Diff for: jscomp/core/js_long.mli

@@ -57,9 +57,6 @@ val equal_null : int64_call
 val equal_undefined : int64_call
 val equal_nullable : int64_call
 
-val discard_sign : int64_call
-val div_mod : int64_call
-val to_hex : int64_call  
 val to_float : int64_call
 val of_float : int64_call
 val compare : int64_call

Diff for: jscomp/core/lam_dispatch_primitive.ml

@@ -296,13 +296,7 @@ let translate loc (prim_name : string)
     | "caml_int64_of_float"
       -> Js_long.of_float args
     | "caml_int64_compare"
-      -> Js_long.compare args 
-    | "js_int64_discard_sign"
-      -> Js_long.discard_sign args
-    | "js_int64_div_mod"
-      -> Js_long.div_mod args
-    | "js_int64_to_hex"
-      -> Js_long.to_hex args    
+      -> Js_long.compare args     
     | "caml_int64_bits_of_float"
       -> Js_long.bits_of_float args     
     | "caml_int64_float_of_bits"

Diff for: jscomp/runtime/caml_format.ml

@@ -377,6 +377,11 @@ let caml_format_int fmt i =
     let f = parse_format fmt in 
     aux f i 
 
+(* FIXME: improve codegen for such cases
+let div_mod (x : int64) (y : int64) : int64 * int64 =  
+  let a, b = Caml_int64.(div_mod (unsafe_of_int64 x) (unsafe_of_int64 y)) in   
+  Caml_int64.unsafe_to_int64 a , Caml_int64.unsafe_to_int64 b 
+*)
 let caml_int64_format fmt x =
   let module String = Bs_string in 
   let f = parse_format fmt in
@@ -391,14 +396,14 @@ let caml_int64_format fmt x =
 
   begin match f.base with
     | Hex ->
-      s := Caml_int64_extern.to_hex x ^ !s       
+      s := Caml_int64.to_hex x ^ !s       
     | Oct ->
       let wbase  = 8L  in
       let  cvtbl = "01234567" in
 
       if  x < 0L then
         begin         
-          let y = Caml_int64.(unsafe_to_int64 (discard_sign (unsafe_of_int64 x)))  in
+          let y = Caml_int64.discard_sign  x in
           (* 2 ^  63 + y `div_mod` 8 *)        
           let quotient_l  = 1152921504606846976L (**)
             (* {lo =   0n; hi =  268435456n } *) (* 2 ^ 31 / 8 *)
@@ -407,7 +412,7 @@ let caml_int64_format fmt x =
           (* let c, d = Caml_int64.div_mod (Caml_int64.add y modulus_l) wbase in
              we can not do the code above, it can overflow when y is really large           
           *)
-          let c, d = Caml_int64_extern.div_mod  y  wbase in
+          let c, d = Caml_int64.div_mod  y  wbase in
 
           let quotient =
             ref (Caml_int64_extern.add quotient_l c )  in
@@ -417,22 +422,22 @@ let caml_int64_format fmt x =
               cvtbl.[ Caml_int64_extern.to_int !modulus] ^ !s ;
 
           while  !quotient <> 0L do
-            let a, b = Caml_int64_extern.div_mod (!quotient) wbase in
+            let a, b = Caml_int64.div_mod (!quotient) wbase in
             quotient := a;
             modulus := b;
             s := Bs_string.of_char cvtbl.[Caml_int64_extern.to_int !modulus] ^ !s ;
           done;
         end
       else
-        let a, b =  Caml_int64_extern.div_mod x wbase  in
+        let a, b =  Caml_int64.div_mod x wbase  in
         let quotient = ref a  in
         let modulus = ref b in
         s :=
           Bs_string.of_char 
             cvtbl.[ Caml_int64_extern.to_int !modulus] ^ !s ;
 
         while  !quotient <> 0L do
-          let a, b = Caml_int64_extern.div_mod (!quotient) wbase in
+          let a, b = Caml_int64.div_mod (!quotient) wbase in
           quotient := a;
           modulus := b;
           s := Bs_string.of_char cvtbl.[Caml_int64_extern.to_int !modulus] ^ !s ;
@@ -443,7 +448,7 @@ let caml_int64_format fmt x =
       let  cvtbl = "0123456789" in
 
       if  x < 0L then
-        let y  = Caml_int64.(unsafe_to_int64 (discard_sign (unsafe_of_int64 x)))  in
+        let y  = Caml_int64.discard_sign x in
         (* 2 ^  63 + y `div_mod` 10 *)        
 
         let quotient_l  = 922337203685477580L (* 2 ^ 63 / 10 *)
@@ -454,8 +459,8 @@ let caml_int64_format fmt x =
         (* let c, d = Caml_int64.div_mod (Caml_int64.add y modulus_l) wbase in
            we can not do the code above, it can overflow when y is really large           
         *)
-        let c, d = Caml_int64_extern.div_mod  y  wbase in
-        let e ,f = Caml_int64_extern.div_mod (Caml_int64_extern.add modulus_l d) wbase in        
+        let c, d = Caml_int64.div_mod  y  wbase in
+        let e ,f = Caml_int64.div_mod (Caml_int64_extern.add modulus_l d) wbase in        
         let quotient =
           ref (Caml_int64_extern.add (Caml_int64_extern.add quotient_l c )
                  e)  in
@@ -465,22 +470,22 @@ let caml_int64_format fmt x =
             cvtbl.[Caml_int64_extern.to_int !modulus] ^ !s ;
 
         while !quotient <> 0L do
-          let a, b = Caml_int64_extern.div_mod (!quotient) wbase in
+          let a, b = Caml_int64.div_mod (!quotient) wbase in
           quotient := a;
           modulus := b;
           s := Bs_string.of_char cvtbl.[Caml_int64_extern.to_int !modulus] ^ !s ;
         done;
 
       else
-        let a, b =  Caml_int64_extern.div_mod x wbase  in
+        let a, b =  Caml_int64.div_mod x wbase  in
         let quotient = ref a  in
         let modulus = ref b in
         s :=
           Bs_string.of_char 
             cvtbl.[ Caml_int64_extern.to_int !modulus] ^ !s ;
 
         while  !quotient <> 0L do
-          let a, b = Caml_int64_extern.div_mod (!quotient) wbase in
+          let a, b = Caml_int64.div_mod (!quotient) wbase in
           quotient := a;
           modulus := b;
           s := Bs_string.of_char cvtbl.[Caml_int64_extern.to_int !modulus] ^ !s ;

Diff for: jscomp/runtime/caml_int64.ml

@@ -46,6 +46,10 @@ let lognot x = Caml_nativeint.logxor x (-1n)
 
 type t = {  hi : nativeint; lo : nativeint ;  }
 
+external unsafe_to_int64 : t -> int64 = "%identity"           
+external unsafe_of_int64 : int64 -> t = "%identity"
+
+
 let to_unsigned (x : nativeint) =
    x >>> 0
 
@@ -374,9 +378,9 @@ let mod_ self other =
   sub self (mul (div self other) other)
 
 
-let div_mod self other =
-  let quotient = div self other in
-  quotient, sub self (mul quotient other)
+let div_mod (self : int64) (other : int64) : int64 * int64 =
+  let quotient = div (unsafe_of_int64 self) (unsafe_of_int64 other) in
+  unsafe_to_int64 quotient, unsafe_to_int64 (sub (unsafe_of_int64 self) (mul quotient (unsafe_of_int64 other)))
 
 let compare self other =
   let v = Pervasives.compare self.hi other.hi in
@@ -392,23 +396,25 @@ let to_int32 x = Caml_nativeint.logor x.lo  0n (* signed integer *)
 
 (* width does matter, will it be relevant to endian order? *)
 
-let to_hex x =
+let to_hex (x : int64) =
+  let {hi = x_hi; lo = x_lo} = unsafe_of_int64 x in 
   let aux v =
     Bs_string.of_int (Caml_nativeint.to_int (Caml_nativeint.shift_right_logical v 0)) ~base:16
   in
-  match x.hi, x.lo with
+  match x_hi, x_lo with
   | 0n, 0n -> "0"
-  | _, 0n -> aux x.hi ^ "00000000"
-  | 0n, _ -> aux x.lo
+  | _, 0n -> aux x_hi ^ "00000000"
+  | 0n, _ -> aux x_lo
   | _, _ ->
-    let lo =  aux x.lo in
+    let lo =  aux x_lo in
     let pad = 8 -Bs_string.length lo in
     if pad <= 0 then
-      aux x.hi ^ lo
+      aux x_hi ^ lo
     else
-      aux x.hi ^ Caml_utils.repeat pad "0" [@bs] ^ lo
+      aux x_hi ^ Caml_utils.repeat pad "0" [@bs] ^ lo
 
-let discard_sign x = {x with hi = Caml_nativeint.logand 0x7fff_ffffn x.hi }
+let discard_sign (x : int64) : int64 = 
+  unsafe_to_int64 { (unsafe_of_int64 x) with hi = Caml_nativeint.logand 0x7fff_ffffn (unsafe_of_int64 x).hi }
 
 (* >>> 0 does not change its bit representation
       it simply makes sure it is an unsigned integer
@@ -465,5 +471,3 @@ let get64 (s : string) (i:int) : t =
             (Caml_nativeint.of_int (Caml_char.code s.[i+6]) << 48 )
             (Caml_nativeint.of_int (Caml_char.code s.[i+7]) << 56 )))
 
-external unsafe_to_int64 : t -> int64 = "%identity"           
-external unsafe_of_int64 : int64 -> t = "%identity"

Diff for: jscomp/runtime/caml_int64.mli

@@ -71,15 +71,18 @@ val of_float : float -> t
 val div : t -> t -> t
 val mod_ : t -> t -> t
 
-val div_mod :  t -> t -> t * t 
+
 val compare : t -> t -> int
-val to_hex : t -> string
 
-val discard_sign : t -> t 
+
+
 val float_of_bits : t -> float 
 val bits_of_float : float -> t 
 val get64 : string -> int -> t
 
 
 external unsafe_to_int64 : t -> int64 = "%identity"           
-external unsafe_of_int64 : int64 -> t = "%identity"
+external unsafe_of_int64 : int64 -> t = "%identity"
+val div_mod :  int64 -> int64 -> int64 * int64
+val to_hex : int64 -> string
+val discard_sign : int64 -> int64 

Diff for: jscomp/runtime/caml_int64_extern.ml

@@ -12,8 +12,8 @@ external to_int : int64 -> int = "%int64_to_int"
 (* external discard_sign : int64 -> int64 = "js_int64_discard_sign" *)
 (* Same as {!Caml_int64.discard_sign} *)
 
-external div_mod : int64 -> int64 -> int64 * int64 = "js_int64_div_mod"
+(* external div_mod : int64 -> int64 -> int64 * int64 = "js_int64_div_mod" *)
 (* Same as {!Caml_int64.div_mod} *)
 
-external to_hex : int64 -> string = "js_int64_to_hex"    
+(* external to_hex : int64 -> string = "js_int64_to_hex"     *)
 (* same as {!Caml_int64.to_hex}*)

Diff for: jscomp/test/int64_test.ml

@@ -129,9 +129,9 @@ let suites :  Mt.pair_suites = Mt.[
         Eq(Array.map Int64.to_int32
              [|0L; 0x0000_0000_8000_0000L|], [|0l;-2147483648l|]));
     "discard_sign", (fun _ ->
-        Eq(Caml_int64.(unsafe_to_int64 (discard_sign (unsafe_of_int64 (-1L)))), 0x7fff_ffff_ffff_ffffL));
-    "div_mod", (fun _ -> Eq(Js_int64.div_mod 7L 3L , (2L,1L)));
-    "to_hex", (fun _ -> Eq(Js_int64.to_hex (-1L), "ffffffffffffffff"));
+        Eq(Caml_int64.discard_sign (-1L), 0x7fff_ffff_ffff_ffffL));
+    "div_mod", (fun _ -> Eq(Caml_int64.div_mod 7L 3L , (2L,1L)));
+    "to_hex", (fun _ -> Eq(Caml_int64.to_hex (-1L), "ffffffffffffffff"));
     "generic_compare", (fun _ ->
         Eq(generic_compare 0x0000_0001_0000_0000L 0x0000_0000_0000_0001L > 0 , true));
     "test_compier_literal", (fun _ ->

Diff for: lib/js/caml_int64.js

@@ -505,32 +505,32 @@ function to_int32(x) {
 }
 
 function to_hex(x) {
+  var x_lo = x[/* lo */1];
+  var x_hi = x[/* hi */0];
   var aux = function (v) {
     return (v >>> 0).toString(16);
   };
-  var match = x[/* hi */0];
-  var match$1 = x[/* lo */1];
   var exit = 0;
-  if (match !== 0 || match$1 !== 0) {
+  if (x_hi !== 0 || x_lo !== 0) {
     exit = 1;
   } else {
     return "0";
   }
   if (exit === 1) {
-    if (match$1 !== 0) {
-      if (match !== 0) {
-        var lo = aux(x[/* lo */1]);
+    if (x_lo !== 0) {
+      if (x_hi !== 0) {
+        var lo = aux(x_lo);
         var pad = 8 - lo.length | 0;
         if (pad <= 0) {
-          return aux(x[/* hi */0]) + lo;
+          return aux(x_hi) + lo;
         } else {
-          return aux(x[/* hi */0]) + (Caml_utils.repeat(pad, "0") + lo);
+          return aux(x_hi) + (Caml_utils.repeat(pad, "0") + lo);
         }
       } else {
-        return aux(x[/* lo */1]);
+        return aux(x_lo);
       }
     } else {
-      return aux(x[/* hi */0]) + "00000000";
+      return aux(x_hi) + "00000000";
     }
   }
 
@@ -598,11 +598,11 @@ exports.to_float = to_float;
 exports.of_float = of_float;
 exports.div = div;
 exports.mod_ = mod_;
-exports.div_mod = div_mod;
 exports.compare = compare;
-exports.to_hex = to_hex;
-exports.discard_sign = discard_sign;
 exports.float_of_bits = float_of_bits;
 exports.bits_of_float = bits_of_float;
 exports.get64 = get64;
+exports.div_mod = div_mod;
+exports.to_hex = to_hex;
+exports.discard_sign = discard_sign;
 /* Caml_int32 Not a pure module */

Diff for: lib/whole_compiler.ml

@@ -92452,9 +92452,6 @@ val equal_null : int64_call
 val equal_undefined : int64_call
 val equal_nullable : int64_call
 
-val discard_sign : int64_call
-val div_mod : int64_call
-val to_hex : int64_call  
 val to_float : int64_call
 val of_float : int64_call
 val compare : int64_call
@@ -92626,12 +92623,6 @@ let compare (args : J.expression list) =
 
 let of_string (args : J.expression list) = 
   int64_call "of_string" args 
-let discard_sign (args : J.expression list) =
-  int64_call "discard_sign" args
-let div_mod (args : J.expression list) =
-  int64_call "div_mod" args
-let to_hex (args : J.expression list) =
-  int64_call "to_hex"  args
 let get64 = int64_call "get64"
 let float_of_bits  =  int64_call "float_of_bits" 
 let bits_of_float = int64_call "bits_of_float"
@@ -95039,13 +95030,7 @@ let translate loc (prim_name : string)
     | "caml_int64_of_float"
       -> Js_long.of_float args
     | "caml_int64_compare"
-      -> Js_long.compare args 
-    | "js_int64_discard_sign"
-      -> Js_long.discard_sign args
-    | "js_int64_div_mod"
-      -> Js_long.div_mod args
-    | "js_int64_to_hex"
-      -> Js_long.to_hex args    
+      -> Js_long.compare args     
     | "caml_int64_bits_of_float"
       -> Js_long.bits_of_float args     
     | "caml_int64_float_of_bits"