flambda-backend: Refactor Debuginfo.t (#1724)

* Make Debuginfo.t abstract
* Debuginfo.t is a record

Author: gretay-js

asmcomp/emitaux.ml

@@ -177,8 +177,7 @@ let emit_frames a =
   in
   let debuginfos = Label_table.create 7 in
   let label_debuginfos rs dbg =
-    let rdbg = List.rev dbg in
-    let key = (rs, rdbg) in
+    let key = (rs, dbg) in
     try Label_table.find debuginfos key
     with Not_found ->
       let lbl = Cmm.new_label () in
@@ -261,7 +260,8 @@ let emit_frames a =
                    (add (shift_left (of_int kind) 1)
                       (of_int has_next)))))
   in
-  let emit_debuginfo (rs, rdbg) lbl =
+  let emit_debuginfo (rs, dbg) lbl =
+    let rdbg = dbg |> Debuginfo.to_list |> List.rev in
     (* Due to inlined functions, a single debuginfo may have multiple locations.
        These are represented sequentially in memory (innermost frame first),
        with the low bit of the packed debuginfo being 0 on the last entry. *)
@@ -346,6 +346,7 @@ let reset_debug_info () =
 (* We only display .file if the file has not been seen before. We
    display .loc for every instruction. *)
 let emit_debug_info_gen dbg file_emitter loc_emitter =
+  let dbg = Debuginfo.to_list dbg in
   if is_cfi_enabled () &&
     (!Clflags.debug || Config.with_frame_pointers) then begin
     match List.rev dbg with

lambda/debuginfo.ml

@@ -87,7 +87,7 @@ module Scoped_location = struct
     cons scopes Sc_method_definition str s
 
   let enter_lazy ~scopes = cons scopes Sc_lazy (str scopes) ""
-  
+
   let enter_partial_or_eta_wrapper ~scopes =
     cons scopes Sc_partial_or_eta_wrapper (dot ~no_parens:() scopes "(partial)") ""
 
@@ -143,20 +143,21 @@ type item = {
   dinfo_scopes: Scoped_location.scopes;
 }
 
-type t = item list
+type t = { dbg : item list; }
 
 type alloc_dbginfo_item =
   { alloc_words : int;
     alloc_dbg : t }
 type alloc_dbginfo = alloc_dbginfo_item list
 
-let none = []
+let none = { dbg = []; }
 
-let is_none = function
+let is_none { dbg } =
+  match dbg with
   | [] -> true
   | _ :: _ -> false
 
-let to_string dbg =
+let to_string { dbg } =
   match dbg with
   | [] -> ""
   | ds ->
@@ -190,12 +191,13 @@ let item_from_location ~scopes loc =
   }
 
 let from_location = function
-  | Scoped_location.Loc_unknown -> []
+  | Scoped_location.Loc_unknown -> { dbg = []; }
   | Scoped_location.Loc_known {scopes; loc} ->
     assert (not (Location.is_none loc));
-    [item_from_location ~scopes loc]
+    { dbg = [item_from_location ~scopes loc]; }
 
-let to_location = function
+let to_location { dbg } =
+  match dbg with
   | [] -> Location.none
   | d :: _ ->
     let loc_start =
@@ -212,15 +214,15 @@ let to_location = function
       } in
     { loc_ghost = false; loc_start; loc_end; }
 
-let inline dbg1 dbg2 =
-  dbg1 @ dbg2
+let inline { dbg = dbg1;  } { dbg = dbg2; } =
+  { dbg = dbg1 @ dbg2;  }
 
 (* CR-someday afrisch: FWIW, the current compare function does not seem very
    good, since it reverses the two lists. I don't know how long the lists are,
    nor if the specific currently implemented ordering is useful in other
    contexts, but if one wants to use Map, a more efficient comparison should
    be considered. *)
-let compare dbg1 dbg2 =
+let compare { dbg = dbg1; } { dbg = dbg2; } =
   let rec loop ds1 ds2 =
     match ds1, ds2 with
     | [], [] -> 0
@@ -245,8 +247,8 @@ let compare dbg1 dbg2 =
   in
   loop (List.rev dbg1) (List.rev dbg2)
 
-let hash t =
-  List.fold_left (fun hash item -> Hashtbl.hash (hash, item)) 0 t
+let hash { dbg; } =
+  List.fold_left (fun hash item -> Hashtbl.hash (hash, item)) 0 dbg
 
 let rec print_compact ppf t =
   let print_item item =
@@ -264,3 +266,9 @@ let rec print_compact ppf t =
     print_item item;
     Format.fprintf ppf ";";
     print_compact ppf t
+
+let print_compact ppf { dbg; } = print_compact ppf dbg
+
+let to_list { dbg; } = dbg
+
+let length { dbg; } = List.length dbg

lambda/debuginfo.mli

@@ -63,7 +63,7 @@ type item = private {
   dinfo_scopes: Scoped_location.scopes;
 }
 
-type t = item list
+type t
 
 type alloc_dbginfo_item =
   { alloc_words : int;
@@ -93,3 +93,7 @@ val compare : t -> t -> int
 val hash : t -> int
 
 val print_compact : Format.formatter -> t -> unit
+
+val to_list : t -> item list
+
+val length : t -> int