simplify string access computations

Author: jvanburen

backend/cmm_helpers.ml

@@ -22,6 +22,10 @@ open Arch
 
 let arch_bits = Arch.size_int * 8
 
+let size_addr = size_addr
+
+let size_float = size_float
+
 type arity =
   { function_kind : Lambda.function_kind;
     params_layout : Lambda.layout list;
@@ -1123,12 +1127,6 @@ let log2_size_addr = Misc.log2 size_addr
 
 let log2_size_float = Misc.log2 size_float
 
-let wordsize_shift = 9
-
-let numfloat_shift = 9 + log2_size_float - log2_size_addr
-
-let addr_array_length_shifted hdr dbg = lsr_const hdr wordsize_shift dbg
-
 (* Produces a pointer to the element of the array [ptr] on the position [ofs]
    with the given element [log2size] log2 element size.
 
@@ -1261,7 +1259,7 @@ let unboxed_packed_array_length arr dbg ~custom_ops_base_symbol
                          dbg)
                       (Cvar custom_ops_index_var) dbg ) ) ))
   in
-  tag_int res dbg
+  res
 
 let unboxed_int32_array_length =
   unboxed_packed_array_length
@@ -1278,15 +1276,15 @@ let unboxed_int64_or_nativeint_array_length arr dbg =
         (* need to subtract so as not to count the custom_operations field *)
         sub_int (get_size arr dbg) (int ~dbg 1) dbg)
   in
-  tag_int res dbg
+  res
 
 let unboxed_vec128_array_length arr dbg =
   let res =
     bind "arr" arr (fun arr ->
         (* need to subtract so as not to count the custom_operations field *)
         sub_int (get_size arr dbg) (int ~dbg 1) dbg)
   in
-  tag_int (lsr_int res (int ~dbg 1) dbg) dbg
+  lsr_int res (int ~dbg 1) dbg
 
 let addr_array_ref arr ofs dbg =
   Cop (mk_load_mut Word_val, [array_indexing log2_size_addr arr ofs dbg], dbg)
@@ -3407,9 +3405,7 @@ let raise_prim raise_kind arg dbg =
 
 let negint arg dbg = Cop (Csubi, [Cconst_int (2, dbg); arg], dbg)
 
-let addr_array_length arg dbg =
-  let hdr = get_header_masked arg dbg in
-  Cop (Cor, [addr_array_length_shifted hdr dbg; Cconst_int (1, dbg)], dbg)
+let addr_array_length arg dbg = get_size arg dbg
 
 (* CR-soon gyorsh: effects and coeffects for primitives are set conservatively
    to Arbitrary_effects and Has_coeffects, resp. Check if this can be improved

backend/cmm_helpers.mli

@@ -17,6 +17,10 @@ open Cmm
 
 val arch_bits : int
 
+val size_float : int
+
+val size_addr : int
+
 type arity =
   { function_kind : Lambda.function_kind;
     params_layout : Lambda.layout list;
@@ -202,12 +206,6 @@ val get_header : expression -> Debuginfo.t -> expression
 (** Load a block's tag *)
 val get_tag : expression -> Debuginfo.t -> expression
 
-(** Arrays *)
-
-val wordsize_shift : int
-
-val numfloat_shift : int
-
 (** Array loads and stores
 
     [unboxed_float_array_ref] and [float_array_ref] differ in the boxing of the
@@ -448,7 +446,7 @@ val raise_prim : Lambda.raise_kind -> unary_primitive
 (** Unary negation of an OCaml integer *)
 val negint : unary_primitive
 
-(** Return the length of the array argument, as an OCaml integer *)
+(** Return the length of the array argument, as a register-width integer *)
 val addr_array_length : unary_primitive
 
 (** Byte swap primitive Operates on Cmm integers (unboxed values) *)

middle_end/flambda2/flambda2.ml

@@ -153,7 +153,7 @@ let lambda_to_cmm ~ppf_dump:ppf ~prefixname ~keep_symbol_tables
      to be computed differently according to the array kind, in the case where
      the width of a float is not equal to the machine word width (at present,
      this happens only on 32-bit targets). *)
-  if Cmm_helpers.wordsize_shift <> Cmm_helpers.numfloat_shift
+  if Cmm_helpers.size_addr <> Cmm_helpers.size_float
      && Flambda_features.flat_float_array ()
   then
     Misc.fatal_error

middle_end/flambda2/from_lambda/lambda_to_flambda_primitives.ml

@@ -660,7 +660,7 @@ let max_with_zero ~size_int x =
   ret
 
 (* actual (strict) upper bound for an index in a string-like read/write *)
-let actual_max_length_for_string_like_access_as_nativeint ~size_int
+let actual_max_length_for_string_like_access ~size_int
     ~(access_size : Flambda_primitive.string_accessor_width) length =
   (* offset to subtract from the length depending on the size of the
      read/write *)
@@ -675,29 +675,33 @@ let actual_max_length_for_string_like_access_as_nativeint ~size_int
     in
     Targetint_32_64.of_int offset
   in
+  (* We need to convert the length into a naked_nativeint because the optimised
+     version of the max_with_zero function needs to be on machine-width integers
+     to work (or at least on an integer number of bytes to work). *)
+  let length =
+    H.Prim
+      (Unary (Num_conv { src = Naked_immediate; dst = Naked_nativeint }, length))
+  in
   match access_size with
   | Eight -> length (* micro-optimization *)
   | Sixteen | Thirty_two | Single | Sixty_four | One_twenty_eight _ ->
     let offset = length_offset_of_size access_size in
-    H.Prim
-      (Binary
-         ( Int_arith (Naked_nativeint, Sub),
-           length,
-           Simple (Simple.const (Reg_width_const.naked_nativeint offset)) ))
-    |> max_with_zero ~size_int
+    let reduced_length =
+      H.Prim
+        (Binary
+           ( Int_arith (Naked_nativeint, Sub),
+             length,
+             Simple (Simple.const (Reg_width_const.naked_nativeint offset)) ))
+    in
+    max_with_zero ~size_int reduced_length
 
 (* String-like validity conditions *)
 
 let string_like_access_validity_condition ~size_int ~access_size ~length
     ~index_kind index : H.expr_primitive =
-  let length =
-    H.Prim
-      (Unary (Num_conv { src = Naked_immediate; dst = Naked_nativeint }, length))
-  in
   check_bound ~index_kind ~bound_kind:Naked_nativeint ~index
     ~bound:
-      (actual_max_length_for_string_like_access_as_nativeint ~size_int
-         ~access_size length)
+      (actual_max_length_for_string_like_access ~size_int ~access_size length)
 
 let string_or_bytes_access_validity_condition ~size_int str kind access_size
     ~index_kind index : H.expr_primitive =

middle_end/flambda2/to_cmm/to_cmm_primitive.ml

@@ -251,7 +251,7 @@ let array_length ~dbg arr (kind : P.Array_kind.t) =
        represented by mixed blocks with tag zero (not custom blocks), and that
        arrays of unboxed products are not packed in any way (e.g. int32#
        elements occupy 64 bits). *)
-    assert (C.wordsize_shift = C.numfloat_shift);
+    assert (C.size_addr = C.size_float);
     C.addr_array_length arr dbg
   | Naked_float32s -> C.unboxed_float32_array_length arr dbg
   | Naked_int32s -> C.unboxed_int32_array_length arr dbg
@@ -861,10 +861,12 @@ let unary_primitive env res dbg f arg =
   | Is_null -> None, res, C.eq ~dbg arg (C.nativeint ~dbg 0n)
   | Get_tag -> None, res, C.get_tag arg dbg
   | Array_length (Array_kind array_kind) ->
-    None, res, array_length ~dbg arg array_kind
+    let len = array_length ~dbg arg array_kind in
+    None, res, C.tag_int len dbg
   | Array_length Float_array_opt_dynamic ->
     (* See flambda2.ml (and comment in [array_length], above). *)
-    None, res, array_length ~dbg arg Values
+    let len = array_length ~dbg arg Values in
+    None, res, C.tag_int len dbg
   | Bigarray_length { dimension } ->
     ( None,
       res,